Discussion :

[RowanMayfair]

Bonjour,

Je bloque sur un problème de dés (à jouer).
c'est frustrant parce que j'ai l'impression qu'il y a une solution simple, mais je ne la trouve pas.

le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
n = int(input('Donnez un entier entre 2 et 12 : '))
 
des = [[chiffre1,chiffre2] for chiffre1 in range(1,7) \
       for chiffre2 in range (1,7)\
      if chiffre1 + chiffre2 == n]
 
print("Il y a {} façon d'obtenir {} avec 2 dés : {}.".format(len(des),n,des))

(la compréhension de liste n'était pas forcément appropriée dans ce cas, mais je m'entraîne )

Donc par exemple si je propose 10, il me répond "Il y a 3 façon d'obtenir 10 avec 2 dés : [[4, 6], [5, 5], [6, 4]]."
Oui mais......4,6 et 6,4 c'est la même chose, il s'agit de dés. Donc en réalité il n'y a que 2 façons de faire 10 avec 2 dés.

Ma question donc : comment je supprime l'un des doublons ?

[olivier1969]

Hello ,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if chiffre1 + chiffre2 == n and chiffre1 <= chiffre2

et du coup ... tu ne conserves qu'une seule des solutions

[RowanMayfair]

Oh mais oui tout simplement !

Merci beaucoup Olivier

[tyrtamos]

Bonjour,

Je suggère une autre approche pour le fun:

Pour simuler le tirage des dés, on peut tirer toutes les combinaisons des 6 nombres (1,2,3,4,5,6) 2 à 2 en utilisant la fonction "combinations_with_replacement" du module itertools. A noter qu'on ne peut pas utiliser ici la fonction "combinations" puisqu'un premier dé avec un nombre n'exclut pas que le 2ème dé ait le même nombre.

On crée ensuite un dictionnaire avec pour clé la somme des 2 dés tirés, et pour valeur la liste des couples de dés qui donne cette somme.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
from itertools import combinations, combinations_with_replacement
 
L = []
R = {}
for elem in combinations_with_replacement([1,2,3,4,5,6], 2):
    L.append(elem)
    s = sum(elem)
    if s in R:
        R[s].append(elem)
    else:
        R[s] = [elem]

Ce qui donne pour la liste L:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (6, 6)]

Et pour le dictionnaire R:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

{2: [(1, 1)], 3: [(1, 2)], 4: [(1, 3), (2, 2)], 5: [(1, 4), (2, 3)], 6: [(1, 5), (2, 4), (3, 3)], 7: [(1, 6), (2, 5), (3, 4)], 8: [(2, 6), (3, 5), (4, 4)], 9: [(3, 6), (4, 5)], 10: [(4, 6), (5, 5)], 11: [(5, 6)], 12: [(6, 6)]}

On fait ce petit calcul au lancement du programme.

Ensuite, à chaque question, par exemple x=7, on obtient la réponse immédiate de toutes les possibilités d'obtenir cette somme: R[7] => [(1, 6), (2, 5), (3, 4)]

[wiztricks]

Salut,

Éviter de créer des doublons pour les trier ensuite est effectivement meilleur: moins d'itérations et moins de tests pour dédoublonner.

S'il est bon de faire de la publicité pour itertools et combinations_with_replacement, avec 2 dés, il y a plus "sobre" pour générer ces couples là:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tirages = ( (i, j) for i in range(1, 7) for j in range(i, 7) )

note: sûr qu'avec un nombre variables de dés...
Puis on remplit la liste en utilisant .setdefault, fonctionnalité de base des dictionnaires, toujours intéressante à connaître:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
R = dict()
for i, j in tirages:
    R.setdefault(i+j, []).append((i, j))

Et çà donne un code plus "compact".

- W

[tyrtamos]

Bonjour,

Merci wiztricks. Effectivement, pour 2 dés, le code est plus simple.

Et avec .setdefault (que je devrais utiliser plus souvent), ma solution peut être aussi plus concise:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
from itertools import combinations_with_replacement
 
R = {}
for elem in combinations_with_replacement([1,2,3,4,5,6], 2):
    R.setdefault(sum(elem), []).append(elem)

Ce qui donne, bien sûr, le même résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 2 => [(1, 1)]
 3 => [(1, 2)]
 4 => [(1, 3), (2, 2)]
 5 => [(1, 4), (2, 3)]
 6 => [(1, 5), (2, 4), (3, 3)]
 7 => [(1, 6), (2, 5), (3, 4)]
 8 => [(2, 6), (3, 5), (4, 4)]
 9 => [(3, 6), (4, 5)]
10 => [(4, 6), (5, 5)]
11 => [(5, 6)]
12 => [(6, 6)]

Et si on applique avec 3 dés, ça marche aussi, et on trouve, par exemple qu'il y a 6 façons d'obtenir une somme de 12:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

12 => [(1, 5, 6), (2, 4, 6), (2, 5, 5), (3, 3, 6), (3, 4, 5), (4, 4, 4)]

[Sve@r]

Bonjour

Puis on remplit la liste en utilisant .setdefault, fonctionnalité de base des dictionnaires, toujours intéressante à connaître:

Que je ne connaissais pas
Quand je pense à tous mes codes où j'ai écrit if truc not in dico: dico[truc]=machin...