NSI Première

Correction

Sans Machine

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

In [ ]:
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 ?

In [2]:
x = 1
n = 5
while n > 1:
    x = x * n
    n = n - 1
In [3]:
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 ?

In [4]:
x = 0
for i in range(2):
    x = x + i
    for j in range(3):
        x = x + j
In [5]:
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
On sort de la boucle
Donc x = 7

Exercice 3

In [6]:
# Une solution possible

def somme(nombre1, nombre2, nombre3):
    """
    La fonction calcule la somme de trois nombres données en paramètre
    @param nombre1: (float) nombre réel 
    @param nombre2: (float) nombre réel
    @param nombre3: (float) nombre réel
    @return: (float) la fonction renvoie la somme des nombres nombre1, nombre2 et nombre3
    """
    return nombre1 + nombre2 + nombre3

# Jeu d'essai
print("Pass test1 --> ",somme(1, 5, 7) == 13)
print("Pass test2 --> ",int(somme(1.2, -6, 5)*10) == 2)

Pass test1 -->  True
Pass test2 -->  True

Exercice 4

In [8]:
def plus_grand(a, b):
    """
    Détermine le plus grand de deux nombres
    @param a: (float) nombre réel 
    @param b: (float) nombre réel
    @return: (float) la fonction renvoie le plus grand des deux nombres a et b

    """
    if a > b:
        return a
    else:
        return b 
plus_grand(-12, 21)
Out[8]:
21

Exercice 5

In [9]:
# Version 1
def plus_grand_bis_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_bis_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
In [10]:
plus_grand_bis_1(-12, 21, 3)
Out[10]:
21
In [11]:
plus_grand_bis_2(-12, 21, 3)
Out[11]:
21

Exercice 6

In [12]:
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
In [13]:
a = 3.5
type(a) # permet d'avoir le type d'une variable
Out[13]:
float
In [14]:
type(a)== float
Out[14]:
True
In [15]:
carre(-2)

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

<ipython-input-12-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
In [16]:
carre(3.5)

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

<ipython-input-12-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
In [17]:
carre(12)
Out[17]:
650

Exercice 7 Diviseurs

QUESTION 1

In [18]:
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
In [19]:
somme_diviseurs(6)
Out[19]:
12

QUESTION 2

In [20]:
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
In [21]:
parfait(6)
Out[21]:
True
In [22]:
parfait_bis(6)
Out[22]:
True

QUESTION 3

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

6
28
In [14]:
# Nombres parfaits compris entre 100 et 1000
for i in range(100, 1000):
    if parfait(i):
        print(i)

496
In [14]:
# 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 8

In [5]:
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.7

Chaîne de Caractères

Exercice 9

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"

In [24]:
def double(mot):
    chaine = ""
    for lettre in mot:
        chaine = chaine + 2*lettre
    return chaine
In [25]:
double('bon')
Out[25]:
'bboonn'

Exercice 10

  1. Ecrire une fonction identique qui prend en argument un mot (type str) et renvoie True si le mot commence et se termine par la même lettre et False sinon.
  2. Ecrire une fonction double_identique qui prend en argument deux mots (type str) et renvoie True si les deux mots commencent par la même lettre et se terminent par la même lettre et False sinon.

In [26]:
# Question 1
def identique(mot):
    if mot[0] == mot[-1]:
        return True
    else:
        return False
In [27]:
identique('laval')
Out[27]:
True
In [28]:
identique('Maison')
Out[28]:
False
In [29]:
# Question 2
def double_identique(mot1, mot2):
    if (mot1[0] == mot2[0]) and (mot1[-1] == mot2[-1]):
        return True
    else:
        return False
In [31]:
double_identique("portez", "profitez")
Out[31]:
True

Exercice 11

QUESTION 1

In [13]:
# version 1
def occurence(c, mot):
    for lettre in mot:
        if lettre == c:
            return True
    return False
occurence("a", "cheval")
Out[13]:
True
In [16]:
# version 2
def occurence2(c, mot):
    for i in range(len(mot)):
        if mot[i] == c:
            return True
    return False

occurence2("f", "cheval")
Out[16]:
False
In [17]:
# Version 3 
def occurence3(c, mot):
    if c in mot:
            return True
    return False

occurence3("v", "cheval")
Out[17]:
True
In [18]:
# Version 4

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

occurence4("h", "cheval")
Out[18]:
True

QUESTION 2

In [19]:
# Version 1

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

occurence("u", "cheval")
Out[19]:
-1
In [20]:
# version 2

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

occurence2("e", "cheval")
Out[20]:
2
In [22]:
# version 3

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

occurence3("v", "cheval")
Out[22]:
3
In [23]:
# version 4

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

occurence("c", "cheval")
Out[23]:
0

Exercice 12

In [28]:
# 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
In [29]:
# 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 13
palindrome

In [31]:
# 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
In [32]:
palindrome("bonjour")
Out[32]:
False
In [ ]: