Programmation autours d'un jeu

[invited08daa90]

Bonjour,
Je recherche un programmeur qui pourrait m’aider a faire tourner un ptit programme au sujet d’un jeu.
Ce jeu se nomme KHALOU et est disponible gratuitement sur Itunes pour Iphone et Ipad.
https://itunes.apple.com/fr/app/khalou/id589404904?mt=8
Je vous laisse en lire les règles. Voici mes requêtes :
Il existe pour ce jeu 2^16 = 65536 positions différentes.
Les jetons de ce jeu peuvent se retourner de différentes façons. Je cherche un petit script a faire tourner qui pourrait me donner :
*Pour chacune des positions : le nombre de retournement minimum pour rendre le damier du jeu tout blanc (le but du jeu). Cela est toujours faisable en 5 retournements minimum (démontré via théorie des groupes).
*Trouver ainsi le nombre totale de positions résolvables en : 1, 2, 3, 4 et 5 retournements minimum.

Qui pourrait m’aider pour cette programmation ?

Merci

Dan
-----

[Chanur]

Bonjour,

Tu aurais pu donner les règles du jeu, parce qu'avec ton lien je ne les ai pas trouvées.
Et tant qu'à faire du copier-coller ...
Enfin bon. Elle sont là : developpez.net, et là : hardware.fr
Maintenant, je ne vois pas très bien ce que tu attends. Comme il apparaît que pour une position donnée, il y a moins de 188628750 mouvements à étudier, il suffit de tout balayer. C'est assez simple à programmer.

A+

[invited08daa90]

oui mais je ne sais pas programmer

[invite2d7144a7]

Bonjour,

Eh bien, c'est l'occasion d'apprendre.

[A voir en vidéo sur Futura]

[Chanur]

C'est même plus rapide que ce que je pensais. Il faut environ 4 millisecondes (sur un AMD à 3.6Gherz) en moyenne pour trouver la solution (testé sur 100000 positions aléatoires).
Je pourrais faire deux fois plus rapide en utilisant les deux coeurs de mon processeur, mais il faudrait deux threads et j'ai la flemme.
C'est un peu brutal comme programmation.

// une position est représentée sur un entier sur 16 bits// les 46 mouvements sont représentés par 46 entiers sur 16 bits
// appliquer un mouvement à une position consiste à faire un Xor entre la position et le mouvement


#include <stdio.h>
// Les 46 mouvements possibles (le 0 final me sert de terminateur)
unsigned short mouvement [47] = {   0xf000  // ligne 1
                                ,   0x0f00  // ligne 2
                                ,   0x00f0  // ligne 3
                                ,   0x000f  // ligne 4
                                ,   0x8888  // colonne 1
                                ,   0x4444  // colonne 2
                                ,   0x2222  // colonne 3
                                ,   0x1111  // colonne 4
                                ,   0x8421  // diagonale 1
                                ,   0x1248  // diagonale 2
                                ,   0xc800  // coins de la ligne 1
                                ,   0xc400
                                ,   0x6400
                                ,   0x6200
                                ,   0x3200
                                ,   0x3100
                                ,   0x0c80  // coins de la ligne 2
                                ,   0x8c00
                                ,   0x0c40
                                ,   0x4c00
                                ,   0x0640
                                ,   0x4600
                                ,   0x0620
                                ,   0x2600
                                ,   0x0320
                                ,   0x2300
                                ,   0x0310
                                ,   0x1300
                                ,   0x00c8  // coins de la ligne 3
                                ,   0x08c0
                                ,   0x00c4
                                ,   0x04c0
                                ,   0x0064
                                ,   0x0460
                                ,   0x0062
                                ,   0x0260
                                ,   0x0032
                                ,   0x0230
                                ,   0x0031
                                ,   0x0130
                                ,   0x008c  // coins de la ligne 4
                                ,   0x004c
                                ,   0x0046
                                ,   0x0026
                                ,   0x0023
                                ,   0x0013
                                ,   0x0000
                                };


void afficher (unsigned short position)
    {
    int i, j, k;
    for (i=0, k=0x8000; i<4; i++)
        {
        for (j=0; j<4; j++, k>>=1)
            {
            if (position & k)
                putchar ('o');
            else
                putchar ('.');
            }
        putchar ('\n');
        }
    putchar ('\n');
    }
int main ()
    {
    int i, j, k;
    register unsigned short * m1;
    register unsigned short * m2;
    register unsigned short * m3;
    register unsigned short * m4;
    register unsigned short * m5;
    
    // Affichage de controle des positions
    // for (m1=mouvement; *m1; m1++)
    //    afficher (*m1);


    // Saisie de la position de départ
    char buffer [10];
    unsigned short position = 0;
    for (i=0, k=0x8000; i<4; i++)
        {
        fgets (buffer, sizeof (buffer), stdin);
        for (j=0; j<4; j++, k>>=1)
            {
            if (buffer [j] != ' ')
                position |= k;
            }
        }
    putchar ('\n');
    afficher (position);


    // essayer en 1 coup
    for (m1=mouvement; *m1; m1++)
        {
        if ((position ^ *m1) == 0)
            {
            printf ("solution en 1 coup :\n");
            afficher (*m1);
            return 0;
            }
        }


    // bon. Ca n'a pas marché. Essayons en 2 coups.
    for (m1 = mouvement; *m1; m1++)
        {
        unsigned short p = position ^ *m1;
        for (m2 = mouvement; *m2; m2++)
            {
            if ((p^*m2) == 0)
                {
                printf ("solution en 2 coups :\n");
                afficher (*m1);
                afficher (*m2);
                return 0;
                }
            }
        }


    // Ca n'a toujours pas marché. En 3 coups, peut-être ?
    for (m1 = mouvement; *m1; m1++)
        {
        unsigned short p1 = position ^ *m1;
        for (m2 = mouvement; *m2; m2++)
            {
            unsigned short p2 = p1 ^ *m2;
            for (m3 = mouvement; *m3; m3++)
                {
                if ((p2^*m3) == 0)
                    {
                    printf ("solution en 3 coups :\n");
                    afficher (*m1);
                    afficher (*m2);
                    afficher (*m3);
                    return 0;
                    }
                }
            }
        }


    // Décidemment, ya rien à faire. Voyons si 4 coups suffisent ...
    for (m1 = mouvement; *m1; m1++)
        {
        unsigned short p1 = position ^ *m1;
        for (m2 = mouvement; *m2; m2++)
            {
            unsigned short p2 = p1 ^ *m2;
            for (m3 = mouvement; *m3; m3++)
                {
                unsigned short p3 = p2 ^ *m3;
                for (m4 = mouvement; *m4; m4++)
                    {
                    if ((p3^*m4) == 0)
                        {
                        printf ("solution en 4 coups :\n");
                        afficher (*m1);
                        afficher (*m2);
                        afficher (*m3);
                        afficher (*m4);
                        return 0;
                        }
                    }
                }
            }
        }


    // On peut essayer en 5, paraît que c'est le maximum.
    for (m1 = mouvement; *m1; m1++)
        {
        unsigned short p1 = position ^ *m1;
        for (m2 = mouvement; *m2; m2++)
            {
            unsigned short p2 = p1 ^ *m2;
            for (m3 = mouvement; *m3; m3++)
                {
                unsigned short p3 = p2 ^ *m3;
                for (m4 = mouvement; *m4; m4++)
                    {
                    unsigned short p4 = p3 ^ *m4;
                    for (m5 = mouvement; *m5; m5++)
                        {
                        if ((p4^*m5) == 0)
                            {
                            printf ("solution en 5 coups :\n");
                            afficher (*m1);
                            afficher (*m2);
                            afficher (*m3);
                            afficher (*m4);
                            afficher (*m5);
                            return 0;
                            }
                        }
                    }
                }
            }
        }


    // Bon. J'arrête là. En principe ça suffit.
    // De toute façon, à ce niveau c'est plus de la programmation, c'est de la dactylographie.


    return 0;
    }

[invited08daa90]

merci, bpc
je suis nul en prog et ne sais pas executer ce sript. Comment puis je le faire via Html ou autre ??

[invite2216f80a]

Google existe aussi...

Tu copies ça dans un fichier, enregistre avec un nom comme script.c
dans un terminal/console : gcc script.c - o exe
puis ./exe

généralement

[invited08daa90]

et ben ca reste du chinois pour moi

[danyvio]

et ben ca reste du chinois pour moi

中国的语言是很容易的！

[invited08daa90]

et ouiiiiiiiiiiiiii

[Paraboloide_Hyperbolique]

Bonsoir,

Ce que defender19 veut dire dans son langage geek, est:

1) copier le code dans un fichier texte avec l'extension "standard" c, car ce script est écrit en langage 'c'.
2) compiler le code. Il propose d'utiliser gcc (qui est la référence des compilateurs gratuit pour le langage 'c' et les fans des systèmes unix).
Cependant, gcc tel quel ne possède pas d'interface graphique et il faut passer par le "terminal/console" (sous Linux) ou "l'invite de commandes" (sous Windows)
pour l'utiliser. Defender19 indique comment appeler gcc via cette fenêtre et les arguments à passer (fichier à compiler et nom du fichier objet '-o' de sortie).

Pour quelqu'un qui débute, c'est plutôt rébarbatif. Si vous préférez les interfaces graphiques, vous pouvez compiler ce code sous Windows (ou sous Linux) avec
Code-blocks, téléchargeable ici: http://www.codeblocks.org/

Comme tout programme, il faut le prendre en main, surtout si vous n'êtes pas familier avec les notions de programmation.
Code-blocks est un IDE (Interface de Devéloppement Intégré) qui possède notamment un compilateur avec un éditeur de texte, le tout intégré dans une interface graphique unique.

Pour pouvoir compiler le code ci-dessus et le faire tourner, vous devez créer un nouveau projet de type "console" et copier-coller le code fournit dans un fichier texte.

[Chanur]

Bonsoir,

je suis nul en prog et ne sais pas executer ce sript. Comment puis je le faire via Html ou autre ??

Euh, oui, pardon, jaurais du être plus explicite.

Merci à defender19 et Paraboloide_Hyperbolique (et peut-être danyvio ???) d'avoir complété.

En plus j'ai écrit quelques âneries : c’était idiot de tester 100000 positions : il n'y en a que 65536 en tout.
Et le choix des variables que j'ai mis en register est absurde. Déjà que c'est d'une utilité discutable ...

Par contre, ne rêve pas, lepatagon, je ne crois pas qu'on puisse faire aussi simple avec un langage comme html.

A+

[invite54165721]

Merci à defender19 et Paraboloide_Hyperbolique (et peut-être danyvio ???)

J'ai utilisé le traducteur de google pour l'intervention de danyvio. Cà signifie "la langue chinoise est très facile"

[deyni]

Bonjour,

Je dirai comme defender19. Si tu es sous linux, ou mac, tu ouvres le terminal et tu tapes:
gcc -o script -Wall -Wextra
Puis:
./script

Si ça marche pas dit nous les warinings que tu vois.

[Chanur]

Bonjour, deyni

Attention , dans la ligne de compilation, il faut donner le nom de ce qu'on compile ...
gcc -o script -Wall -Wextra script.c

Mais de toutes façons, je crois que lepatagon a trouvé son bonheur ailleurs. Je ne suis pas sûr qu'on le reverra.