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

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
70
71
72
73
74
75
76
77
78
79
80
81
82
#!/usr/bin/env python3  
# coding: utf-8  
  
import random  
  
# Le jeu  
def jeu(minValue, maxValue, *, taux=20):  
	historique=[]					# L'historique des réponses  
	plage=(minValue, maxValue)			# La plage de valeurs  
  
	# Préparation jeu  
	taux%=100					# Un taux ne peut pas être supérieur à 100  
	print(  
		"Mémorisez un nombre entre {} et {}, je vais essayer de le retrouver".format(  
			minValue,  
			maxValue,  
		)  
	)  
	input("Appuyez sur <enter> quand vous serez prêt. Et ne trichez pas ensuite...")  
  
	# Boucle de jeu  
	while True:  
		# Evaluation du nombre à proposer: le taux permet d'influer sur une certaine marge  
		delta=int(taux * (plage[1] - plage[0]) // 100)  
		propose=sum(plage) // 2 + random.randint(-delta, delta)  
  
		# Proposition du chiffre, attente réponse joueur  
		while True:  
			rep=input("Je propose {}... +, - ou G ?".format(propose))  
			if rep and rep in "+-G": break  
			print("S'il vous plaît, répondez par + ou - ou G !!!")  
		# while  
  
		# Gagné ?  
		if rep == "G":  
			print("J'ai trouvé {} en {} coups !!!".format(propose, len(historique) + 1))  
			return (True, len(historique) + 1)  
		# if  
  
		# Calcul nouvelle plage de valeurs  
		plage=(plage[0], propose-1) if rep == "-" else (propose+1, plage[1])  
  
		# Si la plage devient incohérente 
		if (plage[0] > plage[1]): 
			# Tricherie dans la réponse 
			posT=tricherie(propose, rep, historique)  
			print(  
				"Tricheur !!! A la réponse {} il avait été proposé {} et répondu \"{}\" - En proposant {} la réponse ne peut pas être \"{}\" !!!".format(  
					posT+1,  
					historique[posT]["nb"],  
					historique[posT]["rep"],  
					propose,  
					rep,  
				)  
			)  
			print("J'ai gagné par forfait en {} coups !!!".format(len(historique) + 1))  
			return (False, len(historique) + 1)  
		# if 
  
		# Enregistrement de la réponse  
		historique.append(  
			{  
				"nb" : propose,  
				"rep" : rep,  
			}  
		)  
	# while  
# jeu()  
  
# Recherche tricherie dans historique 
def tricherie(nb, rep, historique):  
	for (i, h) in enumerate(historique):  
		#print(i, nb, rep, h)  
		# La tricherie se produit si le joueur répond "+" pour une proposition  
		# Alors qu'il avait répondu "-" à une proposition se situant à +1 (et inversement)  
		if h["nb"] + (1 if rep == "-" else -1) == nb: return i  
	# for  
	return None 
# tricherie()  
  
# Lancement du jeu  
jeu(1, 100)

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
def robot_simulation(commandes, obstacles): 
	# Le tableau des déplacements 
	deplacement=( 
		{'dx': 0, 'dy': 1},		# Déplacement vers le nord 
		{'dx': -1, 'dy': 0},		# Déplacement vers l'ouest 
		{'dx': 0, 'dy': -1},		# Déplacement vers le sud 
		{'dx': 1, 'dy': 0},		# Déplacement vers l'est 
	) 
	direction=0				# Robot orienté initialement vers le nord 
	(x, y)=(0, 0)				# Position initiale du robot 
  
  	# Traitement des commandes 
	distance_maxi=0 
	for cmd in commandes: 
		if cmd == 'g': 
			# Le robot tourne à gauche 
			direction=(direction+1) % 4 
		elif cmd == 'd': 
			# Le robot tourne à droite 
			direction=(direction-1) % 4 
		elif cmd in range(1, 10): 
			# Déplacement 
			(dx, dy)=(deplacement[direction]['dx'], deplacement[direction]['dy']) 
			for i in range(cmd): 
				# Si la case suivante est bouchée, on ne se déplace plus 
				if (x + dx, y + dy) in obstacles: break 
  
				# Déplacement 
				x+=dx 
				y+=dy 
  
				# Evaluation distance 
				distance=x**2 + y**2 
				if distance > distance_maxi: distance_maxi=distance 
			# for 
		# else: pass		# Si éventuellement on veut traiter une commande incorrecte 
		# if 
	# for 
  
	return distance_maxi 
# robot_simulation()

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
from itertools import takewhile 
  
def robot_simulation(commandes, obstacles): 
	# Le tableau des déplacements 
	deplacement={ 
		"nord": { 
			"g": "ouest", 		# Identifiant case de gauche 
			"d": "est", 		# Identifiant case de droite 
			"chemin": lambda x, y, nb: ((x, y+k) for k in range(1, nb+1)), 
						# Fonction qui génère le chemin théorique 
		}, 
		"est": { 
			"g": "nord", 		# Identifiant case de gauche 
			"d": "sud", 		# Identifiant case de droite 
			"chemin": lambda x, y, nb: ((x+k, y) for k in range(1, nb+1)), 
						# Fonction qui génère le chemin théorique 
		}, 
		"sud": { 
			"g": "est", 		# Identifiant case de gauche 
			"d": "ouest", 		# Identifiant case de droite 
			"chemin": lambda x, y, nb: ((x, y-k) for k in range(1, nb+1)), 
						# Fonction qui génère le chemin théorique 
		}, 
		"ouest": { 
			"g": "sud", 		# Identifiant case de gauche 
			"d": "nord", 		# Identifiant case de droite 
			"chemin": lambda x, y, nb: ((x-k, y) for k in range(1, nb+1)), 
						# Fonction qui génère le chemin théorique 
		}, 
	} 
  
  	# Fonction de génération des positions 
	def positions(): 
		# On commence par générer la position de départ 
		yield (0, 0) 
  
		# Position initiale du robot 
		(x, y)=(0, 0) 
		direction="nord" 
  
		# Traitement des commandes 
		for cmd in commandes: 
			# Si la commande est une rotation 
			if cmd in ("g", "d"): 
				# La nouvele direction remplace la direction actuelle 
				direction=deplacement[direction][cmd] 
			elif cmd in range(1, 10): 
				# On crée le chemin théorique 
				chemin=deplacement[direction]["chemin"](x, y, cmd) 
  
				# On crée les cases réellement parcourues (tant qu'il n'y a pas d'obstacle) 
				cases_parcourues=tuple(takewhile(lambda c: c not in obstacles, chemin)) 
  
				# Si le robot peut se déplacer 
				if cases_parcourues: 
					# On renvoie sa dernière position 
					yield cases_parcourues[-1] 
				# if 
			#else: pass		# Si éventuellement on veut traiter une commande incorrecte 
			# if 
		# for 
	# positions() 
  
	# Suffit de récupérer le max des distances calculées 
	return max(x**2 + y**2 for (x, y) in positions()) 
# robot_simulation()