class Fraction:
    def __init__(self, num, denom):
        if denom <= 0:
            raise ValueError("Le dénominateur doit être un entier strictement positif.")
        self.num = num
        self.denom = denom
        self._reduce()
    
    def _gcd(self, a, b):
        while b:
            a, b = b, a % b
        return a
    
    def _reduce(self):
        # Réduire la fraction en utilisant le PGCD
        common_divisor = self._gcd(self.num, self.denom)
        self.num //= common_divisor
        self.denom //= common_divisor
    
    def __str__(self):
        if self.denom == 1:
            return str(self.num)
        else:
            return f"{self.num} / {self.denom}"
    
    def __eq__(self, other):
        return self.num == other.num and self.denom == other.denom
    
    def __lt__(self, other):
        return self.num * other.denom < self.denom * other.num
    
    def __add__(self, other):
        new_num = self.num * other.denom + other.num * self.denom
        new_denom = self.denom * other.denom
        return Fraction(new_num, new_denom)
    
    def __mul__(self, other):
        new_num = self.num * other.num
        new_denom = self.denom * other.denom
        return Fraction(new_num, new_denom)

# Tests
f1 = Fraction(3, 4)
f2 = Fraction(2, 3)
f3 = Fraction(6, 8)  # Cela devrait être réduit à 3/4

print(f"f1: {f1}")  # 3 / 4
print(f"f2: {f2}")  # 2 / 3
print(f"f3: {f3}")  # 3 / 4

print(f"f1 == f2: {f1 == f2}")  # False
print(f"f1 == f3: {f1 == f3}")  # True

print(f"f1 < f2: {f1 < f2}")  # False
print(f"f2 < f1: {f2 < f1}")  # True

f4 = f1 + f2
print(f"f1 + f2: {f4}")  # 17 / 12

f5 = f1 * f2
print(f"f1 * f2: {f5}")  # 1 / 2

class Intervalle:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    
    def est_vide(self):
        return self.b < self.a
    
    def __len__(self):
        return max(0, self.b - self.a + 1)
    
    def __contains__(self, x):
        return self.a <= x <= self.b
    
    def __eq__(self, other):
        if self.est_vide() and other.est_vide():
            return True
        return self.a == other.a and self.b == other.b
    
    def __le__(self, other):
        if self.est_vide():
            return True
        if other.est_vide():
            return False
        return other.a <= self.a and self.b <= other.b
    
    def intersection(self, other):
        if self.est_vide() or other.est_vide():
            return Intervalle(0, -1)  # Représente un intervalle vide
        new_a = max(self.a, other.a)
        new_b = min(self.b, other.b)
        if new_a > new_b:
            return Intervalle(0, -1)  # Représente un intervalle vide
        return Intervalle(new_a, new_b)
    
    def union(self, other):
        if self.est_vide():
            return Intervalle(other.a, other.b)
        if other.est_vide():
            return Intervalle(self.a, self.b)
        new_a = min(self.a, other.a)
        new_b = max(self.b, other.b)
        return Intervalle(new_a, new_b)
    
    def __str__(self):
        if self.est_vide():
            return "Intervalle vide"
        return f"[{self.a}, {self.b}]"

# Tests
i1 = Intervalle(1, 5)
i2 = Intervalle(3, 7)
i3 = Intervalle(6, 2)  # Intervalle vide

print(f"i1: {i1}")  # [1, 5]
print(f"i2: {i2}")  # [3, 7]
print(f"i3: {i3}")  # Intervalle vide

print(f"i1 est vide: {i1.est_vide()}")  # False
print(f"i3 est vide: {i3.est_vide()}")  # True

print(f"Longueur de i1: {len(i1)}")  # 5
print(f"Longueur de i3: {len(i3)}")  # 0

print(f"3 est dans i1: {3 in i1}")  # True
print(f"8 est dans i2: {8 in i2}")  # False

print(f"i1 == i2: {i1 == i2}")  # False
print(f"i3 == Intervalle(5, 3): {i3 == Intervalle(5, 3)}")  # True

print(f"i1 <= i2: {i1 <= i2}")  # False
print(f"i3 <= i1: {i3 <= i1}")  # True

i4 = i1.intersection(i2)
print(f"i1 ∩ i2: {i4}")  # [3, 5]

i5 = i1.union(i2)
print(f"i1 ∪ i2: {i5}")  # [1, 7]

i6 = i3.intersection(i1)
print(f"i3 ∩ i1: {i6}")  # Intervalle vide

i7 = i3.union(i1)
print(f"i3 ∪ i1: {i7}")  # [1, 5]

import math

class Angle:
    def __init__(self, angle):
        self.angle = angle % 360
    
    def __str__(self):
        return f"{self.angle} degrés"
    
    def ajoute(self, other):
        self.angle = (self.angle + other.angle) % 360
    
    def cos(self):
        radians = self.angle * math.pi / 180
        return math.cos(radians)
    
    def sin(self):
        radians = self.angle * math.pi / 180
        return math.sin(radians)

# Tests
a1 = Angle(60)
a2 = Angle(300)

print(f"a1: {a1}")  # 60 degrés
print(f"a2: {a2}")  # 300 degrés

# Test de la méthode ajoute
a1.ajoute(a2)
print(f"a1 + a2: {a1}")  # 0 degrés (60 + 300 = 360, qui est réduit à 0)

# Test des méthodes cos et sin
a3 = Angle(90)
print(f"cos(90°): {a3.cos()}")  # Devrait être proche de 0
print(f"sin(90°): {a3.sin()}")  # Devrait être proche de 1

a4 = Angle(180)
print(f"cos(180°): {a4.cos()}")  # Devrait être proche de -1
print(f"sin(180°): {a4.sin()}")  # Devrait être proche de 0

class Date:
    mois_noms = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"]

    def __init__(self, jour, mois, annee):
        self.jour = jour
        self.mois = mois
        self.annee = annee
    
    def __str__(self):
        return f"{self.jour} {Date.mois_noms[self.mois - 1]} {self.annee}"
    
    def __lt__(self, other):
        if self.annee != other.annee:
            return self.annee < other.annee
        if self.mois != other.mois:
            return self.mois < other.mois
        return self.jour < other.jour

# Tests
d1 = Date(8, 5, 1945)
d2 = Date(1, 1, 2000)
d3 = Date(15, 8, 1945)

print(d1)  # 8 mai 1945
print(d2)  # 1 janvier 2000
print(d3)  # 15 août 1945

# Test de la méthode __lt__
print(d1 < d2)  # True
print(d2 < d1)  # False
print(d1 < d3)  # True
print(d3 < d1)  # False

class Temps:
    def __init__(self, heures=0, minutes=0, secondes=0):
        self.__heures = heures
        self.__minutes = minutes
        self.__secondes = secondes
    
    def __str__(self):
        return f"{self.__heures}h:{self.__minutes}min:{self.__secondes}s"
    
    def getHeures(self):
        return self.__heures
    
    def getMinutes(self):
        return self.__minutes
    
    def getSecondes(self):
        return self.__secondes
    
    def ajouter(self, autre):
        secondes = self.__secondes + autre.getSecondes()
        minutes = self.__minutes + autre.getMinutes() + secondes // 60
        heures = self.__heures + autre.getHeures() + minutes // 60
        return Temps(heures % 24, minutes % 60, secondes % 60)
    
    def afficher(self):
        print(self.__str__())

# Tests
t1 = Temps()
t2 = Temps(10, 59, 30)
t3 = Temps(5, 30, 45)

# Affichage des objets
t1.afficher()  # 0h:0min:0s
t2.afficher()  # 10h:59min:30s
t3.afficher()  # 5h:30min:45s

# Utilisation des getters
print(t2.getHeures())  # 10
print(t2.getMinutes())  # 59
print(t2.getSecondes())  # 30

# Addition de deux objets Temps
t4 = t2.ajouter(t3)
t4.afficher()  # 16h:30min:15s