def plusPetit(a, b, c):
    """"
    :entrée a: int
    :entrée b: int
    :entrée c: int
    :sortie : int
    :pré-cond: a, b, c sont des entiers
    :post-cond: le nombre retourné est le plus petit des trois            
    """
    # Remarque : cette solution n'est pas idéale car il n'est pas 
    # recommandé de mettre des return partout dans son algo
    if(a<c):
        if(a<b):
            return a
        else:
            return b
    elif(b<c):
        return b
    else:
        return(c)

# Et surtout, on n'oublie pas de tester notre fonction :
a=1
b=2
c=3
minimum=plusPetit(a,b,c)
print(minimum)

a=2
b=3
c=1
minimum=plusPetit(a,b,c)
print(minimum)

a=3
b=1
c=2
minimum=plusPetit(a,b,c)
print(minimum)



"""
Explanation: Déroulement de la séance : 
* Rendu des activités de la première journée + discussion
* Rendu des copies de l'interro 1 + discussion
* Activité sur le jeu de la tortue pour voir ce que l'on peut faire avec un langage algorithmique minimaliste
* Exercices
Exercice 1 Écrire une fonction qui renvoie le plus petit de trois nombres passés en paramètres.
Nous avons vu plusieurs solutions... et il y en a encore probablement d'autres. 
Important: Observez la nouvelle notation que l'on emploie pour définir les entrées et les sorties... nous serons amenés à en reparler 
Solution 1 (pas vraiment idéale) :
End of explanation
"""


def plusPetitBis(a, b, c):
    """
    :entrée a: int
    :entrée b: int
    :entrée c: int
    :sortie : int
    :pré-cond: a, b, c sont des entiers
    :post-cond: le nombre retourné est le plus petit des trois            
    """
    # Astuce : on compare les valeurs deux à deux et on retient 
    #  la valeur la plus petite dans la variable a. 
    if(a>b):
        a=b
    if(a>c):
        a=c
    return(a)

# Et surtout, on n'oublie pas de tester notre fonction :
a=1
b=2
c=3
minimum=plusPetitBis(a,b,c)
print(minimum)

a=2
b=3
c=1
minimum=plusPetitBis(a,b,c)
print(minimum)

a=3
b=1
c=2
minimum=plusPetitBis(a,b,c)
print(minimum)


"""
Explanation: Solution 2. Cette solution minimaliste est très astucieuse. Lorsque l'on opte pour une "astuce" comme ça, il est préférable de le commenter pour se souvenir, plus tard, de ce que faisait l'astuce. Notez que l'on reprend exactement les mêmes tests.
End of explanation
"""


def afficherTableMult(a, m, n):
    '''
    :entree: a, l'entier à multiplier
    :entree: m et n, les bornes de l'affichage
    :sortie: 
    :pré-condition: n>m
    :post-condition: la table de multiplication est affichée sur la sortie standar
    '''
    for i in range(m,n+1):
        print(a,"*",i,"=",a*i)
        
# Ne jamais oublier de tester son algorithme / son programme !        
a = 5
m = 3
n = 8
afficherTableMult(a, m, n)

"""
Explanation: Exercice 2 Écrire une procédure qui affiche la table de multiplication (de 0 à 10) de n'importe quel nombre.
Solution. Cet exercice a été corrigé au tableau. 
Exercice 3 Écrire une procédure qui affiche la table de multiplication (de m à n) de n'importe quel nombre.
End of explanation
"""


def duree_en_secondes(j, h, m, s):
    """
    :entrée j: int
    :entrée h: int
    :entrée m: int
    :entrée s: float
    :sortie ds: float
    :pré-cond: j > 0 , 0 ≤ h < 24 , 0 ≤ m < 60, 0 ≤ s < 60
    :post-cond: ds est le nombre de secondes correspond à
                une durée de j jours, h heures, m minutes et s secondes.
    """

"""
Explanation: Exercices à faire à la maison 
DM1 Calculer les coefficients d’une droite à partir de deux points.
DM2 Convertir une durée en secondes. Le squelette de l'algorithme est donné ci-dessous.
End of explanation
"""


