Une sélection d'exercices pour apprendre la programmation Python

1
2
3
4
5
6
7
8
9
  
from math import pi 
  
def surfCercle(r): 
  "Surface d'un cercle de rayon r" 
  return pi * r**2 
  
# test : 
print(surfCercle(2.5))

1
2
3
4
5
6
7
8
9
10
11
12
13
def maximum(n1, n2, n3):	 
	"Renvoie le plus grand de trois nombres"   
	if n1 >= n2 and n1 >= n3:   
		return n1   
	elif n2 >= n1 and n2 >= n3:   
		return n2   
	else:   
		return n3   
  
# test :	 
print(maximum(4.5, 5.7, 3.9))	 
print(maximum(8.2, 2.1, 6.7))	 
print(maximum(1.3, 4.8, 7.6))

1
2
3
4
5
6
7
8
9
def maximum(n1, n2, n3):	 
	"Renvoie le plus grand de trois nombres"   
	tmp=n1 if n1 >= n2 else n2 
	return tmp if tmp >= n3 else n3 
  
# test :	 
print(maximum(4.5, 5.7, 3.9))	 
print(maximum(8.2, 2.1, 6.7))	 
print(maximum(1.3, 4.8, 7.6))

1
2
3
4
5
6
7
8
9
10
def maximum(n1, n2, n3):	 
	"Renvoie le plus grand de trois nombres"   
	for n in (n2, n3): 
		if n >= n1: n1=n 
	return n1 
  
# test :	 
print(maximum(4.5, 5.7, 3.9))	 
print(maximum(8.2, 2.1, 6.7))	 
print(maximum(1.3, 4.8, 7.6))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  
def changeCar(ch, ca1, ca2, debut =0, fin =-1):  
  "Remplace tous les caractères ca1 par des ca2 dans la chaîne ch"  
  if fin == -1:  
      fin = len(ch)  
  nch, i = "", 0	# nch : nouvelle chaîne à construire  
  while i < len(ch) :  
      if i >= debut and i <= fin and ch[i] == ca1: 
          nch = nch + ca2  
      else :  
          nch = nch + ch[i]  
      i = i + 1  
  return nch 
  
  
# test : 
print((changeCar("Ceci est une toute petite phrase", " ", "*")))  
print((changeCar("Ceci est une toute petite phrase", " ", "*", 8, 12)))  
print((changeCar("Ceci est une toute petite phrase", " ", "*", 12)))  
print((changeCar("Ceci est une toute petite phrase", " ", "*", fin =12)))

1
2
3
4
5
6
7
8
9
10
11
  
def changeCar(ch, ca1, ca2, debut=0, fin=None): 
    if fin is None: 
        fin = len(ch) 
    newch = "" 
    for index, lettre in enumerate(ch): 
        if debut <= index <= fin and lettre == ca1: 
          newch += ca2 
        else: 
          newch += lettre 
    return newch

1
2
3
4
5
  
def changeCar(ch, ca1, ca2, debut=0, fin=None): 
  if fin is None: 
    fin = len(ch) 
  return ch[:debut]+ch[debut:fin+1].replace(ca1,ca2)+ch[fin+1:]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
# -*- coding : utf8 -*- 
"""Gardien de phare.""" 
  
# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
def hauteurParcourue(nb, h) : 
    print("Pour {:d} marches de {:d} cm, il parcourt {:.2f} m par semaine !" 
              .format(nb, h, nb*h*2*5*7/100.0)) 
  
# Programme principal ========================================================= 
nbMarches = int(input("Combien de marches ?")) 
hauteurMarche = int(input("Hauteur d'une marche (cm) ?")) 
  
hauteurParcourue(nbMarches, hauteurMarche)

1
2
3
4
5
6
7
8
9
10
11
12
13
  
# -*- coding : utf8 -*-  
"""Gardien de phare."""  
  
# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
def hauteurParcourue(nb, h) :  
    print(f"Pour {nb} marches de {h}cm, il parcourt {nb*h*2*5*7/100.0:.2f}m par semaine !") 
  
# Programme principal =========================================================  
nbMarches = int(input("Combien de marches ?"))  
hauteurMarche = int(input("Hauteur d'une marche (cm) ?"))  
  
hauteurParcourue(nbMarches, hauteurMarche)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  
# -*- coding : utf8 -*- 
"""Permis de chasse.""" 
  
# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
def permisSup(p, c, v, a) : 
    pointsPerdus = p + 3*c + 5*v + 10*a 
    nbrePermis = pointsPerdus/100.0 
    return 200*nbrePermis 
  
# Programme principal ========================================================= 
poules = int(input("Combien de poules ?")) 
chiens = int(input("Combien de chiens ?")) 
vaches = int(input("Combien de vaches ?")) 
amis = int(input("Combien d'amis ?")) 
  
payer = permisSup(poules, chiens, vaches, amis) 
  
print("\nA payer :", end=' ') 
if payer == 0: 
    print("rien à payer") 
else : 
    print(payer, "euros")

1
2
3
4
5
  
points = {  "poules" : 1, 
            "chiens" : 3, 
            "vaches" : 5, 
            "amis"   : 10  }

1
2
3
  
def points_perdus(**kwargs): 
    return sum([kwargs.get(victime, 0) * points[victime] for victime in points])

1
2
3
  
# écriture avec paramètres nommés 
print(points_perdus(poules=2, chiens=1, amis=2))    # = 25

1
2
3
4
  
# écriture avec dictionnaire à dépaqueter 
victimes_du_jour = {"poules" : 3, "vaches" : 2} 
print(points_perdus(**victimes_du_jour))    # = 13

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#!/usr/bin/env python3 
# coding: utf-8 
  
# Suite de syracuse 
def syracuse(n): 
	(val, altitude, duree)=(n, 0, 0) 
  
	# Boucle de calcul 
	while True: 
		# Evaluation altitude et durée 
		if val > altitude: altitude=val 
		duree+=1 
  
		# Suite terminée ? 
		if val == 1: return (n, altitude, duree) 
  
		# Calcul terme suivant 
		if val % 2: 
			val=val*3+1 
		else: 
			val//=2 
		# if 
	# while 
# syracuse() 
  
# Recherche altitude et durée max 
(alt_max, duree_max)=(0, 0) 
for n in range(1, 1_000_000+1): 
	# Récupération de la suite pour le nombre en cours 
	s=syracuse(n) 
	# Rappel : la fonction renvoie un tuple qui contient donc plusieurs valeurs... 
  
	# Si l'altitude trouvée est plus grande que l'altitude max mémorisée précédemment 
	if s[1] > alt_max: 
		print("Altitude: ", s) 
		alt_max=s[1] 
	# if 
  
	# Si la durée trouvée est plus grande que la durée max mémorisée précédemment 
	if s[2] > duree_max: 
		print("Durée: ", s) 
		duree_max=s[2] 
	# if 
# for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
Altitude:  (1, 1, 1) 
Durée:  (1, 1, 1) 
Altitude:  (2, 2, 2) 
Durée:  (2, 2, 2) 
Altitude:  (3, 16, 8) 
Durée:  (3, 16, 8) 
Durée:  (6, 16, 9) 
Altitude:  (7, 52, 17) 
Durée:  (7, 52, 17) 
Durée:  (9, 52, 20) 
Altitude:  (15, 160, 18) 
Durée:  (18, 52, 21) 
Durée:  (25, 88, 24) 
Altitude:  (27, 9232, 112) 
Durée:  (27, 9232, 112) 
Durée:  (54, 9232, 113) 
Durée:  (73, 9232, 116) 
Durée:  (97, 9232, 119) 
Durée:  (129, 9232, 122) 
Durée:  (171, 9232, 125) 
Durée:  (231, 9232, 128) 
Altitude:  (255, 13120, 48) 
Durée:  (313, 9232, 131) 
Durée:  (327, 9232, 144) 
Altitude:  (447, 39364, 98) 
Altitude:  (639, 41524, 132) 
Durée:  (649, 9232, 145) 
Altitude:  (703, 250504, 171) 
Durée:  (703, 250504, 171) 
Durée:  (871, 190996, 179) 
Durée:  (1161, 190996, 182) 
Altitude:  (1819, 1276936, 162) 
Durée:  (2223, 250504, 183) 
Durée:  (2463, 250504, 209) 
Durée:  (2919, 250504, 217) 
Durée:  (3711, 481624, 238) 
Altitude:  (4255, 6810136, 202) 
Altitude:  (4591, 8153620, 171) 
Durée:  (6171, 975400, 262) 
Altitude:  (9663, 27114424, 185) 
Durée:  (10971, 975400, 268) 
Durée:  (13255, 497176, 276) 
Durée:  (17647, 11003416, 279) 
Altitude:  (20895, 50143264, 256) 
Durée:  (23529, 11003416, 282) 
Altitude:  (26623, 106358020, 308) 
Durée:  (26623, 106358020, 308) 
Altitude:  (31911, 121012864, 161) 
Durée:  (34239, 18976192, 311) 
Durée:  (35655, 41163712, 324) 
Durée:  (52527, 106358020, 340) 
Altitude:  (60975, 593279152, 335) 
Durée:  (77031, 21933016, 351) 
Altitude:  (77671, 1570824736, 232) 
Durée:  (106239, 104674192, 354) 
Altitude:  (113383, 2482111348, 248) 
Altitude:  (138367, 2798323360, 163) 
Durée:  (142587, 593279152, 375) 
Durée:  (156159, 41163712, 383) 
Altitude:  (159487, 17202377752, 184) 
Durée:  (216367, 11843332, 386) 
Durée:  (230631, 76778008, 443) 
Altitude:  (270271, 24648077896, 407) 
Durée:  (410011, 76778008, 449) 
Durée:  (511935, 76778008, 470) 
Durée:  (626331, 7222283188, 509) 
Altitude:  (665215, 52483285312, 442) 
Altitude:  (704511, 56991483520, 243) 
Durée:  (837799, 2974984576, 525)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#!/usr/bin/env python3 
# coding: utf-8 
  
def synthese_familles(comptes): 
	# On commence par créer un dictionnaire pour ranger les résultats 
	synthese = dict() 
  
	# On traite chaque compte 
	for c in comptes: 
		# L'indication "epargne" étant facultative, il faut gérer le cas... 
		if 'epargne' not in c: 
			epargne = 0 
		else: 
			epargne = c['epargne'] 
  
		# Si le nom de famille n'a pas encore été trouvé 
		if c['nom'] not in synthese: 
			# On le crée dans le dictionnaire 
			synthese[c['nom']] = epargne 
		else: 
			# Il existe déjà, on lui rajoute donc l'épargne en cours 
			synthese[c['nom']] += epargne 
  
	# Il faut maintenant trouver le plus pauvre et le plus riche 
	pauvre, riche = None, None 
	for famille, epargne in synthese.items(): 
		if pauvre is None or epargne < pauvre[1]: 
			pauvre = (famille, epargne) 
		if riche is None or epargne > riche[1]: 
			riche = (famille, epargne) 
  
	# On retourne les informations récupérées 
	return pauvre, riche 
  
# Test de la fonction 
comptes = [ 
	{'nom': 'Boismoneau', 'prenom': 'stephane', 'epargne': 2500}, 
	{'nom': 'Jambon', 'prenom': 'fred', 'epargne': 5000}, 
	{'nom': 'Durois', 'prenom': 'nicolas', 'epargne': 10000}, 
	{'nom': 'Gueux', 'prenom': 'phillipe', 'epargne': 1250}, 
	{'nom': 'Duchan', 'prenom': 'alice', 'epargne': 4530}, 
	{'nom': 'Lepenou', 'prenom': 'amed', 'epargne': 2200}, 
	{'nom': 'Gueux', 'prenom': 'bernard'}, 
	{'nom': 'Jambon', 'prenom': 'steven', 'epargne': 1670}, 
	{'nom': 'Gueux', 'prenom': 'sylvie', 'epargne': 3}, 
	{'nom': 'Durois', 'prenom': 'berbard', 'epargne': 300000} 
] 
print(synthese_familles(comptes))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#!/usr/bin/env python3 
# coding: utf-8 
  
def synthese_familles(comptes): 
	# On commence par créer un dictionnaire pour ranger les résultats 
	synthese = dict() 
  
	# On traite chaque compte 
	for c in comptes: 
		# La méthode dict.get() renvoie une valeur par défaut si la clef demandée n'existe pas. Pratique pour gérer les éléments absents. 
		synthese[c['nom']] = synthese.get(c['nom'], 0) + c.get("epargne", 0) 
  
	# On va récupérer d'un coup le minimum et maximum en passant par les fonctions min() et max() 
	# On commence par créer la fonction qui pourra comparer deux familles 
	cle_epargne = lambda d: d[1]		# Une famille étant composé d'un nom et d'un montant, cette fonction ne traite que le montant 
  
	# On peut maintenant demander immédiatement min et le max de la synthèse des familles 
	# Chaque famille sera comparée par la fonction cle_epargne qui ne traite que les montants 
	# Donc seuls les montants sont pris en compte dans la recherche des min et max 
	famille_pauvre, famille_riche = min(synthese.items(), key = cle_epargne), max(synthese.items(), key = cle_epargne) 
  
	# On retourne les informations récupérées 
	return famille_pauvre, famille_riche 
  
# Test 
comptes = [ 
	{'nom': 'Boismoneau', 'prenom': 'stephane', 'epargne': 2500}, 
	{'nom': 'Jambon', 'prenom': 'fred', 'epargne': 5000}, 
	{'nom': 'Durois', 'prenom': 'nicolas', 'epargne': 10000}, 
	{'nom': 'Gueux', 'prenom': 'phillipe', 'epargne': 1250}, 
	{'nom': 'Duchan', 'prenom': 'alice', 'epargne': 4530}, 
	{'nom': 'Lepenou', 'prenom': 'amed', 'epargne': 2200}, 
	{'nom': 'Gueux', 'prenom': 'bernard'}, 
	{'nom': 'Jambon', 'prenom': 'steven', 'epargne': 1670}, 
	{'nom': 'Gueux', 'prenom': 'sylvie', 'epargne': 3}, 
	{'nom': 'Durois', 'prenom': 'berbard', 'epargne': 300000} 
] 
print(synthese_familles(comptes))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env python3 
# coding: utf-8 
  
def cul_de_chouette(valeur): 
	# Initialisation du résultat 
	res=list()		# Au lieu de res=[] (PEP 203: explicite vaut mieux qu'implicite) 
  
	# Premier dé 
	for i in range(1, 7): 
		# Second dé (qui commence à la valeur du premier) 
		for j in range(i, 7): 
			# Troisième dé (qui commence à la valeur du second) 
			for k in range(j, 7): 
				# Si la somme des dés a la bonne valeur on complète la liste des résultats 
				if (i+j+k) == valeur: res.append((i, j, k)) 
			# for 
		# for 
	# for 
  
	# Tirage terminé - Renvoi des résultats trouvés 
	return res 
# cul_de_chouette() 
  
# Affichage des tirages qui correspondent 
for c in cul_de_chouette(7): print(c)

1
2
3
4
(1, 1, 5) 
(1, 2, 4) 
(1, 3, 3) 
(2, 2, 3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python3 
# coding: utf-8 
  
def cul_de_chouette(valeur): 
	# Premier dé 
	for i in range(1, 7): 
		# Second dé (qui commence à la valeur du premier) 
		for j in range(i, 7): 
			# Troisième dé (qui commence à la valeur du second) 
			for k in range(j, 7): 
				# Si la somme des dés a la bonne valeur 
				if (i+j+k) == valeur: 
					# On retourne le résultat généré 
					yield (i, j, k) 
					# Une fois ce résultat traité par l'appelant, la fonction reprend son travail à partir de ce point 
				# if 
			# for 
		# for 
	# for 
	# Tirage terminé - Toutefois puisque chaque tirage a été retourné au fur et à mesure, il n'y a donc rien à renvoyer 
# cul_de_chouette()

1
2
3
4
(1, 1, 5) 
(1, 2, 4) 
(1, 3, 3) 
(2, 2, 3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#!/usr/bin/env python3 
# coding: utf-8 
  
# Fonction de génération de boucles 
def genere_boucle(*boucles): 
	# Une boucle peut être de la forme: 
	# - (x,) => de 0 à x (non inclus) 
	# - (x, y) => de x (inclus) à y (non inclus) 
	# - (x, y, z) => de x (inclus) à y (non inclus) par pas de z 
	# Il faut donc les calibrer (donc les modifier) 
	boucles=list(boucles)		# Elles ne peuvent plus être tuple 
	for i in range(len(boucles)): 
		match len(boucles[i]): 
			case 1: # Cas [x] 
				boucles[i]=[0, boucles[i][0], 1] 
			case 2: # Cas [x, y] 
				boucles[i]=[boucles[i][0], boucles[i][1], 1] 
		# match 
	# for 
  
	# Initialisation du résultat au min de chaque boucle 
	res=[x[0] for x in boucles] 
  
	# L'initialisation fait partie des résultats à retourner 
	yield res 
  
	# Tant qu'il y a des indices à traiter 
	i=0 
	while i < len(boucles): 
		# On incrémente le résultat en cours avec l'incrément de la boucle en cours 
		res[i]+=boucles[i][2] 
  
		# Si l'incrément de cette boucle n'est pas terminé 
		if res[i] < boucles[i][1]: 
			# On retourne le résultat 
			yield res 
  
			# On repars sur la première boucle 
			i=0 
			continue 
		# if 
  
		# La boucle est au max, on la réinitialise 
		res[i]=boucles[i][0] 
  
		# L'indice passe à la boucle suivante (ce qui permet de quitter si on a terminé 
		i+=1 
	# while 
# genere_boucle()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[1, 1, 0] 
[1, 1, 1] 
[1, 1, 2] 
[1, 1, 3] 
[1, 3, 0] 
[1, 3, 1] 
[1, 3, 2] 
[1, 3, 3] 
[1, 5, 0] 
[1, 5, 1] 
[1, 5, 2] 
[1, 5, 3] 
[2, 1, 0] 
[2, 1, 1] 
[2, 1, 2] 
[2, 1, 3] 
[2, 3, 0] 
[2, 3, 1] 
[2, 3, 2] 
[2, 3, 3] 
[2, 5, 0] 
[2, 5, 1] 
[2, 5, 2] 
[2, 5, 3]

1
2
3
4
5
6
def cul_de_chouette(valeur): 
	for de in genere_boucle((1, 7), (1, 7), (1, 7)): 
		if de[0] <= de[1] <= de[2] and sum(de) == valeur: yield de 
# cul_de_chouette() 
  
for c in cul_de_chouette(7): print(c)

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python3 
# coding: utf-8 
  
import itertools 
def cul_de_chouette(valeur): 
	for de in itertools.product(range(1, 7), repeat=3): 
		if de[0] <= de[1] <= de[2] and sum(de) == valeur: yield de 
# cul_de_chouette() 
  
for c in cul_de_chouette(7): print(c)

1
2
3
4
(1, 1, 5) 
(1, 2, 4) 
(1, 3, 3) 
(2, 2, 3)

1
2
3
4
5
   1 
   9  4  0 
+     8  3 
---------- 
1  0  2  3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#!/usr/bin/env python3 
# coding: utf-8 
  
def somme_2nombres(n1, n2): 
	i = retenue = 0 
	resultat = [] 
  
	# On inverse les nombres pour pouvoir les traiter dans le sens mathématique 
	(n1, n2) = (n1[::-1], n2[::-1]) 
  
	# D'abord on traite les éléments communs aux deux 
	while i < len(n1) and i < len(n2): 
		addition = (n1[i] + n2[i] + retenue) % 10 
		retenue  = (n1[i] + n2[i] + retenue) // 10 
		resultat.append(addition) 
		i += 1 
	# while 
  
 	# Ensuite on traite la partie qui dépasse qui peut être n1... 
	while i < len(n1): 
		addition = (n1[i] + retenue) % 10 
		retenue  = (n1[i] + retenue) // 10 
		resultat.append(addition) 
		i += 1 
	# while 
  
 	# ... ou n2 
	while i < len(n2): 
		addition = (n2[i] + retenue) % 10 
		retenue  = (n2[i] + retenue) // 10 
		resultat.append(addition) 
		i += 1 
	# while 
  
  	# N'oublions pas la retenue 
	if  retenue > 0: resultat.append(1) 
  
 	# On renvoie le résultat remis dans le bon sens 
	return resultat[::-1] 
# somme_2nombres() 
  
# Test de vérification 
print(somme_2nombres([9, 4, 0], [8, 3])) 
print(somme_2nombres([3, 9, 4, 0], [8, 3])) 
print(somme_2nombres([1, 9, 3], [7])) 
print(somme_2nombres([0], [0]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/env python3 
# coding: utf-8 
  
def somme_2nombres(n1, n2): 
	retenue = 0 
	resultat = list()					# Au lieu de resultat=[] (PEP 203: explicite vaut mieux qu'implicite) 
  
	# On inverse les nombres pour pouvoir les traiter dans le sens mathématique 
	(n1, n2) = (n1[::-1], n2[::-1]) 
  
	# On va récupérer leur longueur pour pouvoir évaluer le dépassement 
	(l1, l2) = (len(n1), len(n2)) 
  
	# On traite ensuite le maximum des deux listes 
	for i in range(max(l1, l2)): 
		# On gère le dépassement n1 ou n2 
		x1 = n1[i] if i < l1 else 0 
		x2 = n2[i] if i < l2 else 0 
  
		# Suffit ensuite d'additionner le résultat 
		(retenue, addition) = divmod(x1 + x2 + retenue, 10) 
		resultat.append(addition) 
	# for 
  
	# N'oublions pas la retenue 
	if retenue > 0: resultat.append(1) 
  
	# On renvoie le résultat remis dans le bon sens 
	return resultat[::-1] 
# somme_2nombres() 
  
# Test de vérification 
print(somme_2nombres([9, 4, 0], [8, 3])) 
print(somme_2nombres([3, 9, 4, 0], [8, 3])) 
print(somme_2nombres([1, 9, 3], [7])) 
print(somme_2nombres([0], [0]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#!/usr/bin/env python3 
# coding: utf-8 
  
from collections import deque 
from itertools import zip_longest 
  
def somme_2nombres(n1, n2): 
	retenue = 0 
	resultat = deque() 
  
	# On traite les nombres en les inversant à la volée et en les associant ensembles 
	for (c1, c2) in zip_longest(reversed(n1), reversed(n2), fillvalue=0): 
		# Suffit de calculer le résultat et la retenue... 
		(retenue, c3) = divmod(c1 + c2 + retenue, 10) 
  
		# ... et stocker le calcul sur la gauche du résultat 
		resultat.appendleft(c3) 
	# for 
  
	# N'oublions pas la retenue 
	if retenue > 0: resultat.appendleft(1) 
  
	# Le résultat étant directement dans le bon sens, suffit de le renvoyer 
	return list(resultat) 
# somme_2nombres() 
  
# Test de vérification 
print(somme_2nombres([9, 4, 0], [8, 3])) 
print(somme_2nombres([3, 9, 4, 0], [8, 3])) 
print(somme_2nombres([1, 9, 3], [7])) 
print(somme_2nombres([0], [0]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python3 
# coding: utf-8 
  
def somme_2(tab, cible): 
	resultat = [] 
  
	# Traitement des nombres 
	for i in range(len(tab) - 1): 
		# Traitement des nombres restants 
		for j in range(i + 1, len(tab)): 
			# Si la somme correspond, on la stocke 
			if tab[i] + tab[j] == cible: resultat.append((i, j)) 
		# for 
	# for 
  
	# On retourne le résultat 
	return resultat 
# somme_2() 
  
# Test de vérification 
print(somme_2([-2, -2, -1, -1, 1, 2, 2], cible = 0))

1
2
3
4
from itertools import combinations  
  
def somme_2(tab, cible): 
    return [(i, j) for i, j in combinations(range(len(tab)), 2) if tab[i] + tab[j] == cible]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env python3 
# coding: utf-8 
  
def somme_2(tab, cible): 
	resultat = [] 
	positions = {} 
  
	# Traitement des éléments du tableau 
	for (j, element) in enumerate(tab): 
		# Calcul de la différence à trouver par rapport à l'élément traité 
		diff = cible - element 
  
		# Si la différence a déjà été enregistrée 
		if diff in positions: 
			# Ajouter les couples au résultat 
			resultat+=[(i, j) for i in positions[diff]] 
  
		# Enregistrer la position de l'élément en cours dans le dictionnaire 
		positions.setdefault(element, []).append(j) 
		#print (j, resultat, positions) 
	return resultat 
# somme_2() 
  
# Test de vérification 
print(somme_2([-2, -2, -1, -1, 1, 2, 2], cible = 0))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#!/usr/bin/env python3 
# coding: utf-8 
  
def chemin(p): 
	# Cas particulier: le tableau n'a qu'une ligne 
	if len(p) == 1: return p[0][0] 
  
	# Fonction récursive de recherche dans l'arbre 
	def find_r(r=1, c=0): 
		# Fin de récursivité (si on est arrivé en bas de l'arbre) 
		if r+1 == len(p): 
			# Il n'y a plus que 2 nombres à évaluer 
			return min(p[r][c], p[r][c+1]) 
  
		# On évalue le minimume entre le poids du noeud et celui de son voisin 
		return min(p[r][c] + find_r(r+1, c), p[r][c+1] + find_r(r+1, c+1)) 
	# find_r() 
  
	# Le poids min doit contenir le retour de l'exploration récursive plus le tout premier noeud de la pyramide 
	return find_r() + p[0][0] 
# chemin() 
  
# Tests 
pyramide=[[1,], [2, 3], [4, 4, 1]] 
print(chemin(pyramide)) 
  
pyramide = [[1,], [2, 3], [6, 4, 5], [8, 1, 2, 9]] 
print(chemin(pyramide)) 
  
pyramide = [[1,], [5, 4], [1, 4, 3], [3, 4, 2, 1], [1, 2, 5, 5, 5]] 
print(chemin(pyramide))

1
2
3
4
5
  1     4 4 1 
 2 3     2 3 
4 4 1     1 
 
         pyramide retournée

1
2
3
4
5
 4 4 1      4 4 1 
  6 4        6 4 
   1          5 
 
étape 1    étape 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#!/usr/bin/env python3 
# coding: utf-8 
  
def chemin(p, *, debug=False): 
	# On commence par renverser la pyramide 
	p = reversed(p) 
  
	# On initialise la liste des sommes sur le premier élément de la pyramide (donc sa ligne la plus large) 
	sommes = list(next(p)) 
  
	# Debug 
	if debug: print("somme départ=%s" % sommes) 
  
	# On traite les lignes restantes 
	for ligne in p: 
		# On traite chaque valeur de la ligne 
		for (i, v) in enumerate(ligne): 
			# La somme courante récupère le minima entre elle et son voisin plus la valeur en cours 
			sommes[i] = min(sommes[i], sommes[i + 1]) + v 
		# for 
  
		# On pourrait retirer le dernier élément de la liste sommes, mais on se contentera de l'ignorer. 
		# del sommes[-1] 
  
		# Debug 
		if debug: print("ligne=%s, somme=%s" % (ligne, sommes)) 
	# for 
  
	# Au final, il ne reste qu'un seul élément non ignoré. 
	return sommes[0] 
  
# Tests 
pyramide=[[1,], [2, 3], [4, 4, 1]] 
print(chemin(pyramide, debug=True)) 
  
pyramide = [[1,], [2, 3], [6, 4, 5], [8, 1, 2, 9]] 
print(chemin(pyramide)) 
  
pyramide = [[1,], [5, 4], [1, 4, 3], [3, 4, 2, 1], [1, 2, 5, 5, 5]] 
print(chemin(pyramide))

1
2
3
4
5
6
7
8
9
10
11
12
def max_distance(sieges): 
    n = len(sieges) 
    sieges_occupes = [i for i, siege in enumerate(sieges) if siege == 1] # positions des sièges occupés 
    dmax = max( 
        ((sieges_occupes[i + 1] - sieges_occupes[i]) // 2 for i in range(len(sieges_occupes) - 1)), 
        default = 0, 
    ) # calcul des distances entre deux sièges occupés, on retient la plus grande. 
    if sieges[0] == 0: # il y a peut-être des places libres avant le 1er siège occupé 
        dmax = max(dmax, sieges_occupes[0]) 
    if sieges[n - 1] == 0: # idem après le dernier siège occupé 
        dmax = max(dmax, n - 1 - sieges_occupes[-1]) 
    return dmax

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def max_distance(sieges): 
    n = len(sieges) 
    dmax = 0 
    depart = None 
  
    for i, siege in enumerate(sieges): 
        if siege == 1:  # si le siège à la position i est occupé 
            if depart is None:  # si i est la position du 1er siège occupé rencontré en partant de la gauche 
                dmax = i 
            else: 
                dmax = max(dmax, (i - depart) // 2) 
            depart = i  # on mémorise l'emplacement du dernier siège occupé rencontré 
  
    dmax = max(dmax, n - 1 - depart)  # tenir compte des derniers sièges libres en fin de rangée 
  
    return dmax

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def max_distance(sieges): 
    distance_max = 0 
    nb_sieges_libres_successifs = 0 
    il_y_a_quelqu_un_a_gauche = False 
    for siege in sieges: 
        if siege == 0:  # siège libre 
            nb_sieges_libres_successifs += 1 
        else:  # siège occupé 
            if il_y_a_quelqu_un_a_gauche: 
                distance_max = max(distance_max, (nb_sieges_libres_successifs + 1) // 2) 
            else: 
                distance_max = nb_sieges_libres_successifs 
                il_y_a_quelqu_un_a_gauche = True 
            nb_sieges_libres_successifs = 0 
    distance_max = max(distance_max, nb_sieges_libres_successifs) 
    return distance_max

1
2
3
4
5
6
7
8
9
from itertools import chain, pairwise 
  
def max_distance(sieges): 
    return max( 
        chain( 
            (sieges.index(1), sieges[::-1].index(1)), 
            ((k - j) // 2 for j, k in pairwise(i for i, siege in enumerate(sieges) if siege == 1)), 
        ) 
    )