[OCaml] Mastermind

Fermé

esmeel Messages postés 3 Date d'inscription mardi 10 décembre 2013 Statut Membre Dernière intervention 10 décembre 2013 - Modifié par KX le 10/12/2013 à 19:12
KX Messages postés 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 - 10 déc. 2013 à 20:49

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 :

type pion = Rouge| Vert|Jaune|Bleu|Magenta|Blanc|Noir|Cyan ;;
type combinaisons= Node of bool*(pion*combinaisons)list ;;

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 :

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:

3 réponses

Réponse 1 / 3

KX Messages postés 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 3 015
10 déc. 2013 à 19:12

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 @

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 ?

Réponse 2 / 3

esmeel Messages postés 3 Date d'inscription mardi 10 décembre 2013 Statut Membre Dernière intervention 10 décembre 2013
10 déc. 2013 à 19:22

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 :

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 ;;
type combinaisons= Node of bool*(pion*combinaisons)list

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 :)

KX Messages postés 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 3 015
10 déc. 2013 à 19:28

"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 ?

Réponse 3 / 3

esmeel Messages postés 3 Date d'inscription mardi 10 décembre 2013 Statut Membre Dernière intervention 10 décembre 2013
10 déc. 2013 à 19:38

 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]

KX Messages postés 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 3 015
10 déc. 2013 à 20:49

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 :

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.

Discussions similaires

-HELP- Les MASTERMINDS !

Mastermind : stratégie gagnant

demande d'algo Mastermind

utiliser String.sub en ocaml

programmer le mastermind en pascal

Discussions similaires

Newsletters