Aller au contenu

Sujet n°9

Sujet original

Pour télécharger l'énoncé original, cliquer ici.

Exercice n°1

Soit un nombre entier supérieur ou égal à 1 :

  • s'il est pair, on le divise par 2 ;
  • s’il est impair, on le multiplie par 3 et on ajoute 1.

Puis on recommence ces étapes avec le nombre entier obtenu, jusqu’à ce que l’on obtienne la valeur 1.

On définit ainsi la suite (u_n) par :

  • u_0 = k, où k est un entier choisi initialement ;
  • u_{n+1} = \frac{u_n}{2} si u_n est pair ;
  • u_{n+1} = 3 \times u_n + 1 si u_n est impair.

On admet que, quel que soit l’entier k choisi au départ, la suite finit toujours sur la valeur 1.

Écrire une fonction calcul prenant en paramètres un entier k strictement positif et qui renvoie la liste des valeurs un, en partant de k et jusqu’à atteindre 1.

Commentaires
  1. Le sujet original comporte une coquille :
    Écrire une fonction calcul prenant en paramètres un entier n strictement positif et qui renvoie la liste des valeurs un, en partant de k et jusqu’à atteindre 1.

  2. C'est le classique exemple de la suite de Syracuse, étudié en 1ère NSI.

  3. À nouveau, le mot « liste » est à comprendre dans le sens « liste Python » (c'est-à-dire tableau) plutôt que dans le sens du type abstrait de données liste étudié en Terminale.

Exemple

>>> calcul(7)
[7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
Une solution

Rappel : vous pouvez définir des fonctions supplémentaires si vous le souhaitez.

 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
def suivant(k):
    """
    k - int, entier strictement positif
    Sortie: int - k/2 si k est pair, 3*k+1 sinon
    """
    if k%2 == 0:
        return k//2
    else:
        return 3*k+1


def calcul(k):
    '''
    k - int, entier strictement positif
    Sortie: list - tableau des entiers de k à 1 en suivant le principe de Syracuse
    '''
    tab = [k]
    while k != 1:
        k = suivant(k)
        tab.append(k)
    return tab        


if __name__ == '__main__':
    print(calcul(7) == [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1] )
    print(calcul(15) == [15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1])

Une solution récursive

Cette solution est plus délicate à implémenter, mais tellement gratifiante...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def calcul_rec(k, tab=None):
    '''
    k - int, entier strictement positif
    Sortie: list - tableau des entiers de k à 1 en suivant le principe de Syracuse
    '''
    if tab is None:
        tab = []
    tab.append(k)
    if k == 1:
        return tab
    else:
        if k%2 == 0:
            return calcul_rec(k//2, tab)
        else:
            return calcul_rec(3*k+1, tab)


if __name__ == '__main__':
    print(calcul_rec(7) == [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1] )
    print(calcul_rec(15) == [15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1])

Exercice n°2

On affecte à chaque lettre de l’alphabet un code selon les tableaux ci-dessous :

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
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

Pour un mot donné, on détermine d’une part son code alphabétique concaténé, obtenu par la juxtaposition des codes de chacun de ses caractères, et d’autre part, son code additionné, qui est la somme des codes de chacun de ses caractères.
Par ailleurs, on dit que ce mot est « parfait » si le code additionné divise le code concaténé.

Exemples :

  • Pour le mot "PAUL", le code concaténé est la chaîne '1612112', soit l’entier 1 612 112.
    Son code additionné est l’entier 50 car 16 + 1 + 21 + 12 = 50.
    50 ne divise pas l’entier 1 612 112 ; par conséquent, le mot "PAUL" n’est pas parfait.

  • Pour le mot "ALAIN", le code concaténé est la chaîne '1121914', soit l’entier 1 121 914.
    Son code additionné est l’entier 37 car 1 + 12 + 1 + 9 + 14 = 37.
    37 divise l’entier 1 121 914 ; par conséquent, le mot "ALAIN" est parfait.

Compléter la fonction est_parfait ci-dessous qui prend comme argument une chaîne de caractères mot (en lettres majuscules) et qui renvoie le code alphabétique concaténé, le code additionné de mot, ainsi qu’un booléen qui indique si mot est parfait ou pas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
dico = {"A":1, "B":2, "C":3, "D":4, "E":5, "F":6, "G":7, \
        "H":8, "I":9, "J":10, "K":11, "L":12, "M":13, \
        "N":14, "O":15, "P":16, "Q":17, "R":18, "S":19, \
        "T":20, "U":21,"V":22, "W":23, "X":24, "Y":25, "Z":26}

def est_parfait(mot) :
    # mot est une chaîne de caractères (en lettres majuscules)
    code_c = ""
    code_a = ...
    for c in mot :
        code_c = code_c + ...
        code_a = ...
    code_c = int(code_c)
    if ... :
        mot_est_parfait = True
    else :
        mot_est_parfait = False
    return [code_a, code_c, mot_est_parfait]
Commentaire sur le code original

Pour télécharger l'original du fichier à compléter, cliquer ici.

Exemple

>>> est_parfait("PAUL")
[50, 1612112, False]

>>> est_parfait("ALAIN")
[37, 1121914, True]
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
dico = {"A":1, "B":2, "C":3, "D":4, "E":5, "F":6, "G":7, \
        "H":8, "I":9, "J":10, "K":11, "L":12, "M":13, \
        "N":14, "O":15, "P":16, "Q":17, "R":18, "S":19, \
        "T":20, "U":21,"V":22, "W":23, "X":24, "Y":25, "Z":26}

def est_parfait(mot) :
    # mot est une chaîne de caractères (en lettres majuscules)
    code_c = ""
    code_a = 0
    for c in mot :
        code_c = code_c + str(dico[c])
        code_a = code_a + dico[c]
    code_c = int(code_c)
    if code_c%code_a == 0 :
        mot_est_parfait = True
    else :
        mot_est_parfait = False
    return [code_a, code_c, mot_est_parfait]


if __name__ == '__main__':
    print(est_parfait("PAUL") == [50, 1612112, False])
    print(est_parfait("ALAIN") == [37, 1121914, True])
    print(est_parfait("NICOLAS") == [73, 14931512119, False])