Épreuve pratique NSI 2024 — Sujet 19 : listes de puissances, mots parfaits

Épreuve pratique de NSI, session 2024 — sujet n°19 de la banque nationale. Durée : 1 heure, sur ordinateur. Le candidat traite les deux exercices, notés chacun sur 10 points.

Exercice 1 — listes de puissances d'un entier

On rappelle que :

• le nombre $a^n$ est le nombre $a \times a \times a \times \cdots \times a$, où le facteur $a$ apparaît $n$ fois ;
• en langage Python, l'instruction t[-1] permet d'accéder au dernier élément du tableau t.

Dans cet exercice, l'opérateur ** et la fonction pow ne sont pas autorisés.

Programmer en langage Python une fonction liste_puissances qui prend en argument un nombre entier $a$, un entier strictement positif $n$ et qui renvoie la liste de ses puissances $[a^1, a^2, \ldots, a^n]$.

Programmer également une fonction liste_puissances_borne qui prend en argument un nombre entier $a$ supérieur ou égal à 2 et un entier borne, et qui renvoie la liste de ses puissances, à l'exclusion de $a^0$, strictement inférieures à borne.

Exemples :

>>> liste_puissances(3, 5)
[3, 9, 27, 81, 243]
>>> liste_puissances(-2, 4)
[-2, 4, -8, 16]
>>> liste_puissances_borne(2, 16)
[2, 4, 8]
>>> liste_puissances_borne(2, 17)
[2, 4, 8, 16]
>>> liste_puissances_borne(5, 5)
[]

Exercice 2 — mots parfaits

On affecte à chaque lettre de l'alphabet un code selon le tableau ci-dessous :

Cette table de correspondance est stockée dans un dictionnaire dico où les clés sont les lettres de l'alphabet et les valeurs les codes correspondants.

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}

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. Ainsi, 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. Ainsi, le mot "ALAIN" est parfait.

Compléter la fonction codes_parfait ci-dessous, qui prend en paramètre un mot en majuscule et renvoie un triplet constitué du code additionné, du code concaténé et d'un booléen indiquant si le mot est parfait ou non.

On rappelle que pour tester si un entier a divise un entier b, on utilise l'opérateur modulo : b % a renvoie le reste de la division euclidienne de b par a. Si b % a vaut 0, alors a divise b.

Note : le sujet officiel écrit ici a % b, ce qui inverse les rôles des deux nombres. C'est bien b % a qui donne le reste de la division de b par a.

def codes_parfait(mot):
    """Renvoie un triplet
    (code_additionne, code_concatene, mot_est_parfait) où :
    - code_additionne est la somme des codes des lettres du mot ;
    - code_concatene est le code des lettres du mot concaténées ;
    - mot_est_parfait est un booléen indiquant si le mot est parfait."""
    code_concatene = ""
    code_additionne = ...
    for c in mot:
        code_concatene = code_concatene + ...
        code_additionne = code_additionne + ...
    code_concatene = int(code_concatene)
    mot_est_parfait = ...
    return code_additionne, code_concatene, mot_est_parfait

Exemples :

>>> codes_parfait("PAUL")
(50, 1612112, False)
>>> codes_parfait("ALAIN")
(37, 1121914, True)