ACCUEIL
📖 NSI Première

🌐 Python

📖 NSI Terminale

NSI Première

Correction

Sans Machine

Exercice 1
On donne le script suivant ci-dessous.
Quelle est la valeur finale de x ?

x = 1
n = 5
while n > 1:
    x = x * n
    k = n - 1

La valeur de n ne change pas.
 
Elle reste à 5.

La boucle ne  s'arrète pas. Elle est infinie. 

On ne peut pas avoir de valeur de x. 

Exercice 1 bis
On donne le script suivant ci-dessous.
Quelle est la valeur finale de x ?

x = 1
n = 5
while n > 1:
    x = x * n
    n = n - 1

print(x)

120

Au debut:

• x = 1
• n = 5

On entre dans la boucle

• 1er passage - x = 1x5 = 5 ; n = 5-1 = 4
• 2ème passage - x = 5x4 = 20 ; n = 4-1 = 3
• 3ème passage - x = 20x3 = 60 ; n = 3-1 = 2
• 4ème passage - x = 60x2 = 120 ; n = 2-1 = 1

On a x = 1, alors on quitte la boucle
Donc x = 120

Exercice 2
On donne le script suivant ci-dessous.
Quelle est la valeur finale de x ?

x = 0
for i in range(2):
    x = x + i
    for j in range(3):
        x = x + j

print(x)

7

Au debut:

• x = 0

On entre dans la boucle
Variable i

• 1er passage i = 0
  x = 0 + 0 = 0
  • j = 0: x = 0 + 0 = 0
  • j = 1: x = 0 + 1 = 1
  • j = 2: x = 1 + 2 = 3
• 2ème passage i = 1
  x = 3 + 1 = 4
  • j = 0: x = 4 + 0 = 4
  • j = 1: x = 4 + 1 = 5
  • j = 2: x = 5 + 2 = 7
  </ul> </ul> On sort de la boucle
  Donc x = 7

Ecrire des Fonctions

Exercices sur les fonctions

Exercice 8

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

Une méthode possible

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

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

texte = "RT BTHHPVT CT RDCIXTCI GXTC S XCITGTHHPCI"
for i in range(1, 27):
    print(decale_phrase(texte, i))

SU CUIIQWU DU SEDJYUDJ HYUD T YDJUHUIIQDJ
TV DVJJRXV EV TFEKZVEK IZVE U ZEKVIVJJREK
UW EWKKSYW FW UGFLAWFL JAWF V AFLWJWKKSFL
VX FXLLTZX GX VHGMBXGM KBXG W BGMXKXLLTGM
WY GYMMUAY HY WIHNCYHN LCYH X CHNYLYMMUHN
XZ HZNNVBZ IZ XJIODZIO MDZI Y DIOZMZNNVIO
YA IAOOWCA JA YKJPEAJP NEAJ Z EJPANAOOWJP
ZB JBPPXDB KB ZLKQFBKQ OFBK A FKQBOBPPXKQ
AC KCQQYEC LC AMLRGCLR PGCL B GLRCPCQQYLR
BD LDRRZFD MD BNMSHDMS QHDM C HMSDQDRRZMS
CE MESSAGE NE CONTIENT RIEN D INTERESSANT
DF NFTTBHF OF DPOUJFOU SJFO E JOUFSFTTBOU
EG OGUUCIG PG EQPVKGPV TKGP F KPVGTGUUCPV
FH PHVVDJH QH FRQWLHQW ULHQ G LQWHUHVVDQW
GI QIWWEKI RI GSRXMIRX VMIR H MRXIVIWWERX
HJ RJXXFLJ SJ HTSYNJSY WNJS I NSYJWJXXFSY
IK SKYYGMK TK IUTZOKTZ XOKT J OTZKXKYYGTZ
JL TLZZHNL UL JVUAPLUA YPLU K PUALYLZZHUA
KM UMAAIOM VM KWVBQMVB ZQMV L QVBMZMAAIVB
LN VNBBJPN WN LXWCRNWC ARNW M RWCNANBBJWC
MO WOCCKQO XO MYXDSOXD BSOX N SXDOBOCCKXD
NP XPDDLRP YP NZYETPYE CTPY O TYEPCPDDLYE
OQ YQEEMSQ ZQ OAZFUQZF DUQZ P UZFQDQEEMZF
PR ZRFFNTR AR PBAGVRAG EVRA Q VAGRERFFNAG
QS ASGGOUS BS QCBHWSBH FWSB R WBHSFSGGOBH
RT BTHHPVT CT RDCIXTCI GXTC S XCITGTHHPCI

Le message décodé est : CE MESSAGE NE CONTIENT RIEN D INTERESSANT

Exercice 9

La conjecture de Syracuse (ou de Collatz)

QUESTION 1

def suivant(n):
    if n % 2 == 0:
        return n // 2
    else:
        return 3 * n + 1

QUESTION 2

def syracuse(n):
    while n != 1:
        print(n, end=" → ")
        n = suivant(n)
    print(1)  # Dernier terme

syracuse(7)

7 → 22 → 11 → 34 → 17 → 52 → 26 → 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1

syracuse(50)

50 → 25 → 76 → 38 → 19 → 58 → 29 → 88 → 44 → 22 → 11 → 34 → 17 → 52 → 26 → 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1

Exercice 10

QUESTION 1

def temps_de_vol(n):
    compteur = 0
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        compteur += 1
    return compteur

temps_de_vol(7)

16

Autre version

def temps_de_vol(n):
    compteur = 0
    while n != 1:
        n = suivant(n)
        compteur += 1
    return compteur

temps_de_vol(7)

16

QUESTION 2

def temps_max(nmax):
    max_temps = 0
    for i in range(1, nmax + 1):
        t = temps_de_vol(i)
        if t > max_temps:
            max_temps = t
    print(f"Temps de vol maximal entre 1 et {nmax} : {max_temps}")

temps_max(7)

Temps de vol maximal entre 1 et 7 : 16

temps_max(50)

Temps de vol maximal entre 1 et 50 : 111

QUESTION 3

def temps_max(nmax):
    max_temps = 0
    meilleur_depart = 1
    for i in range(1, nmax + 1):
        t = temps_de_vol(i)
        if t > max_temps:
            max_temps = t
            meilleur_depart = i
    print(f"Le plus grand temps de vol est {max_temps}, obtenu avec le nombre de départ {meilleur_depart}.")

temps_max(7)

Le plus grand temps de vol est 16, obtenu avec le nombre de départ 7.

temps_max(50)

Le plus grand temps de vol est 111, obtenu avec le nombre de départ 27.

Autres exercices sur les fonctions

Exercice 3

# Version 1
def plus_grand_1(a, b, c):
    """
    Détermine le plus grand de trois nombres
    @param a: (float) nombre réel 
    @param b: (float) nombre réel
    @param c: (float) nombre réel
    @return: (float) la fonction renvoie le plus grand des trois nombres a, b et c

    """
    if a > b:
        if a > c:
            return a
        else:
            return c
    else:
        if b > c:
            return b
        else:
            return c
        

# Version 2
def plus_grand_2(a, b, c):
    """
    Détermine le plus grand de trois nombres
    @param a: (float) nombre réel 
    @param b: (float) nombre réel
    @param c: (float) nombre réel
    @return: (float) la fonction renvoie le plus grand des trois nombres a, b et c

    """
    if a > b and a > c:
        return a
    elif b >= a and b > c:
        return b
    else:
        return c

plus_grand_1(-12, 21, 3)

21

plus_grand_2(-12, 21, 3)

21

Exercice 4

def carre(k):
    """
    Calcul la somme des k premiers carrés non nul
    @param k: (int) nombre entier strictement positif
    @return: (int) la somme des carrés
    """
    assert k > 0 and isinstance(k, int),"Vous devez entrer un entier strictement positif"
    somme = 0
    for i in range(1, k+1): # On commence à 1, premiers carrés non nul
        somme = somme + i**2
    return somme

carre(-2)

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
<ipython-input-7-b85394d1dfe2> in <module>
----> 1 carre(-2)

<ipython-input-6-b096026e4c7e> in carre(k)
      5     @return: (int) la somme des carrés
      6     """
----> 7     assert k > 0 and isinstance(k, int),"Vous devez entrer un entier strictement positif"
      8     somme = 0
      9     for i in range(1, k+1): # On commence à 1, premiers carrés non nul

AssertionError: Vous devez entrer un entier strictement positif

carre(3.5)

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
<ipython-input-8-6807518ab331> in <module>
----> 1 carre(3.5)

<ipython-input-6-b096026e4c7e> in carre(k)
      5     @return: (int) la somme des carrés
      6     """
----> 7     assert k > 0 and isinstance(k, int),"Vous devez entrer un entier strictement positif"
      8     somme = 0
      9     for i in range(1, k+1): # On commence à 1, premiers carrés non nul

AssertionError: Vous devez entrer un entier strictement positif

carre(12)

650

Exercice 5 Diviseurs

QUESTION 1

def somme_diviseurs(n):
    """
    Calcul la somme des diviseurs d'un entier naturel
    @param n: (int) nombre entier strictement positif
    @return: (int) la somme des diviseurs de cet entier
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier strictement positif"
    somme = 0
    for i in range(1, n+1): # On commence à 1, premiers carrés non nul
        if n % i == 0:
            somme = somme + i
    return somme

somme_diviseurs(6)

12

QUESTION 2

def parfait(n):
    """
    Détermine si un entier naturel est parfait
    @param n: (int) nombre entier strictement positif
    @return: (bool) retourne True si le nombre est parfait, sinon False
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier naturel non nul"
    if somme_diviseurs(n) == 2 * n:
        return True
    else:
        return False

# Une autre version

def parfait_bis(n):
    """
    Détermine si un entier naturel est parfait
    @param n: (int) nombre entier strictement positif
    @return: (bool) retourne True si le nombre est parfait, sinon False
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier naturel non nul"
    return somme_diviseurs(n) == 2 * n

parfait(6)

True

parfait_bis(6)

True

QUESTION 3

# Nombres parfaits inférieurs à 100
for i in range(1, 100):
    if parfait(i):
        print(i)

6
28

# Nombres parfaits compris entre 100 et 1000
for i in range(100, 1000):
    if parfait(i):
        print(i)

496

# Déterminer les nombres parfaits
compt = 4
i = 1
while compt > 0:
    if parfait(i):
        print(i)
        compt = compt-1
    i= i + 1
    

6
28
496
8128

Exercice 6

from random import randint

def jeu(n):
    """
    Calcul le pourcentage de 6 obtenue sur n tirages aléatoires
    @param n: (int) nombre entier strictement positif
    @return: (float) le pourcentage de 6 obtenu
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier strictement positif"
    nombre_6 = 0
    for i in range(n):
        if randint(1, 6) == 6:
            nombre_6 = nombre_6 + 1
    return 100 * nombre_6 / n
print(jeu(1000))

16.8

Chaîne de Caractères

Exercice 7

Ecrire une fonction double qui prend en argument un mot (type str) et renvoie le mot obtenu en doublant chaque lettre.

Par exemple double("bon") a pour valeur "bboonn"

def double(mot):
    chaine = ""
    for lettre in mot:
        chaine = chaine + 2*lettre
    return chaine

double('bon')

'bboonn'

Exercice 8

QUESTION 1

# version 1
def occurence(c, mot):
    for lettre in mot:
        if lettre == c:
            return True
    return False
occurence("a", "cheval")

True

# version 2
def occurence2(c, mot):
    for i in range(len(mot)):
        if mot[i] == c:
            return True
    return False

occurence2("f", "cheval")

False

# Version 3 
def occurence3(c, mot):
    if c in mot:
            return True
    return False

occurence3("v", "cheval")

True

# Version 4

def occurence4(c, mot):
    return c in mot

occurence4("h", "cheval")

True

QUESTION 2

# Version 1

def occurence(c, mot):
    for i in range(len(mot)):
        if mot[i] == c:
            return i
    return -1

occurence("u", "cheval")

-1

# version 2

def occurence2(c, mot):
    for lettre in mot:
        if lettre == c:
            return mot.index(lettre)
    return -1

occurence2("e", "cheval")

2

# version 3

def occurence3(c, mot):
    if c in mot:
            return mot.index(c)
    return -1

occurence3("v", "cheval")

3

# version 4

def occurence4(c, mot):
    for i,lettre in enumerate(mot):
        if lettre == c:
            return i
    return -1

occurence("c", "cheval")

0

Exercice 9

# version 1

def reverso(mot):
    """
    Inverse l'ordre d'une chaîne de caractères
    paramètre:
        mot : (str) chaîne de caractères
    retour:
        chaîne de caractères
    """
    
    resultat = ""
    for lettre in mot :
        resultat = lettre + resultat
    return resultat

# Jeu d'essai
print("Pass test1 --> ",reverso("")=="")
print("Pass test2 --> ",reverso("a")=="a")
print("Pass test3 --> ",reverso("bonjour")=="ruojnob")
print("Pass test4 --> ",reverso("aa")=="aa")
print("Pass test5 --> ",reverso("laval")=="laval")

Pass test1 -->  True
Pass test2 -->  True
Pass test3 -->  True
Pass test4 -->  True
Pass test5 -->  True

# version 2

def reverso2(mot):
    return mot[::-1]

# Jeu d'essai
print("Pass test1 --> ",reverso2("")=="")
print("Pass test2 --> ",reverso2("a")=="a")
print("Pass test3 --> ",reverso2("bonjour")=="ruojnob")
print("Pass test4 --> ",reverso2("aa")=="aa")
print("Pass test5 --> ",reverso2("laval")=="laval")

Pass test1 -->  True
Pass test2 -->  True
Pass test3 -->  True
Pass test4 -->  True
Pass test5 -->  True

Exercice 10
palindrome

# Une solution possible

def palindrome(mot):
    test = False
    if reverso(mot) == mot and mot !="":
        test = True
    return test
      
# Jeu d'essai
print("Pass test1 --> ",palindrome("") == False)
print("Pass test2 --> ",palindrome("a") == True)
print("Pass test3 --> ",palindrome("bonjour") == False)
print("Pass test4 --> ",palindrome("aa") == True)
print("Pass test5 --> ",palindrome("laval") == True)

Pass test1 -->  True
Pass test2 -->  True
Pass test3 -->  True
Pass test4 -->  True
Pass test5 -->  True

palindrome("bonjour")

False