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

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.

Écrire une fonction survivre(pdv, armor, damage) qui prend 3 entiers positifs ou nul en argument et renvoie un booleen 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

• 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%, 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(50) renvoie 40 et repair(80) affiche "Objet à recycler, son taux d'usure est de 80%."

• Bonus : ajouter le typage et les préconditions.

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

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

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

A 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 avoir si le nombre nb est dans la liste l.

A 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_rammasse(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_rammasse(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_rammasse(chaine,"O")) # doit afficher 3
print(nb_rammasse(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

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

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

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'armmure qui doit être strictment inférieur à 20
• hp correspond à son total de points de vie
• initcorrespond à son initative qui doit être strictment inférieur à 20
• dmgcorrespond au nombre de faces du dés à lancer quand le personnage applique ses dégats.

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. Ecrire une fonction round(perso1,perso2) qui renvoie les deux personnages après un round de combat.

Code de déblocage de la correction :

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

Ecrire 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 minimim et le maximum de la liste l.

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

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

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

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

Ecrire un scrypt qui réalise la procédure suivante :

• L'utilisateur est invité à saisir un nombre de lettres.
• 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
}

Exemple :

Entrez un nombre de lettres : 6
Les fruits qui contiennent 6 lettres sont : banane, orange, fraise, raisin, mangue, citron

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 (ex : "Les fruits qui contiennent 6 lettres sont : banane, orange, fraise, raisin, mangue, citron").

Vous avez à gérer râ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}.

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 ?

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 :

pdv = 30

for i in range(3):
    # "!="" signifie "différent de" 
    if pdv != 30 :
        pdv = pdv + 10*i
    else : 
        pdv = pdv - 10*i

Vous pouvez utiliser la numérotation suivante des lignes :

1) pdv = 30

2) for i in range(3):
    # "!="" signifie "différent de" 
3)     if pdv != 30 :
4)         pdv = pdv + 10*i
5)     else : 
6)         pdv = pdv - 10*i

Réaliser une en-tête de tableau de trace d'exécution comme celle ci-dessous à compléter :

pour déterminer quelle est la valeur de la variable pdv en fin 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 :

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