#!/usr/bin/perl
use strict;
use warnings;
use Algorithm::Permute;
use List::MoreUtils ('uniq');
 
my $winning_pattern = "1.*2.*3";
$winning_pattern .= "|1.*4.*7";
$winning_pattern .= "|1.*5.*9";
$winning_pattern .= "|2.*5.*8";
$winning_pattern .= "|3.*5.*7";
$winning_pattern .= "|3.*6.*9";
$winning_pattern .= "|4.*5.*6";
$winning_pattern .= "|7.*8.*9";
 
my (@array,@first, @second, @result);
my $p = new Algorithm::Permute([1..9]);
while (@array = $p->next) {
  my $a;
  $a = 0;
  @first  = grep {$a^=1} @array;
  $a = 1;
  @second = grep {$a^=1} @array;
 
  $_ = join '', sort @first[0..2];
  if (/$winning_pattern/) {
    push @result, join(' ', @array[0..4])." +1.0";
  }
  else {
    $_ = join '', sort @second[0..2];
    if (/$winning_pattern/) {
      push @result, join(' ', @array[0..5])." -1.0";
    }
    else {
      $_ = join '', sort @first[0..3];
      if (/$winning_pattern/) {
    push @result, join(' ', @array[0..6])." +1.0";
      }
      else {
    $_ = join '', sort @second;
    if (/$winning_pattern/) {
      push @result, join(' ', @array[0..7])." -1.0";
    }
    else {
      $_ = join '', sort @first;
      if (/$winning_pattern/) {
        push @result, join(' ', @array)." +1.0";
      }
      else {
        push @result, join(' ', @array)." 0.0";
      }
    }
      }
    }
  }
}
 
 
@result = sort @result;
@result = uniq @result;
print join("\n", @result);

procedure Jouer(P : in out Partie; J1 : Joueur) is
      Fin : Boolean;
      J2 : Joueur;
   begin
      Evaluer(P, Fin);
 
      if Fin then
         return ;
      end if;
 
      if J1 = TOTO then
         J2 := TITI;
      else
         J2 := TOTO;
      end if;
 
      for I in P.Grille'Range(1) loop
         for J in P.Grille'Range(2) loop
            if P.Grille(I,J) = VIDE then
               P.Grille(I,J) := J1;
               Jouer(P,J2);
               P.Grille(I,J) := VIDE;
            end if;
         end loop;
      end loop;
   end Jouer;
 
   P : Partie := ((others => (others => VIDE)),0,0,0);
begin
   Jouer(P, TOTO);
end;

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;
 
sub permute_init {
  my $digits = shift;
  return([ [[], $digits] ]);
}
 
sub permute_next {
  my $state = shift;
  my ($left, $right);
  my ($newleft, $newright);
  my ($val, $item, $i, $done);
 
  $item = pop @$state;
 
  if (defined($item)) {
    ($left, $right) = @$item;
 
     while (!$done) {
       if (scalar(@$right) > 0) {
     foreach $i (0 .. (scalar(@$right) - 1)) {
       $newright  = [];
       $newleft   = [];
       @$newright = @$right;
       @$newleft  = @$left;
       push(@$newleft, splice(@$newright, $i, 1));
       unshift(@$state, [$newleft, $newright]);
     }
       }
 
       # if(scalar(@$left) > 0){ # avec ce test ci, on a toutes les combinaisons de 1, 2, ... n chiffres
       if (scalar(@$right) == 0) { # avec ce test la, on a toutes les combinaisons de n chiffres
      $val = $left;
      $done = 1;
    }
       else {
     $item = pop(@$state);
     ($left, $right) = @$item;
       }
     }
  }
  return ($state, $val);
}
 
my $digits = [1..5]; #exemple sur 1..5 ici
my $val;
my $state  = &permute_init($digits);
($state, $val) = &permute_next($state);
while (defined($val)) {
  print "@$val\n";
  ($state, $val) = &permute_next($state);
}

@$

import copy
 
def DisplayBoard( Board ):
    print ":--:--:--:"
    for line in Board:
        s = ":"
        for cell in line:
            s = "{0}{1:02d}:".format(s, cell )
        print s
        print ":--:--:--:"
 
 
def DisplayList( BoardList ):
    for i, Board in enumerate( BoardList ):
        print "Move :", i
        DisplayBoard( Board )
        
def DisplayVictory( PlayerId, BoardList ):
    print "Player {0}, won in {1} move(s) :".format( PlayerId, len( BoardList ) )
    #DisplayList( BoardList )
    DisplayBoard( BoardList[ -1 ] )
 
def DisplayDraw( BoardList ):
    print "Draw in {0} move(s) :".format( len( BoardList ) )
    #DisplayList( BoardList )
    DisplayBoard( BoardList[ -1 ] )
 
def IsVictory( Board, PlayerId, i, j ):
    Height = len( Board )
    Width = Height
    iSumHeight = 0
    iSumWidth = 0
    iSumDiag1 = 0
    iSumDiag2 = 0
    for x in xrange( Height ):
        iSumHeight += Board[ x ][ j ]
        iSumWidth += Board[ i ][ x ]
        iSumDiag1 += Board[ x ][ x ]
        iSumDiag2 += Board[ -x+1 ][ x ]
    Target = ( PlayerId * Height )
    if ( iSumHeight == Target ) or ( iSumWidth == Target ) or ( iSumDiag1 == Target ) or ( iSumDiag2 == Target ):
        return True
    return False
 
def IsDraw( Board ):
    for line in Board:
        for cell in line:
            if cell == 0:
                return False
    return True
 
def NextMoves( BoardList, PlayerId ):
    NextBoard = copy.deepcopy( BoardList[ -1 ] )
    for i, line in enumerate( NextBoard ):
        for j in xrange( len( line ) ):
            if NextBoard[i][j] == 0:
                NextBoard[i][j] = PlayerId
                BoardList.append( NextBoard )
                if IsVictory( NextBoard, PlayerId, i, j ):
                    DisplayVictory( PlayerId, BoardList )
                else:
                    if IsDraw( NextBoard ):
                        DisplayDraw( BoardList )
                    else:
                        NextMoves( BoardList, -PlayerId )
                BoardList = BoardList[:-1]
                NextBoard[i][j] = 0
        
 
DefaultBoard = [ [0, 0, 0], [0, 0, 0], [0, 0, 0] ]
NextMoves( [ DefaultBoard ], 1 )

foreach (@result) {
  jovalisate(\$_);
}
 
sub jovalisate {
  my $string = shift;
  my @list = split /\s+/, $$string;
  my $winner = pop @list;
  my @display = ("0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0" );
  print "@display\n";
  my $coup = 1;
  foreach my $i (@list) {
    $display[$i - 1] = $coup++%2 ? "1.0" : "-1.0";
    print "@display\n";
    print "@display\n";
  }
  print "$winner\n"; # a virer si on veut pas la statut du gagnant.
}

#!/usr/bin/perl
use strict;
use warnings;
use Algorithm::Permute;
use List::MoreUtils ('uniq');
 
my $winning_pattern = "1.*2.*3";
$winning_pattern .= "|1.*4.*7";
$winning_pattern .= "|1.*5.*9";
$winning_pattern .= "|2.*5.*8";
$winning_pattern .= "|3.*5.*7";
$winning_pattern .= "|3.*6.*9";
$winning_pattern .= "|4.*5.*6";
$winning_pattern .= "|7.*8.*9";
 
my (@array,@first, @second, @winfirst, @winsecond, @winnone);
my $p = new Algorithm::Permute([1..9]);
while (@array = $p->next) {
  my $a;
  $a = 0;
  @first  = grep {$a^=1} @array;
  $a = 1;
  @second = grep {$a^=1} @array;
 
  $_ = join '', sort @first[0..2];
  if (/$winning_pattern/) {
    push @winfirst, join(' ', @array[0..4]);
  }
  else {
    $_ = join '', sort @second[0..2];
    if (/$winning_pattern/) {
      push @winsecond, join(' ', @array[0..5]);
    }
    else {
      $_ = join '', sort @first[0..3];
      if (/$winning_pattern/) {
    push @winfirst, join(' ', @array[0..6]);
      }
      else {
    $_ = join '', sort @second;
    if (/$winning_pattern/) {
      push @winsecond, join(' ', @array[0..7]);
    }
    else {
      $_ = join '', sort @first;
      if (/$winning_pattern/) {
        push @winfirst, join(' ', @array);
      }
      else {
        push @winnone, join(' ', @array);
      }
    }
      }
    }
  }
}
 
 
@winfirst = sort @winfirst;
@winfirst = uniq @winfirst;
open(my $fh, '>', 'winfirst.txt') or die "cannot open winfirst.txt for writing: $!";
foreach (@winfirst) {
  jovalisate($fh, \$_);
}
close ($fh);
 
@winsecond = sort @winsecond;
@winsecond = uniq @winsecond;
open($fh, '>', 'winsecond.txt') or die "cannot open winsecond.txt for writing: $!";
foreach (@winsecond) {
  jovalisate($fh, \$_);
}
close ($fh);
 
@winnone = sort @winnone;
@winnone = uniq @winnone;
open($fh, '>', 'winnone.txt') or die "cannot open winnone.txt for writing: $!";
foreach (@winnone) {
  jovalisate($fh, \$_);
}
close ($fh);
 
sub jovalisate {
  my $fh = shift;
  my $string = shift;
  my @list = split /\s+/, $$string;
  my @display = ("0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0" );
  print $fh "@display\n";
  my $coup = 1;
  foreach my $i (@list) {
    $display[$i - 1] = $coup++%2 ? "1.0" : "-1.0";
    print $fh "@display\n";
    print $fh "@display\n";
  }
  # print $fh "\n"; # décommenter si on veut séparer chaque partie par une ligne blanche
}

with PragmARC.Ansi_Tty_Control;         use PragmARC.Ansi_Tty_Control;
with PragmARC.REM_NN_Wrapper;           use PragmARC, PragmARC.REM_NN_Wrapper;
with PragmARC.Math.Functions;
 
with Ada.Text_Io;
use Ada;
procedure Main is
 
 
   package Real_Io is new Text_Io.Float_Io(Real);
   use Real_Io;
   package Real_Math is new PragmARC.Math.Functions (Supplied_Real => Real);
   
   Num_Inputs    : constant := 9;
   Num_Outputs   : constant := 9;
   Num_Hiddens   : constant := 9;
   
 
   Reuse_Network : Boolean  := False;
 
   type Register_Type is array (1..Num_Inputs) of Float;
 
   type Game_Type is array (Positive range <> ) of access Register_Type;
 
   Games : Game_Type(1..992) := (others => new Register_Type ' (others => 0.0));
 
   Num_Patterns  : positive  := Games'Length/2;
 
   
 
   procedure Get_Input (Pattern : in Positive;
                        Input : out Node_Set;
                        Desired : out Node_Set) is
   begin
      for I in 1..9 loop
         Input(I)  := Real(Games(Pattern*2-1)(I));
         Desired(I) := Real(Games(Pattern*2)(I));
      end loop;
   end Get_Input;
 
   Char : Character;
   Prob : Register_Type :=  Games(1).all;
 
   package My_Float_Io is new Ada.Text_Io.Float_Io(Float);
   use My_Float_Io;
   Game_file : Text_Io.File_Type;
   Game_File_Name : constant String := "winsecond.txt";
 
begin
   Text_Io.Open(Game_File, Text_Io.In_File, Game_File_Name);
   for I in Games'Range loop
      for j in 1..9 loop
         My_Float_Io.Get(Game_File, games(I)(J));
         --My_Float_Io.Put(Games(I)(J));
      end loop;
      --Text_Io.New_Line;
   end loop;
   Text_Io.Put_Line("Press Enter to continue" );
   Text_Io.Get_Immediate(Char);
   declare
      package Morpion_NN is new Rem_NN(Num_Inputs,
                                       Num_Hiddens,
                                       Num_Outputs,
                                       Num_Patterns,
                                       not Reuse_Network,
                                       False,
                       True,
                                       Get_Input => Get_input);
      
      
      Max_Epochs : constant := 1_000_000;
      RMS_Error  : Real := 1.0;
      Response   : Node_Set(1..Num_Outputs);
      Desired    : Node_Set(1..Num_Outputs);
      Error      : Real := 0.0;
      Converged  : Real := 0.055;
   begin
      for All_Epochs in 1..Max_Epochs loop
 
         for Pattern in 1..Games'length/2 loop
            Morpion_NN.Train;
            Morpion_NN.Respond (Pattern, Response);
            for I in 1..9 loop
               Desired(I) := Real(Games(Pattern*2)(I));
            end loop;
 
            for I in Response'Range loop
               Error :=
                 Error + (Desired(I) - Response(i) );
            end loop;
            RMS_Error := RMS_Error + ((Error/Real(Response'Length)) ** 2);
            Error := 0.0;
         end loop;
         RMS_Error :=
           Real_Math.Sqrt(RMS_Error / Real (Games'length/2)) ;
         exit when RMS_Error <= Converged;
         Text_Io.Put("RMS_Error => " );
         Real_Io.Put(RMS_Error);
 
         Text_Io.New_Line;
      end loop;
      Morpion_NN.Save_Weights;
      Reuse_Network := True;
 
   end;
 
end Main;

with PragmARC.Ansi_Tty_Control;         use PragmARC.Ansi_Tty_Control;
with PragmARC.REM_NN_Wrapper;           use PragmARC, PragmARC.REM_NN_Wrapper;
 
with Text_Io;
use Text_Io;
 
procedure Tictactoe is
         
   task Monitor is
      entry New_Game;
      entry Receive(Char : in Character; Game_Over : out boolean);
      entry Halt;
   end Monitor;
   
   
   Nc : constant Integer := 3;
 
   type Joueur is (E, X, O);
   type Une_Grille is array (1..Nc,1..Nc) of Joueur;
           
   type Partie is record
      Grille : Une_Grille;
   end record;
   
   
   function Test_Ligne(G : Une_Grille) return Joueur;
   function Test_Colone(G : Une_Grille) return Joueur;
   function Test_Diagonale(G : Une_Grille) return Joueur;
   function Match_Nul(G : Une_Grille) return Boolean;
   procedure Evaluer(P : in Partie; Fin : out Boolean; Win : out joueur);
   
   function Test_Ligne(G : Une_Grille) return Joueur is
   begin
      for N in G'Range(1) loop
         if G(N,1) /= E and G(N,1) = G(N,2) and G(N,2) = G(N,3) then
            return G(N,1);
         end if;
      end loop;
      return E;
   end Test_Ligne;
 
   function Test_Colone(G : Une_Grille) return Joueur is
   begin
      for N in G'Range(2) loop
         if G(1,N) /= E and G(1,N) = G(2,N) and G(2,N) = G(3,N) then
            return G(1,N);
         end if;
      end loop;
      return E;
   end Test_Colone;
 
   function Test_Diagonale(G : Une_Grille) return Joueur is
      C : Joueur := G(2,2);
   begin
      if C /= E then
         if (C = G(1,1) and C = G(3,3)) or (C = G(1,3) and C = G(3,1)) then
           return C;
         end if;
      end if;
      return E;
   end Test_Diagonale;
 
   function Match_Nul(G : Une_Grille) return Boolean is
   begin
      for I in G'Range(1) loop
         for J in G'Range(2) loop
            if G(I,J) = E then
               return FALSE;
            end if;
         end loop;
      end loop;
      return TRUE;
   end Match_Nul;
 
   procedure Evaluer(P : in Partie; Fin : out Boolean; Win : out joueur) is
      Gagnant : Joueur := E;
   begin
      Gagnant := Test_Ligne(P.Grille);
      if (Gagnant = X) then
         --P.Toto_Gagne := P.Toto_Gagne + 1;
         Fin := TRUE;     
     Win := X;
         return;
      elsif (Gagnant = O) then
         --P.Titi_Gagne := P.Titi_Gagne + 1;
         Fin := TRUE;
     Win := O;
         return ;
      end if;
 
      Gagnant := Test_Colone(P.Grille);
      if (Gagnant = X) then
         --P.Toto_Gagne := P.Toto_Gagne + 1;
         Fin := TRUE;
     Win := X;
         return ;
      elsif (Gagnant = O) then
         --P.Titi_Gagne := P.Titi_Gagne + 1;
         Fin := TRUE;
     Win := O;
         return ;
      end if;
 
      Gagnant := Test_Diagonale(P.Grille);
      if (Gagnant = X) then
         --P.Toto_Gagne := P.Toto_Gagne + 1;
         Fin := TRUE;
     Win := X;
         return ;
      elsif (Gagnant = O) then
         --P.Titi_Gagne := P.Titi_Gagne + 1;
         Fin := TRUE;
     Win := O;
         return ;
      end if;
 
      Fin := Match_Nul(P.Grille);
 
      if Fin then
         --P.Match_Nul := P.Match_Nul + 1;
     Win := E;
      end if;
 
   end Evaluer;
 
   Num_Inputs    : constant := 9;
   Num_Outputs   : constant := 9;
   Num_Hiddens   : constant := 9;
 
   subtype Register_Type is Node_set(1..Num_Inputs);
   package My_Float_Io is new Text_Io.Float_Io(real);
   use My_Float_Io;
   Reuse_Network : Boolean  := True;
   
   procedure Self(Grille : in out Une_Grille) is
      Prob : Register_Type :=  (others => 0.0);
   begin
      
      for I in Grille'Range(1) loop
     for J in Grille'range(2) loop
        if Grille(I, J) = X then
           prob((3*(I-1))+J) := 1.0;
        elsif Grille(I, J) = O then
           prob((3*(I-1))+J) := -1.0;
        else
           prob((3*(I-1))+J) := 0.0;
        end if;
     end loop;
      end loop;
      Put("Entree : " );
      for I in Prob'Range loop
     Put(Prob(I));
      end loop;
      New_Line;
      declare
               
     
     procedure Get_Input (Pattern : in Positive;
                  Input : out Node_Set;
                  Desired : out Node_Set) is
     begin
        for I in 1..9 loop
           Input(I)  := Real(prob(I));
        end loop;
        Desired := (others => 0.0);
     end Get_Input;
     
     
     package Morpion_NN is new Rem_NN(Num_Inputs,
                      Num_Hiddens,
                      Num_Outputs,
                      1,
                      not Reuse_Network,
                      False,
                      True,
                      Get_Input => Get_input);
     Response : Node_Set(1..Num_Inputs);
      begin
     Morpion_NN.Respond (1, Response);
     for K in Response'Range loop
        if Response(K) >= 0.25 then
           Response(K) := 1.0;
        elsif Response(K) <= -0.25 then
           Response(K) := -1.0;
        else
           Response(K) := 0.0;
        end if;
     end loop;    
     Put("Sortie : " );
     for I in response'Range loop
        Put(response(I));
     end loop;
     for I in Grille'Range(1) loop
        for J in Grille'range(2) loop
           if response((3*(I-1))+J) = 1.0 then
          Grille(I, J) := X;
           elsif response((3*(I-1))+J) = -1.0 then
          Grille(I, J) := O;
           else
          Grille(I, J) := E;
           end if;
        end loop;
     end loop;     
     
      end;
   end self;
   
   
   task body Monitor is
      Section, End_Of_Task : Boolean := False;
      Game : Partie;
      Line : Positive;
      Col  : Positive;
      Player : Joueur := X;
      Winner : Joueur;
      Fin    : Boolean := False;
      
   begin
      while not End_Of_Task loop
     select
        accept New_Game do
           Game.grille := (others => (others => E));
           Section := True;
           Text_Io.Put(Clear_Screen);
           
           for line in 1..3 loop
          for col in 1..3 loop
             if Game.Grille(Line, Col) = X or Game.Grille(Line, Col) = O then
            Text_Io.Put(Joueur'Image(Game.Grille(Line, Col)));
             else
            Put(' ');
             end if;
          end loop;          
          Text_Io.New_Line;
           end loop;
        end New_Game;
     or
        accept Halt do
           End_Of_Task := True;
           Section := False;
        end Halt;        
     end select;
     while Section loop
        accept Receive(Char : in Character; Game_Over : out boolean) do
           case Char is
          when '1' =>
             Line := 3;
             Col := 1;
          when '2' =>
             Line := 3;
             Col := 2;
          when '3' =>
             Line := 3;
             Col := 3;
          when '4' =>
             Line := 2;
             Col := 1;
          when '5' =>
             Line := 2;
             Col := 2;
          when '6' =>
             Line := 2;
             Col := 3;
          when '7' =>
             Line := 1;
             Col := 1;
          when '8' =>
             Line := 1;
             Col := 2;
          when '9' =>
             Line := 1;
             Col := 3;
          when others =>
             null;
           end case;
           if Game.Grille(Line, Col) /=  E then
          Text_Io.Put(Character'Val(7));
          delay 0.1;
          Text_Io.Put(Character'Val(7));
           else
          Game.grille(Line, Col) := X;
          
          
          Text_Io.Put(Clear_Screen);
           
          for line in 1..3 loop
             for col in 1..3 loop
            if Game.Grille(Line, Col) = X or Game.Grille(Line, Col) = O then
               Text_Io.Put(Joueur'Image(Game.Grille(Line, Col)));
            else
               Put(' ');
            end if;
             end loop;          
             Text_Io.New_Line;
          end loop;
          
          Evaluer(game, Fin, Winner);
          Game_Over := Fin;                      
          New_Line;
          delay 0.5;
          if Game_Over then
             Put_Line("Vous avez gagné, félicitations ! " );
             Section := False;
             Text_Io.Put(Character'Val(7));
             delay 0.1;
             Text_Io.Put(Character'Val(7));
             
          else
             Self(Game.Grille);    
             delay 1.0;          
             Text_Io.Put(Clear_Screen);
             for line in 1..3 loop
            for col in 1..3 loop
               if Game.Grille(Line, Col) = X or Game.Grille(Line, Col) = O then
                  Text_Io.Put(Joueur'Image(Game.Grille(Line, Col)));
               else
                  Put(' ');
               end if;
            end loop;          
            Text_Io.New_Line;
             end loop;
             Text_Io.Put(Character'Val(7));
             delay 0.5;
             Evaluer(game, Fin, Winner);
             Game_Over := Fin;                      
             
             if Game_Over then
            Put_Line("Vous avez perdue, domage ! " );
            Section := False;             
            Text_Io.Put(Character'Val(7));
            delay 0.1;
            Text_Io.Put(Character'Val(7));
            delay 0.1;
            Text_Io.Put(Character'Val(7));
             end if;          
          end if;
           end if;
        end Receive;
        
     end loop;
      end loop;
   end Monitor;
   
   Char : Character;
   Success : Boolean := False;
begin
   loop
      Monitor.New_Game;
      loop     
     Get_Immediate(Char);
     Monitor.Receive(Char, success);
     if Success then
        exit;
     end if;
      end loop;
      Put("Continuer ? (o/n) : " );
      Get_Immediate(Char);
      New_Line;
      if Char = 'n' then
     Monitor.Halt;
     exit;
      end if;
   end loop;             
end Tictactoe;