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(5, 4)
(4.5, 0.5)

>>> recherche(0, 7)
(3.5, -3.5)
  1. Compléter la définition de la fonction recherche().

    1
    2
    3
    4
    5
    6
    7
    def recherche(somme, diff):
        """
        somme -
        diff -  
        Sortie:
        """
        pass
    
  2. Compléter le docstring de cette fonction.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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
    """
    a = (somme + diff)/2
    b = (somme - diff)/2
    return (a, b)

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(3, "M")
224

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

>>> rythme_card(16, "F")
214

>>> rythme_card(56, "F")
165

>>> rythme_card(52, "M")
165
  1. Compléter la définition de la fonction rythme_card().

    1
    2
    3
    4
    5
    6
    7
    def rythme_card(age, sexe):
        """
        age -
        sexe -
        Sortie:
        """
        pass
    
  2. Compléter le docstring de cette fonction.

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
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
    """
    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)

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(2022)
False

>>> est_bissextile(1600)
True
  1. Compléter la définition de la fonction est_bissextile().

    1
    2
    3
    4
    5
    6
    def est_bissextile(annee):
        """
        annee – 
        Sortie:
        """
        pass
    
  2. Compléter le docstring de cette fonction.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def est_bissextile(annee):
    """
    annee – int, entier strictement positif
    Sortie: bool - True si annee est bissextile, False sinon
    """
    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 

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(1)
1

>>> fibo(17)
2584
  1. Compléter la définition de la fonction fibo().

    1
    2
    3
    4
    5
    6
    def fibo(n):
        """
        n – 
        Sortie: 
        """
        pass
    
  2. Compléter le docstring de cette fonction.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
def fibo(n):
    """
    n – int, entier positif
    Sortie: int – le n-ième nombre de Fibonacci
    """
    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

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

>>> somme(-7, 7)
0

>>> somme(-14, -3)
-102
  1. Compléter la définition de la fonction somme().

    1
    2
    3
    4
    5
    6
    7
    def somme(a, b):
        """
        a -
        b -
        Sortie: 
        """
        pass
    
  2. Compléter le docstring de cette fonction.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
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)
    """
    if a > b:
        c = a
        a = b
        b = c
    S = 0
    for i in range(a, b+1):
        S = S+i
    return S

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(17, 2)
(8, 1)

>>> quotient_reste(243, 10)
(24, 3)
  1. Compléter la définition de la fonction quotient_reste().

    1
    2
    3
    4
    5
    6
    7
    def quotient_reste(a, b):
        """
        a – 
        b - 
        Sortie: 
        """
        pass
    
  2. Compléter le docstring de cette fonction.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
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 = 0
    while a >= b:
        quotient = quotient + 1
        a = a-b
    reste = a
    return quotient, reste

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(1)
1

>>> som_sup(2022)
64
  1. Compléter la définition de la fonction som_sup().

    1
    2
    3
    4
    5
    6
    def som_sup(A):
        """
        A - 
        Sortie: 
        """
        pass
    
  2. Compléter le docstring de cette fonction.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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
    """
    somme = 0
    compteur = 0
    while somme < A:
        compteur = compteur + 1
        somme = somme + compteur
    return compteur

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

>>> somme_diviseurs(150)
222

>>> somme_diviseurs(496)
496

>>> est_parfait(28)
True

>>> est_parfait(15)
False

>>> est_parfait(150)
False

>>> est_parfait(496)
True

>>> est_parfait(8128)
True
  1. Compléter la définition de ces fonctions.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    def somme_diviseurs(n):
        """
        n – 
        Sortie: 
        """
        pass
    
    
    
    def est_parfait(n):
        """
        n – 
        Sortie: 
        """
        pass
    
  2. Compléter les docstring de ces fonctions.

Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def somme_diviseurs(n):
    """
    n – int, entier strictement positif
    Sortie: int – somme des diviseurs de n, sauf n
    """
    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
    """
    return somme_diviseurs(n) == n