Oyun

Birçoğumuz , bir kurbağayı yoğun bir karayolu ve eve güvenli bir şekilde gelmesi için tehlike dolu bir gölet boyunca güvenli bir şekilde atlamak olan 80'li yılların arcade oyunu Frogger'i biliyoruz .

Bir meydan okuma verildiği bir Frogger klon geliştirmek için birkaç ay önce. Ama neden Frogger oynayabiliyorsanız Frogger'ı klonlayın ? :)

Aşağıdaki basitleştirilmiş oyun ızgarasını düşünün:

 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

Her biri 23 hücre genişliğinde ve kurbağanın güvenli bir şekilde sola ve sağa hareket edebildiği iki güvenli bölgeye, ayrıca 23 hücre genişliğine sahip beş şerit şeridimiz var. Resimsel netlik için sağ ve sol sınırları göz ardı edebilirsiniz.

Kurbağa @, yukarıdaki şekilde a ile gösterildiği gibi, güney güvenli bölgede, orta (12.) hücrede başlar .

Oyundaki süre, kare adı verilen ayrık adımlara ayrılmıştır. Froggy hızlı bir kurbağadır ve bir hücreyi çerçeve başına herhangi bir yönde (yukarı, aşağı, sağ, sol) atlayabilir. Herhangi bir çerçeve için sabit kalmayı da seçebilir. Beş şeritteki trafik aşağıdaki gibi sabit hızlarda hareket eder:

• ekspres şerit batıdaki (şerit 1) trafik her hücreyi 2 hücre sola taşır
• gridlock doğu şeridindeki (şerit 2) trafik her saniye karesinde 1 hücre sağa hareket eder
• serbest akışlı trafikteki batı şeridindeki (şerit 3) her kareyi 1 hücre sola taşır
• gridlock batı şeridindeki (şerit 4) trafik her saniye karesinde 1 hücre sola hareket eder
• ekspres şeritte doğu şeridi (şerit 5) her kareyi 2 kare sağa taşır

Trafiğin kendisi yaklaşık olarak tanımlanır. Bu metin dosyasında 3.000 zaman aralığı . 'Trafik' araçlardan ve araçlar arasındaki boşluklardan oluşur. Boşluk olmayan herhangi bir karakter bir aracın parçasıdır. Metin dosyası, beş şerit şeridine karşılık gelen beş satır içerir (aynı sırada).

Batıya giden şeritlerde, 0 karesinin başlangıcında (oyunun başlangıcı), şeritteki ilk aracın oyun ızgarasının sağ kenarının hemen ötesinde olduğunu düşünüyoruz.

Doğuya giden şeritlerde, trafik ipinin araçların ipin sonunda başladığı anlamında "geri" olarak düşünülmesi gerekir . 0 çerçevesinin başlangıcında, bu şeritlerdeki ilk aracın oyun alanının sol kenarının hemen ötesinde olduğunu düşünüyoruz.

Örnek olarak düşünün:

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

Ardından oyun ızgarası aşağıdaki gibi görünecektir:

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

Bir şeritteki tüm trafik "tükendikten" (yani, dize bittikten) sonra, dizedeki tüm karakterlerin boşluk olduğunu düşünürüz.

Aşağıdakilerden herhangi biri gerçekleşirse kurbağa ezilir :

• kurbağa, herhangi bir çerçevede bir araç tarafından işgal edilen bir hücreyi işgal eder
• kurbağa ekspres şeritte sabit kalır ve bu çerçevede 1 hücre genişliğinde bir araç onun üzerinden geçer.
• kurbağa batıya doğru giden bir araçtan doğuya atlar veya doğuya doğru giden bir araçtan batıya atlar
• kurbağa 7 (çizgi) dışında 23 (hücre) oyun ızgarası dışında herhangi bir kareye atlar

Bunların bir kurbağanın ezildiği tek koşullar olduğunu unutmayın . Özellikle, aynı çerçeve içinde bir genişlik-1 aracı tarafından geçirilen ekspres şeritte bir hücreye hücrenin içine veya dışına atlayan bir kurbağa gibi, "ile" trafiği boyunca atlayan bir kurbağaya izin verilir.

Amaç ve Puanlama

Programlama zorluğunun amacı , son araç oyun ızgarasından çıkmadan önce kurbağayı mümkün olduğunca çok kez yoldan geçirmektir . Yani, program X çerçevesinin tamamlanmasından hemen sonra sona erer , burada X çerçevesi, ızgarayı daha fazla aracın olmadığı bir duruma götüren ilk çerçevedir.

Programınızın çıktısı, aşağıdaki kodlamayı kullanarak kurbağa için hareket sırasını içeren bir dize (veya metin dosyası) olmalıdır:

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

Örneğin, dize <<^.^kurbağanın iki kez sola, sonra yukarı, sonra bir kare için durakladığını, sonra tekrar yukarı hareket ettiğini gösterir.

Kurbağa güney güvenli bölgeden kuzey güvenli bölgeye geçtiğinde bir puan, kurbağa kuzey güvenli bölgeden güney güvenli bölgeye geçtiğinde bir puan kaydedilir.

Bazı önemli kurallar:

1. Kurbağa ezilmemelidir.
2. Lütfen çözümünüzü (hamle sırası) satıriçi veya bir metin dosyası (örn. Pastebin.com kullanarak) program kodunuzla birlikte gönderin.
3. Kurbağamız ileri görüşlü ve öngörüldür, bu nedenle programınız çözüm ararken herhangi bir çerçevedeki tüm trafik verilerini kullanabilir . Bu, henüz oynatma ızgarasına ulaşmamış trafik verilerini içerir.
4. Izgara etrafına sarılmaz. Izgaradan çıkmak kurbağanın ezilmesine neden olur ve bu nedenle izin verilmez.
5. Hiçbir noktada trafik "sıfırlanmaz" ya da kurbağa "ışınlanır". Simülasyon süreklidir.
6. Kurbağa çıktıktan sonra güney güvenli bölgeye dönebilir, ancak bu bir nokta olarak sayılmaz. Aynı şekilde kuzey güvenli bölgesi için.
7. Yarışma kazananı, en yüksek geçiş sayısını veren hareket dizisini üreten programdır.
8. Başka sorularınız veya endişeleriniz varsa, lütfen yorum bölümünde sormaya çekinmeyin.

Eklenen bazı teşvikler için, kazanan programa bunu yapabildiğimde +100 temsilcilik bir ödül ekleyeceğim .

Bonuslar

Kurbağanın temas ettiği oyun ızgarasının her köşesi için % + 2,5 taban puan * (% + 10'a kadar). Izgaranın dört köşesi, iki güvenli bölgenin en sol ve en sağdaki hücreleridir.

Taban puanına +% 25 * Eğer hareket diziniz tüm kurgu için kurbağanın başlangıç ​​hücresinin solunda veya sağında +/- 4 hücre içinde kalmasını sağlıyorsa (tabii ki dikey olarak serbestçe hareket edebilir).

Hiçbir puanlama bonusu, ama OP özel sahne hızlı bir n 'kirli çözüm doğrulayıcı gönderen herkese gidecek, böylece bir programlamak zorunda kalmazsınız. ;) Bir validator basitçe bir dizi hamleyi kabul eder, yasallığını sağlar (kurallara ve trafik dosyasına göre) ve puanını rapor eder (yani toplam geçiş sayısı).

* Toplam puan taban puan artı ikramiye eşittir, en yakın tamsayıya yuvarlanır.

İyi şanslar kurbağa!

C ++: 176

Çıktı:

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

Ziyaret edilen köşelerin X konumu X zamanı X kümesi 8 milyonun altında eyalet kombinasyonu vardır, bu nedenle 1 saniyeden daha kısa sürede kapsamlı bir şekilde aranabilirler. Kodda hata yoksa, yenmek imkansız olmalıdır. En uygun strateji, tüm tahtayı kullanmaktı, çünkü bu, kurbanın 160 kez yoldan geçmesine izin verdi, merkezle sınırlandığında 120'ye karşı. Trafik çok ağır olduğu için köşeleri ziyaret etmek herhangi bir geçişe mal olmadı.

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