Permainan

Sebagian besar dari kita tahu tentang Frogger , game arcade era 80-an di mana tujuannya adalah untuk melompat katak dengan aman melintasi jalan raya yang sibuk dan kolam penuh bahaya untuk tiba dengan selamat di rumah.

Sebuah tantangan dikeluarkan beberapa bulan lalu untuk mengembangkan klon Frogger. Tapi mengapa mengkloning Frogger ketika Anda bisa bermain Frogger? :)

Pertimbangkan kotak permainan yang disederhanakan berikut:

 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

Kami memiliki lima jalur lalu lintas, lebar masing-masing 23 sel, dan dua zona aman (tempat katak dapat bergerak dengan aman ke kiri dan ke kanan), juga lebar 23 sel. Anda dapat mengabaikan batas kanan dan kiri karena ini untuk kejelasan gambar.

Katak kami mulai di zona aman selatan, di sel tengah (ke-12), seperti yang ditunjukkan pada gambar @di atas.

Waktu dalam game dibagi menjadi beberapa langkah yang disebut frame. Froggy adalah katak cepat dan dapat melompat satu sel ke segala arah (atas, bawah, kanan, kiri) per bingkai. Dia juga dapat memilih untuk tetap diam untuk setiap frame. Lalu lintas di lima jalur bergerak dengan kecepatan konstan sebagai berikut:

• lalu lintas di jalur cepat barat (jalur 1) bergerak 2 sel meninggalkan setiap bingkai
• lalu lintas di jalur timur kemacetan (jalur 2) bergerak 1 sel ke kanan setiap frame kedua
• lalu lintas di jalur barat lalu lintas yang mengalir bebas (jalur 3) bergerak 1 sel ke kiri setiap frame
• lalu lintas di jalur barat kemacetan (jalur 4) bergerak 1 sel tersisa setiap frame kedua
• lalu lintas di jalur ekspres timur (jalur 5) bergerak 2 sel ke kanan setiap frame

Lalu lintas itu sendiri secara unik ditentukan untuk kira-kira. 3.000 tanda waktu dalam file teks ini . 'Lalu lintas' terdiri dari kendaraan dan ruang antar kendaraan. Setiap karakter yang bukan merupakan ruang adalah bagian dari kendaraan. File teks berisi lima baris, sesuai dengan lima jalur lalu lintas (dengan urutan yang sama).

Untuk jalur yang mengarah ke barat, pada awal frame 0 (awal permainan), kami menganggap kendaraan pertama di jalur tersebut berada tepat di luar tepi kanan kotak permainan.

Untuk jalur yang menuju ke timur, tali lalu lintas harus dianggap "mundur" dalam arti bahwa kendaraan muncul mulai dari ujung tali. Pada awal frame 0, kami menganggap kendaraan pertama di jalur ini berada tepat di luar tepi kiri lapangan bermain.

Pertimbangkan sebagai Contoh:

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

Maka kotak bermain akan muncul sebagai berikut:

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

Setelah semua lalu lintas di jalur "habis" (mis. String habis), kami menganggap semua karakter dalam string sebagai spasi.

Katak kami diperas jika terjadi hal-hal berikut:

• katak menempati sel yang ditempati oleh kendaraan, pada bingkai apa pun
• katak tetap diam di jalur cepat dan kendaraan sel 1 melewatinya dalam bingkai itu
• katak melompat ke timur "melalui" kendaraan yang menuju ke barat, atau melompat ke barat melalui kendaraan yang menuju ke timur
• katak melompat di luar 7 (garis) dengan 23 (sel) bermain kotak, pada bingkai apa pun

Perhatikan bahwa ini adalah satu - satunya kondisi di mana seekor katak terjepit. Khususnya, katak yang melompat-lompat di sepanjang "dengan" lalu lintas diizinkan, seperti katak yang melompat masuk atau keluar sel dalam jalur cepat yang dilewati oleh kendaraan lebar-1 dalam bingkai yang sama.

Objektif dan Penilaian

Tujuan dari tantangan pemrograman adalah untuk mendapatkan katak menyeberang jalan sebanyak mungkin sebelum kendaraan terakhir keluar dari kisi bermain . Yaitu, program berakhir segera setelah frame X selesai , di mana frame X adalah frame pertama yang membawa grid ke keadaan di mana tidak ada lagi kendaraan yang ada.

Output dari program Anda harus berupa string (atau file teks) yang berisi urutan gerakan untuk katak menggunakan pengkodean berikut:

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

Misalnya, string <<^.^menunjukkan bahwa katak bergerak ke kiri dua kali, lalu naik, lalu berhenti untuk satu bingkai, lalu bergerak ke atas lagi.

Satu titik diberi skor setiap kali katak menyeberang dari zona aman selatan ke zona aman utara, dan satu titik diberi skor setiap kali katak menyeberang dari zona aman utara ke zona aman selatan.

Beberapa aturan penting:

1. Katak tidak harus diperas.
2. Silakan posting solusi Anda (urutan langkah) bersama dengan kode program Anda, baik sebaris atau sebagai file teks (misalnya menggunakan pastebin.com).
3. Katak kami mahir dan prekognisi, karenanya program Anda dapat menggunakan setiap dan semua data lalu lintas dalam kerangka apa pun sembari mencari solusi. Ini termasuk data untuk lalu lintas yang belum mencapai kotak permainan.
4. Grid tidak membungkus. Keluar dari kisi akan menyebabkan katak menjadi terjepit dan karenanya tidak diizinkan.
5. Pada titik tidak lalu lintas "reset" atau katak "teleport". Simulasi ini kontinu.
6. Katak dapat kembali ke zona aman selatan setelah keluar, tetapi ini tidak dihitung sebagai titik. Demikian juga untuk zona aman utara.
7. Pemenang kontes adalah program yang menghasilkan urutan langkah menghasilkan jumlah penyeberangan tertinggi.
8. Untuk pertanyaan atau masalah tambahan, silakan bertanya di bagian komentar.

Untuk beberapa insentif tambahan, saya akan menambahkan hadiah +100 perwakilan ke program pemenang ketika saya bisa melakukannya.

Bonus

+ 2,5% hingga skor dasar * (hingga + 10%) untuk setiap sudut kotak permainan yang disentuh katak. Empat sudut kisi adalah sel paling kiri dan paling kanan dari dua zona aman.

+ 25% ke skor dasar * jika urutan gerakan Anda membuat katak terbatas dalam +/- 4 sel di kiri atau kanan sel awal untuk seluruh simulasi (tentu saja ia dapat bergerak bebas secara vertikal).

Tidak ada bonus penilaian, tetapi alat peraga khusus di OP akan diberikan kepada siapa saja yang memposting validator solusi cepat dan kotor sehingga saya tidak harus memprogramnya. ;) Seorang validator hanya akan menerima serangkaian langkah, memastikan legalitasnya (sesuai aturan dan file lalu lintas), dan melaporkan skornya (yaitu jumlah total penyeberangan).

* Total skor sama dengan skor dasar ditambah bonus, dibulatkan ke bilangan bulat terdekat.

Semoga berhasil, katak!

C ++: 176

Keluaran:

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>>>>

Ada di bawah 8 juta negara kombinasi posisi X waktu X set sudut yang dikunjungi, sehingga mereka dapat dicari secara mendalam dalam waktu kurang dari 1 detik. Jika kode tidak memiliki bug, seharusnya tidak mungkin dikalahkan. Strategi optimal adalah menggunakan seluruh papan, karena itu memungkinkan froggy untuk menyeberang jalan 160 kali, dibandingkan sekitar 120 ketika terbatas pada pusat. Mengunjungi sudut tidak memerlukan biaya penyeberangan karena lalu lintas sangat padat.

/* 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;
}