Loading [MathJax]/extensions/Safe.js

Exercice 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} = 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 n strictement positif et qui renvoie la liste des valeurs u_n , en partant de k et jusqu’à atteindre 1.

Exemple :

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

Jeu de tests (pas entièrement fourni par l'énoncé original) :

Entrée[ ]:
Remarques sur l'énoncé

Cet exercice ne devrait pas être présent un jour d'examen : les candidats n'ayant pas choisi la spécialité Mathématiques peuvent n'avoir rencontré aucun formalisme sur les suites lors de leur scolarité en classe de première et de terminale jusqu'en mars (peut avoir été vu en enseignement scientifique, mais pas avec ces notations).

Solutions 
def calcul(n):
    res = [n]
    while n != 1:
        if n%2 == 0:
            n = n//2
        else:
            n = 3*n + 1
        res.append(n)
    return res

Exercice 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 A B C D E F
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. Le 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.

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]

Exemples :

>>> est_parfait("PAUL") 
[50, 1612112, False] 
>>> est_parfait("ALAIN") 
[37, 1121914, True]
Entrée[ ]:

Jeu de tests (pas entièrement fourni par l'énoncé original) :

Entrée[ ]:
Remarques sur l'énoncé

  • Bien que ce ne soit pas mentionné, le dictionnaire dico peut-être utilisé - en tant que variable globale - à l'intérieur de la fonction est_parfait.

  • Puisque ce dictionnaire n'a pas vocation à être modifié et est utilisé en tant que variable globale, la PEP8 recommande (ce n'est pas obligatoire) de le nommer en majuscules : DICO.

Solutions 
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]
Chargement de Basthon...