NSI Première
Petite Sœur simplifiée
Le problème : la condition gauche != droite ne devient jamais fausse, la boucle ne s'arrête jamais...
La cause : les variables gauche et droite ne sont en fait jamais modifiées dans le programme principal, alors que l'on a l'impression que
c'est pourtant le cas dans la fonction joue...mais ce n'est pas vrai, comme vous le savez maintenant : les variables gauche et droite dans le programme principal ( globales )
et dans la fonction joue ( locales ) ne sont en fait pas les mêmes.
LA solution :
##############IMPORTS#########################
from random import shuffle
#################FONCTIONS###################
def tire_n_cartes(jeu, N):
shuffle(jeu)
return [jeu[i] for i in range(N)]
def affiche_n_cartes(jeu):
for i in range (gauche,droite):
print(jeu[i],end='')
def joue(cote, gauche, droite):
if cote == 'g':
gauche = gauche + 1
affiche_n_cartes(jeu_tire)
if cote == 'd':
droite = droite - 1
affiche_n_cartes(jeu_tire)
return gauche, droite
##########PROGRAMME PRINCIPAL################
jeu_cartes = [('7','Carreau'), ('8','Carreau'),('9','Carreau'), ('10','Carreau'),('V','Carreau'),('D','Carreau'),('R','Carreau'),('A','Carreau'),('7','Coeur'),('8','Coeur'),('9','Coeur'), ('10','Coeur'),('V','Coeur'),('D','Coeur'),('R','Coeur'),('A','Coeur'),('7','Pique'),('8','Pique'),('9','Pique'), ('10','Pique'),('V','Pique'),('D','Pique'),('R','Pique'),('A','Pique'),('7','Trèfle'),('8','Trèfle'),('9','Trèfle'), ('10','Trèfle'),('V','Trèfle'),('D','Trèfle'),('R','Trèfle'),('A','Trèfle')]
jeu_tire = tire_n_cartes(jeu_cartes, 10)
gauche = 0
droite = len(jeu_tire)
while gauche != droite:
print("\n")
cote = input('g ou d ?')
gauche, droite = joue(cote, gauche, droite)
joue;joue.Bien entendu, PERSONNE n'a eu l'idée d'écrire un truc comme :
def joue(cote):
global gauche, droite # beuark
if cote == 'g':
gauche = gauche + 1
affiche_n_cartes(jeu_tire)
if cote == 'd':
droite = droite - 1
affiche_n_cartes(jeu_tire)
def ecrete(tab, a, b):
tab_ecrete = tab[:] # copie du tableau passé en argument
for i in range(len(tab_ecrete)) : # parcours par indice, seul moyen de pouvoir modifier les éléments du tableau
if tab_ecrete[i] < a:
tab_ecrete[i] = a
elif tab_ecrete[i] > b:
tab_ecrete[i] = b
return tab_ecrete
t = [35, 47, 47, 34, 82, 81, 1, 63, 60, 40, 83, 29, 66, 97, 54, 21, 73, 40, 3, 86, 25, 10, 59, 56, 72, 97, 62, 45, 54, 13, 30, 68, 12, 17, 68, 3, 54, 71, 85, 23, 45, 4, 9, 21, 45, 84, 62, 16, 3, 34]
a = 20
b = 80
print(ecrete(tab)) # affiche le tableau écrêté
print(tab) # affiche le tableau d'origine, non modifié
from random import randint
def melanger(tab):
# on ne fait pas de copie puisqu'on veut modifier directement le tableau
for i in range(len(tab)): # pour chaque élément successif du tableau,
indice = randint(0, i-1) # on tire un indice au hasard parmi les indices strictement inférieurs à 'i',
tab[i], tab[indice] = tab[indice], tab[i] # et on échange les éléments d'indice 'i' et 'indice'.
return tab
t = [35, 47, 47, 34, 82, 81, 1, 63, 60, 40, 83, 29, 66, 97, 54, 21, 73, 40, 3, 86, 25, 10, 59, 56, 72, 97, 62, 45, 54, 13, 30, 68, 12, 17, 68, 3, 54, 71, 85, 23, 45, 4, 9, 21, 45, 84, 62, 16, 3, 34]
print(melange(tab))
Attention à l'instruction randint(), qui ne fonctionne pas comme un range() !
Si on supprime l'instruction return, le tableau tab est quand même modifié, illustrant le caractère mutable d'un tableau : même si il n'est pas passé
en argument, il sera quand même modifié à l'intérieur de la fonction...
Là aussi, on veut trier directement le tableau ( on parle d'un tri "en place" ) : on ne travaille donc pas sur une de ses copies.
from random import randint
def tri_01(t):
gauche = 0 # indice du premier élément d'un tableau
droite = len(t)-1 # indice du dernier élément
while gauche != droite : # tant que 'gauche' est différente de 'droite',
if t[gauche] == 0 : # si l'élément à l'indice 'gauche' est un 0,
gauche += 1 # alors, on incrémente 'gauche',
else: # sinon ( donc, si c'est un 1),
t[gauche], t[droite] = t[droite], t[gauche] # on échange les éléments aux indices 'gauche' et 'droite',
droite -= 1 # et on décrémente 'droite'
return t
def tableau_01(N):
return [randint(0,1) for i in range(N)]
t = tableau_01(10)
print(t)
t = tri_01(t)
print(t)
Attention ligne 11, il faut bien échanger les éléments, et pas les indices !
A peine plus compliqué que le précédent...
Le tableau est trié quand milieu est devenu égal à droite :
from random import randint
def drapeau_hollandais(t):
gauche = 0
milieu = 0
droite = len(t)-1
while milieu != droite :
if t[milieu] == 0 :
t[milieu], t[gauche] = t[gauche], t[milieu]
gauche += 1
milieu += 1
elif t[milieu] == 1 :
milieu += 1
else:
t[milieu], t[droite] = t[droite], t[milieu]
droite -= 1
return t
def tableau_012(N):
return [randint(0, 2) for i in range(N)]
t = tableau_012(100)
print(t)
t = drapeau_hollandais(t)
print(t)
from random import randint
def compte_suprplus(L):
tab = [0]*10
for i in range(10):
if L[i] > 25:
tab[i] = L[i] - 25
return tab
def repartition_possible(L):
L_modif = [0]*10
for i in range(10):
L_modif[i] = 25 - L[i]
suppressions = 0
places_dispos = 0
for i in range(10):
if L_modif[i] >= 0:
places_dispos += L_modif[i]
else:
suppressions -= L_modif[i]
print(suppressions, places_dispos)
if suppressions <= places_dispos:
return L_modif
else:
return 'Pas possible'
classes = [randint(20,30) for i in range(10)]
print(classes)
print(repartition_possible(classes))