Il gioco

Molti di noi conoscono Frogger , il gioco arcade degli anni '80 in cui l'obiettivo è di saltare in sicurezza una rana attraverso un'autostrada trafficata e uno stagno pieno di pericoli per arrivare in sicurezza a casa.

Alcuni mesi fa è stata lanciata una sfida per lo sviluppo di un clone Frogger. Ma perché clonare Frogger quando puoi giocare a Frogger? :)

Considera la seguente griglia di gioco semplificata:

 XXXXXXXXXXXXXXXXXXXXXXX  North Safe Zone
 -----------------------
|                       | <<<<       Express Lane West        (Lane 1)
|                       |     >      Gridlock East            (Lane 2)
|                       |   <<       Freeflowing Traffic West (Lane 3)
|                       |    <       Gridlock West            (Lane 4)
|                       |     >>>>   Express Lane East        (Lane 5)
 -----------------------
 XXXXXXXXXXX@XXXXXXXXXXX  South Safe Zone
 \__________ __________/
            '
  23 cells horizontally

Abbiamo cinque corsie di traffico, ognuna larga 23 celle e due zone sicure (dove la rana può spostarsi in modo sicuro a destra e sinistra), larga anche 23 celle. È possibile ignorare i bordi destro e sinistro in quanto questi sono per chiarezza pittorica.

La nostra rana inizia nella zona sicura meridionale, sulla cella centrale (12a), come indicato da una @nella figura sopra.

Il tempo nel gioco è diviso in passaggi discreti chiamati frame. Froggy è una rana veloce e può saltare una cella in qualsiasi direzione (su, giù, a destra, a sinistra) per frame. Può anche scegliere di rimanere fermo per qualsiasi frame. Il traffico nelle cinque corsie si muove a velocità costante come segue:

• il traffico nella corsia espressa ovest (corsia 1) sposta 2 celle a sinistra di ogni fotogramma
• il traffico nella corsia est della parata (corsia 2) si sposta di 1 cella a destra ogni secondo fotogramma
• il traffico nella corsia ovest (corsia 3) a flusso libero si sposta di 1 cella a sinistra di ogni fotogramma
• il traffico nella corsia ovest della parata (corsia 4) si sposta di 1 cella a sinistra ogni secondo fotogramma
• il traffico nella corsia espressa est (corsia 5) sposta di 2 celle a destra di ogni fotogramma

Il traffico stesso è definito in modo univoco per ca. 3.000 timestep in questo file di testo . Il "traffico" è costituito da veicoli e spazi tra i veicoli. Qualsiasi personaggio che non è uno spazio fa parte di un veicolo. Il file di testo contiene cinque righe, corrispondenti alle cinque corsie di traffico (con lo stesso ordine).

Per le corsie in direzione ovest, all'inizio del frame 0 (l'inizio del gioco), consideriamo il primo veicolo nella corsia appena oltre il bordo destro della griglia di gioco.

Per le corsie in direzione est, la stringa di traffico deve essere considerata "all'indietro", nel senso che i veicoli appaiono a partire dalla fine della stringa. All'inizio del fotogramma 0, consideriamo il primo veicolo in queste corsie appena oltre il bordo sinistro del campo di gioco.

Considera come esempio:

Traffic Lane 1:  [|==|  =
Traffic Lane 2:  |) =  o
Traffic Lane 3:  (|[]-[]:
Traffic Lane 4:  <| (oo|
Traffic Lane 5:  |==|] :=)

Quindi la griglia di gioco apparirà come segue:

Start of Frame 0       XXXXXXXXXXXXXXXXXXXXXXX
                                              [|==|  =
                |) =  o
                                              (|[]-[]:
                                              <| (oo|
              |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 1       XXXXXXXXXXXXXXXXXXXXXXX
                                            [|==|  =
                |) =  o
                                             (|[]-[]:
                                              <| (oo|
                |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 2       XXXXXXXXXXXXXXXXXXXXXXX
                                          [|==|  =
                 |) =  o
                                            (|[]-[]:
                                             <| (oo|
                  |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 3       XXXXXXXXXXXXXXXXXXXXXXX
                                        [|==|  =
                 |) =  o
                                           (|[]-[]:
                                             <| (oo|
                    |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Dopo che tutto il traffico in una corsia è "esaurito" (ovvero la stringa si esaurisce), consideriamo tutti i caratteri nella stringa come spazi.

La nostra rana viene schiacciata se si verifica una delle seguenti condizioni:

• la rana occupa una cella occupata da un veicolo, su qualsiasi telaio
• la rana rimane ferma in una corsia espressa e un veicolo di 1 cella di larghezza gli passa sopra in quella cornice
• la rana salta a est "attraverso" un veicolo in direzione ovest, o salta a ovest attraverso un veicolo in direzione est
• la rana salta fuori dal 7 (linea) di 23 (cella) giocando alla griglia, su qualsiasi fotogramma

Nota che queste sono le uniche condizioni in cui una rana viene schiacciata. In particolare, è ammessa una rana che salta insieme al traffico "con", così come una rana che salta dentro o fuori da una cella in una corsia espressa che è passata da un veicolo di larghezza 1 nello stesso telaio.

Obiettivo e punteggio

L'obiettivo della sfida di programmazione è far attraversare la rana il più volte possibile prima che l'ultimo veicolo esca dalla griglia di gioco . Cioè, il programma termina immediatamente dopo il completamento del frame X , dove il frame X è il primo frame che porta la griglia in uno stato in cui non sono presenti più veicoli.

L'output del tuo programma dovrebbe essere una stringa (o file di testo) contenente la sequenza di mosse per la rana usando la seguente codifica:

<   frog moves left
>   frog moves right
^   frog moves up
v   frog moves down
.   frog remains stationary

Ad esempio, la stringa <<^.^indica che la rana si sposta a sinistra due volte, quindi verso l'alto, quindi fa una pausa per un fotogramma, quindi si sposta di nuovo verso l'alto.

Viene assegnato un punto ogni volta che la rana attraversa dalla zona sicura del sud alla zona sicura del nord e un punto viene assegnato ogni volta che la rana attraversa dalla zona sicura del nord alla zona sicura del sud.

Alcune regole importanti:

1. La rana non deve essere schiacciata.
2. Pubblica la tua soluzione (sequenza di mosse) insieme al codice del programma, sia in linea che come file di testo (ad es. Utilizzando pastebin.com).
3. La nostra rana è presciosa e precognitiva, quindi il tuo programma può utilizzare tutti i dati sul traffico in qualsiasi frame mentre cerca soluzioni. Ciò include i dati per il traffico che non ha ancora raggiunto la griglia di riproduzione.
4. La griglia non si avvolge. Uscire dalla griglia farà schiacciare la rana e quindi non è permesso.
5. In nessun caso il traffico "resetta" o la rana "teletrasporta". La simulazione è continua.
6. La rana può tornare nella zona sicura sud dopo essere uscita, ma questo non viene conteggiato come un punto. Allo stesso modo per la zona sicura del nord.
7. Il vincitore del concorso è il programma che genera la sequenza di mosse ottenendo il maggior numero di incroci.
8. Per ulteriori domande o dubbi, non esitare a chiedere nella sezione commenti.

Per un ulteriore incentivo, aggiungerò una ricompensa di +100 rappresentanti al programma vincente quando sarò in grado di farlo.

bonus

+ 2,5% al punteggio di base * (fino a + 10%) per ogni angolo della griglia di gioco toccato dalla rana. I quattro angoli della griglia sono le celle più a sinistra e più a destra delle due zone sicure.

+ 25% al punteggio di base * se la sequenza di mosse mantiene la rana confinata entro +/- 4 celle a sinistra oa destra della sua cella iniziale per l'intera simulazione (ovviamente può muoversi liberamente in verticale).

Nessun bonus per il punteggio, ma i puntelli speciali nel PO andranno a chiunque pubblicherà un validatore di soluzioni rapido e sporco, quindi non devo programmarne uno. ;) Un validatore accetterebbe semplicemente una sequenza di mosse, assicurerebbe la sua legalità (secondo le regole e il file del traffico) e segnalerebbe il suo punteggio (cioè il numero totale di attraversamenti).

* Il punteggio totale è uguale al punteggio di base più il bonus, arrotondato per difetto all'intero più vicino.

Buona fortuna accigliato!

C ++: 176

Produzione:

176
^^^^^^>vvvvvv>^^^^>^^>>>>>>><<<.vv>v<<<.vvv<<<<<<^.^.^.^.>.>^^<.>>>>>>v>v>.>v<<<<v.<.vv<<<<<^^.<^<<<<<<^.^^>>>>vv>.>.v<v.vv>>^>>^<^<<<<<<<^>.>^^<<<.>>>>>vv>v<vvv<<<<<^^.<^^^^.....vv>.>.>.>v<<vvv<<>>>>^>^<.<.^^>^^>>>>vv.>v<vv.v^>^<.<.<^<^>.>^^>>>>vv.v<<<<<<.vvv<<<<^^^<<v^^.>.^^..>>>>>>vv>.>.v.vvv>>>^>^^<<<<<<<<<^>.>^^>>>>vvv<<v.<.vv<<<<<<>>>>>^^^<<<^^^<<>>vv>.v<<>vvv<<><>>>>>>>^>^^<^^^<.>>>>>>>>vv>.>v<<<vvv<<<<<^^^<<v.<.<^<<^.^<<^...>>>>>>>>>>>>>vv>v<vvv<<<<<<<<^>^.<.^^>.>^^<<<<<<<..>>>>vv>.vvvv<<<<>^.v>>>^^.^^>^<^<>>>>>>>>>vv>vvvv<<<<^^^<^>^<<^.>>vv>v<vvv<<<<<<<>>>>>>>^>^^^.^^>>>>>vvv<<vvv<<<^^^^^^<vvv<<<<<<<vvv<<<>>>>>>>>^^.<.<.^.^.^<^<>>>>>>>>>>vvv<<.vvv<<<^^<^<<^^<<^<<<>>>>vv>.vvvv>>^>>^<.<.<^<<<<<.^^<<^.......>vv.>.>.>v<vvv>>>>>>^>^.<.<^<.^^^<.>>>>>>>vvv<<<v.<vv<<<^^<.<.<.<^<<<^>^^..........v<vvvv>v>>>>>^>>^^^>^^>>>vv>v<vvv<<<<<<<<>^^.<.<^<^^^<.........>vv.>.vvvv>>>>^^<.<.<^^^<^<<.v<v>.>.>.>.>.>.>.vvv.v<<<<<^^<^<^>.>.>.>.^<^.>>>>>>>>vv>v<<vvv<<>>>>>^^^.^.>^<^<<<<<<<<.vv.>.v<<<.vvv<>>>>>^>^.<.<.<.<^^.^<<^<.....>>vvv<.>>vvv<<<>>>>>>>>^^^<<<.^.>.>^^.>>>>>vv.>v<vvv<<<>>>>>>^>^<^<<^.^^<vvv<<<<<vv.v<>>>>>>>>>>^>^.^^>^^<<<<.>vv.>.vvvv>^>>^.<.<.<^<<<^>^^>>>vv>v<<<<<vvv<<<>>>>>^^<.<.<.<.<^<^>.^^.>>>>>vv>v<>vvv<<<<<<<^>^.<^<<<<<<<^^^.>>>>>vv>v<>vvv>>>^^<.<^<<<^>^^.>>>>vv>.v<<vvv<<<<<^^^<<<<<^>.^^<>>>>>>>vv>.>v<<vvv<<<<<<<>>>^>>.>^^^.>^^<>>>>>>vv>vv.<.<.vv>>>>^^<.<.<.<^<<^.>^^.>>>>>vv.>.>v<<vvv<<>>>>>^^<.<.<.^^>.>.>^^<<<<<<<<.>>>>>>vv>v<<v.<.<vv<<<<^^.<^<<<.^^^<.vv.>v<vvv<<<>>>>>>^>^<^<<^.^<^<<.>>vv>.>.>.>vvvv>>>>>>^>^^^^^<<<.vvv<<<<<<vvv>>>>>^>^<.<^<<^.>.>.^^>>>>vv>.>v<<<<<<vvv<<<<^^^<.^.>^^>>>>vvv<<v.vv<<<^>>^^<<<.^^<<^>>>>>>>>>vvv.v.vv<>>>>>^>^^<<<<<<<<<<<<<<<<^^^..>>>>>vv>.>.>.>v<<v.<.<.vv<<<<<^^^<^>.^^...>>>>>>>>vv.v<.vvv>>>^>^<.<^^^^>>>vv>v<<<vvv<<<<>>>>>>^>^.<.<^<^>.>^^.>>>>>vv.v<<<<<<<<vvv<<<<^^<^<<<<<><^>.>^^>>>>vv.>.>.vvv.v>>>>>>>^^<.<^<<^^^>>>vv>.>.>.>.>v<<v.<.<vv>>>>^^^<<<<<.^.>^^>>>vv>.>v<vvv<<<<^^<.<.<.^^>^^>>>vv>.>.v<<<v.<vv<<<<^^.<^<<<^^^>>>>vvvvvv<<<<<<<<>^^.^>>^^^<>>>>>>>vvv<<<v.vv>>>>>^>>^^<<<<<^>.^^>>>>vv>.>v<<<<vvv<<<^^<.<.<.<^<<<<<^>^^>>>>vv.>vv.v.v<^>.>^.<.^^^^>>>>vv>.>.>.v<<<<<<vvv>>>>^^<.<.<^<<^^<^>>>>>>vv>v<<.vvv^>^^<<<^>^^<<<<<<.vvv<<vv>.v>>>>>>^>.>^^<<<<<^>.>.>.>.>.^^>>>>vv>.>.>v<<<<<vvv<<<<^^<^<<^.^^>>>>vv>.>.>.>v<vvv<<<<<^^.<.<^<<^^^>>>>>>>>>>>vv>.>.>.>.>vvvv<<<<^^.<.<^<^^^<<<<<<vvv<v.<vv<<<<^v>>>>>>>>>>^^^<.^.>.>.^^>>>>vvv<<<<<<<vvv<<<<<<<>^^.<^<.^^^.>>>>vv>v<vvv<>>>>^^.<.^.^.>.^<^>>>>>>>>vvvv.<.<vv<<<<^^^<<<<<^>.^^<.vv>.v<<vvv<<><>>>>>^>>^.<^<^^^<<<.>>vv>.>v<<<<v.vv>^>>^.<^^.^^.>>>>>vv>.>.>.v<v.<vv<<<<<^.^^^.>^^<>>>>>>vv>.v<<<v.<vv<<<<>>>>>>>>>>>^^<.<.<.<.<^<<^^<^<<<>>>>>>>vv>v<<<vv.v>>>>>>>>^>^<.<^<<<<<<<<<<<.^.>^^<<<vvv.v.<vv<<<^.>>^.<^^.>.>^^<<......vv.v>vvv>>>^.v^>>^^<<^^^<.>>>>>>>vvv<v.<.<.vv<<<<^^<.<.<.^^^^<.>>>>>>>>vvv<v.<vv^.>^^<<^^^vv>vvvv^>>>>>>>^^^^^vvvvvv^^^^^^vvvvvv>>>>

Esistono meno di 8 milioni di stati di combinazioni di posizione X tempo X insieme di angoli visitati, quindi possono essere cercati esaurientemente in meno di 1 secondo. Se il codice non ha bug, dovrebbe essere impossibile da battere. La strategia ottimale era quella di utilizzare l'intera tavola, in quanto ciò consente a Froggy di attraversare la strada 160 volte, rispetto a circa 120 quando è confinato al centro. Visitare gli angoli non è costato alcun attraversamento poiché il traffico era così intenso.

/* feersum  2014/9
 /codegolf/37975/frogger-champion */

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <cstring>

#define B(F, CST, X, Y) best[ ((F)*NCST + (CST)) * BS + (Xmax-Xmin+1) * ((Y)-Ymin) + (X)-Xmin]
#define TL(i) ((int)t[i].length())
#define ABSPEED(I) (speed[i]<0?-speed[i]:speed[i])
#define errr(X) { cout<<"ERROR!!!!!!!!"; return X; }

#define DRAW 0
#if DRAW
    #include <unistd.h>
#endif


using namespace std;

int bc(int cs) {
    int c = 0;
    while(cs) {
        c += cs&1;
        cs >>= 1;
    }
    return c;
}

int main()
{
    const bool bonusTwentyfive = false;
    const int COLS = 23, T_ROWS = 5, YGS = T_ROWS + 2, XGS = COLS + 2;
    string t[5];
    int speed[] = {-4, 1, -2, -1, 4};
    ifstream f("t.txt");
    for(int i = 0; i < T_ROWS; i++)
        getline(f, t[i]);
    if(f.fail())
        return 1;
    f.close();
//for(int i = 0; i < 5; i ++)t[i]="xxx";

    char g[XGS][YGS];

    int mov[][3] = { {-1,  0, '<'},
                     {+1,  0, '>'},
                     { 0, -1, '^'},
                     { 0, +1, 'v'},
                     { 0,  0, '.'} };


    int Ymin = 0, Ymax = YGS-1;


    const int Xstart = 11, Xmaxmove = bonusTwentyfive ? 4 : 10;
    const int Xmin = Xstart - Xmaxmove, Xmax = Xstart + Xmaxmove;

    const int NCST = bonusTwentyfive ? 1 : 1<<4;

    int maxfr = 0;
    for(int i = 0; i < T_ROWS; i++) {
        if(speed[i] < 0) {
            for(int m = 0, n = t[i].length()-1; m < n; ++m,--n)
                swap(t[i][m], t[i][n]);
        }
        int carslen = TL(i);
        for(char*c = &t[i][speed[i]>0?TL(i)-1:0]; carslen; carslen--, speed[i]>0?--c:++c)
            if(*c != ' ')
                break;
        if(carslen)
            maxfr = max(maxfr, ( (carslen + COLS) * 2 + ABSPEED(i)-1 ) / ABSPEED(i));
    }
    const int BS = (Xmax-Xmin+1)*(Ymax-Ymin+1);
    int *best = new int[(maxfr+1)*NCST*BS];
    memset(best, 0xFF, (maxfr+1)*NCST*BS*sizeof(int));
    memset(g, ' ', sizeof(g));
    B(0, 0, Xstart, Ymax) = 0;

    for(int fr = 0; fr < maxfr; fr++) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;
                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(N > B(fr+1, cs|csor, X, Y))
                            B(fr+1, cs|csor, X, Y) = N;
                    }


                }
            }
        }
    }

    int score = 0, xb, yb, cb, nb;
    for(int x = Xmin; x <= Xmax; x++) {
        for(int y = Ymin; y <= Ymax; y++) {
            for(int cs = 0; cs < NCST; cs++) {
                if(B(maxfr, cs, x, y) * (40 + bc(cs)) / 40 >= score) {
                    score = B(maxfr, cs, x, y) * (40 + bc(cs)) / 40;
                    xb = x, yb = y, cb = cs, nb = B(maxfr, cs, x, y);
                }
            }
        }
    }
    char *mvs = new char[maxfr+1];
    mvs[maxfr] = 0;

    for(int fr = maxfr-1; fr >= 0; --fr) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;

                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(X==xb && Y==yb && N == nb && (cs|csor) == cb) {
                            mvs[fr] = mov[m][2];
                            xb = x, yb = y, nb = B(fr, cs, x, y), cb = cs;
                            goto fr_next;
                        }
                    }
                }
            }
        }
        errr(3623);
        fr_next:;
    }

    if((xb-Xstart)|(yb-Ymax)|nb)
        errr(789);
    #if DRAW

        for(int fr = 0; fr <= maxfr; ++fr) {
            memset(g, ' ', sizeof(g));
            for(int r = 0; r < T_ROWS; r++) {
                for(int x = 0; x < XGS; x++) {
                    int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                    ind >= 0 && ind < TL(r) ? g[x][r+1] = t[r][ind] : ' ';
                }
            }
            g[xb][yb] = 'F';
            for(int y = 0; y < YGS; y++) {
                for(int x = 0; x < XGS; x++)
                    cout<<g[x][y];
                cout<<endl;
            }
            cout<<string(XGS,'-')<<endl;
            usleep(55*1000);
            for(int i = 0; i < 5; i++) {
                if(mvs[fr] == mov[i][2]) {
                    xb += mov[i][0];
                    yb += mov[i][1];
                    break;
                }
            }
        }

    #endif
    cout<<score<<endl;
    cout<<mvs<<endl;
}