for etwhile. La récursivité est un choix, pas unesorted intégrée]]>sorted éviterait l'algorithmedemi = puissance(a, n // 2)), pas ladef recherche(x, tab):
gauche, droite = 0, len(tab) - 1
while gauche < droite: # ← ICI
milieu = (gauche + droite) // 2
if tab[milieu] == x:
return milieu
elif tab[milieu] < x:
gauche = milieu + 1
else:
droite = milieu - 1
return -1Quel est le bug ?
]]>tab = [5] et x = 5, on a gauche = droite = 0, lagauche < droite est fausse, on sortmilieu juste avant la boucle]]>milieu est défini à l'intérieur de la boucle,gauche <= droite, pas <]]>< strict, on n'examine pas legauche == droite. La fonctionmilieu est incorrect]]>(gauche + droite) // 2 estimage[i][j] est le pixel de la ligne i et de laj, les indices allant de 0 à n - 1. On tourne l'imageimage[i][j] ?]]>n - 1 - j, colonne i]]>[[1, 2, 3], [4, 5, 6], [7, 8, 9]], elle1 en bas à gauche au lieu d'en haut à droite.]]>j, colonne n - 1 - i]]>[[1, 2, 3], [4, 5, 6], [7, 8, 9]] devient[[7, 4, 1], [8, 5, 2], [9, 6, 3]] : le pixel 1, en [0][0],[0][2].]]>j, colonne i]]>1 resterait en [0][0].]]>n - 1 - i, colonne n - 1 - j]]>1, en haut à gauche, arriverait en bas à droite.]]>RecursionError même pour de grandes entrées.]]>puissance(a, n // 2) dans une variable. Sans cettedef puissance(a, n):
if n == 0:
return 1
if n % 2 == 0:
return puissance(a, n // 2) * puissance(a, n // 2)
return a * puissance(a, n // 2) * puissance(a, n // 2)]]>def puissance(a, n):
if n == 0:
return 1
return a * puissance(a, n - 1)]]>def puissance(a, n):
return a ** n]]>def puissance(a, n):
if n == 0:
return 1
demi = puissance(a, n // 2)
if n % 2 == 0:
return demi * demi
return a * demi * demi]]>an est impair). Complexitét compris entre lesdebut et fin inclus, en coupant l'intervalle en deux :
def somme(t, debut, fin):
if debut == fin:
return t[debut]
milieu = (debut + fin) // 2
return ...Par quoi remplacer les points de suspension pour que
somme([4, 7, 1, 3], 0, 3) renvoie 15 ?
debut == fin.]]>somme(t, debut, milieu) + somme(t, milieu, fin)]]>milieu. Poursomme(t, 0, 1), milieu vaut 0 et le second appel est desomme(t, 0, 1) : la récursion ne s'arrête pas et PythonRecursionError.]]>somme(t, debut, milieu) + somme(t, milieu + 1, fin)]]>debut à milieu et demilieu + 1 à fin, couvrent chaque case une seule fois et sontt[milieu] + somme(t, milieu + 1, fin)]]>milieu ne sont jamais11, soit $7 + 1 + 3$ : la valeur4 est perdue.]]>somme(t, debut, milieu) + somme(t, milieu + 1, fin) + t[milieu]]]>milieu est déjà comptée dans la moitié27.]]>[5, 2, 8, 3]. Quelles sont les listes[2, 3, 5, 8] et []]]>[5], [2], [8], [3]]]>[5, 2] et [8, 3]]]>[2, 5][3, 8].]]>[2, 5] et [3, 8]]]>[5, 2] et [8, 3]. On trie[5, 2][2, 5] après fusion de [5][2] ; [8, 3] devient [3, 8][8] et [3]. La[2, 5] et[3, 8] pour produire [2, 3, 5, 8].]]>def fusion(a, b):
i, j = 0, 0
resultat = []
while i < len(a) and j < len(b):
if a[i] <= b[j]:
resultat.append(a[i])
i += 1
else:
resultat.append(b[j])
j += 1
return resultat]]>a = [1, 4, 7] etb = [2, 3], on obtient [1, 2, 3][1, 2, 3, 4, 7]. Il fautdef fusion(a, b):
return sorted(a + b)]]>a et b sont déjàdef fusion(a, b):
resultat = []
for x in a:
for y in b:
if x <= y:
resultat.append(x)
else:
resultat.append(y)
return resultat]]>a est comparé à chaque élément deb, et chaque comparaison ajoute unedef fusion(a, b):
i, j = 0, 0
resultat = []
while i < len(a) and j < len(b):
if a[i] <= b[j]:
resultat.append(a[i])
i += 1
else:
resultat.append(b[j])
j += 1
resultat.extend(a[i:])
resultat.extend(b[j:])
return resultat]]>i et j pour parcourir les deuxfusion(a, b) qui fusionne deux listesdef tri_fusion(t):
if len(t) <= 1:
return t
milieu = len(t) // 2
gauche = [t[i] for i in range(milieu)]
droite = [t[i] for i in range(milieu, len(t))]
return ...Quelle expression remplace les points de suspension pour que la
fonction trie toute liste ?
fusion(gauche, droite)]]>fusion suppose deux listes déjà triées, or gauche etdroite ne le sont pas. Sur [4, 1, 3, 2], la fonction renvoie[3, 2, 4, 1].]]>tri_fusion(gauche) + tri_fusion(droite)]]>+ met les deux listes bout à bout sans[4, 1, 3, 2] est renvoyée inchangée.]]>tri_fusion(fusion(gauche, droite))]]>t. Le problème ne rétrécit jamais, et Python finit par leverRecursionError.]]>fusion(tri_fusion(gauche), tri_fusion(droite))]]>[4, 1, 3, 2] donne [1, 2, 3, 4].]]>def rech(t, x, g, d):
if g > d:
return False
m = (g + d) // 2
if t[m] == x:
return True
if t[m] < x:
# ligne à compléter
return rech(t, x, g, m - 1)x : c'est un diviser pour régner sansreturn rech(t, x, m + 1, d)]]>t[m] est trop petit, x ne peut être qu'àm, dans l'intervalle de m + 1 à d.]]>return rech(t, x, g, m - 1)]]>t[m] est tropreturn rech(t, x, m, d)]]>m dans l'intervalle peut empêcher lam vaut g.]]>return rech(t, x, g, d)]]>[1, 4, 9] et [2, 3, 10] ?]]>