1. Python : LP1
  2. Python : LP2
  3. Python : LP3
  4. Python : DC1
  5. Python : DC2
  6. Binaire : B1
  7. Binaire : B2
  8. Binaire : B3
  9. HTML : html1
  10. Trace d'exécution : A1
  11. Tris : A3
  12. Dichotomie : A5

Page en évolution constante !

Cette page est dédiée aux exercices de début de séances : des exercices ciblés, assez courts, visant à installer des automatismes.

Vous retrouvez l'équivalent en terminale dans la section avant propos : Warmup - Automatismes .

Cette page est utile pour vous préparer à l'exercice 1 de l'épreuve pratique du baccalauréat et aux contrôles en classe de codage.

A travailler et retravailler sans modération.

Bon codage à vous !

Python : lp1

Proposer un script en python qui :

Aides possibles en cas de difficultés :

Code de déblocage de la correction :

Écrire une fonction set_pv qui prend en paramètres :

Cette fonction set_pv renvoie le nombre de points de vie restant.
Attention ! Dans ce jeu, il faut retirer de pdv les dégâts diminués de l'armure. Par exemple, Si pdv $= 20$, damage$=5$ et armor $=2$ alors pv après le combat vaut $20-5+2=17$.
Ainsi, set_pv(20, 5, 2) doit renvoyer 17.

De plus, cette fonction ne doit être utilisée que dans le cas où les dégâts sont strictement supérieurs au niveau d'armure. Ajouter une précondition pour faire respecter cette attente du jeu.

Les plus rapides peuvent préciser le typage des entrées et des sorties, documenter la fonction et rajouter des préconditions sur les types et valeurs des arguments saisis.

Aides possibles en cas de difficultés :

Voici les étapes à suivre pour réaliser le programme :

  1. Commencer par écrire l'en-tête de la fonction set_pv en n'oubliant aucun paramètre.

  2. Calculer la nouvelle valeur des points de vie en écrivant une formule liant les 3 paramètres puis stocker le résultat de ce calcul dans une variable.

  3. Renvoyer la variable contenant le résultat attendu.

  4. Après avoir testé le bon fonctionnement de la fonction, rajouter une précondition en utilisant le mot-clé assert ; le test peut porter sur le fait que les dégâts doivent être inférieurs au niveau de l'armure et/ou sur le fait que les points de vie correspondent à un nombre entier strictement positif.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def ...:
    assert ..., "Armure plus importante que les dégâts"   # précondition à rajouter en dernier
    assert type(pdv) == ... and pdv ..., "les points de vie sont un nombre entier strictement positif."
    pdv = ... # calcul du nouveau niveau de point de vie
    return ...

# test :
# sous forme d'affichage :
print(set_pv(20, 5, 2)) # comparer la valeur affichée avec 17
# par comparaison directe avec un assert :
assert(set_pv(20, 5, 2) == 17), "test ne passant pas avec set_pv(20, 5, 2)"

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

print, +, str

Écrire un scrypt affiche : "La NSI, c'est super, on apprend à coder 4h dans la semaine."

Il faudra utiliser une variable matiere contenant NSI et une variable heure qui contient 4.

Contraintes : utiliser print, + et str.

Code de déblocage de la correction :

print, +, str, input, int

Écrire un scrypt affiche : "Ton personnage à 12 pv, il vient de subir une attaque à 5 pv, il lui reste 7 pv"

Il faudra utiliser une variable pv contenant les points de vie de votre personnage et une variable damage qui contiendra la valeur de l'attaque.

Contraintes : utiliser input, et éventuellement print, +, int et str.

Code de déblocage de la correction :

fonction

Écrire une fonction decomposer_prix qui prend en paramètre un prix TTC TTC et un taux de TVA t et qui renvoie le couple (=tuple) formé du prix Hors Taxe et du montant de la TVA.

Aide : les liens entre prix TTC, prix HT et TVA sont :

Tests :

Aides possibles en cas de difficultés :

Voici les étapes à suivre pour réaliser le programme :

  1. Commencer par écrire l'en-tête de la fonction decomposer_prix en n'oubliant aucun paramètre.

  2. Calculer le prix hors-taxe $HT$ en fonction des paramètres TTC et t en manipulant la formule $TTC = HT\times\left(1+\dfrac{t}{100}\right)$.

  3. Calculer le montant ds taxes $TVA$ en fonction du paramètre TTC et de la variable HT en manipulant la formule $TTC = HT + TVA$.

  4. Renvoyer les deux variables attendues.

  5. Après avoir testé le bon fonctionnement de la fonction, les plus rapides peuvent rajouter le typage des paramètres ainsi qu'une documentation.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def ...:
    """
    Documentation à rajouter s'il reste du temps 
    """
    HT = ...
    TVA = ...
    return ... 

# premier test :
print(decomposer_prix(300, 20))
# second test :
...

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Le but est de construire une fonction qui calcule la nouvelle moyenne par rajout d'une nouvelle note coefficientée.
On note $moy$ la moyenne sur un ensemble de notes dont la somme des coefficients est $somme$.
On rajoute une note $note$ de coefficient $coeff$.
On admet que la nouvelle moyenne est donnée par la formule mathématique suivante : $new\_moy=\dfrac{moy \times somme + note \times coeff}{somme + coeff}$.

Proposer une fonction set_moyenne qui prend deux paramètres moy et somme.
Cette fonction doit demander à l'utilisateur deux informations à l'utilisateur :

Cette fonction calcule ensuite la nouvelle moyenne puis renvoie ce nombre.

Tests :

Aides possibles en cas de difficultés :

Voici les étapes à suivre pour réaliser le programme :

  1. Commencer par écrire l'en-tête de la fonction set_moyenne en n'oubliant aucun paramètre.

  2. Demander à l'utilisateur la nouvelle note puis le coefficient de cette note.

  3. Ne pas oublier d'utiliser des variables pour stocker les informations recueillies ainsi que de changer le type de ces informations pour pouvoir effectuer des calculs avec, sachant que les notes peuvent être des nombres à virgule.

  4. Calculer la nouvelle moyenne en utilisant la formule mathématique : $new\_moy=\dfrac{moy \times somme + note \times coeff}{somme + coeff}$.

  5. Renvoyer la valeur de la nouvelle moyenne.

  6. Après avoir testé le bon fonctionnement de la fonction, les plus rapides peuvent rajouter le typage des paramètres ainsi qu'une documentation.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et des tests proposés ci-dessus.

def ...
    note = ...  # saisie de la note par l'utilisateur
    note = ...  # transtypage sous forme d\'un flottant
    coeff = ... # saisie et transtypage en une seule étape du coefficient
    ...         # calcul de la nouvelle moyenne 
    return ...  # renvoi de la nouvelle moyenne 

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Les plus rapides peuvent :

Code de déblocage de la correction :

Le but de proposer un script qui permet de connaître le volume d'un cylindre.
On rappelle la formule d'un cylindre de hauteur $h$ et de base de rayon $r$ : $Volume=\pi\times\ r^2\times h$.

Proposer un algorithme qui :

Tests :

  • La valeur de $\pi$ avec 30 décimales est $\pi\approx 3.14159265358979323846264338379$.

  • la fonction round(valeur, nb_decimales) qui renvoie le nombre valeur arrondi au nombre décimal le plus proche, nombre décimal ayant au plus nb_decimales chiffres derrière la virgule.
    Exemple : round(3.14159, 3) renvoie 3.142.

Aides possibles en cas de difficultés :

Voici les étapes à suivre pour réaliser le programme :

  1. Commencer par demander à un utilisateur de saisir la précision attendue de $\pi$ pour les calculs.

  2. penser à utiliser une variable pour stocker l'information et à la transtyper pour pouvoir l'utiliser dans des calculs mathématiques.

  3. Commencer par écrire l'en-tête de la fonction volume_cylindre en n'oubliant aucun des trois paramètres.

  4. Utiliser la fonction round pour arrondir $\pi$ avec la précision attendue (cf. coup de pouce attaché à cet exercice)

  5. Calculer le volume en utilisant la formule mathématique : $Volume=\pi \times r^2\times h$.

  6. Renvoyer la valeur du volume.

  7. Tester le bon fonctionnement du script.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et des tests proposés ci-dessus.

precis = ...

def ...:
    pi = round(3.14159265358979323846264338379, ...)
    volume = ...
    return ...

# tests
print(volume_cylindre(15, 8, ...)) # saisir 3 comme precision
print(volume_cylindre(10, 2, ...)) # saisir 8 comme précision

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Les plus rapides peuvent :

Code de déblocage de la correction :

Python : lp2

Écrire une fonction survivre(pdv, armor, damage) qui prend 3 entiers positifs ou nul en argument et renvoie un booléen True si pdv>0 et False sinon.

Pour ce jeu, on rappelle que pour déterminer les nouveaux points de vie, il faut retirer de pdv les dégâts diminués de l'armure. Si pdv = 20, damage =5 et armor =2 alors pdv après le combat vaut 20-5+2=17.

Ajouter un assert qui vérifie que les damage sont supérieur à l'armor.

Par exemple : survivre(15, 12, 20) renvoie True.

Par exemple : survivre(15, 12, 45) renvoie False.

Par exemple : survivre(15, 12, 5) provoque un message d'erreur.

Code de déblocage de la correction :

Un personnage d'un jeu vidéo dispose de plusieurs outils. Chaque outil possède un pourcentage d'usure et certains sont réparables. Un objet réparable ayant un pourcentage d'usure d'au moins 80% doit être réparé.
Proposer une fonction a_reparer qui prend en paramètre :

Cette fonction renvoie un booléen : True signifiant que l'outil est à réparer, False signifiant le contraire.

Vérifier entre autres que :

Les plus rapides peuvent préciser le typage, rajouter des préconditions sur les arguments puis une documentation.

Code de déblocage de la correction :

Un combattant de votre jeu possède un score_combattant défini par la fonction modification_score(score_vie,score_dommage,nombre_armes) qui possède les paramètres suivants :

Cette fonction renvoie deux informations (un tuple) :

Coder cette fonction et faire des tests. Ajouter des assert pour les préconditions et un docstring pour documenter votre fonction

Exemples de tests :

Code de déblocage de la correction :

Dans un jeu vidéo, le joueur peut commencer avec trois principales catégories de personnages ; chaque catégorie de personnage conduit à un niveau d'expérience exp de départ différent :

Proposer une fonction a_pour_exp ayant pour paramètre categorie une chaîne de caractères donnant la catégorie du personnage choisi et renvoyant le niveau d'expérience de départ en exp.
Faire en sorte qu'une chaîne de caractères différente de trois principales catégories conduise à une expérience nulle.

Par exemple :

Les plus rapides peuvent préciser le typage des paramètres, une précondition et une documentation.

Code de déblocage de la correction :

Vous devez coder une fonction test_variables avec trois paramètres qui sont les variables :

Votre fonction ne retourne rien, vous pouvez le coder en utilisant return None

A vous de coder des assert dans votre fonction pour tester les différentes préconditions

A vous de faire différents tests

Quelques rappels en python :

Pour les plus rapides, prenez l'habitude de documenter votre fonction avec des docstring

Code de déblocage de la correction :

Pour gérer l'interface de démarrage d'un jeu vidéo, vous avez à créer une fonction lancement.
Celle-ci est sans paramètre et va exécuter les tâches suivantes :

Code de déblocage de la correction :

fonction warning(pdv) structure conditionnelle

Créer une fonction warning avec comme paramètre un entier pdv.

Cette fonction permet de renvoyer un message :

À vous d'écrire un docstring pour commenter votre fonction et des préconditions en utilisant des assert

Code de déblocage de la correction :

fonction jeter_de(face)

Créer une fonction jeter_de avec comme paramètre un entier face.

Cette fonction renvoie un nombre aléatoire compris entre 1 et le nombre de faces (donné en argument par la variable face ) du dé

Aide python: pour obtenir un nombre aléatoire entre 1 et en python

# Obtenir et afficher un nombre aléatoire entre 1 et 6
# A tester
from random import randint
a= randint(1, 6)
print(a)  

À vous d'écrire un docstring pour commenter votre fonction et des préconditions en utilisant des assert

Code de déblocage de la correction :

fonctionelif if structure conditionnelle print + str

  1. Créer une fonction repair(usury) avec comme paramètre un entier usury entre 0 et 100 qui renvoie la valeur d'usure de l'objet après réparation dans le cas où l'objet est réparable et affiche un texte en cas de non réparabilité. Plus précisément :

    • L'usure est diminuée de 10 si celle-ci est entre 40 et 60, cette nouvelle usure est renvoyée.

    • L’usure est diminuée de 20 si celle-ci est en dessous de 40 (tout en restant un nombre positif ou nul), cette nouvelle usure est renvoyée.

    • si l'usure est au dessus de 60, pas de réparation mais un affichage "à recycler ..." précisant le niveau d'usure est attendu.

    Par exemple :
    repair(34) renvoie 14.
    repair(17) renvoie 0.
    repair(50) renvoie 40.
    repair(80) affiche "Objet à recycler, son taux d'usure étant de 80%."

  2. Pour les plus rapides : ajouter le typage des paramètres, des préconditions et une documentation.

Aides possibles en cas de difficultés :

Voici des conseils :

  1. Commencer par écrire l'en-tête de la fonction usury en précisant le seul paramètre.

  2. Traiter d'abord le cas d'une usure supérieure à 60.

  3. Traiter ensuite le cas d'une usure entre 40 et 60.

  4. Traiter ensuite le cas d'une usure entre 20 et 40.

  5. Traiter ensuite le cas d'une usure entre 0 et 20.

  6. Utiliser un elif permet d'écrire "compris entre 40 et 60" avec une seule comparaison.

  7. Après avoir testé le bon fonctionnement de la fonction, rajouter deux préconditions en utilisant le mot-clé assert ; les tests portent sur le fait que l'usure doit être un nombre entier compris entre 0 et 100.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et des tests proposés ci-dessus.

def repair(usury):
    if usury > 60:
        return ...
    elif ...
        return usury - 10
    elif ...
        return ...
    else: 
        return ...

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Python : LP3

Vous programmez un jeu vidéo.
Le personnage principal de votre jeu doit rencontrer un boss final.
Ce personnage possède un certain nombre de points de vie, nombre stocké dans une variable nommée pv.
Le boss final possède 8 points de vie.
Lors du combat final, à chaque tour du combat, le lancer d'un dé à six faces est simulé : le nombre obtenu est le nombre de points de vie perdus par le personnage principal. Cependant, le boss final perd un point de vie à chaque tour du combat.
Le combat se poursuit jusqu'à ce que soit le personnage, soit le boss n'ait plus de points de vie.
Dans le cas où le personnage et le boss n'ont plus de points de vie à l'issue du combat, le personnage perd la partie.
Compléter ci-dessous la fonction combattre qui prend en paramètre le nombre de points de vie pv du personnage au début du combat final et renvoie la chaîne de caractères "Victoire !" dans le cas où le personnage gagne le combat et la chaîne "Défaite !" dans le cas où le personnage perd la partie.

Tester aussi la fonction complétée. Vous devez entre autres obtenir les résultats suivants :

from random import randint
def combattre(pv):
    pv_boss = ...
    ... :
        perte = randint(...,...)
        pv_boss = ...
        pv = ...
    if ...:
        return "Victoire !"
    else:
        return "Défaite !"

Code de déblocage de la correction :

Compléter la fonction test_entier(l) qui prend en paramètre l une liste.

Cette fonction renvoie un booléen : True si un élément de type int est dans la liste, False sinon

Rappel : tester le code type(4) et type([1, 2, 3])

def test_entier(l):
    test= ...
    for ... in l :
        if type(elt) == ... :
            test = ...
    return test


test_entier(['ok', 2, 'pas_ok'])
            

L'exécution de l'algorithme doit renvoyer le booléen True

À vous de vérifier votre code à l'aide de la fonction test() suivante :


def test() :
    assert test_entier(['je', 2, 4]) == True
    assert test_entier(['bob', 'max', [1, 5, 4], 1]) == True
    assert test_entier([[1, 2], [3, 4]]) == False
    assert test_entier(['boby', 'Mimi']) == False
    assert test_entier([]) == False
    assert test_entier([2]) == True
    return None

test()

Faire une trace de l'algorithme avec l'exécution : test_entier(['ok', 2, 'pas_ok'])

L'utilisation de for vous semble-t-elle appropriée ?

Code de déblocage de la correction :

while

Blingbling veut ranger son tas de pièces d'or dans son coffre. Son coffre peut contenir au maximum 1000 pièces d'or.

Son tas de pièces est situé à coté de son coffre.

Il remplit son coffre par poignées allant de 3 à 8 pièces.

On veut savoir en combien de poignées, le coffre sera plein.

Les instructions suivantes renvoie un nombre aléatoire entre 8 et 25.

from random import *
print(randint(8,25))
            

Écrire une fonction nb_poignees() qui renvoie le nombre de poignées nécessaire à remplir le coffre.

Code de déblocage de la correction :

while

On génère une liste de 30 nombres aléatoires compris entre 0 et 10 par le code l =[randint(0,10) for i in range(30)]

Tester ce code afin d'afficher la liste de 30 nombres il faut penser à importer la bibliothèque random en utilisant from random import *.

À vous de modifier ce code pour obtenir une liste de 100 nombres aléatoires compris entre 10 et 30.

On écrit une fonction est_dans(l,nb = 4) avec comme paramètres l une liste et nb un entier initialisé à 4.

Cette fonction renvoie un booléen qui permet de savoir si le nombre nb est dans la liste l.

À vous de compléter cette fonction dont le code ci-dessous est incomplet :

def est_dans(l,nb = 4):
    test=False
    n=len(l) # len(l) renvoie le nombre d'éléments dans l
    i=....
    while i ... len(l):
        if l[i] == .... :
            test= ....
        i+=1
    return ....
 

A vous de tester votre fonction avec :

l =[randint(0,10) for i in range(30)]
print(l)
print(est_dans(l,5))
print(est_dans(l)) # Si vous voulez tester 4, nb est initialisé à 4

A vous de proposer des tests qui renvoient un False en jouant soit sur la construction de la liste l, soit sur la valeur de nb.

Code de déblocage de la correction :

for chaîne de caractères occurrence

Lors d'un jeu vidéo, un personnage récolte différents objets.
Ces objets sont modélisés par un caractère ; voici quelques caractères possibles avec leur signification en terme d'objet :

La succession des objets ramassés est stockée dans une chaîne de caractères.
Par exemple, la chaîne de caractères "BXOBOOXP" signifie que le personnage a successivement ramassé du bois, du vide, de l'or, du bois, de l'or, de l'or, du vide et enfin une pierre.

Compléter la fonction ci-dessous nb_ramasse(chaine, objet) avec comme paramètres chaine une chaîne de caractères représentant une succession d'objets ramassés et objet un caractère unique représentant un objet possiblement ramassé.
Cette fonction doit renvoyer le nombre d'objets objet présent dans chaine.

def nb_ramasse(chaine: str, objet: str) -> int:
    """
    chaine est une chaîne de caractères et objet est un caractère seul.
    Fonction qui renvoie le nombre de fois où le caractère objet apparaît dans chaine.
    """
    nombre = ...
    for ... :
        if ... :
            nombre = ....
    return ....
 

À vous de tester votre fonction avec :

chaine = "BXOBOOXP"
print(nb_ramasse(chaine,"O")) # doit afficher 3
print(nb_ramasse(chaine,"A")) # doit afficher 0

Pour les plus rapides, proposer des préconditions portant sur chaineet sur objet (type, valeurs possibles, ...).

Pour connaître la longueur du chaîne de caractères ch, il suffit de saisir len(ch).

Code de déblocage de la correction :

liste

Écrire la fonction nombrePlusGrandQue(l,x) qui prend en paramètres une liste l de nombres et un nombre x.

Cette fonction renvoie le dernier nombre de la liste l supérieur ou égal au nombre x. Si ce nombre n'existe pas, cette fonction renvoie None.

À vous de tester votre fonction avec :

assert nombrePlusGrandQue([1, 2, 2, 8, 3, 5, 6, 0, 10, 4], 5) == 10
assert nombrePlusGrandQue([1, 2, 2, 8, 3, 5, 6, 0, 10, 4], 12) == None
assert nombrePlusGrandQue([1, 2, 2, 8, 3, 5, 6, 0, 10, 4], 4) == 4

Code de déblocage de la correction :

while, for, input, float

  1. Écrivez une fonction en Python appelée saisir_note qui demande à l'utilisateur de saisir une note entre 0 et 20. La fonction doit continuer à demander une saisie valide jusqu'à ce que l'utilisateur entre une note correcte.
  2. Définissez une fonction nommée calculer_moyenne qui prend en paramètre le nombre de notes à saisir, utilise la fonction saisir_note pour obtenir ces notes, puis calcule et renvoie la moyenne de ces notes.

Code de déblocage de la correction :

liste

Écrire la fonction nombrePlusGrandQue(l,x) qui prend en paramètres une liste l de nombres et un nombre x.

Cette fonction renvoie le dernier nombre de la liste l supérieur ou égal au nombre x. Si ce nombre n'existe pas, cette fonction renvoie None.

À vous de tester votre fonction avec :

assert nombrePlusGrandQue([1, 2, 2, 8, 3, 5, 6, 0, 10, 4], 5) == 10
assert nombrePlusGrandQue([1, 2, 2, 8, 3, 5, 6, 0, 10, 4], 12) == None
assert nombrePlusGrandQue([1, 2, 2, 8, 3, 5, 6, 0, 10, 4], 4) == 4

Code de déblocage de la correction :

for, if, else

votre clavier est défaillant, la touche * n'est plus fonctionnelle.
Pour résoudre ce problème, vous décidez de créer une fonction multiplier qui prend en paramètres deux entiers a et b et qui renvoie la valeur de leur produit $a\times b$ en n'ayant effectué que des additions et des inversions de signes.

  1. Proposer la fonction multiplier demandée dans le cas où le premier argument a est un entier naturel (c'est-à-dire positif ou nul).

    Tests possibles :

    >>>multiplier(4, 5)
    20 
    >>>multiplier(2, -3)
    -6 
    >>>multiplier(0, 10)
    0 
  2. Augmenter le script réalisé pour que la fonction prenne aussi le cas où le premier argument a est strictement négatif.

    >>>multiplier(-4, 5)
    -20 
    >>>multiplier(-7, -3)
    21 
    >>>multiplier(-3, 0)
    0 
Aides possibles en cas de difficultés :

Voici des conseils :

  1. Commencer par écrire l'en-tête de la fonction multiplier en précisant les deux paramètres.

  2. Dans le cas où $a\ge 0$, remarquer que $a\times b=\underbrace{b+...+b}_{a\text{ fois}}$.

  3. Utiliser une variable stockent les additions successives.

  4. Utiliser une boucle for pour effectuer les a additions de b.

  5. Pour traiter le cas négatif, utiliser une structure conditionnelle.

  6. Remarquer que si $a\le 0$ alors $-a\ge 0$ et que l'on peut reproduire la démarche du cas positif avec $-a$.

  7. Remarquer que si $a\le 0$, $a\times b=-[(-a)\times b]$.

  8. Tester le bon fonctionnement de la fonction à l'aide des tests proposés.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et des tests proposés ci-dessus.

def multiplier(a: int, b: int) -> int:
    if ...:
        resultat = ...
        for i in range(...):
            resultat = resultat + ...
        return ...
    else: # cas où a<0
        a = ...
        resultat = ...
        for i in range(...):
            resultat = resultat + ...
        resultat = ...
        return resultat
    
print(multiplier(4, 5))
print(multiplier(2, -3))
print(multiplier(0, 10))
print(multiplier(-4, 5))
print(multiplier(-7, -3))
print(multiplier(-3, 0))

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Compléter la fonction vois_voyelles qui prend en paramètre une chaîne de caractères texte et qui renvoie une chaîne de caractères dans laquelle toutes les voyelles du texte saisi comme argument par le caractère "😜". Comme cet emoji a pour code Unicode U+1F61C, d'après le site officiel, il peut donc être obtenu en Python avec "\U0001f61c".

def vois_voyelles(texte: str) -> str:
    ensemble_voyelles = ...
    texte_modifie = ...
    for lettre ...:
        if lettre.lower() ...:      # .lower() sert à mettre en minuscule le caractère lettre
            texte_modifie = ...
        else:
            texte_modifie = ...
    return ...

Voici un exemple d'utilisation de la fonction :

>>>blague = "Pourquoi les plongeurs plongent-ils toujours en arrière ? Euh ? Eh bien, parce que sinon ils tombent encore dans le bateau ! Ah!"
print(vois_voyelles(blague))
P😜😜rq😜😜😜 l😜s pl😜ng😜😜rs pl😜ng😜nt-😜ls t😜😜j😜😜rs 😜n 😜rr😜èr😜 ? 😜😜h ? 😜h b😜😜n, p😜rc😜 q😜😜 s😜n😜n 😜ls t😜mb😜nt 😜nc😜r😜 d😜ns l😜 b😜t😜😜😜 ! 😜h!
 

Code de déblocage de la correction :

Python : dc1

Un personnage d'un jeu vidéo accumule des points lors de différentes parties, points stockés dans une liste points.
Proposer une fonction sommer_points qui prend en paramètre une liste de nombres entiers et qui renvoie la somme de tous ces nombres entiers.

Par exemple :

points = [4, 17, 2, 12, 34, 8]
sommer_points(points)

renvoie 77.

Code de déblocage de la correction :

Les scores obtenu par un personnage de jeu vidéo sont sauvegardés dans une liste resultats.
Proposer une fonction meilleur_score qui prend en paramètre une liste de nombres entiers, sensés correspondre aux scores obtenus par le personnage, et qui renvoie le plus grand des nombres entiers de cette liste.

Tester la fonction obtenue en vérifiant que pour resultats = [45, 78, 59, 21, 84, 68, 72, 53, 60, 65], meilleur_score(resultats) renvoie 84.

Code de déblocage de la correction :

Une joueuse de jeu vidéo a obtenu différents scores au cours de parties durant une semaine ; ces scores sont stockés dans une liste scores.
Cette joueuse aimerait connaître la moyenne des scores obtenus en ne prenant en compte que les scores dépassant 100 points.
Proposer une fonction get_mean qui prend en paramètre une liste scores et qui renvoie la moyenne des valeurs dépassant 100 présentes dans cette liste.

Par exemple :

Code de déblocage de la correction :

L'ADN (Acide DésoxyriboNucléique) est une molécule présente dans la plupart des cellules des êtres vivants qui contient l'information génétique leurs permettant de se développer, de fonctionner et de se reproduire.
L'ADN est formé de deux brins enroulés l'un autour de l'autre pour former une double hélice.
Chaque brin est formé de quatre bases azotées

  • l'adénine "A",

  • la thymine "T",

  • la cytosine "C",

  • la guanine "G".

Pour que les deux brins se lient, les bases ne s’associent que par certaines paires :

  • l'adénine et la thymine s'associent ensemble,

  • la cytosine et la guanine s'associent ensemble.

Par exemple, le fragment de brin d'ADN "ACGTTA" se lie avec le fragment de brin complémentaire "TGCAAT".

Proposer une fonction second_brin_ADN qui prend en paramètre une liste brin1 formée de caractères "A", "T", "G" et "C" et qui renvoie la liste formée des caractères correspondant au brin complémentaire de brin1.
Par exemple, comme le brin d'ADN "ACGTTA" a pour complémentaire "TGCAAT", second_brin_ADN(["A", "C", "G", "T", "T", "A"]) renvoie ["T", "G", "C", "A", "A", "T"].

Pour les plus rapides : modifier la fonction obtenue de sorte qu'elle renvoie la liste ["Erreur, brin1 contient des bases non attendues !?!"] si la liste brin1 contient une autre base que "A", "T", "G" ou "C".
Par exemple, comme le brin d'ADN "ACGTTA" a pour complémentaire "TGCAAT", second_brin_ADN(["A", "B", "C"]) renvoie ["Erreur, brin1 contient des bases non attendues !?!"].

Aides possibles en cas de difficultés :

Une démarche possible :

  1. Créer par extension la liste réponse.

  2. Balayer la liste des éléments par les valeurs.

  3. À chaque itération, comparer l'élément étudié de la liste avec chacun des quatre types possibles de base azotée.

  4. Rajouter à la liste réponse la lettre de la base azotée complémentaire.

  5. Tester la fonction créée à l'aide de l'exemple proposé.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def second_brin_ADN(brin1: list) -> list:
    """
    brin1 est une liste ne contenant que les caractères "A", "T", "G" et "C" modélisant un brin d'ADN.
    Fonction qui renvoie le brin d'ADN complémentaire du brin1,
    sachant que les bases "A" et "T" sont complémentaires l'une de l'autre et "G" et "C".
    """
    # Création du brin2 par extension
    brin2 = ...
    for ...:
        if ... == "A":
            brin2.append(...)
        elif ...:
            ...
        elif ...:
            ...
        else:
            ...
    return brin2

assert second_brin_ADN(["A", "C", "G", "T", "T", "A"]) == ["T", "G", "C", "A", "A", "T"]

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Écrire une fonction split(l)l est une liste qui renvoie deux listes gauche et droite. gauche contiendra la première moitié de la liste l et droite la seconde.

split([2, 5, 7, 0, 1, 2]) renvoie [2, 5, 7], [0, 1, 2]

split([2, 5, 7, 0, 1, 2, 5]) renvoie [2, 5, 7], [0, 1, 2, 5]

Code de déblocage de la correction :

Écrire une fonction est_membre qui prend en paramètres une chaîne de caractères nom et une liste groupe dont les éléments sont des chaînes de caractères.
Cette fonction renvoie None si nom n'appartient pas à la liste mais renvoie la position de nom dans la liste groupe si cette chaîne appartient à la liste.

Voici des testes possible :
est_membre("moi", ["toi", "elle", "lui", "moi", "iel"]) renvoie 3.
est_membre("Alice", ["Bob", "Charlie", "alice", "Elie"]) renvoie None.

Aides possibles en cas de difficultés :

Une démarche possible :

  1. Balayer la liste des éléments par les positions

  2. À chaque itération, comparer l'élément de la liste étudié avec le membre recherché.

  3. Le cas du renvoi None peut être traité après le traitement du cas où le membre est présent.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def est_membre(nom: str, groupe: list):
    # Balayage des éléments de la liste par les positions
    for ...:
        # cas où l'élément considéré dans la liste correspond au membre recherché   
        if ...:
            ...    
    ...

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Lors d'une course d'endurance, chaque candidat porte un dossard. Le premier candidat inscrit porte le numéro 0, le deuxième porte le numéro 1, ainsi de suite au fil des inscriptions.
Les temps d'arrivée en seconde sont sauvegardés dans une liste temps telle que temps[i] correspond au temps mis en seconde par le candidat portant le numéro i.
Proposer une fonction plus_rapide qui prend en paramètre une liste de nombres entiers, sensés correspondre au temps mis par chaque candidat, et qui renvoie le tuple formé par le numéro de dossard du candidat le plus rapide et par le temps mis par ce cadidat.

Tester la fonction obtenue en vérifiant que pour temps = [8651, 8331, 9236, 8492, 7891, 8024, 7945, 8633, 8282], plus_rapide(temps) renvoie 4, 7891.

Aides possibles en cas de difficultés :

Une démarche possible :

  1. Créer deux variables, l'une qui contiendra progressivement le temps minimal lors de la course et la seconde le numéro de dossard correspondant à ce temps minimal.

  2. Balayer la liste des éléments par les positions.

  3. À chaque itération, comparer l'élément de la liste étudié avec le temps minimal déjà connu.

  4. Renvoyer un tuple formé de deux variables.

  5. Vérifier la fonction avec le test proposé.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def plus_rapide(lst: list) -> tuple:
    min = ... 
    pos_min = ...
    for ...: # balayage par les positions
        if ...:
            min = ...
            ...
    return ... 

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Python : dc2

Fight !

Les personnages d'un jeu sont stockés dans une structure de donnée type dict.

Les clés de ce dictionnaire sont : name, hp, ca, init,dmg

Par exemple :

perso1 = {'name' : "Gamora" , 'hp' : 32, 'ca' : 15, 'init' : 14,'dmg':8}

Un round de combat correspond à une attaque de la part des deux personnages.

Rappel : Simulation d'un dé - code à tester

import random
for _ in range(10):
    print(random.randint(1,10))
 
  1. Proposer un ou plusieurs personnage(s) implémenté(s) avec la structure de donnée proposée.
  2. Code de déblocage de la correction :

  3. Écrire une fonction round(perso1, perso2) qui renvoie les deux personnages après un round de combat.
  4. Code de déblocage de la correction :

  5. Écrire une fonction combat(perso1,perso2) qui renvoie perso1 , perso2 et le nombre de tour de jeu quand un des perso est tombé à 0 en hp.
  6. Code de déblocage de la correction :

Écrire une fonction min_max(l)l est une liste qui renvoie le dictionnaire dont les clefs sont les mots Min et Max et les valeursle minimum et le maximum de la liste l.

assert min_max([4, 10, 2, 8]) == {'Min': 2, 'Max': 10}

assert min_max([-4, -10, -12, -8]) == {'Min': -12, 'Max': -4}

Vous devez organiser vos propres tests et pourquoi pas, provoquer des erreurs

Penser à utiliser des assert pour la gestion des erreurs et des docstring pour le descriptif de votre fonction.

Pour les plus expérimentés, vous pouvez traiter le cas où la liste est vide

Code de déblocage de la correction :

Sur le réseau social "T'es_NSI", différents élèves ont posté des commentaires. Plusieurs contributeurs ont reçus des "likes", "J'aime" en français, de la part d'autres membres.

Les résultats de ces "J'aime" sont enregistrés dans un dictionnaire plebiscite dont les clés sont les noms des contributeurs des "J'aime" et la valeur associée est la liste des auteurs des commentaires pour lesquels ces contributeurs ont attribué un "J'aime".
Voici un exemple de dictionnaire :

plebiscite = {"Alice": ["Bob", "Charlie"], "Bob": ["Emir", "Fahima"], "Charlie": [], "Dmitri": ["Fahima", "Charlie"], 
              "Emir": ["Alice", "Bob", "Fahima"], "Fahima": ["Emir", "Charlie"], "Grincheux": []} 

Dans l'exemple précédent, Alice a attribué un "J'aime" à un ou des commentaires publiés par Bob et Charlie tandis que Charlie n'a attribué de "J'aime" à personne.

  1. Écrire une fonction nb_jaime qui prend en paramètre un dictionnaire likes comme décrit ci-dessus et renvoie le dictionnaire dont :

    • les clés sont les personnes présentes dans le dictionnaire likes, soit comme clé, soit dans la liste des auteurs likés,

    • la valeur associée est le nombre de personnes ayant likés un de leur commentaire.

    Vous pouvez tester votre fonction avec le fait que nb_jaime(plebiscite) doit renvoyer {'Alice': 1, 'Bob': 2, 'Charlie': 3, 'Emir': 2, 'Fahima': 3, 'Dmitri': 0, 'Grincheux': 0}.

  2. Aides possibles en cas de difficultés :

    Une démarche possible :

    1. balayer le dictionnaire likes par les clés

    2. gérer le cas d'une clé n'apparaissant pas encore dans le dictionnaire solution.

    3. balayer la liste associé à la clé.

    4. Gérer le cas d'un nom apparaissant pour la première fois comme liké.

    5. Gérer le cas d'un nom ayant déjà été liké.

    D'autres manières existent, ...
    Par exemple, effectuer un premier balayage par les clés de likes afin de créer un dictionnaire associant à chacune des personnes du réseau la valeur 0 puis balayer à nouveau le dictionnaire par les valeurs : chacune des listes obtenues est à balayer pour augmenter de 1 le nombre associé à chaque nom rencontré dans la liste.

    En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

    Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

    def nb_jaime(likes: dict)->dict:
        """
        Renvoie le dictionnaire dont les clés sont les personnes connues du réseau,
        et les valeurs le nombre de personnes qui leur ont attribué des "J'aime".
        """
        dico = ...             # dictionnaire associant à chaque membre connu du réseau le nombre de "J'aime" reçu.
        for cle in likes.keys():
            if cle ...:        # cas d'une personne n'apparaissant pas encore dans dico 
                dico[cle] = ...
            for nom in ...:    # balayage des noms de personnes ayant été likées 
                if nom ...:    # cas d'une personne n'apparaissant pas encore dans dico 
                    dico[nom] = ...
                else:
                    dico[nom] = ...
        return ...

    Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

    Code de déblocage de la correction :

  3. Écrire une fonction pertinence qui prend en paramètre un dictionnaire likes comme décrit ci-dessus et renvoie la liste des contributeurs ayant reçu le plus de "J'aime".

    Vous pouvez utiliser le renvoi de la fonction nb_jaime réalisée à la question 1.

    Vous pouvez tester votre fonction avec le fait que pertinence(plebiscite) doit renvoyer ['Charlie', 'Fahima'].

Aides possibles en cas de difficultés :

Une démarche possible :

  1. récupérer le dictionnaire associant à chaque personne le nombre de likes obtenus.

  2. balayer le dictionnaire likes

  3. gérer le cas d'une nouvelle valeur maximale

  4. Gérer le cas d'une nouvelle personne likée autant que le maximum connu.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def pertinence(likes: dict)->list:
    """
    Renvoie la liste des personnes ayant le plus reçu de "J'aime".
    """
    dico = ...       # dictionnaire associant à chaque membre connu du réseau le nombre de "J'aime" reçu.
    maxi = ...       # variable stockant le plus grand maximum trouvé
    noms = ...       # liste stockant l'ensemble des personnes le plus likées
    for cle, valeur in ...: 
        if ...:  # cas d'un nouveau maximum
            maxi = ...
            noms = ... 
        ...: # cas d'une nouvelle personne ayant reçu le plus de "J'aime" pour l'instant
            ...
    return ...

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Le groupe Queen a créé en 1975 l'album "A night at the opera" qui contient différents morceaux.
Le dictionnaire a_night_at_the_opera associe à chaque titre de morceaux la liste formée de l'auteur puis de la durée du morceau en secondes.

a_night_at_the_opera = {"Death on Two Legs (Dedicated to…)": ["Freddie Mercury", 223], 
                        "Lazing on a Sunday Afternoon": ["Freddie Mercury", 68], 
                        "I'm in Love with My Car": ["Roger Taylor", 185], 
                        "You're My Best Friend": ["John Deacon", 170],
                        "'39": ["Brian May", 205], 
                        "Sweet Lady": ["Brian May", 241], 
                        "Seaside Rendezvous": ["Freddie Mercury", 133],
                        "The Prophet's Song": ["Brian May", 497], 
                        "Love of My Life": ["Freddie Mercury", 218], 
                        "Good Company": ["Brian May", 206], 
                        "Bohemian Rhapsody": ["Freddie Mercury", 355],
                        "God Save the Queen": ["", 71]}

Proposer une fonction duree qui prend en argument un dictionnaire dico de structure comme a_night_at_the_opera et renvoie la durée totale de l'album.
print(duree(a_night_at_the_opera)) doit renvoyer le nombre $2572$.

Code de déblocage de la correction :

Recherche de fruits

Écrire un scrypt qui réalise la procédure suivante :

  1. L'utilisateur est invité à saisir un nombre de lettres.

  2. Le programme vérifie si le nombre de lettres correspond à un fruit du dictionnaire.

    • Si aucun fruit ne correspond au nombre de lettres saisi, le programme affiche un message indiquant qu'aucun fruit ne correspond.

    • Si un seul fruit correspond au nombre de lettres saisi, le programme affiche son nom.

    • Si plusieurs fruits correspondent au nombre de lettres saisi, le programme affiche leurs noms.


fruits = {
    "abricot": 7,
    "ananas": 6,
    "avocat": 6,
    "banane": 6,
    "cassis": 6,
    "cerise": 6,
    "citron": 6,
    "clémentine": 10,
    "fraise": 6,
    "framboise": 9,
    "goyave": 6,
    "grenade": 7,
    "kiwi": 4,
    "mandarine": 9,
    "mangue": 6,
    "melon": 5,
    "myrtille": 8,
    "nectarine": 9,
    "orange": 6,
    "pamplemousse": 12,
    "papaye": 6,
    "pastèque": 8,
    "pêche": 5,
    "physalis": 8,
    "pomelo": 6,
    "pomme": 5,
    "prune": 5,
    "raisin": 6,
    "tomate": 6
}

Exemples :

Entrez un nombre entier : 22
Il n'y a pas de fruit avec 22 lettres.
Entrez un nombre entier : 12
Le seul fruit avec 12 lettres est : pamplemousse.
Entrez un nombre entier : 6
Les fruits avec 6 lettres sont : ['ananas', 'avocat', 'banane', 'cassis', 'cerise', 'citron', 'fraise', 'goyave', 'mangue', 'orange', 'papaye', 'pomelo', 'raisin', 'tomate']

Consignes :

Code de déblocage de la correction :

Vous avez à gérer grâce à un programme python les stocks d'un étal de vente.
Sur cet étal, peuvent être rajoutés des éléments à vendre mais certains peuvent être retirés du fait de leur vente.
Le contenu de l'étal est stocké dans un dictionnaire qui associe à chacun nom de l'élément à vendre l'effectif de cet élément.

Par exemple, à un moment donné l'ensemble des éléments présent sur l'étal est donné par : stock = {"sandalette": 8, "short": 12, "chemisette": 9,"maillot":3}

Vous devez créer une fonction mettreAJour qui prend trois paramètres :

Cette fonction doit renvoyer le dictionnaire donnant l'ensemble des éléments présents sur l'étal.
Penser à supprimer l'association du dictionnaire une fois le dernière exemplaire d'un type d'élément vendu.

Voici des exemples d'utilisation de cette fonction afin de pouvoir la tester :

Aides possibles en cas de difficultés :

Une démarche possible :

  1. Balayer la liste des éléments à rajouter à l'étal.

  2. Gérer le cas d'un élément déjà présent dans le dictionnaire stocks.

  3. Gérer le cas d'un nouvel élément non présent dans le dictionnaire stocks.

  4. Balayer la liste des éléments à rajouter à l'étal.

  5. Gérer le cas où il reste encore au moins un élément du type considéré.

  6. Supprimer l'association du dictionnaire stocks dans le cas où il ne reste plus d'élément du type considéré.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def mettreAJour(stocks, vendus, rajouts):
    # Balayage des éléments à rajouter du stock présent sur l'étal
    # commencer par le rajout car il se peut qu'un élément initialement absent de l'étal ait été posé sur l'étal puis aussitôt vendu
    for elt in ...:
        # cas où elt correspond à un élément déjà présent sur l'étal   
        if elt in ...:
            ...    # effectif augmenté de 1  
        else:      # cas où elt correspond à un nouvel élément sur l'étal 
            stocks[elt] = ...
    
    # Balayage des éléments à retirer du stock présent sur l'étal
    for elt in ...:   
        # on suppose dans la suite que chaque élément vendu elt est bien une cle du dictionnaire stocks
        if stocks[elt] ...:    # cas où il reste encore au moins un exemplaire de l'élément à l'issue de la vente
            ...    # effectif diminué de 1
        else:
            ...    # suppression de l'association car disparition du type d'élément de l'étal puisque effectif tombé à 0
    return stocks

Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Code de déblocage de la correction :

Dans un jeu vidéo, chaque joueur gère un royaume.
Les caractéristiques de chaque royaume sont stockés dans un dictionnaire.

Voici deux dictionnaires associés à deux royaumes distincts :

Il est possible dans le jeu vidéo d'effectuer des alliances entre royaumes.
À partir de deux royaume, une alliance crée un nouveau royaume où le nombre de mines, la puissance et la population sont ajoutées et où les autres éléments possibles sont conservés.
Copier et compléter la fonction alliance ci-dessous pour qu'elle renvoie le dictionnaire associé au royaume créé par l'alliance des deux royaumes donnés en argument.

Par exemple :

def alliance(roy1: dict, roy2: dict) -> dict:
    dico = {}
    for cle, val in ...:
        dico... = ...
    for cle in ...:
        if cle not in ...:
            dico[cle] = ...
        else:
            dico[cle] = ...
    return dico

Code de déblocage de la correction :

Différents centres météos ont effectué des mesures lors de passages de dépressions atmosphériques.

L'ensemble des résultats est stocké sous forme d'un dictionnaire :

Voici un exemple de tel dictionnaire :

Der = {
        "Chantecoq": {
            "printemps": [4, 985],
            "ete": [3, 990],
            "automne": [5, 981],
            "hiver": [7, 978]
        },
        "Cornee": {
            "printemps": [3, 991],
            "ete": [1, 998],
            "automne": [3, 989],
            "hiver": [4, 984]
        },
        "Nemours": {
            "printemps": [3, 990],
            "ete": [0, 0],
            "automne": [3, 986],
            "hiver": [5, 976]
        },
        "Champaubert": {
            "printemps": [5, 984],
            "ete": [3, 994],
            "automne": [6, 980],
            "hiver": [8, 975]
        },
    }

Lecture du dictionnaire : À Chantecoq, au printemps, il y a eu 4 dépressions mesurées avec une pression moyenne sur ces 4 mesures de 985 (hectoPascals).

Rappel mathématique pour le calcul de la moyenne de toutes les mesures de Chantecoq:
La moyenne de 985, 990, 981 et 978 obtenus respectivement 4 fois, 3 fois, 5 fois et 7 fois est le résultat du calcul : $\dfrac{985\times 4+990\times 3+981\times 5+978\times 7}{4+3+5+7}$.

Pour déterminer le calcul de la moyenne de pression de toutes les dépressions mesurées sur une année sur une station donnée, une fonction incomplète a déjà été réalisée. Compléter la fonction suivante de sorte :

def moyenne_pression(mesures: dict, centre: str) -> float:
    '''Renvoie la moyenne des dépressions mesurées au niveau du lieu centre, 
    selon le dictionnaire mesures. 
    Si centre n'est pas dans le dictionnaire, la fonction renvoie None.'''
    if centre ...:
        return None
    else:
        annee = mesures[centre]        
        nb_mesures = ...
        total_pressions = ...
        for ... in annee.values():
            effectif, pression = valeurs
            nb_mesures = ...
            total_pressions = ... + ... * effectif
        return round(... / nb_mesures, 2 ) # pour arrondir à 2 décimales

Voici un jeu de tests possibles :

Code de déblocage de la correction :

Le DNS (Domain Name System) permet de faire le lien entre une adresse IP et un nom de domaine.
Par exemple l'adresse IP "31.207.36.134" correspond au site de cours ayant pour nom de domaine "monlyceenumerique.fr".

On suppose qu'un ensemble de telles associations adresse IP : nom de domaine est stocké dans un dictionnaire.
Proposer une fonction inverser_dictionnaire qui prend en paramètre un dictionnaire de telles associations et qui renvoie le dictionnaire inverse associant à chaque nom de domaine son adresse IP.

Par exemple :
Si on considère le dictionnaire IP_vers_nomDomaine :

IP_vers_nomDomaine = {
                      "31.207.36.134": "monlyceenumerique.fr",
                      "217.70.184.55": "qwant.fr",
                      "185.75.143.93": "education.gouv.fr",
                      "185.15.58.224": "wikipedia.org"
                     } 

alors la fonction construite est telle que :

>>>inverser_dictionnaire(IP_vers_nomDomaine)
{"monlyceenumerique.fr": "31.207.36.134", "qwant.fr": "217.70.184.55", "education.gouv.fr": "185.75.143.93", "wikipedia.org": "185.15.58.224"}
Aides possibles en cas de difficultés :

Une démarche possible :

  1. Créer un dictionnaire réponse vide.

  2. Balayer le dictionnaire donné comme paramètre.

  3. Rajouter l'association inversée valeur: clef dans le dictionnaire réponse voulu.

En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.

Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.

def inverser_dictionnaire(dico: dict) -> dict:
    dico_rep = ...
    for cle, valeur in ...:
        ...
    return dico_rep

Code de déblocage de la correction :

Binaire : B1

Pour gérer les connexions à un jeu vidéo, vous étudiez les adresses IP des joueurs.
Pour des raisons de sécurité, vous réduisez temporairement l'accès à votre jeu aux seul.e.s joueurs et joueuses de votre établissement.

On admet que les joueurs autorisés ont une adresse IP commençant par 192.168.

  1. Quelle est l'écriture binaire de 168 ?

  2. Le joueur ayant pour adresse IP écrite en binaire 11000000.10101000.00110010.00010111 peut-il se connecter à votre jeu ?

Code de déblocage de la correction :

Binaire : B2

On modélise la représentation binaire d'un entier signé par un tableau d'entiers dont les éléments sont 0 ou 1.

Par exemple :

Pour obtenir l'écriture décimale d'un nombre négatif dont on a une représentation binaire en complément à deux, donc lorsque le bit de poids fort est 1, il suffit d'appliquer les étapes suivantes :

Le but de cet exercice est de créer une fonction qui effectue automatiquement la première étape et ce que la liste fournie comme argument représente un nombre positif ou négatif.

Les listes formées d'un premier terme $1$ suivie que de termes $0$ ne peuvent pas être données en argument puisqu'elles correspondent au plus petit nombre négatif que l'on peut écrire en complément à deux avec ce nombre de termes : retirer 1 à ce nombre minimal n'a pas de sens.

Compléter la fonction retirer1 ci-dessous qui prend en paramètre une liste de $0$ et de $1$, qui correspond à l'écriture binaire d'un nombre entier signé $nb$, et qui renvoie la liste de $0$ et de $1$ qui correspond à l'écriture binaire du nombre entier signé $nb-1$.
Cette fonction commence par vérifier que la liste saisie comme argument est une liste correspondant au plus petit nombre nombre que l'on peut représenter en complément à deux avec le nombre de bits considérés.

def retirer1(lst: list) -> list:
    # création de la liste correspond au nombre minimal que l'on peut écrire avec ce nombre de bits [1, 0, ..., 0]
    n = len(lst)
    l_nb_min = [...]
    for i in range(...):
        l_nb_min.append(...)
    if lst == l_nb_min:
        return ["La liste saisie comme argument correspond au nombre minimal que l'on peut écrire avec ce nombre de bits"]
    else:
        # recherche de la position du premier 1 dans l'écriture binaire en partant du poids faible
        i=n-1
        while i... and lst[i]==...:
            i=i-1

        # transformation en 0 du premier 1 trouvé et en 0 de tous les bits de poids plus faible
        if i...:
            lst[...] = 0
            for k in range(...,...):
                lst[k] = 1
            return lst
        else: # cas du nombre 0
            return [...] # en créant la liste par compréhension

Voici un jeu de tests :

assert retirer1([0, 0, 0, 0, 0, 0, 0, 1]) == [0, 0, 0, 0, 0, 0, 0, 0]
assert retirer1([1, 0, 0, 0, 0, 0, 0, 0]) == ["La liste saisie comme argument correspond au nombre minimal que l'on peut écrire avec ce nombre de bits"]
assert retirer1([0, 0, 0, 0, 0, 0, 0, 1]) == [0, 0, 0, 0, 0, 0, 0, 0]
assert retirer1([0, 0, 1, 0, 0, 0, 0]) == [0, 0, 0, 1, 1, 1, 1]
assert retirer1([0, 0, 0, 0, 0, 0]) == [1, 1, 1, 1, 1, 1]
assert retirer1([]) == []

Code de déblocage de la correction :

Binaire : B3

L'addition des trois couleurs rouge, verte et bleue permet de reconstituer la couleur blanche :
Plus généralement, on peut reconstituer toute couleur en mélangeant trois inetensités de rouge, de vert et de bleu : on parle de code RGB.

Par exemple, la couleur rebeccapurple est codée en hexadécimal par #663399 et en RGB par le triplet $(102,51,153)$ car $66_{16}=102_{10}$, $33_{16}=51_{10}$ et $99_{16}=153_{10}$.

  1. La couleur lightsalmon (ou saumon pâle en français) est codé par le code hexadécimal #FFA07A.
    Sachant que les deux premiers caractères donnent le niveau de rouge, les deux suivant le niveau de vert et les deux derniers celui de bleu, déterminer la valeur décimale de chacune des trois intensités de couleur.

  2. La couleur cornflower blue (ou bleu bleuet en français) est codé par le code RGB (100,149,237).
    Déterminer le code hexadécimal codant le couleur cornflower blue.

Code de déblocage de la correction :

Les adresses IPv6 sont formés de 16 octets, chaque octet est écrit en hexadécimal et chaque groupe de 2 octets est séparé d'un signe deux-points ":".
Par exmple, $2001:0db8:0000:85a3:0000:0000:ac1f:8001$ est une adresse IPv6.

  1. Les adresses IPv6 correspondant à liens locaux commencent toutes par les deux octets écrits en hexadécimal par $FE80$.

    Écrire $FE80$ en binaire.

  2. Les adresses locales uniques commencent toutes par les deux octets suivant : $1111110000000000$.

    Écrire $1111110000000000$ en hexadécimal.

  3. Les adresses reservées pour les traducteurs de protocoles commencent par deux octets dont la valeur concaténée écrite en décimal vaut $100$.

    Écrire $100$ en hexadécimal.

  4. Pour les plus rapides :

    Les adresses reservées pour les traducteurs de protocoles se poursuivent par deux octets écrits dont la valeur concaténée écrite en décimal vaut $65435$.

    Écrire $65435$ en hexadécimal puis en binaire.

Code de déblocage de la correction :

HTML : html1

A vous d'écrire le code HTML qui permet d'avoir ce rendu visuel ci-dessous :

Vous pouvez vous rendre sur la source : Source Wikipédia

Vous pouvez aussi copier-coller le texte brut :

Un texte est une série orale ou écrite de mots perçus comme constituant un ensemble cohérent, porteur de sens et utilisant les structures propres à une langue (conjugaisons, construction et association des phrases…)1. Un texte n'a pas de longueur déterminée sauf dans le cas de poèmes à forme fixe comme le sonnet ou le haïku. L'étude formelle des textes s'appuie sur la linguistique, qui est l'approche scientifique du langage. Étymologie « Texte » est issu du mot latin « textum », dérivé du verbe « texere » qui signifie « tisser ». Le mot s'applique à l'entrelacement des fibres utilisées dans le tissage, voir par exemple Ovide : « Quo super iniecit textum rude sedula Baucis = (un siège) sur lequel Baucis empressée avait jeté un tissu grossier »2 ou au tressage (exemple chez Martial « Vimineum textum = panier d'osier tressé »). Le verbe a aussi le sens large de construire comme dans « basilicam texere = construire une basilique » chez Cicéron3. Le sens figuré d'éléments de langage organisés et enchaînés apparaît avant l'Empire romain : il désigne un agencement particulier du discours. Exemple : « epistolas texere = composer des épîtres » - Cicéron (ier siècle av. J.-C.)4 ou plus nettement chez Quintilien (ier siècle apr. J.-C.) : « verba in textu jungantur = l'agencement des mots dans la phrase »5. Les formes anciennes du Moyen Âge désignent au xiie siècle le volume qui contient le texte sacré des Évangiles, puis au xiiie siècle, le texte original d'un livre saint ou des propos de quelqu'un. Au xviie siècle le mot s’applique au passage d'un ouvrage pris comme référence et au début du xixe siècle le mot texte a son sens général d'« écrit »6. Texte littéraire Un texte répond de façon plus ou moins pertinente à des critères qui en déterminent la qualité littéraire. On retient en particulier la structure d'ensemble, la syntaxe et la ponctuation, l'orthographe lexicale et grammaticale, la pertinence et la richesse du vocabulaire, la présence de figures de style, le registre de langue et la fonction recherchée (narrative, descriptive, expressive, argumentative, injonctive, poétique). C'est l'objet de l'analyse littéraire. En informatique En informatique, la notion de texte s'oppose à la notion de données binaires, on parle alors : de texte brut dans un protocole de télécommunication ; de document texte si le logiciel utilisé permet de formater le texte ; ou encore de texte formaté ou riche lorsque les indications de formats sont données en texte brut (exemple : Rich Text Format) ; de fichier texte dans un fichier qui ne contient que des caractères sans mise en forme autre que les sauts de lignes et le choix des caractères.


A vous d'insérer également un lien vers la source.

L'image est accessible sur le lien : image wikipédia

Code de déblocage de la correction :

Trace d'exécution: A1

for, boucle, trace d'exécution

Réaliser la trace d'exécution pour l'algorithme suivant :

1 n ← 3 2 sto ← 1 3 for i←n to 2xn 4 sto←sto+i 5 ECRIRE sto

Pour cela, vous pouvez reproduire, compléter et poursuivre le tableau ci-dessous :

Numéro variable locale : n variable locale : sto variable locale : i
1
2
...

Code de déblocage de la correction :

pseudo code, for, boucle, trace d'exécution

Réaliser la trace d'exécution de l'algorithme suivant :

pdv = 20
for i in range(5):
    pdv = pdv - i

Voici le même algorithme avec les numéros de ligne mentionnés :

1) pdv = 20
2) for i in range(5):
3)     pdv = pdv - i

Pour cela, vous pouvez reproduire, compléter et poursuivre le tableau ci-dessous :

Numéro variable locale : pdv variable locale : i
1
2
...

Code de déblocage de la correction :

for each,boucle, trace d'exécution

Réaliser la trace d'exécution de l'algorithme suivant :

l=[12,8,15]
nb_de_notes = 0
somme_notes = 0
for nb in l:
    somme_notes = somme_notes + nb 
    nb_de_notes = nb_de_notes + 1
moyenne = somme_notes / nb_de_notes

Vous pouvez utiliser la numérotation suivante des lignes :

1) l=[12,8,15]
2) nb_de_notes = 0
3) somme_notes = 0
4) for nb in l:
5)     somme_notes = somme_notes + nb 
6)     nb_de_notes = nb_de_notes + 1
7) moyenne = somme_notes / nb_de_notes

Une en-tête de tableau de trace d'exécution possible :

Numéro l nb_de_notes somme_notes nb moyenne
1
2
...

En utilisant votre trace d'exécution, que contient la variable moyenne ?

Code de déblocage de la correction :

trace d'exécution

On donne la fonction suivante :

def mystere(ch):
    """
    fonction qui prend en paramètre une chaîne de caractère
     et qui renvoie un booleen
    """
    chr = ''
    for elt in ch :
        chr = elt + chr 
    if ch == chr :
        return True
    else :
        return False
                

Vous pouvez utiliser la numérotation suivante des lignes :

def mystere(ch):
    """
    fonction qui prend en paramètre une chaîne de caractère
     et qui renvoie un booleen
    """
    1. chr = ''
    2. for elt in ch :
    3.    chr = elt + chr 
    4. if ch == chr :
    5.     return True
    6. else :
    7.    return False

Réaliser la trace d'exécution avec ch = 'NSI' puis avec ch = 'SONOS'

tris : A3

On considère un tableau equipe stockant pour chaque joueur dans un dictionnaire son pseudo de joueurs ainsi que le score obtenu à une compétition.

Voici un exemple de tel tableau implémenté en python sous forme de liste de dictionnaires :

equipe = [{'nom': "Jeu_suis", 'score': 234},
          {'nom': "Or_jeu", 'score': 105},
          {'nom': "Bin!Jeu!", 'score': 340},
          {'nom': "RatJeu", 'score': 32},
          {'nom': "JeuN&bot", 'score': 291},
          {'nom': "Marrer_car_jeu", 'score': 56},
          {'nom': "JeuTuIles", 'score': 154}]

Le but est de trier ce tableau en fonction des scores à l'aide du tri par sélection puis de renvoyer la liste des noms de joueurs classés par ordre croissant de leur score obtenu.

Dans l'algorithme de tri par sélection : à chaque étape, on parcourt le sous-tableau des éléments non rangés et on place l'élément ayant le plus petit score en première position de ce sous-tableau.

Exemple avec le tableau :

equipe = [{'nom': "Jeu_suis", 'score': 234},{'nom': "Or_jeu", 'score': 105},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "RatJeu", 'score': 32},
                    {'nom': "JeuN&bot", 'score': 291},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "JeuTuIles", 'score': 154}]

  • Étape 1 : on parcourt tous les éléments du tableau, on permute l'élément avec le plus petit score avec le premier. Le tableau devient :

    equipe = [{'nom': "RatJeu", 'score': 32},{'nom': "Or_jeu", 'score': 105},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "Jeu_suis", 'score': 234},
                                {'nom': "JeuN&bot", 'score': 291},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "JeuTuIles", 'score': 154}]
  • Étape 2 : on parcourt tous les éléments sauf le premier déjà trié, on permute l'élément avec le plus petit score avec le seconde (premier du sous-tableau non trié). Le tableau devient :

    equipe = [{'nom': "RatJeu", 'score': 32},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "Jeu_suis", 'score': 234},
                                {'nom': "JeuN&bot", 'score': 291},{'nom': "Or_jeu", 'score': 105},{'nom': "JeuTuIles", 'score': 154}]
  • Et ainsi de suite.

Le code de la fonction selectionner qui implémente cet algorithme est donné ci-dessous.

def selectionner(tab: list)->list:
    N = len(...)
    for k in range(...):
        imin = ...
        for i in range(..., N):
            if tab[i]['score'] < ... :
                imin = i
        ... , tab[imin] = tab[imin] , ...
    # liste des noms classés par ordre croissant du score obtenu
    classement = []
    for joueur in ...:
        classement.append(...)
    return ...

Compléter le code de cette fonction de façon à obtenir :

>>> equipe = [{'nom': "Jeu_suis", 'score': 234},{'nom': "Or_jeu", 'score': 105},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "RatJeu", 'score': 32},{'nom': "JeuN&bot", 'score': 291},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "JeuTuIles", 'score': 154}]
>>> print(selectionner(equipe))
['RatJeu', 'Marrer_car_jeu', 'Or_jeu', 'JeuTuIles', 'Jeu_suis', 'JeuN&bot', 'Bin!Jeu!']

Rappel : l'instruction a, b = b, a permet d'échanger les contenus de a et de b.

Code de déblocage de la correction :

dichotomie : A5

Dans un jeu vidéo, une souris avance continuement de gauche à droite et doit creuser des tunnels pour traverser des murs de longueurs variées.

Les murs à percer seront modélisés de la manière suivante :

Pour savoir si la souris a déjà percé un mur ou non et pour connaître la position de la souris dans le cas où le mur est en cours de percement, une fonction etat_mur est utilisée dans le jeu.
Cette fonction prend en paramètre une liste de caractères de la forme un des trois types présentés ci-dessus et renvoie une chaîne de caractères donnant l'état du mur.
Il y a trois états possibles :

Sachant que la comparaison de deux caractères majuscules respecte l'ordre alphabétique, compléter la fonction etat_mur ci-dessous.

Jeu de tests possibles :

assert etat_mur(["X", "X", "X", "X", "X", "X", "X", "X"]) == "sain"
assert etat_mur(["S", "X", "X", "X", "X", "X", "X", "X"]) == "attaqué en position 0"
assert etat_mur(["O", "O", "O", "S", "X", "X", "X", "X", "X", "X", "X"]) == "attaqué en position 3"
assert etat_mur(["O", "O", "O", "O", "O", "O", "O", "S"]) == "attaqué en position 7"
assert etat_mur(["O", "O", "O", "O", "O", "O", "O", "O"]) == "traversé"
            

Fonction à compléter :

def etat_mur(lst: list) -> str:
    """
    lst est un tableau non vide de caractères "O", "S" et "X" rangés dans un ordre respectant l'ordre alphabétique
    et où "S" apparaît au plus une fois.
    renvoie une chaîne de caractères donnant l'état de la chaîne.
    La méthode par dichotomie est utilisée.
    """
    n = len(lst)
    i_min = 0
    i_max = ...
    if ...:
        return "sain"
    while i_min ... i_max:
        i_mil = ...
        if lst[i_mil] == ...:
            return "attaqué en position "+str(...)
        elif ...:
            i_min = ...
        else:
            i_max = ...
    return ...

Code de déblocage de la correction :

Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International