Ada

[Ada] Mon implémentation du Jeu du Taquin ::=la file de priorités

Recherche :

Sujet(s) à lire :
- {Vb.net} Form Opacity

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : [Ada] Mon implémentation du Jeu du Taquin ::=la file de priorités

Profil supprimé

:heink: :hello: Bonjour à tous et toutes,

la premiere partie du topic relate des evenements survenuent l'hors du developpement des premieres versions (lire le debut du topic)

A ce jour le problème principal est d'implémenter une file de priorité, (lire les derniers messages)
la version courante exploite un algorithme A* ou A etoile avec des listes chaînées (voir les sources)

Merci à tous et toutes :jap: :sol:

<<MESSAGE ORIGINAL>>

:hello:

Je me propose de réaliser avec Ada un jeu du Taquin dont le solutionnement est une liste des permutations effectuée durant le mélange

mes sources sont disponibles ICI

n'esitez pas à participer à ce topic

Ma spécification de P_Taquin

Code :

with P_Les_Types_Taquin;
use P_Les_Types_Taquin;
generic
   N : T_Borne_1;
   M : T_Borne_1;
package P_Taquin is
   type T_Taquin is private;
   subtype T_Borne_2 is natural range 0..(N*M)-1;
   procedure Afficher(Dans : in T_Taquin);
   procedure Initialiser_Un_jeton(Dans : in out T_Taquin);
   procedure Melanger_Un_Jeton(Dans : in out T_Taquin);
   procedure Ranger_Un_Jeton(Dans : in out T_Taquin);
   function Sont_Egales(Gauche, Droit : T_taquin) return Boolean;
   procedure Vider(Un : in out T_Taquin);
private
   subtype T_Count is Natural range 0..T_Borne_2'last+1;
   type T_Place;
   type T_Ptr_place is access T_Place;
   type T_Place is
      record
         Suivant : T_Ptr_place;
         Id : T_Borne_2 := 0;
      end record;
     type T_Tab_2d is array (Positive range <>,
                              Positive range <> ) of T_Place;
   type T_Matrice_Jeton(N : T_Borne_1;
                        M : T_Borne_1) is
     record
        Matrice : T_Tab_2d(1..N,1..M);
        K : T_Borne_1 := 1;
        L : T_Borne_1 := 1;
        Count : T_count := 0;
     end record;
   type T_Liste is
      record
         Longueur : Natural := 0;
         Tete, Precedent, Courant : T_Ptr_place:= null;
      end record;
   type T_Taquin is
      record
         Etat : T_Matrice_Jeton(N,M);
         Liste_Vide : T_Liste;
         Liste_De_Permutation : T_Liste;
      end record;
end P_Taquin;

Cette implémentation du jeu du Taquin ne reflétant pas en réalité le vrai problème posé, j'envisage d'y remédier. Malheuresement mes connaissances en mathématique, algorithmie et structure de donnée sont aujourd'hui insufisantes. Je me lance donc à la recherche d'un spécificateur qui souhaiterait partager le plaisir d'ecrire ou de réecrire une implémentation du jeu du Taquin avec Ada :love:

Message édité par Profil supprimé le 11-06-2006 à 18:17:00

Publicité

Profil supprimé

l'ultime operation, la construction de la liste des identifiants des voisins de l'élément vide dans une matrice

la specification

Code :

procedure Construction_Liste_Vide(dans : in out T_taquin);
      -- construire la liste des valeur des jetons voisins de l'element vide
      -- de la matrice du taquin

Si vous avez des idées ....

Profil supprimé

j'ai fait ça

Code :

procedure Construction_Liste_Vide(dans : in out T_taquin) is
      -- construire la liste des valeur des jetons voisins de l'element vide
      -- de la matrice du taquin
      X_Vide : T_Borne_2;
      Y_Vide : T_Borne_2;
      Nouveau : T_Ptr_Place;
   begin
      X_Vide := Absisse(Dans,0);
      Y_Vide := ordonnee(Dans,0);
      Dans.Liste_Vide.Tete := null;
      Dans.Liste_Vide.Courant := null;
      Dans.Liste_Vide.Longueur := 0;
     if not ((X_Vide + 1) > n ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(X_Vide+1,Y_Vide).id);
        Dans.Liste_Vide.Tete := Nouveau;
        Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
        Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
     end if;
     if not ((X_Vide - 1) < 1 ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(X_Vide-1,Y_Vide).id);
        if Dans.Liste_Vide.Tete = null then
           Dans.Liste_Vide.Tete := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
           Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
        else
           Dans.Liste_Vide.Courant.suivant := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
           Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete.Suivant;
        end if;
     end if;
     if not ((Y_Vide + 1) > m ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(x_Vide,Y_Vide+1).id);
        if Dans.Liste_Vide.Tete = null then
           Dans.Liste_Vide.Tete := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
           Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
        else
           Dans.Liste_Vide.Courant.suivant := Nouveau;
           Dans.Liste_Vide.Courant := Dans.Liste_Vide.Courant.Suivant;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
        end if;
     end if;
     if not ((y_Vide - 1) < 1 ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(x_Vide,Y_Vide-1).id);
        if Dans.Liste_Vide.Tete = null then
           raise Program_Error;
           Dans.Liste_Vide.Tete := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
        else
           Dans.Liste_Vide.Courant.suivant := Nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
        end if;
     end if;
end Construction_Liste_vide;

mais dans l'etat, ça marche pas :lol: et je suis bien embété

Message édité par Profil supprimé le 12-05-2006 à 10:17:10

Profil supprimé

j'ai fait ça

Code :

procedure Construction_Liste_Vide(dans : in out T_taquin) is
      -- construire la liste des valeur des jetons voisins de l'element vide
      -- de la matrice du taquin
      X_Vide : T_Borne_2;
      Y_Vide : T_Borne_2;
      Nouveau : T_Ptr_Place;
   begin
      X_Vide := Absisse(Dans,0);
      Y_Vide := ordonnee(Dans,0);
      Dans.Liste_Vide.Tete := null;
      Dans.Liste_Vide.Courant := null;
      Dans.Liste_Vide.Longueur := 0;
     if not ((X_Vide + 1) > n ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(X_Vide+1,Y_Vide).id);
        Dans.Liste_Vide.Tete := Nouveau;
        Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
        Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
     end if;
     if not ((X_Vide - 1) < 1 ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(X_Vide-1,Y_Vide).id);
        if Dans.Liste_Vide.Tete = null then
           Dans.Liste_Vide.Tete := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
           Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
        else
           Dans.Liste_Vide.Courant.suivant := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
           Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete.Suivant;
        end if;
     end if;
     if not ((Y_Vide + 1) > m ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(x_Vide,Y_Vide+1).id);
        if Dans.Liste_Vide.Tete = null then
           Dans.Liste_Vide.Tete := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
           Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
        else
           Dans.Liste_Vide.Courant.suivant := Nouveau;
           Dans.Liste_Vide.Courant := Dans.Liste_Vide.Courant.Suivant;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
        end if;
     end if;
     if not ((y_Vide - 1) < 1 ) then
        nouveau := new T_Place ' (null,
                                  Dans.Etat.Matrice(x_Vide,Y_Vide-1).id);
        if Dans.Liste_Vide.Tete = null then
           raise Program_Error;
           Dans.Liste_Vide.Tete := nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
        else
           Dans.Liste_Vide.Courant.suivant := Nouveau;
           Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
        end if;
     end if;
end Construction_Liste_vide;

ça ça marche presque

mais j'ai encore un petit probleme, apriori, avec le tirage aleatoire [:atreyu]

Message édité par Profil supprimé le 12-05-2006 à 11:14:16

Profil supprimé

Il manque 1 élément dans ma liste des jetons voisins du vide [:kernel-panic]

Profil supprimé

Maintenant, j'ai bien tous mes voisins dans ma liste, mais ça marche toujours pas,

Il doit y avoir un problème avec le tirage aleatoire à moins que ce soit cette function L_element (Dans : T_Liste;place : in Positive) return T_Borne_2;

Code :

function L_Element (Dans : T_Liste;place : in Positive) return T_Borne_2 is
      Courant : T_Ptr_place := Dans.Tete;
   begin
      if Place > 1 then
         for I in 1..Place-1 loop
            Courant := Courant.Suivant;
         end loop;
      end if;
      if Courant = null then
         raise Program_Error;
      end if;
      return Courant.Id;
   end L_Element;

Si non c'est le tirage aleatoire qui marche pas bien puisqu'il me renvoie presque toujours les même valeurs [:666rip666]

La spécification de P_Random_Sans_Remise

Code :

generic
   Borne : Positive;
package P_Random_Sans_Remise is
   pragma Elaborate_body(P_Random_Sans_Remise);
   function Random return Positive;
end P_Random_Sans_Remise;

Le corp de P_Random_Sans_Remise

Code :

with Ada.Numerics.Discrete_Random;
package body P_Random_Sans_Remise is
   count : natural := 0;
   subtype T_Borne is Positive range 1..Borne;
   Package P_T_Borne_Random is new Ada.Numerics.Discrete_Random(T_Borne);
   T_Borne_Gen : P_T_Borne_Random.Generator;
   use P_T_Borne_Random;
   type T_Tab is array (Positive range 1..Borne) of T_Borne;
   Tab_Image : T_Tab := (others => T_Borne'first);
 
   procedure Permute(Tab : in out T_Tab;I,J : T_Borne) is
      Tampon : positive := Tab(I);
   begin
      Tab(I) := Tab(J);
      Tab(J) := Tampon;
   end Permute;
 
   function Random return Positive is
   begin
      if Count = Borne then
         raise Program_Error;
      else
         Count := Count + 1;
      end if;
      Return Tab_image(Count);
   end Random;
begin
   for I in Tab_Image'Range loop
      Tab_Image(I) := I;
   end loop;
   for I in 1..4 loop--Tab_Image'Length/2 loop
      Permute(Tab_Image,
              Random(T_Borne_Gen),
              Random(T_Borne_Gen));
   end loop;
end P_Random_Sans_Remise;

JagStang spécifier dans son message à ce sujet de mélanger N/2 fois le tableau, mais en mélangant un peut plus, ça marche un peut mieu.

Ma procedure Melanger_Un_Jeton(Dans : in out T_Taquin);

Code :

procedure Melanger_Un_Jeton(Dans : in out T_Taquin) is
      subtype T_Borne_Random is Positive range 1..Dans.Liste_Vide.Longueur;
      Package P_T_Borne_2_random is new Ada.Numerics.Discrete_Random(T_Borne_random);
      --T_Borne_Gen : P_T_Borne_2_Random.Generator;
      --use P_T_Borne_2_Random;
      package P_Vide_Random is new P_Random_Sans_Remise(Dans.Liste_Vide.longueur);
      use P_Vide_Random;
      Elu : T_Borne_2;
      Nouveau : T_Ptr_place;
   begin
      --      Elu := L_Element(Dans.Liste_Vide,P_Vide_Random.Random);
      Elu := L_Element(Dans.Liste_Vide,Random);--(T_Borne_Gen));
      Nouveau  := new T_Place ' (null,elu);
      Permuter(Dans,elu);
      Construction_Liste_Vide(Dans);
      if Dans.Liste_De_Permutation.Longueur = 0 then
         Dans.Liste_De_Permutation.Tete := Nouveau;
         Dans.Liste_De_Permutation.Courant := Dans.Liste_De_Permutation.Tete;
      else
         Dans.Liste_De_Permutation.Courant.suivant := Nouveau;
         Dans.Liste_De_permutation.Precedent := Dans.Liste_De_permutation.Courant;
         Dans.Liste_De_Permutation.Courant := Dans.Liste_De_Permutation.Courant.Suivant;
      end if;
      Dans.Liste_De_Permutation.Longueur :=
        Dans.Liste_De_Permutation.Longueur + 1;
   end Melanger_Un_Jeton;

Ma procedure Ranger_Un_Jeton(Dans : in out T_Taquin);

Code :

procedure Ranger_Un_Jeton(Dans : in out T_Taquin) is
   begin
      if Dans.Liste_De_Permutation.Longueur /= 0 then
         Dans.Liste_De_permutation.Courant := Dans.Liste_De_permutation.Precedent;
         Renverser(Dans.Liste_De_Permutation);
         Dans.Liste_De_Permutation.Longueur := 0;
         Permuter(Dans,Dans.Liste_De_permutation.tete.Id);
         Dans.Liste_De_permutation.Courant := Dans.Liste_De_permutation.Tete.suivant;
      else
         Permuter(Dans,Dans.Liste_De_permutation.Courant.Id);
         Dans.Liste_De_permutation.Courant :=
           Dans.Liste_De_permutation.Courant.Suivant;
      end if;
   end Ranger_Un_Jeton;

Profil supprimé

Et bien, on pourait se demander ce que fait Ada.Numerics.Discrete_Random, parce-que ça random pas beaucoup ...

Alors voila, en plus maintenant random est vraiment sans remise

Code :

function Random(Strategique : positive) return Positive is
      Resultat : Positive;
      Elu : Positive := 1;
   begin
      loop
         Resultat := Tab_image(elu);
         Elu := Elu+1;
         exit when Resultat /= Strategique;
      end loop;
      Return resultat;
   end Random;

Mais ça mélange toujours trés mal

Message édité par Profil supprimé le 12-05-2006 à 16:50:13

Profil supprimé

J'ai légèrement modifié ma procedure Initialiser_Un_jeton(Dans : in out T_Taquin); pour avoir 2 fois plus de possibilités au premier coup

Code :

procedure Initialiser_Un_jeton(Dans : in out T_Taquin) is
   begin
      if ((dans.Etat.K = N/2) and (dans.Etat.L = M/2)) then
         null;  -- Jeton central non initialisé
      else
         dans.Etat.Matrice(dans.Etat.k,Dans.Etat.l).id := Dans.etat.Count+1;
         Dans.etat.Count := Dans.etat.Count + 1;
      end if;
      if Dans.etat.k = N then
            Dans.etat.L := Dans.etat.L + 1;
            Dans.etat.K := 1;
         else
            Dans.etat.K := Dans.etat.K + 1;
         end if;
      if Dans.Etat.Count = T_Borne_2'Last then
         Construction_Liste_vide(Dans);
      end if;
   end Initialiser_Un_Jeton;

Le probleme concernant le tirage aleatoire se pose toujours, (saletée de machine) :heink:
En effet, à chaque appel du programme le jeton vide prend le même chemin. Stupéfiant :pt1cable:

Profil supprimé

[:aganemnon] Comment repousser les limites de Ada.Numerics.Disctrete_Random.Random ou de Srandom, la fonction C de génération de nombre aléatoire :??:

[:atreyu]

D'un coup, j'ai un doute, en effet, ne demeure t-il pas un bug au sein de ce petit programme :??:

Message édité par Profil supprimé le 12-05-2006 à 18:34:06

Profil supprimé

j'ai retapé la construction de la liste des voisins de l'élément vide pour pallier au maigre résultat de Ada.Numerics.Discrete_Random en y intégrant une part d'aleatoire.

Code :

procedure Construction_Liste_Vide(dans : in out T_taquin) is
      -- construire la liste des valeur des jetons voisins de l'element vide
      -- de la matrice du taquin
 
 
      function down(X,Y : T_Borne_1) return T_Borne_2 is
      begin
         if not ((X + 1) > N) then
            return Dans.Etat.Matrice(X+1,Y).Id;
         else
            return 0;
         end if;
      end down;
 
      function up(X,Y : T_Borne_1) return T_Borne_2 is
      begin
         if not ((X -1) < 1) then
            return Dans.Etat.Matrice(X-1,Y).Id;
         else
            return 0;
         end if;
      end up;
 
      function right(X,Y : T_Borne_1) return T_Borne_2 is
      begin
         if not ((Y + 1) > M) then
            return Dans.Etat.Matrice(X,Y+1).Id;
         else
            return 0;
         end if;
      end right;
 
      function left(X,Y : T_Borne_1) return T_Borne_2 is
      begin
         if not ((Y - 1) < 1) then
            return Dans.Etat.Matrice(X,Y-1).Id;
         else
            return 0;
         end if;
      end left;
 
      type Coordonnees_To_Id is access function(X,Y : T_Borne_1) return T_Borne_2;
      subtype Methodes is Positive range 1..4;
      type Tab_solution is array (Positive range 1..4) of Coordonnees_To_Id;
      Solution : Tab_Solution :=
        (1 => Up'Access,
         2 => Down'Access,
         3 => Right'Access,
         4 => Left'Access);
      Package P_Solution_random is new Ada.Numerics.Discrete_Random(methodes);
      solution_Gen : P_Solution_random.Generator;
      use P_Solution_Random;
      procedure Permute(Tab : in out Tab_solution;I,J : methodes) is
         Tampon : Coordonnees_To_Id := Tab(I);
      begin
         Tab(I) := Tab(J);
         Tab(J) := Tampon;
      end Permute;
      X_Vide : T_Borne_2;
      Y_Vide : T_Borne_2;
      Nouveau : T_Ptr_Place;
   begin
    X_Vide := Absisse(Dans,0);
      Y_Vide := ordonnee(Dans,0);
      Dans.Liste_Vide.Tete := null;
      Dans.Liste_Vide.Courant := null;
      Dans.Liste_Vide.Longueur := 0;
      for I in 1..128 loop
         Permute(Solution,Random(Solution_Gen),Random(Solution_Gen));
      end loop;
      for I in 1..4 loop
         if Solution(I)(x_Vide,y_Vide) /= 0 then
            Nouveau := new T_Place ' (null,Solution(I)(x_Vide,y_Vide));
            if Dans.Liste_Vide.Tete = null then
               Dans.Liste_Vide.Tete := Nouveau;
               Dans.Liste_Vide.courant := Dans.Liste_Vide.Tete;
               Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
            else
               Dans.Liste_Vide.Courant.suivant := Nouveau;
               Dans.Liste_Vide.Courant := Dans.Liste_Vide.Courant.Suivant;
               Dans.Liste_Vide.Longueur := Dans.Liste_Vide.Longueur + 1;
            end if;
         end if;
      end loop;
   end Construction_Liste_vide;

Mais ça marche pas encore :cry:

Message édité par Profil supprimé le 13-05-2006 à 10:06:57

Publicité

Profil supprimé

Voila, ça tourne, les sources sont disponibles ICI :jap:

Profil supprimé

Profil supprimé

En attendant l'affluance sur ce topic, :lol:
je m'amuse un peut :heink:

Code :

put("Positionner une matrice lines x columns > 1 avec un element vide en k,l, l'afficher, la melanger aleatoirement, l'ordonner" );
put("durant les deux derniere phases, la matrice doit être affiché à chaque deplacement de tuile." );

:pt1cable:
procedure Ranger_Une_Tuile(Dans : in out T_Jeu_Du_Taquin) is
Un_Char : Character;
Vide_Passe : Boolean := False;
begin
if Dans.Liste_Initiale.tete = null then
Dans.Matrice_Ordonnee := Dans.Matrice_melangee;
end if;
if Dans.Liste_Initiale.Courant = null then
Construire_Liste(Dans.Liste_Initiale, Dans.Matrice_ordonnee);
if not Vide_Passe then
Tronquer_queu_Liste(Dans.Liste_Initiale,0);
else
Tronquer_tete_Liste(Dans.Liste_Initiale,0);
end if;
Dans.Liste_Initiale.Courant := null;--Dans.Liste_Initiale.Tete;
-- while Dans.Liste_Initiale.Courant.Suivant /= null loop
-- Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Courant.Suivant;
-- end loop;
Renverser(Dans.Liste_Initiale);
Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Tete;
else
Permuter(Dans.Matrice_Ordonnee,Dans.Liste_Initiale.Courant.Id);
Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Courant.Suivant;
if Dans.Liste_Initiale.Courant.Id = 0 then
Vide_Passe := True;
Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Courant.Suivant;
end if;
end if;

Afficher(Dans.Liste_Initiale);
Get_Immediate(Un_Char);
------------------------------------------------------------
end Ranger_Une_tuile;

Message édité par Profil supprimé le 15-05-2006 à 14:36:52

Profil supprimé

:hello: J'ai un gros problème URGENT, please HELP ME [:kernel-panic]

En effet, je suis bloqué par mon incapacité à comprendre pourquoi dans le ma procedure ranger_une_tuile, à la ligne 58, ma liste_initiale n'est pas renversée lors de son affichage.

En fait je ne comprend pas le role de courant dans renverser, j'ai du mal à analiser ce probleme, vue que je suis dans l'algo du taquin, je fatigue.

:??: ?? Courant doit prendre quel valeur pour renverser la totalité de la liste ?? :??:

J'ai déjas utilisé les procedures renverser(sans l'avoir analisé) et afficher dans d'autres circonstances, elles fonctionnent tres bien.

Code :

procedure Renverser(La_Liste: in out T_Liste) is
      P : T_Ptr_Place := null;             -- la liste l', initialement vide
      Q : T_Ptr_Place;                                                        -- variable locale
   begin
      if La_Liste.Longueur = 0 then return; end if;
      while La_Liste.Tete /= null loop
         Q := La_Liste.Tete;
         La_Liste.Tete := La_Liste.Tete.Suivant;-- passer à fin (l)
         Q.Suivant := P;
         P := Q;                                                -- l' := premier(l) :: l'
         if Q = La_Liste.Courant then
            La_Liste.Precedent := La_Liste.Tete;
         end if;                                                         -- nouveau précédant
      end loop;
      La_Liste.Tete := P;                                                  -- le résultat
   end Renverser;
   procedure Tronquer_Queu_Liste(Dans : in out T_Liste; Id : T_Borne_2) is
   begin
      Dans.Courant := Dans.Tete;
      while Dans.Courant /= null and then
        Dans.Courant.Id /= Id loop
         Dans.Precedent := Dans.Courant;
         Dans.Courant := Dans.Courant.Suivant;
      end loop;
      Dans.Precedent.Suivant := null;
   end Tronquer_Queu_Liste;
 
   procedure Tronquer_tete_Liste(Dans : in out T_Liste; Id : T_Borne_2) is
   begin
      Dans.Courant := Dans.Tete;
      while Dans.Courant /= null and then
        Dans.Courant.Id /= Id loop
         Dans.Precedent := Dans.Courant;
         Dans.Courant := Dans.Courant.Suivant;
      end loop;
      Dans.Tete := Dans.Precedent.Suivant;
   end Tronquer_tete_Liste;
 
 
   procedure Ranger_Une_Tuile(Dans : in out T_Jeu_Du_Taquin) is
      Un_Char : Character;
      Vide_Passe : Boolean := False;
   begin
      if Dans.Liste_Initiale.tete = null then
         Dans.Matrice_Ordonnee := Dans.Matrice_melangee;
      end if;
      if Dans.Liste_Initiale.Courant = null then
         Construire_Liste(Dans.Liste_Initiale, Dans.Matrice_ordonnee);
         if not Vide_Passe then
            Tronquer_queu_Liste(Dans.Liste_Initiale,0);
         else
            Tronquer_tete_Liste(Dans.Liste_Initiale,0);
         end if;
         Dans.Liste_Initiale.Courant := null;--Dans.Liste_Initiale.Tete;
--         while Dans.Liste_Initiale.Courant.Suivant /= null loop
--            Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Courant.Suivant;
--         end loop;
         Renverser(Dans.Liste_Initiale);
         Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Tete;
      else
         raise Program_Error;
         Permuter(Dans.Matrice_Ordonnee,Dans.Liste_Initiale.Courant.Id);
         Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Courant.Suivant;
         if Dans.Liste_Initiale.Courant.Id = 0 then
            Vide_Passe := True;
            Dans.Liste_Initiale.Courant := Dans.Liste_Initiale.Courant.Suivant;
         end if;
      end if;
 
      Afficher(Dans.Liste_Initiale);
      Get_Immediate(Un_Char);
   ------------------------------------------------------------
   end Ranger_Une_tuile;

La totalité des sources de Taquin_9 est disponible ICI

Message édité par Profil supprimé le 15-05-2006 à 15:23:32

Profil supprimé

C'est bon, merci, j'ai trouvé que, comme je n'est pas incrémenté longueur durant la creation de la liste le premier test de renverser terminait le procedure prématurément. [:dawa_neowen]

ChOoN

heureusement que t'as trouvé bj
De rien pour notre aide

Profil supprimé

cet algorithme est-il applicable dans mon cas ?

Soit C le chemin (liste d'états) menant d'un état E à l'état initial. Une fonction heuristique possible est : h(C) = longueur(C) + d(E).

Soit I l'état initial. F une file d'attente de chemins avec priorité h, et D un dictionnaire des états déjà visités. On suppose que I est différent de l'état final.

1. Rentrer le chemin réduit à I dans F (avec h(I)) et dans D
2. Fini := faux
3. Tant que (non Fini) et (F non vide) faire
1. Sortir un chemin C de F de priorité minimale; soit E le premier élément de C
2. Pour tous les successeurs S de E et tant que (non Fini) faire
1. Si S est l'état final alors Fini := Vrai et Solution := inverse(S.C)
2. Sinon, si S n'est pas dans D alors rentrer S.C dans F (avec h(S)) et S dans D

référence : Dijkstra

Autre ressources

METHODOLOGIE ET STRUCTURES DE DONNEES avec un exemple d'application au jeu du taquin (3x3)
Résolution de problèmes en Intelligence Artificielle
L'algorithme A*

Répartition de la charge dans les algorithmes parallèles irréguliers

Ce problème, la resolution du jeu du/de taquin est considéré comme difficile, moi qui ai eu du mal à parvenir a la 4eme .... [:666rip666]

Je ne cherche pas la meilleur solution, d'ailleur son calcule est assé lourd ; Je ne rejéterais quans même pas cette ultime algorithme ideal ; Bien que je ne soi pas préssé, je me contenterai, dans un premier temps, d'un algorithme qui trouve une solution, Et ce serait déjàs pas mal

L'orsque les problèmes de resolution seront résoluts, j'envisagerai une version graphique avec GtkAda,

Je rappel que je ne suis ni étudiant, bien que (autodidacte en formation continue), ni salarié, ça c'est sure !
je rappel aussi que j'ai du champagne pour ceux qui m'aide a atteindre mes objectifs

j'ai faî ecrire un truc pas mal cet après midi mais j'ai eu un problème avec une inversion de liste et j'ai oublié ce que j'étais en train de faire ; Dommage

Avec un peut de travail et un peut de patience, je pense y arriver. Un peut d'aide ne serait pas de refus, tout de même.

Message édité par Profil supprimé le 16-05-2006 à 02:07:11

Profil supprimé

Trève de plaisenterie,

Je suis en train de lire Christian Carrez dans Structures de données en Java,C++ et Ada 95.pour implémenter mon Jeu du Taquin

Ce qui m'interresse, ce sont les arbres généraux. Pour la resolution du taquin j'opte pour les arbres généraux avec aîné et frère droit

l'implementation du type presenté dans le livre, est en Java

Code :

public class noeud [
    object contenu ;
    boolean frere_null  true ;
    noeud aine = null ;
    noeu suivant = null ;
    noeud (object val) { contenue val ; } ; // je ne comprend pas la derniere ligne  ! //
}

j'ai besoin d'un peut d'aide pour traduire cette déclaration du Java à l'Ada

Code :

type T_Arbre ;
type T_Ptr_Arbre is access T_Arbre ;
type T_Arbre is
    record
         Contenue : T_Item ;
         Frere_null  : boolean ;
         aine           : T_Ptr_Arbre := null;
         suivant      : T_Ptr_Arbre := null;
    -- je ne comprend pas la derniere ligne ! --
    en record;

Merci :jap:

Message édité par Profil supprimé le 16-05-2006 à 10:44:57

Loki du placard

Pour le code java

La dernière ligne est le constructeur de la classe java. On passe en paramètre la variable val de type Object et on l'affecte à contenu.

en Ada, tu fait quelquechose dans ce style :

procedure Create( N : out Noeud; Val : in T_Item) is
begin
N.Contenue := Val;
end Create;

Ca répond à ta question?

Message cité 1 fois

Profil supprimé

Erreur de ma part, un arbre p-aire sera suffisant. En effet on connait le nombre maximum de fils de chaque noeud, en l'occurence : 4
Et la coup de bole j'ai la declaration en Ada [:666rip666]

Message cité 1 fois

Profil supprimé

Hum, toutes mes excuse Loki du placard

Profil supprimé

Loki du placard a écrit :

Euh, je comprend pas trop en fait,
Ce serait pas un truc du genre

type Noeud(val : item) is
record
--
--
--
end record;

Profil supprimé

Donc, en fait, mon type est complet ?

Code :

type T_Arbre ;
    type T_Ptr_Arbre is access T_Arbre ;
    type T_Arbre is
       record
            Contenue : T_Item ;
            Frere_null  : boolean ;
            aine           : T_Ptr_Arbre := null;
            suivant      : T_Ptr_Arbre := null;
       -- je ne comprend pas la derniere ligne ! --
       en record;

Profil supprimé

C'est pas ça encore, bref je sais pas comment ça s'appel, c'est un arbre général, oui. une repérsentation contiguë par niveau.

Ce qui doit donner :

Code :

type T_Arbre;
type T_Ptr_Arbre is access T_Arbre;
type T_Foret is array (positive range 1..4) of T_Ptr_Arbre;
type T_Arbre is
    record
        Contenu : T_Item;
        Foret       : T_Foret
    end record;

Corrigez moi si je me trompe ! :heink:

Loki du placard

Citation :

Euh, je comprend pas trop en fait,
Ce serait pas un truc du genre

type Noeud(val : item) is
record
--
--
--
end record;

Non, pas du tout. En java, il ne faut pas oublier que les déclarations et le code proprement dit sont dans le même source. La ligne 6 de ton exemple en java est une méthode, plus exactement un constructeur. C'est codé sur une ligne, et on peut faire plus lisible, mais ça correspond parfaitement à la méthode create que j'ai envoyé.

Message cité 1 fois

Profil supprimé

Loki du placard a écrit :

Citation :

Euh, je comprend pas trop en fait,
Ce serait pas un truc du genre

type Noeud(val : item) is
record
--
--
--
end record;

Ok, merci Loki du placard

je reprend mon type T_Arbre que j'ai définit ainsi

Code :

type T_Noeud;
   type T_Ptr_Noeud is access T_Noeud;
   type T_foret is array (Positive range 1..4) of T_Ptr_Noeud;
   type T_Noeud is
      record
         Sous_Arbre : T_Foret;
         Matrice : T_Matrice(N,M);
      end record;
 
   type T_Arbre is
      record
         Taille : Natural := 0;
         Profondeur : Natural := 0;
         Racine : T_Noeud;
         Courant : T_Noeud;
         Parent  : T_Noeud;
      end record;

Integré à mon type T_Jeu_Du_Taquin

Code :

type T_Jeu_Du_Taquin is limited
      record
         Count : T_Borne_2 := 0; -- nombre d'elements dans la matrice initiale;
         Matrice_Initiale : T_Matrice(N,M);
         Matrice_Melangee : T_Matrice(N,M);
         Matrice_Ordonnee : T_Matrice(N,M);
         Liste_Des_Voisins_De_Vide : T_Liste;
         Arbre_De_Resolution : T_Arbre;
      end record;

Dans le code suivant,
absisse et ordonnee sont deux fonctions renvoyants une valeur correspondant à leur nom,
solution est un tableau de pointeur sur les fonctions up, down, left et right renvoyants 0 si aucun element ne correspond a la position correspondante à leur nom par rapport à une position donnée, l'id de l'element correspondant si non.

dans la boucle while, certainement innadaptée, j'initialise le premier noeud de l'arbre de resolution du Jeu du Taquin

Code :

procedure Ranger_Une_Tuile(Dans : in out T_Jeu_Du_Taquin) is
 
   begin
      ------------------------------------------------------------
      if Dans.Arbre_De_Resolution.taille = 0 then
         Dans.Matrice_Ordonnee := Dans.Matrice_Melangee;
         Dans.Arbre_De_Resolution.Racine.Matrice := Dans.Matrice_Ordonnee;
         Dans.Arbre_De_Resolution.Taille :=
           Dans.Arbre_De_Resolution.Taille + 1;
         Dans.Arbre_De_Resolution.Courant := Dans.Arbre_De_Resolution.Racine;
         while not Sont_Egales(Dans.Arbre_De_Resolution.Courant.Matrice,
                               Dans.Matrice_Initiale) loop
            for I in Methodes loop
               if Solution(I)(Absisse(Dans.Arbre_De_Resolution.Courant.Matrice,0),
                              Ordonnee(Dans.Arbre_De_Resolution.Courant.Matrice,0),
                              Dans.Arbre_De_Resolution.Courant.Matrice) /= 0 then
                  Dans.Arbre_De_Resolution.Courant.Sous_Arbre(I) :=
                    new T_Noeud ' ((others => null),Dans.Arbre_De_Resolution.Courant.Matrice);
                  Permuter(Dans.Arbre_De_Resolution.Courant.Sous_Arbre(I).Matrice,
                           Solution(I)
                           (Absisse(Dans.Arbre_De_Resolution.Courant.Matrice,0),
                            ordonnee(Dans.Arbre_De_Resolution.Courant.Matrice,0),
                            Dans.Arbre_De_Resolution.Courant.Matrice));
 
               
 
               end if;
            end loop;
         end loop;
      else
         null;
      end if;
 
      ------------------------------------------------------------
   end Ranger_Une_tuile;

Mon probleme :heink: : construire l'arbre j'usqu'a trouver la solution :pt1cable:

Une question que je me pose aussi : comment vais-je retrouver le chemin de la solution pour resoudre mon Jeu du Taquin ?

Avis aux arboriculteurs

Profil supprimé

Pour m'echauffer un peut, j'ai fait un truc de ouf, qui marche pas évidemment :pt1cable: , un truc recursif, mais je suis vraiment pas fort en la matière. d'ailleur c'est pas une fonction mais une procedure :??: n'y prété pas trop d'attention, je l'ai faite au pif :pfff: il manque certainement quelque chose.

Code :

procedure Construire_Arbre_De_Resolution(courant : in out T_Noeud;
                                            Matrice_initiale : in T_matrice) is
   begin
      New_Line;
      for I in Methodes loop
         if Solution(I)(Absisse(Courant.Matrice,0),
                        Ordonnee(Courant.Matrice,0),
                        Courant.Matrice) /= 0 then
            Courant.Sous_Arbre(I) :=
              new T_Noeud ' ((others => null),Courant.Matrice);
            Permuter(Courant.Sous_Arbre(I).Matrice,
                     Solution(I)
                     (Absisse(Courant.Sous_Arbre(I).Matrice,0),
                      ordonnee(Courant.Sous_Arbre(I).Matrice,0),
                      Courant.Sous_Arbre(I).Matrice));
            if Courant.Sous_Arbre(I) /= null then
            Afficher(Courant.Sous_Arbre(I).Matrice);
            end if;
         end if;
      end loop;
      if not Sont_Egales(Courant.Matrice,Matrice_initiale) then
         for I in T_Foret'Range loop
            if Courant.Sous_Arbre(I) /= null then
 
               Construire_Arbre_De_Resolution(Courant.Sous_Arbre(I).all,
                                              Matrice_initiale);
            end if;
         end loop;
      end if;
      delay 1.0;
   end Construire_Arbre_De_Resolution;
 
   Procedure Ranger_Une_Tuile(Dans : in out T_Jeu_Du_Taquin) is
   begin
      ------------------------------------------------------------
      if (Dans.Arbre_De_Resolution.Racine.Sous_Arbre(1) = null and
        Dans.Arbre_De_Resolution.Racine.Sous_Arbre(2) = null and
        Dans.Arbre_De_Resolution.Racine.Sous_Arbre(3) = null and
        Dans.Arbre_De_Resolution.Racine.Sous_Arbre(4) = null) then
         Dans.Matrice_Ordonnee := Dans.Matrice_Melangee;
         Dans.Arbre_De_Resolution.Racine.Matrice := Dans.Matrice_Ordonnee;
         Dans.Arbre_De_Resolution.Courant := Dans.Arbre_De_Resolution.Racine;
         Construire_Arbre_De_Resolution(Dans.Arbre_De_Resolution.Courant,
                                        Dans.Matrice_initiale);
         Dans.Arbre_De_Resolution.racine := Dans.Arbre_De_Resolution.courant;
      else
         null;
      end if;
 
      ------------------------------------------------------------
   end Ranger_Une_tuile;

si qu'elqu'un pouvait me confirmer qu'un procedure recursive c'est forcement une function, ça m'arrangerait

Message édité par Profil supprimé le 16-05-2006 à 18:02:07

Profil supprimé

Erreur de segmentation :cry:
(je suis sous Linux)

Avec une matrice 2x2 mon petit programme génère une erreur de segmentation.

Il y a qu'elque chose qui cloche ? [:666rip666]

Message cité 1 fois

Profil supprimé

[:trotter88] [:atreyu]

je comprend pas pourquoi cette procedure ne trouve pas la solution

Un chti coup pouce, svp ici --> message prec, ou ici sources html

Message édité par Profil supprimé le 17-05-2006 à 00:47:14

Profil supprimé

Citation :

Bien qu'avoir implémenté la procedure contruire_arbre_de_resolution au pif, elle devrait tourner,

j'ai fait une version sous forme de fonction qui est maintenant ma version de developpement courante.

cette fonction est sensé construire un arbre de toute les combinaisons possibles à partir de la matrice melangée du jeu du taquin jusqu'a trouver une solution.

Merci à ceux qui planchent ou qui vont plancher

apprentitux

Rassures-moi : t'as interfacé avec du C ?

Parceque normalement, pas de ça en Ada ....

Message cité 1 fois

Profil supprimé

apprentitux a écrit :

Rassures-moi : t'as interfacé avec du C ?

Parceque normalement, pas de ça en Ada ....

A la, moi je suis sure d'avoir généré des Erreur de segmentation toute l'après midi, falait voir le code aussi

Enfin bref, je me ratrape un peut, j'ai réussi à généré une solution avec ma petite function construire arbre ... ,
c'est pas finit mais ça vien, Il ne me reste plus qu'a retrouver le chemin de resolution (a l'envers) est ça roule

Profil supprimé

il marche toujours pas en fait,

Trop surpris, j'ai fait un erreur de vaiable et du coup ben c'est toujours n'importe quoi en fait

Message édité par Profil supprimé le 17-05-2006 à 18:30:57

Profil supprimé

quelqun aurais le code d'un arbre general p-aire ou avec aîné et frere droit ça m'avancerai, Ada bien sur

j'en suis la, faire un paquetage generique d'un arbre general p-aire ou avec aîné et frere droit, je sais pas le quel choisir [:666rip666]

Message cité 1 fois

Profil supprimé

:hello: :heink:

j'placarde mon code, encore au cas ou !!

dans la procedrue suivante, je trouve plus le resultat, c'est à dire
que j'arrive pas a sortir quant je trouve le resultat, pourtant j'ai mis des exit Main_Loop par tout

c'es dans un n-arbre "à la jovalise"

Code :

procedure Construire_arbre_De_Solution(Dans : in out T_Arbre;Matrice_Melangee,Matrice_Initiale : T_matrice) is
 
      Nouvelle_Matrice : T_Matrice;
 
 
 
      procedure Init_Racine(Dans : in out T_Arbre;Matrice_initiale : T_Matrice) is
      begin
         Dans.racine :=
           new T_Noeud ' (null,null,null,Matrice_initiale,Dans.Courant);
         Dans.Courant := Dans.Racine;
      end;
 
 
 
      function L_Element_Courant(Dans : T_Arbre) return T_Matrice is
      begin
         return Dans.Courant.Matrice;
      end;
      function A_Un_Fils(Dans : T_Arbre) return Boolean is
      begin
         if Dans.Courant.suivant /= null then
            return True;
         else
            Return False;
         end if;
      end ;
      function A_Un_frere(Dans : T_Arbre) return Boolean is
      begin
         if Dans.Courant.Frere_courant /= null then
            return True;
         else
            Return False;
         end if;
      end ;
 
      procedure Passer_Au_Suivant(Dans : in out T_Arbre) is
      begin
         Dans.Courant := Dans.Courant.Suivant;
      end;
 
      procedure Passer_Au_Parent(Dans : in out T_Arbre) is
      begin
         Dans.courant := Dans.Courant.Parent;
      end ;
 
 
 
      ------------------------------------------------------------------
 
   begin
 
      Init_Racine(Dans,Matrice_Melangee);
 
 
  Main_Loop :
      loop
         Put_line("TATA" );
         if Sont_Egales(Dans.Courant.Matrice,Matrice_Initiale) then
            exit;
         end if;
         while A_Un_fils(dans) loop
            Passer_Au_Suivant(Dans);
         end loop;
         for I in Methodes'range loop                              -- pour up, right, down, left
            if Solution(i)(Absisse(L_Element_courant(Dans),0),       -- si solution(i) /= 0
                           Ordonnee(L_Element_courant(Dans),0),
                           L_Element_courant(Dans)) /= 0 then
 
 
               Nouvelle_Matrice := L_Element_courant(dans);
 
               Permuter(Nouvelle_matrice,
                        Solution(i)
                        (Absisse(Nouvelle_Matrice,0),
                         ordonnee(Nouvelle_Matrice,0),
                         Nouvelle_Matrice));-- permute dans noeud suivant avec solution(I)
 
               Afficher(Nouvelle_Matrice);
               if not A_Un_Frere(Dans) then
                  Put_line("TOTO" );
                  delay 1.0;
                  Dans.Courant.Suivant :=
                    new T_Noeud ' (null,
                                   null,
                                   null,
                                   Nouvelle_Matrice,Dans.Courant);
 
 
               elsif Dans.Courant.Suivant.Frere_aine = null then
                  Dans.Courant.Suivant.Frere_aine :=
                    new T_Noeud ' (null,
                                   Dans.Courant.Frere_Aine,
                                   Dans.Courant.Suivant,
                                   Nouvelle_Matrice,Dans.Courant);
                  Dans.Courant.Suivant.Frere_Courant := Dans.Courant.suivant.Frere_aine;
 
               else
                 Dans.Courant.Suivant.Frere_Courant.suivant :=
                    new T_Noeud ' (null,
                                   Dans.Courant.Frere_Aine,
                                   Dans.Courant.Suivant,
                                   Nouvelle_Matrice,Dans.Courant);
                  Dans.Courant.Suivant.Frere_Courant := Dans.Courant.Suivant.Frere_Courant.Suivant;
 
               end if;
 
            end if;
         end loop;
         Dans.Courant.Suivant.Frere_Courant := Dans.Courant.Suivant.Frere_Aine;
         if Dans.Courant /= Dans.Racine then
            Passer_Au_Parent(Dans);
         end if;
         Dans.Courant := Dans.Courant.Suivant;
         if Sont_Egales(Dans.Courant.Matrice,Matrice_Initiale) then
            exit;
         end if;
         if Dans.Courant.Frere_Courant /=null then
            Dans.Courant := Dans.Courant.Frere_Courant;
            Dans.Courant.Frere_Courant := Dans.Courant.Frere_Courant.Suivant;
            for I in Methodes'range loop                              -- pour up, right, down, left
            if Solution(i)(Absisse(L_Element_courant(Dans),0),       -- si solution(i) /= 0
                           Ordonnee(L_Element_courant(Dans),0),
                           L_Element_courant(Dans)) /= 0 then
 
 
               Nouvelle_Matrice := L_Element_courant(dans);
 
               Permuter(Nouvelle_matrice,
                        Solution(i)
                        (Absisse(Nouvelle_Matrice,0),
                         ordonnee(Nouvelle_Matrice,0),
                         Nouvelle_Matrice));-- permute dans noeud suivant avec solution(I)
 
               Afficher(Nouvelle_Matrice);
               if not A_Un_Frere(Dans) then
                  Put("TOTO" );
                  delay 1.0;
                  Dans.Courant.Suivant :=
                    new T_Noeud ' (null,
                                   null,
                                   null,
                                   Nouvelle_Matrice,Dans.Courant);
                  if Sont_Egales(Dans.Courant.Suivant.Matrice,Matrice_Initiale) then
                     exit Main_loop;
                  end if;
 
               elsif Dans.Courant.Suivant.Frere_aine = null then
                  Dans.Courant.Suivant.Frere_aine :=
                    new T_Noeud ' (null,
                                   Dans.Courant.Frere_Aine,
                                   Dans.Courant.Suivant,
                                   Nouvelle_Matrice,Dans.Courant);
                  Dans.Courant.Suivant.Frere_Courant := Dans.Courant.suivant.Frere_aine;
                  if Sont_Egales(Dans.Courant.Suivant.Frere_Aine.matrice,Matrice_Initiale) then
                     exit Main_loop;
                  end if;
               else
                  Dans.Courant.Suivant.Frere_Courant.suivant :=
                    new T_Noeud ' (null,
                                   Dans.Courant.Frere_Aine,
                                   Dans.Courant.Suivant,
                                   Nouvelle_Matrice,Dans.Courant);
                  Dans.Courant.Suivant.Frere_Courant := Dans.Courant.Suivant.Frere_Courant.Suivant;
                  if Sont_Egales(Dans.Courant.Suivant.Frere_Courant.matrice,Matrice_Initiale) then
                     exit Main_loop;
                  end if;
               end if;
 
            end if;
            end loop;
            Dans.Courant.Suivant.Frere_Courant := Dans.Courant.Suivant.Frere_Aine;
         else
            Passer_Au_Parent(Dans);
         end if;
      end loop Main_Loop;
   end Construire_Arbre_De_Solution

Profil supprimé

:hello:

Oa, la spec, ça me suffira [:666rip666]

Profil supprimé

Je fait des tentatives par deduction mais si je suis partie avec une mauvaise abstraction du type je m'en sortirai pas :??:

svp, jetez un coup d'oeuil a mon T_Arbre :heink:

Code :

type T_Noeud;
   type T_Ptr_Noeud is access T_Noeud;
 
     type T_Noeud is
        record
           Suivant : T_Ptr_Noeud;    --pointeur sur suivant
           Frere_aine : T_Ptr_Noeud;      -- pointeur file frere
           Frere_Courant : T_Ptr_Noeud;  -- pointeur frere courant
           Matrice : T_Matrice;                   -- element de l'abre
           Parent : T_Ptr_Noeud;                -- pointeur sur le noeud parent
        end record;
 
   type T_Arbre is
      record
         Racine : T_Ptr_Noeud;  -- pointeur sur la racine de l'arbre
         Courant : T_Ptr_Noeud;  -- pointeur sur le noeud courant de l'arbre
--         Frere_Courant : T_Ptr_Noeud; -- non utilisé
      end record;

Merci :jap:

Profil supprimé

:heink: J'ai un problème avec la procedruee construire_arbre_de_solution lignes 298 à 582 concernent le passage au frere_courant qui est en faite le frere suivant à visiter;

apres une iteration de passer_frere_suivant, courant.frere_courant doit prendre la valeur de courant.frere_courant.frere_courant, le frere suivant frere_courant
c'est ce que je fait ligne 434 a l'aide du tampon

ainsi en passant alternativement d'un courant a un frere_courant au courant, ainsi de suite, grace a passer_frere_suivant et passer_au_parent, je passe au frere suivant;

le probleme est que c'a n'itere pas, le frere_courant ne passe pas au frere suivant frere_courant.frere_courant;

les sources de Taquin_9 sont disponibles ICI

construire_arbre_de_solution est dans p_taquin.adb

Profil supprimé

[:cid] [:666rip666]

j'ai enfin réussi a itere mes frere_courant, a priorie ça tourne

c'est un peut long a calculer mais ça sort la solution (testé à chaud avec matrice 2x2 et 3x3)

le reste, c'est de la rigolade, je vais essayer de suprimer les doublons direct,

je fait quelque test d'ici demain et je marque resolut dans le titre du topic [:666rip666]

Profil supprimé

Bon, ben fausse anonce, ça marche toujours pas,
pour une matrice 2x2 pas de probleme [:666rip666]

A+

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

Ada

[Ada] Mon implémentation du Jeu du Taquin ::=la file de priorités

Sujets relatifs
[RESOLU] retourner l'extension d'un fichier dans un champ file avec JS	[Algo][Résolut]Cherche algorithmes pour le Jeu du Taquin
implémentation du protocole	[Batch] Automatiser save file en codage ANSI
file() ou file_get_contents() en safe mode	Petit programme pour faire ses comptes ; C'est quoi ce gros bug
Problème pour récupérer le champ texte d'une input type file	File et tableau de record
[Batch File] Problème d'espace
Plus de sujets relatifs à : [Ada] Mon implémentation du Jeu du Taquin ::=la file de priorités

Page générée en 0.290 secondes