Forum Clubic

Urgent: pb en langage Caml

bonjour,
j’ai besoin d’un coup de main urgent pour un projet en caml

je voudrais réaliser un jeu mastermind
un joueur choisi de 4 couleurs parmi 7. L’autre jouer doit essayer de trouver la combinaison choisie. A partir d’une combinaison de départ, il va analyser la réponse faite par l’autrre joueur, et proposer une nouvelle combinaison qui correspond aux caracteristiques données, ce qui revient à reduire l’ensemble des solutions possibles en écartant toutes celles qui ne correspondent pas aux réponses données. La réponse faite est composée d’au maximum 4 pions: rouge si la couleur est à la bonne place, blanc si elle fait partie de la combinaison choisie mais que sa position est mauvaise. Par itération, il obtiendra ainsi la combinaison choisie au départ.

C super urgent!
alors si une star du CAML veut bien me répondre je serai super content
*** on evite les emails pour le spam****@hotmail.com

Bah deja OCaml y’a que moi qui pratique, enfin Sans-Nom va bientot si mettre…

De plus un modo va venir te dire que l on est pas des chiens, qu’on va pas te lacher sur un plateau le code tout fait.

Mais on va quand meme essayer de te faire avancer.
Deja, esce que tu est obliger d’utilisez Ocaml?
Tu dois le faire en mode texTe?

Algorithme basique:

tu creer une variable contenant la suite a trouver (exemple, 5657 represente la suite, de 1-7 pour la couleur), mais tu peux aussi creer un type somme.

tu créer une fonction qui a 2 argument, le 1er cest la proposition du joueur, le 2eme la serie a trouver.
cette fonction retournera la serie de blanc rouge et pas de pionts.

et après, c’est que du bonheur [:matleflou]

une fonction qui recupere la proposition du joueur
une qui “imprime” le resultat a l’ecran
un test qui regarde si le nb de coups max est pas atteind

Et puis tu assemble tout ca et c’est bon :stuck_out_tongue:

Moi me mettre à OCaml? t’es fou ou quoi? je veux dire entre OCaml, Projet Tutoré et Archi des Ordi, j’ai pris Tutoré, Archi des ordis et ce truc qu’est le OCaml…

je suis pas fou non plus :o

Scuse je viens de relire mon topic OCaml.
Autant pour moi.

Correction du 1er post:

JE suis le seul a programmer en OCaml, alors si tu veux que je le fasse donne moi de l argent :stuck_out_tongue:

C’est malin… au passage, je croyais que la maison ne faisait pas dans la ponte de code tout fait? :slight_smile:

j’attends de voir si le créateur du topic s’est retroussé les manches :slight_smile:

merci les gars de vous interreser a mon pb!

mon projet viens juste de commencer! l’idée de creer 2 fonctions est bonnes. Je rajouterai des commentaires tout a l’heure! car j’aurai plus d’info pour avancer.

Pour l’instant je suis encore dans le coup! mais merci de ne pas m’abandonner si je suis trop en galere

la reponse de “le syndicat” est envisageable si vraiment je suis a la rue! meme si la maison tout logiquement n’est pas censé faire ce travail

le prog devra d’abord analyser toutes les solutions possibles. puis l’autre fonction devra énumérer 4 couleurs. Le prog doit comparer les couleurs avec l’autre fonction.
Et en fonction de la reponse, enlevera des solutions possibles de maniere a avoir une solution unique a la fin.

Mon pb est que le caml est tout nouveau pour moi et que je ne vois pas comment coder ca!

Mais tu le veux en mode texte?
Pourquoi e prog devra d’abord analyser toutes les solutions possibles? il ne connais pas la combinaison gagnante?

Ce soir ou demain j’essayerais de faire le programme en guise d entrainement pour mon partiel

Prenez pas tout ce que je dis au 1er degré :o

le syndicat aide moi je t’en supplie!
** les mails, c par mp ***@yahoo.fr si y a moyen de se parler aussi par mail

c’est bon chiale pas bichon :stuck_out_tongue: jver poster mon code sur cette page mais j’ai pâs tout a fait terminer.

Repond deja à ces questions:

  • C’est en mode texte?
  • Au depart l’ordi choisi une combinaison gagnante de 4 pions sans repetition (pas de Bleu, Vert, Bleu, Jaune).
    Puis le joueur donne ca proposition
    puis l’ordi donne la reponse en Rouge Blanc ou Vide
    puis ca recommence jusqu’a que le joueur gagne non?

on utilise soit linux, on cré les fonctions sous un editeur et on compile sous ocaml!
sinon on peut le faire sous windows avec ocaml aussi et les fonctions dans un bloc note par exemple.

il y a 7 couleurs differentes
l’ordi en choisi 4

et le joueur donne sa proposition l’ordi repond en rouge, blanc ou vide
puis relance le programme en eliminant cette solution.

Le but étant d’arrivé a la solution unique

merci bcp et n’hesite pas a me redemander des explications

Mastermind v1.0 :sol:

[cpp]
exception BAD_INPUT;;

type pion = Blanc | Noir | Rouge | Vert | Bleu | Jaune | Orange | Vide;;

(* type enregistrement representant une “main” *)
type main = {mutable prem: pion; mutable deux: pion; mutable trois: pion; mutable quat: pion};;

(* main a trouver *)
let main_a_trouver = {prem=Blanc; deux=Rouge; trois=Vert; quat=Noir};;

let main_gagnante = [Blanc; Rouge; Orange; Noir];;

let ref main_joueur = [Blanc; Orange; Vert; Bleu];;

let rec size liste n =
match liste with
[]->n
|tete::queue-> size queue (n+1);;

let rec est_dans_main pion main =
match main with
[]->false
|tete::queue-> if tete=pion then true else est_dans_main pion queue;;

est_dans_main Vert main_gagnante;;
est_dans_main Noir main_gagnante;;

let indice_pion pion main =
let rec indice_pion_bis pion main n =
match main with
[]-> -1
| tete::queue -> if tete=pion then n else indice_pion_bis pion queue (n+1)
in indice_pion_bis pion main 0;;

let a = indice_pion Vert main_gagnante;;
let b = indice_pion Noir main_gagnante;;
let c = (string_of_int a);;
let d = (string_of_int b);;
let () = print_string c in (print_newline (); print_newline (); );;
let () = print_string d in (print_newline (); print_newline (); );;

let reponse_pion pion pion_gagnant main_gagnante =
if pion = pion_gagnant then [Rouge]
else
if indice_pion pion main_gagnante > -1 then [Blanc] else [Vide];;

let reponse_main main_joueur main_gagnante =
let rec reponse_main_bis main_joueur main_gagnante n =
match main_joueur with
[] -> []
| tete :: queue -> (reponse_pion tete (List.nth main_gagnante n) main_gagnante) @ reponse_main_bis queue main_gagnante (n+1)
in
reponse_main_bis main_joueur main_gagnante 0;;

let f = reponse_main [Vert; Bleu; Rouge; Jaune] [Vert; Rouge; Noir; Jaune];;
let g = reponse_main [Vert; Bleu; Rouge; Jaune] [Vert; Bleu; Rouge; Jaune];;

let efface_ecran =
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline () in
let () = print_newline ()
in print_newline () ;;

let print_header =
let () = print_newline () in
let () = print_string “############################################################” in
let () = print_newline () in
let () = print_string “##### #####” in
let () = print_newline () in
let () = print_string “##### Mastermind V1.0 #####” in
let () = print_newline () in
let () = print_string “##### #####” in
let () = print_newline () in
let () = print_string “##### Le_syndicat 13/01/04 #####” in
let () = print_newline () in
let () = print_string “##### #####” in
let () = print_newline () in
let () = print_string “############################################################” in
print_newline ();;

let string_of_pion pion=
match pion with
Blanc -> "Blanc "
| Noir -> "Noir "
| Bleu -> "Bleu "
| Rouge -> "Rouge "
| Vert -> "Vert "
| Jaune -> "Jaune "
| Orange -> "Orange "
| Vide -> "Vide ";;

let rec string_of_main main=
match main with
[]-> “”
|tete::queue -> (string_of_pion tete)^(string_of_main queue);;

let pion_of_int i =
match i with
1 -> Blanc
| 2 -> Noir
| 3 -> Rouge
| 4 -> Vert
| 5 -> Bleu
| 6 -> Jaune
| 7 -> Orange
|_-> raise BAD_INPUT;;

let rec get_pion() =
let () = print_newline() in
let () = print_string "1 - Blanc " in
let () = print_newline() in
let () = print_string "2 - Noir " in
let () = print_newline() in
let () = print_string "3 - Rouge " in
let () = print_newline() in
let () = print_string "4 - Vert " in
let () = print_newline() in
let () = print_string "5 - Bleu " in
let () = print_newline() in
let () = print_string "6 - Jaune " in
let () = print_newline() in
let () = print_string "7 - Orange " in
let () = print_newline() in
let () = print_string “Entrer un nombre entre 1 et 7 svp” in
let () = print_newline() in
let readpion = read_int () in
try pion_of_int readpion with
| BAD_INPUT -> get_pion ();;

let print_int_choix n =
match n with
1 -> print_string “1 - Blanc”
| 2 -> print_string “2 - Noir”
| 3 -> print_string “3 - Rouge”
| 4 -> print_string “4 - Vert”
| 5 -> print_string “5 - Bleu”
| 6 -> print_string “6 - Jaune”
| 7 -> print_string “7 - Orange”
|_-> print_string “Appel fct print_choix illogique !!”;;

let rec print_liste_choix liste =
match liste with
[]-> print_newline ()
| tete::queue -> let () = print_newline ()
in let () = print_int_choix tete
in print_liste_choix queue;;

let readpion = read_int () in
try pion_of_int readpion with
| BAD_INPUT -> get_pion ();;

let listrm a liste =
let rec listrm_bis a liste accu =
match liste with
[]-> accu
| tete::queue -> if a=tete then listrm_bis a queue accu else listrm_bis a queue accu@[tete]
in List.rev (listrm_bis a liste []);;

let rec get_one_pion liste =
let () = print_liste_choix liste
in let () = print_string “Entrez un nombre svp”
in let () = print_newline ()
in let pion_int_tmp = read_int ()
in try pion_of_int pion_int_tmp with
| BAD_INPUT -> get_one_pion liste;;

let rec get_good_int liste =
let () = print_liste_choix liste
in let () = print_string “Entrez un nombre svp”
in let () = print_newline ()
in let pion_int_tmp = read_int ()
in if not (est_dans_main pion_int_tmp liste)
then let () = efface_ecran
in get_good_int liste
else pion_int_tmp;;

let manche () =
let () = efface_ecran
in let liste_all = [1;2;3;4;5;6;7]
in let () = efface_ecran
in let good_pion_lu_1 = get_good_int liste_all
in let liste_all_2 = listrm good_pion_lu_1 liste_all
in let () = efface_ecran
in let good_pion_lu_2 = get_good_int liste_all_2
in let liste_all_3 = listrm good_pion_lu_2 liste_all_2
in let () = efface_ecran
in let good_pion_lu_3 = get_good_int liste_all_3
in let liste_all_4 = listrm good_pion_lu_3 liste_all_3
in let () = efface_ecran
in let good_pion_lu_4 = get_good_int liste_all_4
in let () = efface_ecran
in let correcte_main_lu =
[ pion_of_int good_pion_lu_1;
pion_of_int good_pion_lu_2;
pion_of_int good_pion_lu_3;
pion_of_int good_pion_lu_4]

in let () = efface_ecran
in let () = print_string "Vous Proposez : "
in let () = print_string (string_of_main correcte_main_lu)
in let () = print_newline ()
in let reponse_main = reponse_main correcte_main_lu main_gagnante
in let () = print_string "Reponse : "
in let () = print_string (string_of_main reponse_main)
in reponse_main;;

let print_win n =
let () = print_newline ()
in let phrase = “Vous avez gagner en “^(string_of_int n)^” coup(s)”
in let () = print_string phrase
in print_newline ();;
let partie =
let rec partie n =
let res_tmp = manche ()
in if res_tmp = [Rouge;Rouge;Rouge;Rouge]
then print_win n
else partie (n+1)
in partie 1;;

[/cpp]

Le code marche mais je dois retoucher 2-3 truc d’affichage, donc rien de
grave.
Tu peux deja y jouer :smiley: en attendant ce soir, je reposterais la version finale

tu dois trouver : (click sur le carre pour voir la reponse !)
[spoiler]
Blanc - Rouge - Orange - Noir
[/spoiler]

Mais fait moi le plaisir de me dire Ta (enfin ma) note

[:acrylic]

yes ca gere!

par contre quand j’execute, au moment où il me demande d’entrer un nombre, il ne prend rien!
je tape un nombre ou une suite de nombre ca n’avance pas!

peux tu me dire pk stp?

il y a aussi un petit souci

le programme en faite est censé voir toutes les solutions possibles et determine a l’aide de la fonction random une solution a trouver.
c’est pas un joueur qui choisit mais le programme.

ouais je dois corriger quelques trucs aussi.
Tu dois le rendre pour quand?
C’est normal, tu dois clicker sur le top-level et la ca marchera, tu a surement taper le 1 mais dans la fenetre du haut de xemacs, si tu l utilise.

je dois le rendre pour mercredi.

j’arrive pas bien a utiliser le prog.

Je t’explique le principe de la correction.
La prof a un programme qui test notre programme.
La solution doit pouvoir changer a chaque fois. Il faut utiliser la fonction “random” qui trouvera une solution a chercher.

apres nous ce qui serait bien, c’est d’avoir une question qui demande de choisir 4 couleurs.
là on rentrerai les numeros des couleurs comme elles sont définis.

Le programme devra alors donner sa reponse en disant combien y a de pions rouges, combien de pions blancs et par le deduction le nombre de “vide”.

de la l’ordi repose sa question au joueur en redemandant de taper une réponse.
et ainsi de suite jusqu’a trouver la bonne réponse.

tu te sens capable d’ameliorer ton prog pour arriver a cette idée là?

quand je copier coller de ton prog dans objectif caml sous windows, et que je tape ENTRER, le prog se lance et s’arrete a
1 - Blanc
2 - Noir
3 - Rouge
4 - Vert
5 - Bleu
6 - Jaune
7 - Orange
Entrez un nombre svp

de là je ne sais pas quoi faire, j’ai beau taper des nombres ca marche pas!
c quoi ton histoire de top level!
explique moi un peu comment tu fais pour le faire fonctionner

j’ai tellement envi de jouer au mastermind!!!

ça commence à me gaver, tu harceles ce pauvre syndicaliste (;)) alors que tu n’as rien fait.

Il t’a proposé un prog de base, tu devrais déjà etre content.

encore une supplication sur du codage et je ferme ce topic sans négociations.