[OCaml] Mastermind
esmeel
Messages postés
3
Statut
Membre
-
KX Messages postés 19031 Statut Modérateur -
KX Messages postés 19031 Statut Modérateur -
Bonjour,
Bonjour ,
Dans le cadre d'un projet de 1 ère année , on nous demande de programmer un mastermind en ocaml, de façon à ce que l'ordinateur puisse trouver la combinaison en un nombre limité de coups .On nous oblige a choisir un type arborescent pour les combinaisons ,j'ai donc défini ce type :
J'ai vraiment besoin d'aide pour écrire cette fonction et merci .
Bonjour ,
Dans le cadre d'un projet de 1 ère année , on nous demande de programmer un mastermind en ocaml, de façon à ce que l'ordinateur puisse trouver la combinaison en un nombre limité de coups .On nous oblige a choisir un type arborescent pour les combinaisons ,j'ai donc défini ce type :
type pion = Rouge| Vert|Jaune|Bleu|Magenta|Blanc|Noir|Cyan ;;J'ai quelques difficultés a écrire une fonction qui génère la combinaison la plus longue possible et qui a pour paramètre l'ensemble des combinaisons encore possibles, celà dit avec un type de combinaisons string list list , j'ai réussi a écrire cette fonction , mais je ne sais pas comment l'aborder avec le type arborescent que j'ai définit :
type combinaisons= Node of bool*(pion*combinaisons)list ;;
let rec combinaison_liste taille =
let rec construire_aux l=
match l with
|[]->[]
|t::q->(("Rouge"::t)::(("Vert"::t)::(("Jaune"::t)::(("Bleu"::t)::(("Magenta"::t)::(("Blanc"::t)::(("Noir"::t)::(("Cyan"::t)::construire_aux q))))))))
in match taille with
|1->(["Rouge"],["Vert"],["Jaune"],["Bleu"],["Magenta"],["Blanc"],["Noir"],["Cyan"])
|n-> if n<=0 then failwith "n doit etre un nombre strictement positif "
else construire_aux (combinaison_liste(taille-1)) ;;
J'ai vraiment besoin d'aide pour écrire cette fonction et merci .
A voir également:
- [OCaml] Mastermind
- Technique mastermind ✓ - Forum C
- Mastermind ✓ - Forum Programmation
- Mastermind technique - Forum C
3 réponses
Rouge, Vert, Bleu etc. sont des constantes de type pion, tu ne dois donc pas les manipuler avec des guillemets comme des chaînes de caractères.
Ensuite lorsque tu fais a::b alors b est une liste mais a est un élément, tu ne peux pas l'utiliser comme une liste. Si tu veux concaténer deux listes alors utilises @
Exemple :
Cependant je ne suis pas sûr que cela corresponde à ce que tu veux faire...
Tu devrais peut-être expliquer mieux ton problème (tes entrées, tes sorties).
Parce qu'après c'est pareil, dans ta fonction principale tu as des erreurs, mais comme on ne sait pas ce que tu veux vraiment faire avec difficile de te dire comment corriger ça proprement... Un petit exemple ?
Ensuite lorsque tu fais a::b alors b est une liste mais a est un élément, tu ne peux pas l'utiliser comme une liste. Si tu veux concaténer deux listes alors utilises @
construire_aux : pion list list -> pion list = <fun>
let rec construire_aux = function
[]->[]
|t::q->(Rouge::t)@(Vert::t)@(Jaune::t)@(Bleu::t)@(Magenta::t)@(Blanc::t)@(Noir::t)@(Cyan::t)@(construire_aux q);;
Exemple :
construire_aux [[Rouge];[Bleu;Vert]];;
[Rouge; Rouge; Vert; Rouge; Jaune; Rouge; Bleu; Rouge; Magenta; Rouge; Blanc; Rouge; Noir; Rouge; Cyan; Rouge; Rouge; Bleu; Vert; Vert; Bleu; Vert; Jaune; Bleu; Vert; Bleu; Bleu; Vert; Magenta; Bleu; Vert; Blanc; Bleu; Vert; Noir; Bleu; Vert; Cyan; Bleu; Vert]
Cependant je ne suis pas sûr que cela corresponde à ce que tu veux faire...
Tu devrais peut-être expliquer mieux ton problème (tes entrées, tes sorties).
Parce qu'après c'est pareil, dans ta fonction principale tu as des erreurs, mais comme on ne sait pas ce que tu veux vraiment faire avec difficile de te dire comment corriger ça proprement... Un petit exemple ?
Merci d'avoir répondu , excusez moi j'ai du mal m'exprimer ,en fait au début j'avais défini un type combinaison :
sans définir de type pion et j'ai ainsi écris la fonction construire .Mais après avoir relu le sujet du projet , on nous impose de choisir un type arborescent pour combinaisons ce qui m'a ammené a choisir comme type :
type combinaison string list list
sans définir de type pion et j'ai ainsi écris la fonction construire .Mais après avoir relu le sujet du projet , on nous impose de choisir un type arborescent pour combinaisons ce qui m'a ammené a choisir comme type :
type pion = Rouge| Vert|Jaune|Bleu|Magenta|Blanc|Noir|Cyan ;;Or , en définissant ce type , je n'ai pas su comment définir cette même fonction construire qui doit génèrer la combinaison la plus longue possible et qui a pour paramètre l'ensemble des combinaisons encore possibles.J'espère que je me suis bien exprimé cette fois ci :)
type combinaisons= Node of bool*(pion*combinaisons)list
"génèrer la combinaison la plus longue possible et qui a pour paramètre l'ensemble des combinaisons encore possibles"
Pour moi c'est assez obscur...
Est-ce que tu pourrais donner un petit exemple à la main ? Supposons qu'on limite les couleurs à Bleu, Rouge, Vert, quel résultat attendrais-tu pour taille=2 et taille=3 ?
Pour moi c'est assez obscur...
Est-ce que tu pourrais donner un petit exemple à la main ? Supposons qu'on limite les couleurs à Bleu, Rouge, Vert, quel résultat attendrais-tu pour taille=2 et taille=3 ?
val plus_longue_combinaison : combinaisons -> Pion list;par exemple pour une taille de 2 elle doit pouvoir générer : [Rouge,Vert], [Rouge,Bleu],[Bleu,Vert] et pour une taille 3 il y en a qu'une seule [Rouge,Vert,Bleu]
Normalement avec la récursivité on doit avoir un paramètre petit associé à un résultat petit, et de proche augmenter le résultat à cause d'un paramètre plus grand. Toi c'est l'inverse que tu as.
Il faudrait plutôt réfléchir en terme de nombre d'éléments à enlever, plutôt que taille à obtenir.
Exemple :
Evidemment ce n'est pas tout à fait ce que tu veux, mais dans la manière de raisonner tu devrais partir dans cette direction : paramètre petit, résultat petit.
Il faudrait plutôt réfléchir en terme de nombre d'éléments à enlever, plutôt que taille à obtenir.
Exemple :
f [1,2,3] 0 = [[1,2,3]]
f [1,2,3] 1 = (f [1,2] 0)@(f [1,3] 0)@(f [2,3] 0) = [[1,2],[1,3],[2,3]]
f [1,2,3] 2 = (f [1,2] 1)@(f [1,3] 1)@(f [2,3] 1) = ((f [1] 0)@(f [2] 0))@((f [1] 0)@(f [3] 0))@((f [2] 0)@(f [3] 0)) = [[1],[2],[1],[3],[2],[3]]
Evidemment ce n'est pas tout à fait ce que tu veux, mais dans la manière de raisonner tu devrais partir dans cette direction : paramètre petit, résultat petit.
