Aller au contenu

Bases de programmation

Chaque exercice est fourni avec un fichier Python à compléter et un énoncé « papier » distribué à l'élève et reproduit ci-dessous.

Remarques importantes

  1. Les exercices de cette page ne sont pas classés par ordre de « difficulté », cette notion de difficulté étant subjective et dépendante de chaque élève.

  2. Les solutions proposées ne sont que des propositions !
    Il existe d'autres codes valables pour répondre à chaque problème que ceux proposés ici : il ne faut pas hésiter à les soumettre à votre enseignant pour qu'il vous donne son avis sur les idées mises en oeuvre.

Somme et différence

On connaît deux valeurs entières qui correspondent respectivement à la somme et à la différence de deux nombres (pas forcéments entiers). Comment retrouver ces deux nombres ?

Exemple

La somme des deux nombres est -2, leur différence est 4.
Ces deux nombres sont 1 et -3 (il n'y a pas d'autre possibilité).

Dans cet exercice, la fonction recherche() doit renvoyer ces deux nombres connaissant, dans l'ordre, leur somme et leur différences (entières).
Les deux nombres renvoyés sont tels que le premier nombre moins le deuxième donne la différence.

Exemples

>>> recherche(-2, 4)
(1.0, -3.0)

>>> recherche(4, -5)
(-0.5, 4.5)

>>> recherche(4.0, 3)
AssertionError: Le premier argument n'est pas entier
  1. Compléter la définition de la fonction recherche(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def recherche(somme, diff):
        """
        somme -
        diff -  
        Sortie:
    
        >>> recherche(-2, 4)
        (1.0, -3.0)
    
        >>> recherche(4, -5)
        (-0.5, 4.5)
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def recherche(somme, diff):
    """
    somme - int, somme des deux nombres cherchés
    diff - int, différence des deux nombres cherchés
    Sortie: (float, float), couple des deux nombres tels que leur somme
            vaut somme et leur différence vaut diff

    >>> recherche(-2, 4)
    (1.0, -3.0)

    >>> recherche(4, -5)
    (-0.5, 4.5)
    """
    assert isinstance(somme, int), "Le premier argument n'est pas entier"
    assert isinstance(diff, int), "Le second argument n'est pas entier"

    a = (somme + diff)/2
    b = (somme - diff)/2
    return (a, b)



if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(recherche(5, 4) == (4.5, 0.5))        
    print(recherche(0, 7) == (3.5, -3.5))

Rythme cardiaque

Le rythme cardiaque maximum que peut prendre le coeur d'un individu dépend de l'âge et du sexe de cet individu.
Ce rythme cardiaque maximum se calcule de la façon suivante :

  • « 230 – 2 × âge » pour les enfants entre 0 et 10 ans ;
  • « 220 – 1,1 × âge » pour les garçons de plus de 10 ans ;
  • « 230 – âge » pour les filles de plus de 10 ans ;
  • 165 pour les femmes de plus de 55 ans comme pour les hommes de plus de 50 ans.

Dans cet exercice, la fonction rythme_card() doit :

  • prendre en paramètres un entier positif age et une chaîne de caractères M ou F,

  • renvoyer le rythme cardiaque maximal (entier) de l'individu obtenu selon les règles décrites ci-dessus.

Exemples

>>> rythme_card(3, "F")
224

>>> rythme_card(16, "M")
202

>>> rythme_card(56, "fille")
AssertionError: Le genre doit être M ou F
  1. Compléter la définition de la fonction rythme_card(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    def rythme_card(age, sexe):
        """
        age -
        sexe -
        Sortie: 
    
        >>> rythme_card(3, "F")
        224
        >>> rythme_card(16, "M")
        202
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def rythme_card(age, sexe):
    """
    age - int, entier strictement positif
    sexe - str, "M" pour homme ou "F" pour femme
    Sortie: int - Rythme cardiaque maximum calculé en fonction de l'âge
            et du sexe

    >>> rythme_card(3, "F")
    224
    >>> rythme_card(16, "M")
    202
    """
    assert sexe == 'M' or sexe == 'F', "Le genre doit être M ou F"
    if 0 <= age <= 10:
        Rmax = 230 - 2*age

    elif sexe == "M":
        if 10 < age <= 50 :
            Rmax = 220 - 1.1*age
        else:
            Rmax = 165

    else:
        if 10 < age <= 55 :
            Rmax = 230 - age
        else:
            Rmax = 165

    return int(Rmax)



if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(rythme_card(3, "M") == 224)
    print(rythme_card(56, "F") == 165)

Années bissextiles

Les années bissextiles sont les années divisibles par 4, à l'exception de celles qui sont divisibles par 100 sans l'être par 400.

Exemples

  • 2000 est une année bissextile (2000 est divisible par 4. 2000 est divisible par 100 mais aussi par 400 : il ne fait donc pas partie des exceptions).
  • 2012 est divisible par 4 mais pas par 100 : 2012 est bissextile.
  • 1900 est divisible par 4, par 100 mais pas par 400 : 1900 n'est pas bissextile.

La fonction est_bissextile() a pour paramètre un entier strictement positif (l'année) puis renvoie True lorsque l'année est bissextile ou False dans le cas contraire.

Exemples

>>> est_bissextile(2000)
True

>>> est_bissextile(2012)
True

>>> est_bissextile(1900)
False

>>> est_bissextile(-100)
AssertionError: L'année doit être strictement positive.
  1. Compléter la définition de la fonction est_bissextile(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def est_bissextile(annee):
        """
        annee – 
        Sortie: 
    
        >>> est_bissextile(2000)
        True
        >>> est_bissextile(2012)
        True
        >>> est_bissextile(1900)
        False
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def est_bissextile(annee):
    """
    annee – int, entier strictement positif
    Sortie: bool - True si annee est bissextile, False sinon

    >>> est_bissextile(2000)
    True
    >>> est_bissextile(2012)
    True
    >>> est_bissextile(1900)
    False
    """
    assert annee > 0, "L'année doit être strictement positive."
    if annee%4 != 0 :                              # Pas divisible par 4
        return False
    elif (annee%100 == 0) and (annee%400 != 0):    # divisible par 100 et pas par 400
        return False
    else :
        return True        



if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(est_bissextile(2022) == False)
    print(est_bissextile(1600) == True)

Nombres de Fibonacci

On appelle « nombres de Fibonacci » les nombres obtenus par somme des deux précédents.

Les deux premiers nombres de Fibonacci sont F_0 = 1 et F_1 = 1.
On a ensuite F_2 = 2, F_3 = 3, F_4 = 5, F_5 = 8, F_6 = 13, etc...

La fonction fibo() prend en paramètres un entier positif ou nul n et doit renvoyer le n-ième nombre de Fibonacci en respectant cette règle.

Exemples

>>> fibo(0)
1

>>> fibo(5)
8

>>> fibo(7)
21

>>> fibo(-4)
AssertionError: Il faut entrer un entier positif ou nul !
  1. Compléter la définition de la fonction fibo(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def fibo(n):
        """
        n – 
        Sortie: 
    
        >>> fibo(0)
        1
        >>> fibo(5)
        8
        >>> fibo(7)
        21
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def fibo(n):
    """
    n – int, entier positif
    Sortie: int – le n-ième nombre de Fibonacci

    >>> fibo(0)
    1
    >>> fibo(5)
    8
    >>> fibo(7)
    21
    """
    assert n >= 0, "Il faut entrer un entier positif ou nul !"
    if (n == 0) or (n == 1):
        return 1
    else:
        f_ancien = 1
        f_actuel = 1
        for i in range(2, n+1):
            f_nouveau = f_ancien + f_actuel
            f_ancien = f_actuel
            f_actuel = f_nouveau
        return f_nouveau


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(fibo(1) == 1)
    print(fibo(17) == 2584)

Somme d'entiers successifs

La fonction somme() prend en paramètres deux entiers a et b et doit renvoyer la somme des entiers compris entre a (inclus) et b (inclus).

Exemples

>>> somme(-2, 4)
7

>>> somme(5, 11)
56

>>> somme(7, 7)
7

>>> somme(4, 3)
7
  1. Compléter la définition de la fonction somme().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    def somme(a, b):
        """
        a -
        b -
        Sortie: 
    
        >>> somme(5, 11)
        56
        >>> somme(7, 7)
        7
        >>> somme(4, 3)
        7
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def somme(a, b):
    """
    a - int, première borne de l'intervalle d'entiers
    b - int, seconde borne de l'intervalle d'entiers
    Sortie: int, somme des entiers compris entre a et b (inclus)

    >>> somme(5, 11)
    56
    >>> somme(7, 7)
    7
    >>> somme(4, 3)
    7
    """
    if a > b:
        c = a
        a = b
        b = c
    S = 0
    for i in range(a, b+1):
        S = S+i
    return S



if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(somme(-7, 7) == 0)    
    print(somme(-14, -3) == -102)

Quotient et reste

Soient a et b deux entiers positifs. Pour déterminer le quotient et le reste de la division entière de a par b sans utiliser les opérations quotient « // » et modulo « % » qui sont interdites dans cet exercice, il faut soustraire b à a jusqu'à ce cette différence devienne inférieure à b.
Le quotient correspond au nombre de soustractions effectuées tandis que le reste est le résultat de la dernière soustraction.

Attention !

Il est interdit d'utiliser les opérations quotient « // » et modulo « % » dans cet exercice...

Exemples

>>> quotient_reste(14, 3)
(4, 2)

>>> quotient_reste(3, 14)
(0, 3)

>>> quotient_reste(5, 0)
AssertionError: Le second argument doit être strictement positif.
  1. Compléter la définition de la fonction quotient_reste(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    def quotient_reste(a, b):
        """
        a – 
        b - 
        Sortie: 
    
        >>> quotient_reste(14, 3)
        (4, 2)
        >>> quotient_reste(3, 14)
        (0, 3)
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def quotient_reste(a, b):
    """
    a – int, entier positif ou nul
    b - int, entier strictement positif
    Sortie: (int, int) – le premier entier est le quotient de la division entière de a par b,
            l'autre entier est le reste de cette division.

    >>> quotient_reste(14, 3)
    (4, 2)
    >>> quotient_reste(3, 14)
    (0, 3)
    """
    assert b > 0, "Le second argument doit être strictement positif."
    quotient = 0
    while a >= b:
        quotient = quotient + 1
        a = a-b
    reste = a
    return quotient, reste



if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(quotient_reste(17, 2) == (8, 1))
    print(quotient_reste(243, 10) == (24, 3))

Somme dépassant une valeur

Soit A un entier strictement positif. On cherche le plus petit entier n tel que la somme des entiers de 1 à n dépasse le nombre A.

Exemple

On considère le nombre 17.
La somme 1 + 2 + 3 + 4 + 5 vaut 15 et la somme 1 + 2 + 3 + 4 + 5 + 6 vaut 21. 6 est donc le plus petit entier tel que la somme de 1 à cet entier dépasse 17.

La fonction som_sup() prend donc pour paramètre un entier naturel A et doit renvoyer le plus petit entier n tel que la somme S = 0+1+2+...+n soit supérieure ou égale à A.

Exemples

>>> som_sup(17)
6

>>> som_sup(102587)
453

>>> som_sup(-5)
AssertionError: L'argument doit être strictement positif.
  1. Compléter la définition de la fonction som_sup(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    def som_sup(A):
        """
        A - 
        Sortie: 
    
        >>> som_sup(17)
        6
        >>> som_sup(102587)
        453
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def som_sup(A):
    """
    A - int, entier positif ou nul
    Sortie: int - plus petit entier n tel que 0+1+2+...+n est supérieur ou égal à A

    >>> som_sup(17)
    6
    >>> som_sup(102587)
    453
    """
    assert A >= 0, "L'argument doit être un entier strictement positif."
    somme = 0
    compteur = 0
    while somme < A:
        compteur = compteur + 1
        somme = somme + compteur
    return compteur


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(som_sup(1) == 1)
    print(som_sup(2022) == 64)

Nombres parfaits

On appelle nombre parfait tout entier égal à la somme de ses diviseurs, mis à part lui-même.

Exemples

Les diviseurs de 28 sont 1, 2, 4, 7, 14 et 28.
La somme de ces diviseurs, hormis 28, est : 1 + 2 + 4 + 7 + 14 = 28. 28 est donc un nombre parfait.

Par contre, les diviseurs de 15 sont 1, 3, 5 et 15.
Comme 1 + 3 + 5 = 9 ≠ 15, 15 n'est pas un nombre parfait.

L’objectif de cet exercice est d’obtenir un programme Python permettant de déterminer l'ensemble des nombres parfaits jusqu'à un certain seuil.

Pour remplir cette tâche, on vous demande de compléter le code de deux fonctions :

  • La fonction somme_diviseurs() qui prend en paramètre un entier n strictement positif et qui renvoie la somme des diviseurs de n, n exclus.

  • La fonction est_parfait() qui prend en paramètre un entier n strictement positif et qui renvoie True lorsque n est parfait et False sinon.

Exemples

>>> somme_diviseurs(28)
28

>>> somme_diviseurs(15)
9

>>> est_parfait(28)
True

>>> est_parfait(15)
False

>>> somme_diviseurs(-4)
AssertionError: L'argument doit être un entier strictement positif
  1. Compléter la définition de ces fonctions, sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    def somme_diviseurs(n):
        """
        n – 
        Sortie: 
    
        >>> somme_diviseurs(28)
        28
        >>> somme_diviseurs(15)
        9
        """
        pass
    
    
    
    def est_parfait(n):
        """
        n – 
        Sortie: 
    
        >>> est_parfait(28)
        True
        >>> est_parfait(15)
        False
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter les docstring de ces fonctions.

  3. Ajouter, pour chaque fonction, au moins un nouveau test avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def somme_diviseurs(n):
    """
    n – int, entier strictement positif
    Sortie: int – somme des diviseurs de n, sauf n

    >>> somme_diviseurs(28)
    28
    >>> somme_diviseurs(15)
    9
    """
    assert isinstance(n, int) and n > 0, "L'argument doit être un entier strictement positif"
    somme = 0
    for i in range(1, n):
        if n%i == 0:
            somme = somme + i
    return somme


def est_parfait(n):
    """
    n – int, entier strictement positif
    Sortie: bool – True si n est parfait, c'est-à-dire un entier égal à
            la somme de ses diviseurs hormis lui-même,
            False sinon

    >>> est_parfait(28)
    True
    >>> est_parfait(15)
    False
    """
    return somme_diviseurs(n) == n


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(somme_diviseurs(150) == 222)
    print(somme_diviseurs(496) == 496)
    print(est_parfait(150) == False)
    print(est_parfait(496) == True)
    print(est_parfait(8128) == True)