Aller au contenu principal

TP - Révisions

Au préalable
  1. Se créer un dossier Terminale NSI sur votre ordinateur ou clé USB
  2. Dans ce dossier, créer un dossier Rappel

Sur EduPython ou autre instance python, faire :

  1. Créer un nouveau fichier en cliquant sur l'icône 📄, ou en appuyant sur CTRL+N
  2. Enregistrer le fichier sous le nom TP_Rappel en cliquant sur l'icône 💾, ou en appuyant sur CTRL+S
TP

L'ensemble des exercices se fait sur python.

Échauffement​

Exercice 1 : Somme​

Écrire une fonction somme(n) qui retourne, à partir d'un entier positif n, la somme des n + (n-1) + (n-2) + ... + 0.

def somme(n) :
    """
    Renvoie la somme des n + (n-1) + (n-2) + ... + 0
    """

Exercice 2 : Maximum​

Écrire une fonction maximum(a,b) qui prend 2 entiers a et b, et retourne l'entier le plus grand.

def maximum(a,b) :
    """
    Renvoie le maximum entre a et b
    """

Exercice 3 : Une puissance​

Écrire une fonction puissance(a,b) qui prend en paramètre 2 entiers, et retourne ab.

def puissance(a,b) :
    """
    Renvoie a^b
    """

Exercice 4 : Une factorielle​

Écrire une fonction factorielle(n) qui retourne, à partir d'un entier positif n, la factorielle de ce nombre. On rappelle que la factorielle d'un nombre n correspond à l'opération suivante : n * (n-1) * (n-2) * ... * 1.

def factorielle(n) :
    """
    Renvoie la factorielle du nombre n
    """

Exercice 5 : Suite de Fibonacci​

La suite de Fibonacci est une suite mathématique définie comme suit :
A l'initialisation, F0 = 0;
A la première étape, F1 = 1;
A l'étape n, Fn = Fn-1 + Fn-2, pour n > 1.
Écrire une fonction Fibonacci(n), qui pour un entier n > 1, retourne le nombre de la n-ième valeur de la suite de Fibonacci.

def fibonacci(n) :
    """
    Renvoie le nieme terme de la suite de Fibonacci
    """

Listes​

Exercice 1 : Somme d'éléments​

Écrire une fonction somme(l) qui prend une liste en entrée et retourne la somme des éléments la composant.

def somme(l) :
    """
    Renvoie la somme des éléments de la liste
    """

Exercice 2 : Maximum​

Écrire une fonction maximum(l) qui prend une liste en entrée et retourne le plus grand des éléments la composant.

def maximum(l) :
    """
    Renvoie le plus grand des éléments de la liste
    """

Exercice 3 : Echange​

Écrire une fonction echange(l, i, j) qui prend une liste en entrée et échange la place des éléments i et j.

def echange(l,i,j) :
    """
    Échange les éléments i et j de la liste
    """

Exercice 4 : Recherche​

Écrire une fonction recherche(l,i) qui prend une liste en entrée et retourne vrai si l'élément i existe dans la liste l, faux sinon.

def recherche(l,i) :
    """
    Renvoie vrai si l[i] existe, faux sinon
    """

Exercice 5 : Miroir​

Écrire une fonction miroir(l) qui prend une liste en entrée et retourne une liste dont les éléments sont inversés : le dernier devient premier etc...

def miroir(l) :
    """
    Renvoie la liste miroir de celle en paramètre
    """

Exercice 6 : Palindrome​

Écrire une fonction palindrome(mot) qui prend un mot en entrée (chaine de caractères) et retourne vrai si le mot est un palindrome, faux sinon. Un mot est un palindrome s'il peut se lire dans les 2 sens, exemple : kayak.

def palindrome(mot) :
    """
    Renvoie vrai si le mot en paramètre est un palindrome, faux sinon
    """

Dictionnaires​

Exercice 1 : Pokémon​

Les pokémons sont des créatures issues du jeu vidéo éponyme. Dans ce jeu, le pokédex représente un outil permettant de recenser les différentes espèces de pokémons. On définit un pokémon par un numéro représentant son entrée dans le pokédex, son nom, sa taille et son poids.
La mascotte du jeu, Pikachu, sera représenté comme suit :
{"identifiant":25, "nom":"pikachu", "taille":0.4, "poids":6}.

Écrire une fonction entree_pokemon(id, nom, taille, poids) qui prend pour id un entier, pour nom une chaine de caractère, pour taille et poids un réel, et qui renvoie un dictionnaire associé.

def entree_pokemon(id,nom,taille,poids) :
    """
    Renvoie un dictionnaire associé à l'identifiant du pokémon correspondant au nom, ainsi que sa taille et son poids
    """

Exercice 2 : Pokédex​

L'exercice 1 nous a fait créer des entrées de type dictionnaire pour chaque pokémon. Nous allons maintenant modéliser le pokédex, un dictionnaire recoupant les informations de chaque espèce de pokémon. Le pokédex aura ainsi cette forme :
{25: ["pikachu", 0.4, 6], 4: ["salamèche", 0.6, 8.5], ...}
Écrire une fonction entree_pokedex(pokedex, pokemon) qui prend un dictionnaire en entrée (le pokédex avec des informations ou non), ainsi qu'un dictionnaire d'un pokémon, et renvoie le dictionnaire du pokédex avec les informations du dictionnaire du pokémon en entrée.

Attention

Les clés du dictionnaire du pokédex correspondent à l'id clé du dictionnaire pokémon, et la valeur associée à la clé dans le pokédex est une liste comportant le nom, la taille et le poids.
Exemple : le pokémon {"id":25, "nom":"pikachu", "taille":0.4, "poids":6} deviendra dans le pokédex : {25 :["pikachu", 0.4, 6]}.

def entree_pokedex(pokedex, pokemon) :
    """
    Prend en entrée 2 dictionnaires : pokedex et pokemon
    Renvoie le dictionnaire pokedex avec les informations du pokemon en entrée
    """