Exercices

Exercice 1

Écrire une fonction maxi qui prend comme paramètres deux nombres n1 et n2 et qui renvoie le plus grand élément entre n1 et n2.

Exemple d'utilisation

>>> maxi(3,1)
3

Vous pouvez utiliser la fonction de tests ci-dessous : 

1
2
3
4
5
def test_maxi():
    assert maxi(3,4) == 4
    assert maxi(5,2) == 5
    assert maxi(7,7) == 7
    print("tests ok")

Correction 
1
2
3
4
5
def maxi(n1, n2):
    if n1 < n2 :
        return n2
    else :
        return n1

Exercice 2

Écrire une fonction moyenne qui prend en paramètres trois nombres a, b et c et qui renvoie la moyenne de ces trois nombres.

Exemple d'utilisation

>>> moyenne(6, 15, 9)
10
Correction 
1
2
def moyenne(a, b, c):
    return (a + b + c) / 3

Exercice 3

Écrire une fonction somme qui prend en paramètre un entier positif n et qui renvoie la somme de tous les entiers de 1 à n.

\(S = 1+2+3+4+5+ \dots +(n-1) + n\)

Exemple d'utilisation

>>> somme(10)
55
Correction 
1
2
3
4
5
def somme(n):
    s = 0
    for k in range(1, n+1):
        s += k
    return s

Exercice 4

Écrire une fonction nb_voyelles qui prend en paramètre la chaine de caractères mot renvoie le nombre de voyelles de mot.

Exemple d'utilisation

>>> nb_voyelles("bonjour")
3

Vous pouvez utiliser la fonction de tests ci-dessous : 

1
2
3
4
5
def test_nb_voyelles():
    assert nb_voyelles("bonjour") == 3
    assert nb_voyelles("fdjgdhk") == 0
    assert nb_voyelles("au") == 2
    print("tests ok")

Correction 
1
2
3
4
5
6
7
def nb_voyelles(mot):
    voyelles = 'aeiouy'
    nb = 0
    for lettre in mot:
        if lettre in voyelles:
            nb += 1
    return nb

Exercice 5

Définissez une fonction decale qui décale de 3 rangs dans l'alphabet la lettre majuscule lettre passée en paramètre (après Z, on recommencera à A..)

Aide 

>>> ord('A')
65
>>> chr(65)
'A'

Exemple d'utilisation

>>> decale('F')
'I'

Vous pouvez utiliser la fonction de tests ci-dessous : 

1
2
3
4
def test_decale():
    assert decale('A') == 'D'
    assert decale('Z') == 'C'
    print('tests ok !')

Correction 

1
2
3
4
5
6
7
8
def decale(lettre):
    rang_lettre = ord(lettre)
    rang_nouvelle_lettre = rang_lettre + 3
    if rang_nouvelle_lettre > ord('Z'):
        rang_nouvelle_lettre -= 26
    nouvelle_lettre = chr(rang_nouvelle_lettre)  

    return nouvelle_lettre
ou mieux, en utilisant le modulo % :

1
2
3
4
5
6
def decale(lettre):
    rang_ancienne_lettre = ord(lettre) - 65
    rang_nouvelle_lettre = (rang_ancienne_lettre + 3) % 26 + 65  
    nouvelle_lettre = chr(rang_nouvelle_lettre)

    return nouvelle_lettre

Exercice 6

Rajoutez un paramètre n à la fonction précédente pour pouvoir décaler la lettre de n rangs.

Exemple d'utilisation

>>> decale('B', 5)
'G'

Vous pouvez utiliser la fonction de tests ci-dessous : 

1
2
3
4
5
def test_decale():
    assert decale('A', 3) == 'D'
    assert decale('A', 5) == 'F'
    assert decale('Z', 1) == 'A'
    print('tests ok !')

Correction 
1
2
3
4
5
6
7
8
def decale(lettre, n):
    rang_lettre = ord(lettre)
    rang_nouvelle_lettre = rang_lettre + n
    if rang_nouvelle_lettre > ord('Z'):
        rang_nouvelle_lettre -= 26
    nouvelle_lettre = chr(rang_nouvelle_lettre)  

    return nouvelle_lettre

Exercice 7

Utilisez la fonction précédente pour créer la fonction decale_phrase qui prend en paramètres une phrase p et un nombre n et qui décale toutes les lettres de p de n rangs. On laissera les espaces intacts.

Exemple d'utilisation

>>> decale_phrase("PAS MAL DU TOUT", 4)
'TEW QEP HY XSYX'
Correction 
1
2
3
4
5
6
7
8
9
def decale_phrase(p, n):
    phrase_decalee = ''
    for lettre in p:
        if lettre == ' ':
            phrase_decalee += ' '
        else:
            nouvelle_lettre = decale(lettre, n)
            phrase_decalee += nouvelle_lettre
    return phrase_decalee

Exercice 8

Décodez la phrase RT BTHHPVT CT RDCIXTCI GXTC S XCITGTHHPCI.

Exercice 9

La conjecture de Syracuse (ou de Collatz) postule ceci :

Prenons un nombre \(n\) : si \(n\) est pair, on le divise par 2, sinon on le multiplie par 3 puis on ajoute 1. On recommence cette opération tant que possible. Au bout d'un certain temps, on finira toujours par tomber sur le nombre 1.

Q1. Écrire une fonction suivant qui prend en paramètre un nombre n renvoie le successeur den, suivant les règles énoncées ci-dessus.

Q2. Écrire une fonction syracuse qui affiche tous les termes de la suite de Syracuse depuis un nombre n passé en paramètre jusqu'à (on l'espère !) 1.

Exercice 10

Q1. Écrire une fonction temps_de_vol qui prend un nombre n en paramètre et qui renvoie le nombre d'étapes pour arriver à 1, en partant de n.

Q2. Écrire une fonction temps_max(nmax) qui affiche le plus grand temps de vol pour un nombre entre 1 et nmax.

Q3. Modifier cette fonction pour afficher aussi le nombre de départ donnant ce plus grand temps de vol.