Discussion: Jeu du morpion

  1. #1
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut Jeu du morpion

    Bonjour,
    Je cherche à résoudre un exercice qui concerne le jeu de morpion mais je bloque car dans cet exercice une strategie est imposée à l'ordi et je n'arrive pas à traduire cette strategie en algo. Quelqu'un pourrait-il m'aider ?
    Stratégie joueur B :
    1) Le trait (tour) étant au joueur B, ce dernier parcourt d'abord ligne par ligne chaque case disponible du damier pour verifier si plaçant (provisoirement) son pion dans cette case, il réalise ainsi immédiatement un alignement ; si cela est possible, il place effectivement son pion dans la case en question et il a gagné.
    2) Si la stratégie 1) a echoué il parcourt à nouveau ligne par ligne les cases disponibles et place son pion dans la premiere case pouvant donner la possibilité au joueur A de réaliser un alignement au coup suivant.
    3) Si les deux stratégies précédentes ont échoué, il place son pion dans la première case disponible (toujours dans un parcours ligne par ligne).

  2. #2
    Membre éclairé

    Homme Profil pro
    Formation: Chimie et Physique (structure de la matière)
    Inscrit en
    décembre 2010
    Messages
    347
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 70
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Formation: Chimie et Physique (structure de la matière)
    Secteur : Enseignement

    Informations forums :
    Inscription : décembre 2010
    Messages : 347
    Points : 713
    Points
    713
    Billets dans le blog
    5

    Par défaut Jeu du morpion

    Bonjour,

    Tu ne donnes pas les dimensions de la grille, c.a.d. le nombre de cases présentes dans les lignes et les colonnes. Je suppose que la grille est carrée, et que chaque joueur doit aligner 5 pions.
    L'énoncé impose une stratégie très simple, afin d'éviter les complications qui pourraient devenir rapidement insurmontables.
    Pour voir ce qu'il y a sur une ligne ou une colonne, et détecter les éventuels alignements réalisables, il faut faire un inventaire systématique du contenu observé sur 5 cases consécutives, en comptant par exemple:
    # 1 pour une case vide,
    # 100 pour un pion (A) et
    # 10000 pour un pion (B);
    les résultats seront dépourvus d'ambiguïté, puisque tu obtiendras: 5 pour 5 cases vides, 500 pour 5 pions (A) et 50000 pour 5 pions (B) - les trois domaines de valeurs ne se recouvrent pas.
    Une ligne ou une colonne de (c) cases contient (c-4) séquences de 5 cases accolées, et les valeurs à repérer pour les deux partenaires seront
    # 401 (4 pions A et 1 case vide) et
    # 40001 (4 pions B et une case vide).
    Les résultats possibles, immédiatement lisibles et compris entre 5 et 50000, peuvent être consignées dans une variable Word; un barême plus serré (1, 10, 100), conduisant à un maximum de 500, ne permet pas d'utiliser un entier de type Byte ... alors autant prendre son aise.
    L'état actuel de la grille est mémorisé dans un tableau comportant (c*c) entiers Word, initialement tous nuls (cases vides) et se remplissant progressivement (Tij =1 ou 100 selon la couleur du pion). On peut aussi envisager un tableau de caractères, représentable sur l'écran texte.
    Maintenant, à toi de te lancer dans la rédaction du code.


    Le français, notre affaire à tous
    Grand Dictionnaire Terminologique

  3. #3
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    pour l'instant je commence a 3*3 pour diminuer le nombre de possibiliter et faciliter la comprehenssion de l'ennoncer mais j'ai peur de me perdre car je suis
    seulement a la premier strategie de b et mon code me parrait un peut long:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    program strategie_b;
    const
      symbolb = '+';
    var
      cases: array[1..3, 1..3] of char;
      ok: boolean;
      a, b, c, d: integer;
      finpartie: boolean;
    begin
      for a := 1 to 3 do
        for b := 1 to 3 do
          cases[a, b] := ' ';
      ok := false;
      while (not ok) do
        if (cases[1, 1] = '+') and (cases[1, 2] = '+') then
          if cases[1, 3] = ' ' then
          begin
            cases[1, 3] := '+';
            ok := true;
            finpartie := true;
            writeln('les pions + gagne')
          end
          else if (cases[1, 2] = '+') and (cases[1, 3] = '+') then
            if cases[1, 1] = ' ' then
            begin
              cases[1, 1] := '+';
              ok := true;
              finpartie := true;
              writeln('les pions + gagne')
            end
            else if (cases[1, 1] = '+') and (cases[1, 3] = '+') then
              if cases[1, 2] = ' ' then
              begin
                cases[1, 2] := '+';
                ok := true;
                finpartie := true;
                writeln('les pions + gagne')
              end
                {-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
              else if (cases[1, 1] = '+') and (cases[2, 2] = '+') then
                if cases[3, 3] = ' ' then
                begin
                  cases[3, 3] := '+';
                  ok := true;
                  finpartie := true;
                  writeln('les pions + gagne')
                end
                else if (cases[1, 1] = '+') and (cases[3, 3] = '+') then
                  if cases[2, 2] = ' ' then
                  begin
                    cases[2, 2] := '+';
                    ok := true;
                    finpartie := true;
                    writeln('les pions + gagne')
                  end
                  else if (cases[2, 2] = '+') and (cases[3, 3] = '+') then
                    if cases[1, 1] = ' ' then
                    begin
                      cases[1, 1] := '+';
                      ok := true;
                      finpartie := true;
                      writeln('les pions + gagne')
                    end
                      {-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                    else if (cases[1, 1] = '+') and (cases[2, 1] = '+') then
                      if cases[3, 1] = ' ' then
                      begin
                        cases[3, 1] := '+';
                        ok := true;
                        finpartie := true;
                        writeln('les pions + gagne')
                      end
                      else if (cases[1, 1] = '+') and (cases[3, 1] = '+') then
                        if cases[2, 1] = ' ' then
                        begin
                          cases[2, 1] := '+';
                          ok := true;
                          finpartie := true;
                          writeln('les pions + gagne')
                        end
                        else if (cases[2, 1] = '+') and (cases[3, 1] = '+') then
                          if cases[1, 1] = ' ' then
                          begin
                            cases[1, 1] := '+';
                            ok := true;
                            finpartie := true;
                            writeln('les pions + gagne')
                          end
                            {--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                          else if (cases[1, 2] = '+') and (cases[2, 2] = '+') then
                            if cases[3, 2] = ' ' then
                            begin
                              cases[3, 2] := '+';
                              ok := true;
                              finpartie := true;
                              writeln('les pions + gagne')
                            end
                            else if (cases[1, 2] = '+') and (cases[3, 2] = '+') then
                              if cases[2, 2] = ' ' then
                              begin
                                cases[2, 2] := '+';
                                ok := true;
                                finpartie := true;
                                writeln('les pions + gagne')
                              end
                              else if (cases[2, 2] = '+') and (cases[3, 2] = '+')
                                then
                                if cases[1, 2] = ' ' then
                                begin
                                  cases[1, 2] := '+';
                                  ok := true;
                                  finpartie := true;
                                  writeln('les pions + gagne')
                                end
                                  {---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                else if (cases[1, 3] = '+') and (cases[1, 2] = '+')
                                  then
                                  if cases[3, 1] = ' ' then
                                  begin
                                    cases[3, 1] := '+';
                                    ok := true;
                                    finpartie := true;
                                    writeln('les pions + gagne')
                                  end
                                  else if (cases[1, 3] = '+') and (cases[3, 1] = '+')
                                    then
                                    if cases[2, 2] = ' ' then
                                    begin
                                      cases[2, 2] := '+';
                                      ok := true;
                                      finpartie := true;
                                      writeln('les pions + gagne')
                                    end
                                    else if (cases[2, 2] = '+') and (cases[3, 1] =
                                      '+') then
                                      if cases[1, 3] = ' ' then
                                      begin
                                        cases[1, 3] := '+';
                                        ok := true;
                                        finpartie := true;
                                        writeln('les pions + gagne')
                                      end
                                        {-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                      else if (cases[2, 1] = '+') and (cases[2, 2] =
                                        '+') then
                                        if cases[2, 3] = ' ' then
                                        begin
                                          cases[2, 3] := '+';
                                          ok := true;
                                          finpartie := true;
                                          writeln('les pions + gagne')
                                        end
                                        else if (cases[2, 1] = '+') and (cases[2, 3]
                                          = '+') then
                                          if cases[2, 2] = ' ' then
                                          begin
                                            cases[2, 2] := '+';
                                            ok := true;
                                            finpartie := true;
                                            writeln('les pions + gagne')
                                          end
                                          else if (cases[2, 2] = '+') and (cases[2,
                                            3] = '+') then
                                            if cases[2, 1] = ' ' then
                                            begin
                                              cases[2, 1] := '+';
                                              ok := true;
                                              finpartie := true;
                                              writeln('les pions + gagne')
                                            end
                                              {----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                            else if (cases[1, 3] = '+') and
                                              (cases[2, 3] = '+') then
                                              if cases[3, 3] = ' ' then
                                              begin
                                                cases[3, 3] := '+';
                                                ok := true;
                                                finpartie := true;
                                                writeln('les pions + gagne')
                                              end
                                              else if (cases[1, 3] = '+') and
                                                (cases[3, 3] = '+') then
                                                if cases[2, 3] = ' ' then
                                                begin
                                                  cases[2, 3] := '+';
                                                  ok := true;
                                                  finpartie := true;
                                                  writeln('les pions + gagne')
                                                end
                                                else if (cases[2, 3] = '+') and
                                                  (cases[3, 3] = '+') then
                                                  if cases[1, 3] = ' ' then
                                                  begin
                                                    cases[1, 3] := '+';
                                                    ok := true;
                                                    finpartie := true;
                                                    writeln('les pions + gagne')
                                                  end
    end.

  4. #4
    Membre éclairé

    Homme Profil pro
    Formation: Chimie et Physique (structure de la matière)
    Inscrit en
    décembre 2010
    Messages
    347
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 70
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Formation: Chimie et Physique (structure de la matière)
    Secteur : Enseignement

    Informations forums :
    Inscription : décembre 2010
    Messages : 347
    Points : 713
    Points
    713
    Billets dans le blog
    5

    Par défaut Jeu du morpion

    Bonjour,

    Tu as rédigé un programme entier, donc déjà réfléchi au sujet.

    1°) Il est malheureusement peu compréhensible et ingérable, parce que constitué d'un seul bloc; il faut absolument regrouper les instructions par petits paquets, dans des procédures plus faciles à comprendre.
    Connais-tu le sens des instructions:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    PROCEDURE P1(VAR Ok1: Boolean);
      BEGIN
        Ok1:= True
      END;
    Cela rendrait service, mais peut être contourné pour l'instant.

    2°) Tu fais intervenir une variable booléenne notée <Ok>, qui devient vraie (True) quand le joueur (B) a effectué une action: il s'agit de l'une des 3 opérations définies dans l'énoncé, qui seront codifiées dans les procédures <ActionB1>, >ActionB2> et <ActionB3>.

    3°) Tu as pris d'autre part une grille à 3*3 cases, ce qui n'est pas un problème; on admettra que le joueur doit réaliser des alignements de 3 pions. D'où l'intervention permanente de la valeur 3, qu'on a intérêt à mémoriser en constante (notée Nc). Il sera ainsi très facile de modifier cette valeur.

    4°) Je n'ai lu pour les cases, que les valeurs '+' et ' ', alors que 3 états doivent être envisagés:
    ' ' (case vide), 'A' ou 'B' (présence d'un pion): la notation est évidente.

    Peux-tu déjà donner une ébauche de programme, comportant les procédures mentionnées, qui serait dépourvue d'instructions (une coquille vide en quelque sorte), mais malgré tout compilable ? Elle commencerait par l'initialisation de la grille vide, suivie des actions (1, 2, 3).


    Le français, notre affaire à tous
    Grand Dictionnaire Terminologique

  5. #5
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    merci

  6. #6
    Membre éclairé

    Homme Profil pro
    Formation: Chimie et Physique (structure de la matière)
    Inscrit en
    décembre 2010
    Messages
    347
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 70
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Formation: Chimie et Physique (structure de la matière)
    Secteur : Enseignement

    Informations forums :
    Inscription : décembre 2010
    Messages : 347
    Points : 713
    Points
    713
    Billets dans le blog
    5

    Par défaut

    Debogeur,

    Bénéficier d'une aide à distance suppose de ta part un minimum d'autonomie et d'initiative, sinon l'intervenant sera conduit à te livrer un programme dont tu n'auras pas compris trois lignes, et cela ne te servira à rien d'autre qu'à rendre éventuellement un devoir qui ne fera pas illusion ... c'est une perte de temps pour tous, et l'on n'est pas là pour ça.

    Tu disposais d'une ébauche de programme, et je t'ai fourni sur deux messages toute une série d'indications dont tu ne tiens pratiquement aucun compte; je m'étonne que quelqu'un comme toi qui se déclare étudiant dans le secteur "High Tech / Éditeur de logiciels" ne sache pas prendre le train en marche, et écrire un nouveau programme - mal fagoté peut-être - mais comportant au moins des éléments utilisables.

    Je suppose que le langage utilisé est celui de Turbo Pascal 7, puisque tu es intervenu fin mars sur le forum correspondant, avec un résultat d'ailleurs mitigé.
    J'ai eu aussi l'impression que derrière le pseudonyme interviennent deux personnes, dont un adulte probablement enseignant: est-ce que je me trompe ?

    Il faut te demander sérieusement si tu ne trouverais pas une aide beaucoup plus efficace sur place, compte tenu de ton niveau, auprès de ton groupe de travail ou d'un étudiant ayant une formation appropriée. Tu dois par ailleurs disposer de toute une série de cours et d'exercices. A toi de prendre une décision.


    # PS 18 H : Je vois que tu viens de reprendre une édition enfin lisible du code, je te laisse donc une chance: mais il y a beaucoup à faire !

    1°) a) Au sujet de cette énorme procédure , il devrait y en avoir plusieurs, et nettement plus courtes ! On ne peut s'en sortir qu'en envisageant un petit nombre d'instructions. Mais je n'ai pas vu l'ensemble du programme; il faudrait le montrer.
    b) Tu envisages un déplacement des pions, alors que le jeu consiste à en déposer de nouveaux: j'espère qu'il ne s'agit pas d'un autre énoncé !
    c) Il contient néanmoins un suite d'instructions intéressantes:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    case a of #75 : begin i := i - 4; end;
                  #77 : begin i := i + 4; end;
                  #72 : begin j := j - 2; end;
                  #80 : begin j := j + 2; end;                
    end;
    qui relie la frappe d'un caractère à l'un des 4 déplacements possibles sur une grille:
    #75 = 'K' --> dep. vers le haut [ (i) désignant la ligne, et (j) la colonne je suppose ]
    #77 = 'M' --> dep. ' ' ' ' ' ' bas
    #72 = 'H' --> dep. ' ' ' ' 'la gauche
    #80 = 'P' --> dep. ' ' ' ' ' ' ' droite
    D'abord les délimiteurs <BEGIN/END> ne sont pas indispensables lorsqu'ils n'encadrent qu'une seule instruction;
    ensuite pourquoi ne pas utiliser le pavé numérique pour l'association des caractères aux directions de déplacement ? Tu aurais ainsi:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
      7   8   9
      4   5   6
      1   2   3
    
    CASE a OF  '8': i:= i - 4;
               '2': i:= i + 4;
               '4': j:= j - 2;
               '6': j := j + 2  END;
    Voilà un bloc d'instructions qui pourra te servir de modèle.

    2°) Pour en revenir à l'énoncé, je te propose un programme vide mais pourtant compilable; vérifie en le lançant qu'il n'y a pas de message d'erreur, et que le contenu est compatible avec ta version de TP7 - je viens de le vérifier sous Virtual P.
    Morpion_01.pas
    Ton premier travail: par une série d'instructions écrites à l'intérieur de la procédure InitG entre les délimiteurs BEGIN et END), initialiser la grille (Gr) en mettant dans les 9 cases le caractère ' '; puis déposer dans 4 de ces cases 2 pions (A) et 2 pions (B) (caractères 'A' et 'B').


    J'attends la réponse.


    Le français, notre affaire à tous
    Grand Dictionnaire Terminologique

  7. #7
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    ok tu as reson merci

  8. #8
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Voici une ébauche de mon programme. Il y a quelques ajustements à faire et ce sera bon.
    Merci wiwaxia pour l'aide ; je n'ai malheuresement pas réussi à utiliser ta procédure de déplacement.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    program morpion;
    uses crt;
    const symbol='+';
    type echiquier=array[1..3,1..3]of char;
    procedure initial;
    begin
    gotoxy(2,1); writeln('+---+---+---+');
    gotoxy(2,2); writeln('|   |   |   |');
    gotoxy(2,3); writeln('+---|---|---|');
    gotoxy(2,4); writeln('|   |   |   |');
    gotoxy(2,5); writeln('+---|---|---|');
    gotoxy(2,6); writeln('|   |   |   |');
    gotoxy(2,7); writeln('+---+---+---+');
    end;
    procedure strategieB(var ok:boolean;var cases:echiquier);
    procedure strategieB1(var ok:boolean;var cases:echiquier);
    begin
    if (cases[1,1]='+') and (cases[1,2]='+') then
                                              if cases[1,3]=' ' then
                                                                begin
                                                                cases[1,3]:='+';
                                                                gotoxy(12,2);
                                                                write(symbol);
                                                                ok:=true;
                                                                writeln('les pions + gagne')
                                                                end
                                                                else
                                                                if (cases[1,2]='+') and (cases[1,3]='+') then
                                                                                                         if cases[1,1]=' ' then
                                                                                                         begin
                                                                                                         cases[1,1]:='+';
                                                                                                         gotoxy(4,2);
                                                                                                         write(symbol);
                                                                                                         ok:=true;
                                                                                                         writeln('les pions + gagne')
                                                                                                         end
                                                                                                         else
                                                                                                         if (cases[1,1]='+') and (cases[1,3]='+') then
                                                                                                                                                  if cases[1,2]=' ' then
                                                                                                                                                  begin
                                                                                                                                                  cases[1,2]:='+';
                                                                                                                                                  gotoxy(8,2);
                                                                                                                                                  write(symbol);
                                                                                                                                                  ok:=true;
                                                                                                                                                  writeln('les pions + gagne')
                                                                                                                                                  end
    else
                                                                                                                                                  if (cases[1,1]='+') and (cases[2,2]='+') then
                                                                                                                                                                                           if cases[3,3]=' ' then
                                                                                                                                                                                                             begin
                                                                                                                                                                                                             cases[3,3]:='+';
                                                                                                                                                                                                             gotoxy(12,6);
                                                                                                                                                                                                             write(symbol);
                                                                                                                                                                                                             ok:=true;
                                                                                                                                                                                                             writeln('les pions + gagne')
                                                                                                                                                                                                             end
                                                                                                                                                                                                             else
                                                                                                                                                                                                             if (cases[1,1]='+') and

  9. #9
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    else
                                                                                                                                                  if (cases[1,1]='+') and (cases[2,2]='+') then
                                                                                                                                                                                           if cases[3,3]=' ' then
                                                                                                                                                                                                             begin
                                                                                                                                                                                                             cases[3,3]:='+';
                                                                                                                                                                                                             gotoxy(12,6);
                                                                                                                                                                                                             write(symbol);
                                                                                                                                                                                                             ok:=true;
                                                                                                                                                                                                             writeln('les pions + gagne')
                                                                                                                                                                                                             end
                                                                                                                                                                                                             else
                                                                                                                                                                                                             if (cases[1,1]='+') and (cases[3,3]='+') then
                                                                                                                                                                                                                                                      if cases[2,2]=' ' then
                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                      cases[2,2]:='+';
                                                                                                                                                                                                                                                      gotoxy(8,2);
                                                                                                                                                                                                                                                      write(symbol);
                                                                                                                                                                                                                                                      ok:=true;
                                                                                                                                                                                                                                                      writeln('les pions + gagne')
                                                                                                                                                                                                                                                      end
                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                      if (cases[2,2]='+') and (cases[3,3]='+') then
                                                                                                                                                                                                                                                      if cases[1,1]=' ' then
                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                      cases[1,1]:='+';
                                                                                                                                                                                                                                                      gotoxy(4,2);
                                                                                                                                                                                                                                                      write(symbol);
                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                      writeln('les pions + gagne')
                                                                                                                                                                                                                                                      end

  10. #10
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    else
                                                                                                                                                                                                                                                      if (cases[1,1]='+') and (cases[2,1]='+') then
                                                                                                                                                                                                                                                                                               if cases[3,1]=' ' then
                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                 cases[3,1]:='+';
                                                                                                                                                                                                                                                                                                                 gotoxy(4,6);
                                                                                                                                                                                                                                                                                                                 write(symbol);
                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                 writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                 end
                                                                                                                                                                                                                                                                                                                 else
                                                                                                                                                                                                                                                                                                                 if (cases[1,1]='+') and (cases[3,1]='+') then
                                                                                                                                                                                                                                                                                                                                                          if cases[2,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                            begin
                                                                                                                                                                                                                                                                                                                                                                            cases[2,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                            gotoxy(4,4);
                                                                                                                                                                                                                                                                                                                                                                            write(symbol);
                                                                                                                                                                                                                                                                                                                                                                            ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                            writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                            end
                                                                                                                                                                                                                                                                                                                                                                            else
                                                                                                                                                                                                                                                                                                                                                                            if (cases[2,1]='+') and (cases[3,1]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                     if cases[1,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                     begin
                                                                                                                                                                                                                                                                                                                                                                                                                     cases[1,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                     gotoxy(4,2);
                                                                                                                                                                                                                                                                                                                                                                                                                     write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                     ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                     writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                     end
    {--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                                                                                                                                                                                                                                                                                                                                                                                                     else
                                                                                                                                                                                                                                                                                                                                                                                                                     if (cases[1,2]='+') and (cases[2,2]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                              if cases[3,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cases[3,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                gotoxy(8,6);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (cases[1,2]='+') and (cases[3,2]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if cases[2,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[2,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (cases[2,2]='+') and (cases[3,2]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if cases[1,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[1,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(8,2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end

  11. #11
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    if (cases[1,3]='+') and (cases[1,2]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                              if cases[3,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cases[3,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                gotoxy(4,6);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (cases[1,3]='+') and (cases[3,1]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if cases[2,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[2,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (cases[2,2]='+') and (cases[3,1]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if cases[1,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[1,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(12,2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
     {-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (cases[2,1]='+') and (cases[2,2]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if cases[2,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cases[2,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gotoxy(12,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (cases[2,1]='+') and (cases[2,3]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if cases[2,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cases[2,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (cases[2,2]='+') and (cases[2,3]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if cases[2,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cases[2,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gotoxy(4,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end

  12. #12
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    else                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (cases[1,3]='+') and (cases[2,3]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               if cases[3,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 cases[3,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 gotoxy(12,6);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (cases[1,3]='+') and (cases[3,3]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if cases[2,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 cases[2,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (cases[2,3]='+') and (cases[3,3]='+') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if cases[1,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 cases[1,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 gotoxy(12,2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 write(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln('les pions + gagne')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 end
    end;
    procedure strategieB2(var ok:boolean;var cases:echiquier);
    begin
    if (cases[1,1]='*') and (cases[1,2]='*') then
                                              if cases[1,3]=' ' then
                                                                begin
                                                                cases[1,3]:='+';
                                                                gotoxy(12,2);
                                                                writeln(symbol);
                                                                ok:=true;
     
                                                                end
                                                                else
                                                                if (cases[1,2]='*') and (cases[1,3]='*') then
                                                                                                         if cases[1,1]=' ' then
                                                                                                         begin
                                                                                                         cases[1,1]:='+';
                                                                                                         gotoxy(4,2);
                                                                                                         writeln(symbol);
                                                                                                         ok:=true;
     
                                                                                                         end
                                                                                                         else
                                                                                                         if (cases[1,1]='*') and (cases[1,3]='*') then
                                                                                                                                                  if cases[1,2]=' ' then
                                                                                                                                                  begin
                                                                                                                                                  cases[1,2]:='+';
                                                                                                                                                  gotoxy(8,2);
                                                                                                                                                  writeln(symbol);
                                                                                                                                                  ok:=true;
     
     
                                                                                                                                                  end
    {-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                                                                                                                                  else
                                                                                                                                                  if (cases[1,1]='*') and (cases[2,2]='*') then
                                                                                                                                                                                           if cases[3,3]=' ' then
                                                                                                                                                                                                             begin
                                                                                                                                                                                                             cases[3,3]:='+';
                                                                                                                                                                                                             gotoxy(12,6);
                                                                                                                                                                                                             writeln(symbol);
                                                                                                                                                                                                             ok:=true;
     
     
                                                                                                                                                                                                             end
                                                                                                                                                                                                             else
                                                                                                                                                                                                             if (cases[1,1]='*') and (cases[3,3]='*') then
                                                                                                                                                                                                                                                      if cases[2,2]=' ' then
                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                      cases[2,2]:='+';
                                                                                                                                                                                                                                                      gotoxy(8,4);
                                                                                                                                                                                                                                                      writeln(symbol);
                                                                                                                                                                                                                                                      ok:=true;
     
     
                                                                                                                                                                                                                                                      end
                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                      if (cases[2,2]='*') and (cases[3,3]='*') then
                                                                                                                                                                                                                                                      if cases[1,1]=' ' then
                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                      cases[1,1]:='+';
                                                                                                                                                                                                                                                      gotoxy(4,2);
                                                                                                                                                                                                                                                      writeln(symbol);
                                                                                                                                                                                                                                                      ok:=true;
     
     
                                                                                                                                                                                                                                                      end
    {-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                      if (cases[1,1]='*') and (cases[2,1]='*') then
                                                                                                                                                                                                                                                                                               if cases[3,1]=' ' then
                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                 cases[3,1]:='+';
                                                                                                                                                                                                                                                                                                                 gotoxy(4,6);
                                                                                                                                                                                                                                                                                                                 writeln(symbol);
                                                                                                                                                                                                                                                                                                                 ok:=true;
     
     
                                                                                                                                                                                                                                                                                                                 end
                                                                                                                                                                                                                                                                                                                 else
                                                                                                                                                                                                                                                                                                                 if (cases[1,1]='*') and (cases[3,1]='*') then
                                                                                                                                                                                                                                                                                                                                                          if cases[2,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                            begin
                                                                                                                                                                                                                                                                                                                                                                            cases[2,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                            gotoxy(4,4);
                                                                                                                                                                                                                                                                                                                                                                            writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                            ok:=true;
     
     
                                                                                                                                                                                                                                                                                                                                                                            end
                                                                                                                                                                                                                                                                                                                                                                            else
                                                                                                                                                                                                                                                                                                                                                                            if (cases[2,1]='*') and (cases[3,1]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                     if cases[1,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                     begin
                                                                                                                                                                                                                                                                                                                                                                                                                     cases[1,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                     gotoxy(4,2);
                                                                                                                                                                                                                                                                                                                                                                                                                     writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                     ok:=true;
     
     
                                                                                                                                                                                                                                                                                                                                                                                                                     end

  13. #13
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    else
                                                                                                                                                                                                                                                                                                                                                                                                                     if (cases[1,2]='*') and (cases[2,2]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                              if cases[3,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cases[3,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                gotoxy(8,6);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ok:=true;
     
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (cases[1,2]='*') and (cases[3,2]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if cases[2,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[2,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (cases[2,2]='*') and (cases[3,2]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if cases[1,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[1,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(8,2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
    {---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                     if (cases[1,3]='*') and (cases[1,2]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                              if cases[3,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cases[3,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                gotoxy(4,6);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (cases[1,3]='*') and (cases[3,1]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if cases[2,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[2,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (cases[2,2]='*') and (cases[3,1]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if cases[1,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           cases[1,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           gotoxy(12,2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           end
     {-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (cases[2,1]='*') and (cases[2,2]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if cases[2,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cases[2,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gotoxy(12,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (cases[2,1]='*') and (cases[2,3]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if cases[2,2]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cases[2,2]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (cases[2,2]='*') and (cases[2,3]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if cases[2,1]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cases[2,1]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gotoxy(4,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end

  14. #14
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    else                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (cases[1,3]='*') and (cases[2,3]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               if cases[3,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 cases[3,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 gotoxy(12,6);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (cases[1,3]='*') and (cases[3,3]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if cases[2,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 cases[2,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 gotoxy(8,4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 end                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (cases[2,3]='*') and (cases[3,3]='*') then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if cases[1,3]=' ' then
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 begin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 cases[1,3]:='+';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 gotoxy(12,2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 writeln(symbol);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ok:=true;
     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 end
     
     
    end;
    procedure strategieB3(var ok:boolean;var cases:echiquier);
    begin
    if cases[1,1]=' ' then
                      begin
                      cases[1,1]:='+';
                      gotoxy(4,2);
                      write('+')
                      end
                      else
                      if cases[1,2]=' ' then
                                         begin
                                        cases[1,2]:='+';
                                        gotoxy(8,2);
                                        write('+')
                                        end
                                        else 
                                        if cases[1,3]=' ' then
                                                          begin
                                                          cases[1,3]:='+';
                                                          gotoxy(12,2);
                                                          write('+')
                                                          end
     else 
     if cases[2,1]=' ' then
                       begin
                       cases[2,1]:='+';
                       gotoxy(4,4); 
                       write('+');
                       ok:=true
                       end
                       else
                       if cases[2,2]=' ' then
                                         begin
                                         cases[2,2]:='+';
                                         gotoxy(8,4);
                                         write('+');
                                         ok:=true;
                                         end
                                         else
                                         if cases[2,3]=' ' then
                                                           begin
                                                           cases[2,3]:='+';
                                                           gotoxy(12,4);
                                                           write('+');
                                                           ok:=true
                                                           end
      else
      if cases[3,1]=' ' then
                         begin
                        cases[3,1]:='+';
                        gotoxy(4,6);
                        write('+');
                        ok:=true
                        end
                        else
                        if cases[3,2]=' ' then
                                          begin
                                          cases[3,2]:='+';
                                          gotoxy(8,6);
                                          writeln('+');
                                          ok:=true
                                          end
                                          else
                                          if cases[3,3]=' ' then
                                          begin
                                          cases[3,3]:='+';
                                          gotoxy(12,6);
                                          write('+');
                                          ok:=true;
                                          end
    end;

  15. #15
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    begin
    strategieB1(ok,cases);
    strategieB2(ok,cases);
    strategieB3(ok,cases)
    end;
     
    procedure deplacement;
    var i,j:integer;
    a:char;
    begin
    i:=8;
    j:=4;
    a:=readkey;
    while a<>#13 do
               begin
               begin
               case a of #75 : begin i := i - 4; end;
                         #77 : begin i := i + 4; end;
                         #72 : begin j := j - 2; end;
                         #80 : begin j := j + 2; end;                
    end;
    gotoxy(i,j);
    a:=readkey;
    end;
    if a=#13 then
             writeln('*');
    end;
    end;
    procedure gagne(var cases:echiquier;finparti:boolean);
    var
    i,j,casesvides:integer;
    begin 
    for i:=1 to 3 do
    begin
    if cases[i,2]<>' ' then
                       if (cases[i,1]=cases[i,2]) and (cases[i,2]=cases[i,3]) then
                                                                   finparti:=true;
     if cases[2,i]<>' ' then
                        if (cases[1,i]=cases[2,i]) and (cases[2,i]=cases[3,i]) then
                                                                    finparti:=true;
     if cases[2,2]<>' ' then
                        if (cases[1,1]=cases[2,2]) and (cases[2,2]=cases[3,3]) then
                                                                    finparti:=true;
     if cases[2,2]<>' ' then
                        if (cases[1,3]=cases[2,2]) and (cases[2,2]=cases[3,1]) then
                                                                     finparti:=true
    end;
    i := 1; j := 1;
         CasesVides := 0;
         while ( j < 4 ) do
         begin
              if (cases[i,j] = ' ') then
              begin
                   CasesVides := CasesVides + 1;
              end;
              i := i + 1;
              if ( i = 4 ) then
              begin
                   j := j + 1; i := 1;
              end;
         end;
         if ( CasesVides = 0 ) then finParti:= true;
    end;
    var
    i,j:integer;
    cases:echiquier;
    ok,finparti:boolean;
    begin
    initial;
    for i:=1 to 3 do
    for j:=1 to 3 do
    cases[i,j]:=' ';
    ok:=false;
    finparti:=false;
    while finparti=false do
    begin
    strategieB(ok,cases);
    ok:=false;
    deplacement;
    gagne(cases,finparti);
    end
    end.

  16. #16
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    2 974
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 2 974
    Points : 10 674
    Points
    10 674
    Billets dans le blog
    4

    Par défaut

    @debogeur

    Il n'a pas l'air mauvais ce programme. Il y a de l'idée. Mais est-ce qu'il vous serait possible de le poster en entier dans un seul message ?

  17. #17
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2015
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : Gabon

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 26
    Points : 5
    Points
    5

    Par défaut

    le site impose une longeur des messages

  18. #18
    Membre expert
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    2 388
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 2 388
    Points : 3 733
    Points
    3 733

    Par défaut

    salut

    en piece attaché ce serait mieux
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  19. #19
    Membre expert
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    2 388
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 2 388
    Points : 3 733
    Points
    3 733

    Par défaut

    salut,

    après un bon déblayage de code il te reste pas mal de boulot d'optimisation

    la première chose pour initialiser ton tableau a vide
    tu peut faire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
      Fillchar(cases,Sizeof(cases),' ');
    ensuite ta fonction Gagne peut etre beaucoup plus simple
    je m'explique pour contrôler une ligne il te suffit de tester une case pivot
    imaginons que je prenne la case[1,1]
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     ((cases[1,1]= Symbol) and  (  ( (cases[1,1]=cases[1,2] )  and (cases[1,1]=cases[1,3])    // pour l'horizontal
                                                         or ( (cases[1,1]=cases[2,1] )  and (cases[1,1]=cases[3,1]))   // pour la verticale  
                                                                ))
    la plus complique est la case centrale car en plus de l'horizontal et la verticale il faut aussi verifier les diagonane
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     ((cases[2,2]= Symbol) and  (    ( (cases[2,2]=cases[1,2] )  and (cases[2,2]=cases[3,2])    // pour l'horizontal
                                                          or ( (cases[2,2]=cases[2,1] )  and (cases[2,2]=cases[2,3]))   // pour la verticale  
                                                          or ( (cases[2,2]=cases[1,1] )  and (cases[2,2]=cases[3,3]))   //1 diagonale
                                                          or ( (cases[2,2]=cases[1,3] )  and (cases[2,2]=cases[3,1]))   //2 diagonale 
                                                                ))
    je te laisse faire la case pivot [3,3]

    tout ceci nous dis si nous avons trois pions identique alignés si oui cela veut dire que le détenteur du symbole est vainqueur sinon pas de gagnant
    donc que la partie est finie parcontre et tu l'as bien vue la partie peut aussi se terminer si toutes les case sont rempli pour ma part j'en ferais une fonction a part histoire de bien dissocier les deux test
    genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
       fonction CaseVideExiste(cases:echiquier) : Boolean
       var 
           i       : integer;
           Plein : Boolean;
       begin
         i:= 1;
         Plein := False;   
         while i <= 6 and not(Plein) do 
         begin
            Plein := (Case[i] = ' ') or (Case[i+3] = ' ') 
            inc(i);
         end;
          CaseVideExiste := Plein
       end;
    effectivement ici on utilise le fait que pascal créer les cellule du tableau de façon linéaire en mémoire
    ce qui veut dire que bon j'ai pas encore regardé tes procédure de stratégie mais à première vu il y a beaucoup de code qui ce répète donc il doit être possible de simplifier
    Ps : d’après ce que je vois tu n'as pas trop compris l'utilité du var en paramètre de fonction
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  20. #20
    Membre éclairé

    Homme Profil pro
    Formation: Chimie et Physique (structure de la matière)
    Inscrit en
    décembre 2010
    Messages
    347
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 70
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Formation: Chimie et Physique (structure de la matière)
    Secteur : Enseignement

    Informations forums :
    Inscription : décembre 2010
    Messages : 347
    Points : 713
    Points
    713
    Billets dans le blog
    5

    Par défaut

    Citation Envoyé par debogeur Voir le message
    voici une ebauche de mon program il y a quelques ajustement a faire et se sera bon merci wiwaxia pour l aide je n ai pas malheuresement reussi a utiliser ta procedure de deplacement
    program morpion;
    uses crt;
    const symbol='+';
    type echiquier=array[1..3,1..3]of char;
    procedure initial;
    begin ...
    end;
    Un programme sur 8 messages consécutifs, là je suis submergé !
    Les instructions doivent être insérées entre des balises 'code'
    [CODE ] [/CODE] obtenues en cliquant sur le bouton <#>

    Ainsi le début de ton programme devient:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     
     program morpion;
     uses crt;
     const symbol='+';
     type echiquier=array[1..3,1..3]of char;
     
     procedure initial;
       begin
         gotoxy(2,1); writeln('+---+---+---+');
         gotoxy(2,2); writeln('| | | |');
         gotoxy(2,3); writeln('+---|---|---|');
         gotoxy(2,4); writeln('| | | |');
         gotoxy(2,5); writeln('+---|---|---|');
         gotoxy(2,6); writeln('| | | |');
         gotoxy(2,7); writeln('+---+---+---+');
     end;
    L'indentation est possible, et le texte beaucoup plus facile à déchiffrer.

    Pour un texte entier, le fichier *.pas peut être passé en pièces jointes - d'autres viennent aussi de te le signaler.

    Prenons le début: tu as l'idée de tracer une grille contenant les 9 cases: mais le nom et le résultat indiquent que tu confonds ce tracé avec l'initialisation des cases toutes vides; mais c'est pour l'instant sans conséquence.
    J'y trouve 2 sortes de chaînes de caractères, que tu pourrais passer en constantes (T1, T2); et les coordonnées dépendent toutes de celles que tu as choisi pour le coin supérieur droit (X1, Y1): pourrais-tu alléger cette procédure en partant de ce qui suit ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
     procedure initial;
       const X1 = 2; Y1 = 1, T1 = '+---+---+---+'; T2 = '|     |     |     |'
       begin
         gotoxy(X1, Y1); write(T1);
         gotoxy(X1, Y1+1); write(T2);
         gotoxy(??); write(??);
         gotoxy(??); write(??);
         gotoxy(??); write(??);
         gotoxy(??); write(??);
         gotoxy(??); write(??)
     end;


    Le français, notre affaire à tous
    Grand Dictionnaire Terminologique

Discussions similaires

  1. [Erlang]Code jeux de morpion ou bataille navale
    Par pascal_06 dans le forum Langages fonctionnels
    Réponses: 1
    Dernier message: 17/04/2015, 08h10
  2. Développement jeux vidéo : quelles bases à avoir absolument ?
    Par Ezechiel dans le forum Développement 2D, 3D et Jeux
    Réponses: 174
    Dernier message: 10/03/2012, 18h40
  3. [Débutant] jeux du morpion + réinitialisation de la partie
    Par herosion dans le forum MATLAB
    Réponses: 6
    Dernier message: 22/11/2011, 17h57
  4. jeux de caractères
    Par AHO dans le forum InterBase
    Réponses: 11
    Dernier message: 05/02/2003, 18h45
  5. Editeur de MAP en delphi pour jeux directX
    Par PetitScorpion dans le forum DirectX
    Réponses: 5
    Dernier message: 09/07/2002, 18h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo