Cette page est dédiée aux exercices de début de séances : des exercices ciblés, assez courts, visant à installer des automatismes.
Vous retrouvez l'équivalent en terminale dans la section avant propos : Warmup - Automatismes .
Cette page est utile pour vous préparer à l'exercice 1 de l'épreuve pratique du baccalauréat et aux contrôles en classe de codage.
A travailler et retravailler sans modération.
Bon codage à vous !
É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 positifinLife
: booléenratio
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)
int
int
float
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.
fonction
warning(pdv)
structure conditionnelle
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
fonction
jeter_de(face)
Créer une fonction jeter_de
avec comme paramètre un entier face
.
Cette fonction renvoie un nombre aléatoire compris entre 1 et le nombre de faces (donné en argument par la variable face
) du dé
Aide python: pour obtenir un nombre aléatoire entre 1 et en python
# Obtenir et afficher un nombre aléatoire entre 1 et 6
# A tester
from random import randint
a= randint(1,6)
print(a)
À vous d'écrire un docstring
pour commenter votre fonction et des préconditions en utilisant des assert
fonction
elif
if
structure conditionnelle
print
+
str
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, :
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'])
for
vous semble-t-elle appropriée ?
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
.
for
chaine de caractères
occurence
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 chaine
et sur objet
(type, valeurs possibles, ...).
Pour connaître la longueur du chaîne de caractères ch
, il suffit de saisir len(ch)
.
liste
Écrire la fonction nombrePlusGrandQue(l,x)
qui prend en paramètres une liste l
de nombres
et un nombre x
.
Cette fonction renvoie le dernier nombre de la liste l
supérieur ou égal au nombre x
.
Si ce nombre n'existe pas, cette fonction renvoie None
.
À vous de tester votre fonction avec :
assert nombrePlusGrandQue([1,2,2,8,3,5,6,0,10,4],5) == 10
assert nombrePlusGrandQue([1,2,2,8,3,5,6,0,10,4],12) == None
assert nombrePlusGrandQue([1,2,2,8,3,5,6,0,10,4],4) == 4
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.
L'ADN (Acide DésoxyriboNucléique) est une molécule présente dans la plupart des cellules des êtres vivants qui contient l'information
génétique leurs permettant de se développer, de fonctionner et de se reproduire.
L'ADN est formé de deux brins enroulés l'un autour de l'autre pour former une double hélice.
Chaque brin est formé de quatre bases azotées
l'adénine "A"
,
la thymine "T"
,
la cytosine "C"
,
la guanine "G"
.
Pour que les deux brins se lient, les bases ne s’associent que par certaines paires :
l'adénine et la thymine s'associent ensemble,
la cytosine et la guanine s'associent ensemble.
Par exemple, le fragment de brin d'ADN "ACGTTA"
se lie avec le fragment de brin
complémentaire "TGCAAT"
.
Proposer une fonction second_brin_ADN
qui prend en paramètre une liste brin1
formée de caractères "A"
, "T"
, "G"
et "C"
et
qui renvoie la liste formée des caractères correspondant au brin complémentaire de
brin1
.
Par exemple, comme le brin d'ADN "ACGTTA"
a pour complémentaire "TGCAAT"
,
second_brin_ADN(["A","C","G","T","T","A"])
renvoie ["T","G","C","A","A","T"]
.
Pour les plus rapides : modifier la fonction obtenue de sorte qu'elle renvoie la liste
["Erreur, brin1 contient des bases non attendues !?!"]
si la liste brin1
contient une autre base que "A"
, "T"
, "G"
ou "C"
.
Par exemple, comme le brin d'ADN "ACGTTA"
a pour complémentaire "TGCAAT"
,
second_brin_ADN(["A","B","C"])
renvoie ["Erreur, brin1 contient des bases non attendues !?!"]
.
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 à 20hp
correspond à son total de points de vieinit
correspond à son initative qui doit être strictment inférieur à 20dmg
correspond 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.
Rappel : Simulation d'un dé - code à tester
import random
for _ in range(10):
print(random.randint(1,10))
round(perso1,perso2)
qui renvoie les deux personnages après un round de combat.combat(perso1,perso2)
qui renvoie perso1 , perso2 et le nombre de tour de jeu quand un des perso est tombé à 0 en hp.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 valeurs
le 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.
É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}
.
É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 :
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 :
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.
Quelle est l'écriture binaire de 168 ?
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.
Les listes formées d'un premier terme $1$ suivie que de termes $0$ ne peuvent pas être données en argument puisqu'elles correspondent au plus petit nombre négatif que l'on peut écrire en complément à deux avec ce nombre de termes : retirer 1 à ce nombre minimal n'a pas de sens.
Compléter la fonction retirer1
ci-dessous qui prend en paramètre une
liste de $0$ et de $1$, qui correspond à l'écriture binaire d'un nombre entier signé $nb$, et qui renvoie
la liste de $0$ et de $1$ qui correspond à l'écriture binaire du nombre entier signé $nb-1$.
Cette fonction commence par vérifier que la liste saisie comme argument est une liste correspondant au plus petit nombre
nombre que l'on peut représenter en complément à deux avec le nombre de bits considérés.
def retirer1(lst: list) -> list:
# création de la liste correspond au nombre minimal que l'on peut écrire avec ce nombre de bits [1,0,...,0]
n = len(lst)
l_nb_min = [...]
for i in range(...):
l_nb_min.append(...)
if lst == l_nb_min:
return ["La liste saisie comme argument correspond au nombre minimal que l'on peut écrire avec ce nombre de bits"]
else:
# recherche de la position du premier 1 dans l'écriture binaire en partant du poids faible
i=n-1
while i... and lst[i]==...:
i=i-1
# transformation en 0 du premier 1 trouvé et en 0 de tous les bits de poids plus faible
if i...:
lst[...] = 0
for k in range(...,...):
lst[k] = 1
return lst
else: # cas du nombre 0
return [...] # en créant la liste par compréhension
Voici un jeu de tests :
assert retirer1([0,0,0,0,0,0,0,1]) == [0, 0, 0, 0, 0, 0, 0, 0]
assert retirer1([1,0,0,0,0,0,0,0]) == ["La liste saisie comme argument correspond au nombre minimal que l'on peut écrire avec ce nombre de bits"]
assert retirer1([0,0,0,0,0,0,0,1]) == [0, 0, 0, 0, 0, 0, 0, 0]
assert retirer1([0,0,1,0,0,0,0]) == [0, 0, 0, 1, 1, 1, 1]
assert retirer1([0,0,0,0,0,0]) == [1, 1, 1, 1, 1, 1]
assert retirer1([]) == []
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}$.
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.
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.
Les adresses IPv6 correspondant à liens locaux commencent toutes par les deux octets écrits en hexadécimal par $FE80$.
Écrire $FE80$ en binaire.
Les adresses locales uniques commencent toutes par les deux octets suivant : $1111110000000000$.
Écrire $1111110000000000$ en hexadécimal.
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.
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 de l'algorithme suivant :
pdv = 20
for i in range(5):
pdv = pdv - i
Voici le même algorithme avec les numéros de ligne mentionnés :
1) pdv = 20
2) for i in range(5):
3) pdv = pdv - i
Pour cela, vous pouvez reproduire, compléter et poursuivre le tableau ci-dessous :
Numéro | variable locale : pdv |
variable locale : i |
---|---|---|
1 | ||
2 | ||
... |
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 :
Numéro | Contrôle | variable locale : pdv |
variable locale : i |
---|---|---|---|
1 | |||
2 | |||
... |
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 :
Numéro | l |
nb_de_notes |
somme_notes |
nb |
moyenne |
---|---|---|---|---|---|
1 | |||||
2 | |||||
... |
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.
Dans l'algorithme de tri par sélection : à chaque étape, on parcourt le sous-tableau des éléments non rangés et on place l'élément ayant le plus petit score en première position de ce sous-tableau.
Exemple avec le tableau :
equipe = [{'nom': "Jeu_suis", 'score': 234},{'nom': "Or_jeu", 'score': 105},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "RatJeu", 'score': 32},
{'nom': "JeuN&bot", 'score': 291},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "JeuTuIles", 'score': 154}]
Étape 1 : on parcourt tous les éléments du tableau, on permute l'élément avec le plus petit score avec le premier. Le tableau devient :
equipe = [{'nom': "RatJeu", 'score': 32},{'nom': "Or_jeu", 'score': 105},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "Jeu_suis", 'score': 234},
{'nom': "JeuN&bot", 'score': 291},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "JeuTuIles", 'score': 154}]
Étape 2 : on parcourt tous les éléments sauf le premier déjà trié, on permute l'élément avec le plus petit score avec le seconde (premier du sous-tableau non trié). Le tableau devient :
equipe = [{'nom': "RatJeu", 'score': 32},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "Jeu_suis", 'score': 234},
{'nom': "JeuN&bot", 'score': 291},{'nom': "Or_jeu", 'score': 105},{'nom': "JeuTuIles", 'score': 154}]
Et ainsi de suite.
Le code de la fonction selectionner
qui implémente cet algorithme est donné ci-dessous.
def selectionner(tab: list)->list:
N = len(...)
for k in range(...):
imin = ...
for i in range(..., N):
if tab[i]['score'] < ... :
imin = i
... , tab[imin] = tab[imin] , ...
# liste des noms classés par ordre croissant du score obtenu
classement = []
for joueur in ...:
classement.append(...)
return ...
Compléter le code de cette fonction de façon à obtenir :
>>> equipe = equipe = [{'nom': "Jeu_suis", 'score': 234},{'nom': "Or_jeu", 'score': 105},{'nom': "Bin!Jeu!", 'score': 340},{'nom': "RatJeu", 'score': 32},{'nom': "JeuN&bot", 'score': 291},{'nom': "Marrer_car_jeu", 'score': 56},{'nom': "JeuTuIles", 'score': 154}]
>>> print(selectionner(equipe))
['RatJeu', 'Marrer_car_jeu', 'Or_jeu', 'JeuTuIles', 'Jeu_suis', 'JeuN&bot', 'Bin!Jeu!']
Rappel : l'instruction a, b = b, a
permet d'échanger les contenus de a
et de b
.
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 ...
Les différents
auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative
Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0
International