Campeão Frogger

11

O jogo

A maioria de nós conhece o Frogger , o jogo de fliperama da década de 80 em que o objetivo é pular um sapo com segurança por uma estrada movimentada e um lago cheio de perigos para chegar com segurança em casa.

Há alguns meses, foi lançado um desafio para o desenvolvimento de um clone Frogger. Mas por que clonar Frogger quando você pode jogar Frogger? :)

Considere a seguinte grade de jogo simplificada:

 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

Temos cinco faixas de tráfego, cada uma com 23 células de largura e duas zonas seguras (onde o sapo pode se mover com segurança para a esquerda e direita), também com 23 células de largura. Você pode ignorar as bordas direita e esquerda, pois são para fins de clareza pictórica.

Nosso sapo começa na zona segura do sul, na célula central (12ª), como indicado por um @na figura acima.

O tempo no jogo é dividido em etapas discretas chamadas frames. Froggy é um sapo rápido e pode saltar uma célula em qualquer direção (cima, baixo, direita, esquerda) por quadro. Ele também pode optar por permanecer parado por qualquer quadro. O tráfego nas cinco faixas se move a velocidades constantes da seguinte maneira:

  • o tráfego na pista expressa oeste (pista 1) move 2 células restantes em cada quadro
  • o tráfego na pista leste do bloqueio (pista 2) move 1 célula para a direita a cada segundo quadro
  • o tráfego na faixa oeste de tráfego livre (faixa 3) move 1 célula restante em cada quadro
  • o tráfego na pista oeste do bloqueio (pista 4) move 1 célula restante a cada segundo quadro
  • o tráfego na pista expressa leste (pista 5) move 2 células para a direita em cada quadro

O tráfego em si é definido exclusivamente por aprox. 3.000 timesteps neste arquivo de texto . 'Tráfego' consiste em veículos e espaços entre os veículos. Qualquer personagem que não seja um espaço faz parte de um veículo. O arquivo de texto contém cinco linhas, correspondentes às cinco faixas de tráfego (com a mesma ordem).

Para as pistas na direção oeste, no início do quadro 0 (o início do jogo), consideramos o primeiro veículo na pista um pouco além do limite direito da grade de jogo.

Para as faixas para o leste, a sequência de tráfego deve ser considerada "invertida" no sentido de que os veículos aparecem começando no final da sequência. No início do quadro 0, consideramos o primeiro veículo nessas faixas um pouco além da margem esquerda do campo de jogo.

Considere como um exemplo:

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

A grade de jogo aparecerá da seguinte maneira:

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

Depois que todo o tráfego em uma faixa estiver "esgotado" (ou seja, a sequência acabar), consideraremos todos os caracteres da sequência como espaços.

Nosso sapo é esmagado se ocorrer um dos seguintes:

  • o sapo ocupa uma célula ocupada por um veículo, em qualquer estrutura
  • o sapo permanece parado em uma via expressa e um veículo de 1 célula de largura passa por ele nesse quadro
  • o sapo pula para o leste "através" de um veículo que se dirige para o oeste ou pula para o oeste através de um veículo que se dirige para o leste
  • o sapo salta fora da grade de 7 (linha) por 23 (célula), em qualquer quadro

Observe que essas são as únicas condições sob as quais um sapo é esmagado. Em particular, um sapo pulando o tráfego "com" é permitido, assim como um sapo pulando para dentro ou para fora de uma célula em uma faixa expressa que é ultrapassada por um veículo de largura 1 no mesmo quadro.

Objetivo e Pontuação

O objetivo do desafio de programação é colocar o sapo na estrada o maior número de vezes possível antes que o último veículo saia da grade de jogo . Ou seja, o programa termina imediatamente após a conclusão do quadro X , em que o quadro X é o primeiro quadro que leva a grade a um estado em que não há mais veículos presentes.

A saída do seu programa deve ser uma string (ou arquivo de texto) contendo a sequência de movimentos do sapo usando a seguinte codificação:

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

Por exemplo, a corda <<^.^indica que o sapo se move para a esquerda duas vezes, depois para cima, faz uma pausa para um quadro e depois para cima novamente.

Um ponto é marcado sempre que o sapo cruza da zona segura sul para a zona segura norte e um ponto é marcado sempre que o sapo cruza da zona segura norte para a zona segura sul.

Algumas regras importantes:

  1. O sapo não deve ser esmagado.
  2. Poste sua solução (sequência de movimentos) junto com o código do programa, em linha ou como um arquivo de texto (por exemplo, usando pastebin.com).
  3. Nosso sapo é presciente e precognitivo, portanto, seu programa pode usar todos e quaisquer dados de tráfego em qualquer quadro enquanto procura soluções. Isso inclui dados para o tráfego que ainda não atingiu a grade de reprodução.
  4. A grade não se enrola. Sair da grade fará com que o sapo seja esmagado e, portanto, não é permitido.
  5. Em nenhum momento o tráfego "reinicia" ou o sapo "se teleporta". A simulação é contínua.
  6. O sapo pode retornar à zona segura sul depois de sair, mas isso não é contado como um ponto. Da mesma forma para a zona segura norte.
  7. O vencedor do concurso é o programa que gera a sequência de movimentos que produz o maior número de cruzamentos.
  8. Para qualquer dúvida ou preocupação adicional, não hesite em perguntar na seção de comentários.

Para obter algum incentivo adicional, adicionarei uma recompensa de +100 representantes ao programa vencedor quando puder.

Bónus

+ 2,5% na pontuação básica * (até + 10%) para todos os cantos da grade de jogo em que o sapo toca. Os quatro cantos da grade são as células mais à esquerda e mais à direita das duas zonas seguras.

+ 25% para a pontuação base * se a sua sequência de movimentos mantiver o sapo confinado a +/- 4 células à esquerda ou à direita da célula inicial durante toda a simulação (é claro que ele pode se mover livremente na vertical).

Não há bônus de pontuação, mas adereços especiais no OP serão direcionados a qualquer pessoa que postar um validador de solução rápido e sujo, para que eu não precise programar um. ;) Um validador simplesmente aceitaria uma sequência de movimentos, garantiria sua legalidade (de acordo com as regras e o arquivo de tráfego) e relataria sua pontuação (ou seja, o número total de cruzamentos).

* A pontuação total é igual à pontuação base mais o bônus, arredondado para o número inteiro mais próximo.

Boa sorte rã!

COTO
fonte
Para quem quiser postar um validador de solução: Não poste como resposta .
Geobits
De fato. Um link para o código em um comentário ou como um adendo a uma solução seria a maneira preferida de enviar um validador.
COTO
O primeiro quadro no qual as faixas lentas avançam deve ser o mesmo que o primeiro quadro no qual as outras faixas avançam, ou um quadro depois?
feersum
Além disso, é possível marcar alcançando a zona final no primeiro quadro em que todos os carros limparam o campo?
feersum
@feersum: as faixas lentas avançam um quadro depois. Eles permanecem imóveis no primeiro quadro, como indicado no exemplo. Quanto à pontuação do sapo no último quadro: sim, é possível. Se o sapo se mudou para uma zona segura no mesmo quadro em que o último veículo sai do campo de jogo, é marcado um ponto.
COTO 21/09

Respostas:

5

C ++: 176

Resultado:

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

Existem menos de 8 milhões de combinações de estados da posição X tempo X conjunto de cantos visitados, para que possam ser pesquisados ​​exaustivamente em menos de 1 segundo. Se o código não possui bugs, deve ser impossível vencer. A estratégia ideal era usar toda a prancha, pois isso permite que os sapos atravessem a estrada 160 vezes, contra cerca de 120 quando confinados ao centro. Visitar as esquinas não custou nenhuma passagem, pois o tráfego era muito pesado.

/* 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;
}
feersum
fonte
1
Não tenho certeza de como você está definindo "estados". Se considerarmos que o estado do sistema é o perfil de tempo do movimento do sapo, existem aproximadamente 5 ^ 3000 estados, correspondentes ao perfil de movimento para as 5 ^ 3000 entradas possíveis (cinco entradas possíveis por ~ 3000 quadros). Obviamente, apenas uma fração deles será admissível, mas o número de estados admissíveis seria impossível de pesquisar por centenas de ordens de magnitude. Quando você enviar sua resposta final, envie uma lista de movimentos junto com ela.
COTO 21/09
Além disso, caso não esteja claro, observe que o sapo pode pular para a esquerda e para a direita enquanto estiver no trânsito, desde que nenhuma das regras "esmagadas" seja violada. Você não está limitado a esperar por janelas onde o sapo é capaz de saltar verticalmente sem movimento lateral.
COTO 21/09
@COTO No meu cálculo de "estados", esqueci uma coisa importante, ou seja, o número de passagens até agora, então tentei dar uma explicação mais clara. A especificação foi muito bem escrita. Parece que interpretei todos esses problemas específicos corretamente na primeira vez.
feersum
Calculo o ideal como 162 + 10% = 178 cruzamentos, mas o seu está próximo o suficiente. Eu realmente não queria que isso se tornasse capaz de força bruta, mas evidentemente eu deveria ter pensado mais no problema. Para ser justo, conceder-lhe-ei o 100 rep.
COTO
Aparentemente, tenho que esperar 24 horas antes de conceder a "recompensa". Por que motivo: quem sabe. O SE não deve querer que as respostas sejam recompensadas pontualmente. Se fizéssemos isso, os terroristas venceriam. : O
COTO