Nous allons voir comment implémenter un MasterMind en Python, mais uniquement en mode console.
MasterMind en Python: le jeu
Le jeu du MasterMind consiste deviner une combinaison de couleurs.
À chaque proposition, votre adversaire doit vous dire:
- combien de couleurs sont au(x) bon(s) endroit(s), sans indiquer lesquelles;
- combien de couleurs sont bonnes mais pas au bon endroit.
Vous l’aurez compris, votre adversaire, ce sera l’ordinateur… C’est lui qui décidera la combinaison de couleurs à trouver.
MasterMind en Python: implémentation
Préliminaires
Nous allons décider du fait que les couleurs seront représentées par des lettres capitalisées de l’alphabet latin: A, B, C, D, …
Nous allons donc écrire une première fonction qui retourne l’alphabet sur lequel s’appuyer pour générer une combinaison de couleurs à trouver:
from string import ascii_uppercase
def gen_colors(code_size):
if code_size <= 26:
return ascii_uppercase[:code_size]
else:
return ascii_uppercaseCette fonction retourne donc les n premières lettres de l’alphabet si n< 27, et retourne l’alphabet complet si n > 26.
>>> gen_colors(5)
'ABCDE'
>>> gen_colors(200)
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'Il nous faut maintenant une fonction retournant une combinaison aléatoire de n couleurs prises parmi toutes celles de ce nouvel ensemble.
from random import choice
def gen_code(code_size, colors):
r = ''
for _ in range(code_size):
r += choice(colors)>>> gen_code(5,'ABCDEFGH')
'GCBAG'Vérifications
Nous allons dans un premier temps écrire une fonction check_guess(guess, code_size, colors) qui vérifie si, d’une part, la longueur de “guess” est la même que code_size, et d’autre part si une couleur présente dans “guess” est aussi dans “colors”:
def check_guess(guess, code_size, colors):
present_colors = [ i in colors for i in guess ]
return len( guess ) == code_size and False not in present_colorsJ’ai opté pour cette solution, mais il y a d’autres possibilités.
Ici, je construis une liste de booléens correspondants au fait que chaque élément de “guess” se trouve ou non dans “colors”. Si il n’y a aucun “False” dans cette liste, cela signifie que toutes les couleurs proposées sont dans l’alphabet autorisé.
Si la longueur de “guess” est la même que celle de “colors” ET si aucun “False” est dans la liste construite, la fonction renvoie “True”.
Renvoi du nombre de bonnes couleurs
def score_guess(code, guess):
n_good_position = 0
n_false_position = 0
if len( code ) == len( guess ):
for i in range( len(code) ):
if code[i] == guess[i]:
n_good_position += 1
elif guess[i] in code:
n_false_position += 1
return n_good_position , n_false_position>>> score_guess('ABCD' , 'AABC')
(1, 3)Il y a en effet 1 bonne lettre (à sa place) et en tout 3 lettres correctes mais pas à la bonne place (le second ‘A’ est à la deuxième position et non à la 1ère, le ‘B’ et le ‘C’ sont bonnes mais pas au bon endroit).
Le jeu
def play(code_size, nb_colors):
print(f'Les différentes couleurs possibles sont: {gen_colors(nb_colors)}.')
print(f'Le code à trouver est de longueur {code_size}.')
n = 0
to_find = gen_code(code_size, gen_colors(nb_colors)) # combinaison à trouver
while True:
guess = input(f'{n} --> ').upper()
if not check_guess(guess, code_size, gen_colors(nb_colors)):
print('Mauvaise taille ou couleur...')
elif guess != to_find:
print( score_guess(to_find, guess) )
n += 1
else:
print( f'Félicitations, vous avez trouvé après {n+1} essais!' )
break>>> play(4,4)
Les différentes couleurs possibles sont: ABCD.
Le code à trouver est de longueur 4.
0 --> ABCD
(1, 2)
1 --> ABBB
(0, 1)
2 --> CBCC
(1, 2)
3 --> BBDD
(1, 1)
4 --> DBCB
(0, 2)Bon, je ne sais pas pour vous mais c’est assez frustrant de ne pas trouver après un certain nombre d’essais.
Je vais donc ajouter un argument à ma fonction pour limiter le nombre de coups maximum.
def play(code_size, nb_colors , nb_max = None):
print(f'Possible colors are: {gen_colors(nb_colors)}.')
print(f'Code size is {code_size}.')
n = 0
count = 0
to_find = gen_code(code_size, gen_colors(nb_colors)) # combinaison à trouver
while True:
if nb_max != None and n <= nb_max or nb_max == None:
guess = input(f'{n} --> ').upper()
if not check_guess(guess, code_size, gen_colors(nb_colors)):
print('Mauvaise taille ou couleur...')
elif guess != to_find:
print( score_guess(to_find, guess) )
n += 1
else:
print( f'Félicitations, vous avez trouvé après {n+1} essais!' )
break
else:
print(f'Il fallait trouver: {to_find}')
break>>> play(4,4,3)
Possible colors are: ABCD.
Code size is 4.
0 --> aaaa
(1, 3)
1 --> bbbb
(1, 3)
2 --> cccc
(1, 3)
3 --> abcd
(1, 3)
Il fallait trouver: DACBMémorisation des propositions
Dans la pratique, il est possible de s’y perdre avec toutes les propositions que l’on a faites.
Si l’on souhaite ne pas compter les coups identiques, on peut mémoriser tous les coups dans une liste L.
def play(code_size, nb_colors , nb_max = None):
print(f'Possible colors are: {gen_colors(nb_colors)}.')
print(f'Code size is {code_size}.')
n = 0
count = 0
to_find = gen_code(code_size, gen_colors(nb_colors)) # combinaison à trouver
L = []
while True:
if nb_max != None and n <= nb_max or nb_max == None:
guess = input(f'{n} --> ').upper()
if not check_guess(guess, code_size, gen_colors(nb_colors)):
print('Mauvaise taille ou couleur...')
elif guess in L:
print('Proposition déjà faite avant...')
elif guess != to_find:
print( score_guess(to_find, guess) )
L.append( guess )
n += 1
else:
print( f'Félicitations, vous avez trouvé après {n+1} essais!' )
break
else:
print(f'Il fallait trouver: {to_find}')
break>>> play(4,4,3)
Possible colors are: ABCD.
Code size is 4.
0 --> abcd
(0, 4)
1 --> abcd
Proposition déjà faite avant...
1 --> aabb
(0, 4)
2 --> bbbb
(1, 3)
3 --> dcba
(2, 2)
Il fallait trouver: BCDABon, là, on est pas mal non ?
