Proposer un script en python qui :

• demande à l'utilisateur son âge,

• stocke l'information obtenue dans une variable age,

• affiche un texte "Dans deux ans, vous aurez ... ans." où les ... sont remplacés par l'âge qu'aura l'utilisateur dans deux ans.

age = ...(input("..."))
print("Dans deux ans, vous aurez", ..., ...)                    

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

• un entier positif pdv correspondant au nombre de points de vie du personnage,

• un entier positif ou nul armor correspondant au nombre de points d'armure du personnage,

• et un entier positif damage correspondant au nombre de points de dégâts subis sans armure.

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.

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)"

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.

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.

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 :

• $TTC = HT\times\left(1+\dfrac{t}{100}\right)$

• $TTC = HT + TVA$

Tests :

• decomposer_prix(300, 20) renvoie (250.0, 50.0)

• decomposer_prix(100, 10) renvoie (90.9090909090909, 9.090909090909093)

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

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

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 :

• la nouvelle note obtenue,

• le coefficient de cette note.

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

Tests :

• set_moyenne(15, 8) renvoie, si la nouvelle note est 12 avec un coefficient de 2, le nombre 14.4.

• set_moyenne(11.25, 7) renvoie, si la nouvelle note est 14.5 avec un coefficient de 4, le nombre 12.431818181818182.

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 

Les plus rapides peuvent :

• Rajouter le typage de chaque paramètre,

• Rajouter une documentation,

• Arrondir la moyenne renvoyée à $10^{-2}$ près en utilisant 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.

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 :

• demande à l'utilisateur le nombre de décimales de $\pi$ avec lequel il souhaite travailler,

• définit une fonction volume_cylindre qui prend en paramètre deux nombres h et r ainsi qu'un entier precision correspondant au nombre de décimales avec lequel le calcul du volume doit être fait.
  Cette fonction renvoie la valeur du volume calculé.

Tests :

• volume_cylindre(15, 8, precis) renvoie le nombre 3016.3199999999997 lorsque la variable precis stocke le nombre 3.

• volume_cylindre(10, 2, precis) renvoie le nombre 125.663706 lorsque la variable precis stocke le nombre 8.

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

Les plus rapides peuvent :

• Rajouter le typage de chaque paramètre,

• Rajouter une documentation,

É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.

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 :

• un booléen reparable qui vaut True dans le cas où l'objet est réparable et False sinon.

• un entier positif usure, inférieur ou égal à 100, donnant le pourcentage d'usure de l'objet.

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

Vérifier entre autres que :

• pour un outil non réparable d'usure 90%, a_reparer(False, 90) renvoie False.

• pour un outil réparable d'usure 82%, a_reparer(True, 82) renvoie True.

• pour un outil réparable d'usure 69%, a_reparer(True, 69) renvoie False.

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

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 :

• un entier positif score_vie

• un entier score_dommage

• un entier positifnombre_armes

Cette fonction renvoie deux informations (un tuple) :

• Le nouveau score calculé par la formule score_vie*2 + nombre_armes - score_dommage*3

• Un booléen : True si le nouveau score est strictement supérieur à 10, False sinon

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

Exemples de tests :

• modification_score(10, 10, 3)

• modification_score(20, 10, 3)

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 :

• une exploratrice commence avec 120 exp,

• un fugitif commence avec 10 exp,

• un soldat commence avec 30 exp.

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 :

• a_pour_exp("exploratrice") renvoie le nombre entier 120.

• a_pour_exp("fugitif") renvoie le nombre entier 10.

• a_pour_exp("diplomate") renvoie le nombre entier 0.

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

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

• attack : entier positif
• inLife : booléen
• ratio flottant positif (nombre à virgule)

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 :

• type(variable) pour tester le type de la variable. Par exemple type(True)
• type int
• type int
• type float
• type bool

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

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 :

• afficher en console un premier menu comme celui-ci :
  Bienvenue !
Que désirez-vous faire ?
Choix 1 : commencer une nouvelle partie
Choix 2 : charger une partie
Choix 3 : quitter le jeu

• Demander au joueur de saisir son choix.

• Afficher le texte correspondant au choix effectué par le joueur (comme vérification) ou un message d'erreur en cas de saisie différente de celles attendues.

• renvoyer un nombre entier : soit le nombre correspondant à un choix possible soit -1 en cas d'erreur de saisie.

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

Cette fonction permet de renvoyer un message :

• " Attention, vous êtes en danger" si pdv est compris entre 1 et 2

• " Votre score de vie est limite" si pdv est compris entre 3 et 5

• " Vous êtes en forme" si pdv est supérieur ou égal à 6

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

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

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.

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

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 :

• combattre(6) renvoie "Défaite !".

• combattre(50) renvoie "Victoire !".

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

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'])

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.

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.

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 :

• "B" : morceau de bois,

• "F" : bloc de fer,

• "O" : pièce d'or,

• "P" : pierre,

• "X" : du vide,

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, ...).

É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

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.

É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

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 

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))

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!
 

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.

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.

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 :

• get_mean([45, 264, 153, 8, 687, 569, 349, 169]) renvoie 365.1666666666667.

• get_mean([75, 69]) renvoie 0.

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 !?!"].

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"]

Écrire une fonction split(l) où 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]

É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.

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 ...:
            ...    
    ...

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.

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

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

• ca correspond à la classe d'armure qui doit être strictement inférieur à 20
• hp correspond à son total de points de vie
• initcorrespond à son initiative qui doit être strictement inférieur à 20
• dmgcorrespond au nombre de faces du dés à lancer quand le personnage applique ses dégâts.

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.

• Le premier personnage à agir est celui qui a l'initiative la plus élevée.
• Le perso attaque lance un dé à 20 faces.
• Si le résultat obtenu est supérieur ou égale à la ca de l'autre personnage alors on lance un dé correspondant à dmg.
• On retire à hp du personnage défenseur le score affiché par le dé.
• Si le seconde personnage n'est pas mort, le processus précédent s'applique.

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.

Code de déblocage de la correction :

2. Écrire une fonction round(perso1, perso2) qui renvoie les deux personnages après un round de combat.

Code de déblocage de la correction :

3. É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.

Code de déblocage de la correction :

Écrire une fonction min_max(l) où 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

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}.

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 :

2. É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'].

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 ...

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$.

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 :

• Utilisez le dictionnaire fourni dans le programme.

• Utilisez une boucle et une liste pour stocker les résultats correspondant au nombre de lettres saisi.

• Affichez les résultats sous la forme d'une phrase lisible avec ou sans liste directement affichée (ex : "Les fruits qui contiennent 6 lettres sont : Les fruits avec 6 lettres sont : ananas, avocat, banane, cassis, cerise, citron, fraise, goyave, mangue, orange, papaye, pomelo, raisin, tomate,").

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 :

• un dictionnaire de structure similaire à stock ci-dessus,

• une liste vendus contenant le nom de chaque élément vendu depuis la dernière mise à jour,

• une liste rajouts contenant le nom de chaque élément remis sur l'étal depuis la dernière mise à jour,

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 :

• Si le stock est donné par stock2 = {"sandalette": 8, "short": 12, "chemisette": 9, "maillot": 3}, alors mettreAJour(stock2, ["sandalette", "maillot", "sandalette", "sandalette"], ["chemisette"]) doit renvoyer le dictionnaire {"sandalette": 5, "short": 12, "chemisette": 10, "maillot": 2}.

• Si le stock est donné par stock3 = {"short": 2, "chemisette": 1, "maillot": 1}, alors mettreAJour(stock3, ["maillot"], ["chemisette"]) doit renvoyer le dictionnaire {"short": 2, "chemisette": 2}.

• Si le stock est donné par stock4 = {"short": 2, "chemisette": 1, "maillot": 1}, alors mettreAJour(stock4, ["maillot"], ["sandalette", "maillot"]) doit renvoyer le dictionnaire {"short": 2, "chemisette": 1,"maillot": 1, "sandalette": 1}.

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

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 :

• royaume1 = {"mines": 4,
              "puissance": 485,
              "population": 12365,
              "merveille": 1,
              "port": 2}

• royaume2 = {"mines": 1,
              "puissance": 302,
              "population": 14289,
              "port": 5,
              "personnage_illustre": 2}

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 :

• alliance(royaume1, {}) renvoie {'mines': 4, 'puissance': 485, 'population': 12365, 'merveille': 1, 'port': 2}.

• alliance(royaume1, royaume2) renvoie {'mines': 5, 'puissance': 787, 'population': 26654, 'merveille': 1, 'port': 7, 'personnage_illustre': 2}.

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

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 :

• dont les clés sont les noms des centres météos,

• dont les valeurs sont des dictionnaires dont les clés sont les noms des quatre saisons et les valeurs sont une liste formée du nombre de mesures et de la pression moyenne obtenue sur ces mesures.

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 :

• qu'elle prenne en paramètre un dictionnaire du type comme ci-dessus et une chaîne de caractères correspondant à un nom de lieu de capteur,

• qu'elle calcule la moyenne dans le cas où ce lieu est bien présent dans le dictionnaire,

• qu'elle renvoie cette moyenne arrondie à 2 décimales.

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 :

• >>> moyenne_pression(Der, "Beaulieu")
  None        

• >>> moyenne_pression(Der, "Chantecoq")
  982.16        

• >>> moyenne_pression(Der, "Cornee")
  988.55        

• >>> moyenne_pression(Der, "Nemours")
  982.55        

• >>> moyenne_pression(Der, "Champaubert")
  981.0        

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"}

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

Dans un jeu vidéo expérimental, chaque joueur possède plusieurs caractéristiques :

• "pseudo" qui donne le nom du joueur,

• "genre" qui peut prendre comme valeur "Femme", "Homme, "Autre", Hobbit, ...

• "experience" qui donne le nombre de points d'expérience accumulé par le joueur.

Le jeu est implémenté de telle sorte qu'à chaque joueur correspond un dictionnaire dont les clés sont les trois caractéristiques énoncées ci-dessus.

Par exemple, voici le dictionnaire stockant les informations d'un joueur à un moment donné :

gamer1451024 = {"pseudo": "Hash_hill", "genre": "Autre", "experience": 3509726}

Tout ensemble de joueurs est stocké dans une liste de tels dictionnaires.
Par exemple, voici la liste correspondant aux joueurs de l'équipe "A_freed_home_not_afreed" :

a_freed_home_not_afreed = [{"pseudo": "Hash_hill", "genre": "Autre", "experience": 3509726},
                           {"pseudo": "Herr_mi1", "genre": "Femme", "experience": 6128033},
                           {"pseudo": "EK-THOR", "genre": "Homme", "experience": 1756263},
                           {"pseudo": "EQ_BE:&^3", "genre": "Femme", "experience": 4638914},
                           {"pseudo": "Je_mene_Hellas", "genre": "Homme", "experience": 5891304},
                           {"pseudo": "Tirer6As", "genre": "Autre", "experience": 7058210},
                           {"pseudo": "K_cendres", "genre": "Femme", "experience": 3835534}]
            

Proposer une fonction moyenne qui prend en parmètres une liste de dictionnaires equipe similaire à l'exemple précédent ainsi qu'une chaîne de caractères genre et qui renvoie la moyenne du niveau d'expérience des membres de l'équipe equipe ayant pour genre genre.
Si aucun joueur de l'équipe n'est du genre considéré, la fonction renvoie 0.

Par exemple :
moyenne(a_freed_home_not_afreed, "Femme") renvoie la valeur 4867493.666666667.
moyenne(a_freed_home_not_afreed, "Homme") renvoie la valeur 3823783.5.
moyenne(a_freed_home_not_afreed, "Hobbit") renvoie la valeur 0.

def moyenne(equipe: list, genre: str) -> float:
    somme = ...
    effectif = ...
    for ... in ...:
        if ... == genre:
            somme = ...
            effectif = ...
    if effectif ...:
        moy = ...
    else:
        moy = ...
    return moy

a_freed_home_not_afreed = [{"pseudo": "Hash_hill", "genre": "Autre", "experience": 3509726},
                           {"pseudo": "Herr_mi1", "genre": "Femme", "experience": 6128033},
                           {"pseudo": "EK-THOR", "genre": "Homme", "experience": 1756263},
                           {"pseudo": "EQ_BE:&^3", "genre": "Femme", "experience": 4638914},
                           {"pseudo": "Je_mene_Hellas", "genre": "Homme", "experience": 5891304},
                           {"pseudo": "Tirer6As", "genre": "Autre", "experience": 7058210},
                           {"pseudo": "K_cendres", "genre": "Femme", "experience": 3835534}]

print(moyenne(a_freed_home_not_afreed, "Femme"))
print(moyenne(a_freed_home_not_afreed, "Homme"))
print(moyenne(a_freed_home_not_afreed, "Hobbit"))

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 réseau local.

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 ?

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 :

• le tableau [0, 1, 0, 1, 0, 0, 1, 1] représente l'écriture binaire de l'entier, positif car ayant comme bit de poids fort 0, dont l'écriture décimale est 2**6 + 2**4 + 2**1 + 2**0 = 83.

• le tableau [1, 0, 0, 0, 0, 0, 0, 0] représente l'écriture binaire de l'entier, négatif car ayant comme bit de poids fort 1, dont l'écriture décimale -128.

• le tableau [1, 1, 1, 1, 1, 1, 1, 1] représente l'écriture binaire de l'entier, négatif car ayant comme bit de poids fort 1, dont l'écriture décimale -1.

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 :

• Étape 1 : commencer par soustraire 1.

• Étape 2 : changer les 0 en 1 et les 1 en 0.

• Étape 3 : convertir en décimal le nombre binaire obtenir.

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.

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([]) == []

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.

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.

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 :

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

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

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 :

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 :

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 :

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

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'

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.

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 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!']

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 :

• Un mur de $n$ cases non encore creusé par la souris sera modélisé par une liste contenant $n$ caractères "X", soit ["X","X",...,"X"].

• Un mur de $n$ cases totalement creusé par la souris sera modélisé par une liste contenant $n$ caractères "O", soit ["O","O",...,"O"].

• Un mur de $n$ cases où la souris a déjà creusé $p$ cases, avec $0\le p\lt n$ et où cette souris se trouve en la $(p+1)^{\text{ième}}$ case sera modélisé par une liste contenant $p$ caractères "O", suivi d'un caractère "S", suivi de $n-p-1$ caractères "X", soit ["O",...,"O","S","X",...,"X"].

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 :

• "sain", dans le cas où le mur n'a pas encore était touché par la souris

• "traversé", dans le cas où le mur a été entièrement traversé par la souris.

• "attaqué en position k" dans le cas où la souris est en train de creusé le mur est se trouve actuellement en position k.

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 ...