NSI Première

Exercices Récapitulatifs évalués

Correction

Le travail ci-dessous est à faire en binôme.

Ne pas utiliser les commandes natives de python

Exercice 1

Écrire une fonction qui ajoute un entier à chaque élément d’une liste.
La liste et le nombre à ajouter seront passés en paramètres.

Exemple d’exécution :
liste de départ : L = [1, 2, 3, 4, 5]
nombre à ajouter : 3
affichage : [4, 5, 6, 7, 8]

In [1]:
# solution 1 
# Avec les indices, on modifie la liste originale

def ajoute(liste, nombre):
    long = len(liste)
    for i in range(long):
        liste[i] = liste[i] + nombre
    return liste

L = [1, 2, 3, 4, 5]
n = 3
ajoute(L, n)
Out[1]:
[4, 5, 6, 7, 8]
In [3]:
# solution 2
# Parcours par éléments. Création d'une autre liste

def ajoute (liste,nombre):
    nouvelle_liste = [] 
    for element in liste:
        nouvelle_liste.append(element + nombre)
    return nouvelle_liste

L = [1, 2, 3, 4, 5]
n = 3
ajoute(L, n)
Out[3]:
[4, 5, 6, 7, 8]
In [4]:
# solution 3
# Parcours par compréhention. Création d'une autre liste

def ajoute (liste,nombre):
    return [element + nombre for element in liste]

L = [1, 2, 3, 4, 5]
n = 3
ajoute(L, n)
Out[4]:
[4, 5, 6, 7, 8]

Exercice 2

Écrire une fonction qui renvoie sous forme de tuple les chiffres d’un nombre entier positif passé en paramètre.

Exemple d’exécution :
nombre de départ : n = 123456
affichage : (1, 2, 3, 4, 5, 6)

In [6]:
# solution 1 
# Avec une boucle sur les tuples

def renvoie_tuple(nombre):
    nombre = str(nombre)
    tuple_tmp = ()
    for chiffre in nombre:
        tuple_tmp = tuple_tmp + (int(chiffre),)
    return tuple_tmp

n = 123456
renvoie_tuple(n)
Out[6]:
(1, 2, 3, 4, 5, 6)
In [7]:
# solution 2 
# Avec une ecriture en compréhention et la commande tuple

def renvoie_tuple(nombre):
    return tuple(int(chiffre) for chiffre in str(nombre))

n = 123456
renvoie_tuple(n)
Out[7]:
(1, 2, 3, 4, 5, 6)

Exercice 3

Écrire une fonction qui renvoie un entier dont les chiffres sont passés en paramètre sous forme de tuple

Exemple d’exécution :
tuple de départ : t = (1, 2, 3, 4, 5, 6)
affichage : 123456

In [12]:
# solution 1 
# Avec une boucle sur un tuple et utilisation d'une chaine de caractères

def renvoie_entier(Tuple):
    nombre = ''
    for valeur in Tuple:
        nombre += str(valeur)
    return int(nombre)

t = (1, 2, 3, 4, 5, 6)
renvoie_entier(t)
Out[12]:
123456
In [13]:
# solution 2 
# Avec une boucle sur un tuple et utilisation des entiers

def renvoie_entier(Tuple):
    nombre = 0
    for element in Tuple:
        nombre = nombre * 10 + element
    return nombre

t = (1, 2, 3, 4, 5, 6)
renvoie_entier(t)
Out[13]:
123456

Exercice 4

Écrire une fonction qui attend deux listes d’entiers L1 et L2 passées en paramètre et qui retourne la concatènation de ces deux listes, sans doublons.

Exemple d'execution: si L1 = [13, 15, 12, 17, 15 ] et L2 = [18, 15, 14, 13, 19, 20] alors le programme crée la liste L3 = [13, 15, 12, 17, 18, 14, 19, 20] et l’affiche.

In [14]:
# solution 1

def concatenation(L1, L2):
    liste = []
    for entier in L1:
        if entier not in liste:
            liste.append(entier)
    for entier in L2:
        if entier not in liste:
            liste.append(entier)
    return liste

L1 = [13, 15, 12, 17, 15 ]
L2 = [18, 15, 14, 13, 19, 20]
L3 = concatenation(L1, L2)
L3
Out[14]:
[13, 15, 12, 17, 18, 14, 19, 20]
In [15]:
# solution 2

def concatenation_bis(L1, L2):
    L = L1 + L2
    liste = []
    for entier in L:
        if entier not in liste:
            liste.append(entier)
    return liste

L1 = [13, 15, 12, 17, 15 ]
L2 = [18, 15, 14, 13, 19, 20]
L3 = concatenation_bis(L1, L2)
L3
Out[15]:
[13, 15, 12, 17, 18, 14, 19, 20]
In [ ]: