Dead Frog Walking

Introdução

Jonny quer jogar Frogger. No entanto, ele não é muito bom. De fato, ele apenas tentará seguir em frente, e somente depois que as plataformas forem movidas.

Descubra se o sapo de Jonny consegue chegar ao fim do caminho ou se ele morre a caminho.

Desafio

O programa receberá como entrada uma grade Frogger composta por 0s e 1s, com o seguinte formato:

A grade terá largura e comprimento aleatórios e pelo menos 3x3
1 representa plataformas
0 representa água
F representa a posição inicial do sapo
Cada primeira e última linha da grade será composta por apenas 1s e não se moverá, e o sapo Fserá colocado aleatoriamente na última linha
Cada camada intermediária estará sempre em movimento e terá um <ou >no final de cada linha indicando se ela se move para a esquerda ou direita

É permitido substituir esses símbolos pelos seus, desde que sejam todos distintos e você especifique as substituições na sua resposta.

A entrada pode estar em qualquer formato compatível (string com quebras de linha, array de strings, array de caracteres, ...).

Regras do Desafio

A cada turno, todas as plataformas se moverão um quadrado, com base na direção indicada pelo sinal <ou>
As plataformas reaparecem no outro lado da grade se forem empurradas para fora da "tela"
Se o sapo estiver em uma plataforma móvel, ele se moverá junto com ele
Depois disso, o sapo pulará um quadrado em direção à linha superior. O sapo se move a cada turno.
O sapo morre se pular na água ( 0) ou tocar o lado da grade junto com uma plataforma em movimento

Seu programa precisa gerar um valor verdadeiro se o sapo sobreviver e um valor falso caso contrário.

Isso é código-golfe , então a resposta mais curta em bytes vence. Aplicam-se brechas padrão.

Exemplos

Exemplo 1

Entrada

Resultado

1

Execução

Turno 1:

Turno 2:

Turno 3:

Exemplo 2

Entrada

Resultado

0

Execução

Turno 1:

Turno 2:

Turno 3:

code-golf array-manipulation decision-problem grid BgrWorker
fonte

As linhas intermediárias sempre estarão em movimento? Podemos pegar uma lista de linhas como entrada? Se uma linha não está se movendo, podemos assumir que ela termina com um caractere diferente de <ou >então podemos usar matrizes retangulares como entrada? A propósito, bom desafio!

dylnan

@dylnan Esclarei isso no texto do desafio. As camadas intermediárias estarão sempre em movimento e sempre terão um <ou >no final.

BgrWorker 18/06/19

O sapo se move para frente a cada turno, mesmo quando há um 0na frente, ou vai esperar o próximo 1? Se puder esperar, seguirá adiante em todos 1, ou poderá esperar de maneira inteligente? 11111 00001< 00011< 11F11Ou seja, com o caso de teste , será falsey porque pula na água ( pasta de passos ); será falsey porque se move fora do quadro ( pasta de passos ); ou será verdade porque aguarda com inteligência a segunda plataforma antes de pular para a frente ( pasta de passos )?

Kevin Cruijssen

@KevinCruijssen ele se move cada turno, e terá todo o prazer de suicídio (como eu disse, Jonny não é um jogador muito bom)

BgrWorker

@BgrWorker Ok, isso torna o desafio realmente mais viável. :) Talvez edite-o na descrição do desafio, para que o sapo avance a cada turno, mesmo que pule para a 0.

Kevin Cruijssen

Respostas:

Python 2 , 168 165 152 145 145 137 129 bytes

s=input();x=s[-1].find('F');L=len(s[0]);i=k=1
for l in s[-2:0:-1]:d=('<'in l)%-2|1;k*=l[(x-d*i)%L]>'0'>-1<x+d<L;x+=d;i+=1
print k

Experimente online!

Formato de entrada é uma lista de strings; caracteres com significados, conforme indicado na declaração do problema.

Explicação:

ié o número do turno (começando no turno 1); xé a posição do sapo no início desse turno.

A linha em que o sapo está prestes a pisar é a corda l (observe que, por meio da fatia, elas são colocadas de baixo para cima). d=('<'in l)%-2|1produz -1ou 1depende da direção em que a linha está se movendo.

Como esta é a iquinta volta, essa linha terá mudado de sua posição original pori bytes; e assim, o personagem no qual o sapo está prestes a pular é l[(x-d*i)%L]onde Lestá a largura da linha; portanto, queremos que ele seja igual a '1'; ou seja, >'0'.

Além disso, queremos verificar se o sapo não será desviado da borda no início do próximo turno; essa é a função da expressão -1<x+d<L.

Essas condições são encadeadas (já que '0'>-1é sempreTrue ); e, a qualquer momento, a expressão resultante for falsa, kse tornará (e permanecerá) 0.

De qualquer forma, atualizamos a posição do sapo x+=de aumentamos o número da linha; ensaboar, enxaguar, repetir.

Chas Brown
fonte

Python 2 , 246 245 244 242 bytes

^{-3 byte graças ao Sr. Xcoder}
^{-1 byte graças a Jonathan Frech}

m=input()
exec"""for i,r in enumerate(m):
 d=-int(min('1',r[-1]));q=r[d*2]
 if m[i+1:]:r=sum([r[d+1:d-1],[[q,' '][q<'L']]][::d-~d],[])+r[-1:]
 if'F'in r:j=r.index('F');r[j]='L';m[i-1][j]=min('F',m[i-1][j])
 m[i]=r
"""*~-len(m)
print'F'in m[0]

Experimente online!

Explicação

d é a direção em que cada camada se moverá
q é o personagem que será envolvido
- [q,' '][q<'L'] vai deixar o sapo fora da tela
sum([r[d+1:d-1],[[q,' '][q<'L']]][::d-~d],[])+r[-1:]removerá o último caractere (a direção), depois remova o primeiro caractere e o anexará ou removerá o segundo último e o anexará (com base em d) e anexará a direção de volta, movendo efetivamente toda a linha para a esquerda / direita.
if'F'in r:j=r.index('F');r[j]='L';m[i-1][j]=min('F',m[i-1][j]) vai fazer o sapo pular pra frente
min('F',m[i-1][j]) vai fazer o sapo cair na água
A comparação de caracteres ( mine <) segue a ordem' ' < '0' < '1' < 'F' < 'L'

A entrada será uma lista de caracteres:
' '- água
'F'- sapo
'L'- plataforma
'0'- mova a camada para a esquerda
'1'- mova a camada para a direita

Cajado
fonte

if i<len(m)-1poderia ser if~-len(m)>i.

Jonathan Frech

Java 8, 293 277 bytes

a->{for(int l=a.length-1,x=a[l].indexOf('F'),y=l,i,t=a[0].length()-1,b;y>0;y--){for(i=l;i-->1;a[i]=a[i].endsWith("<")?a[i].substring(1,t+1)+a[i].charAt(0*(x-=b))+"<":a[i].charAt(t)+a[i].substring(0*(x+=b),t)+">")b=i==y?1:0;if(x<0|x>t||a[y].charAt(x)<49)return 0>1;}return 1>0;}

Usa os caracteres padrão, conforme especificado na descrição do desafio ( 01F<>).

Experimente online.

Explicação:

a->{                         // Method with String-array parameter & boolean return-type
  for(int l=a.length-1,      //  Amount of rows minus 1
       x=a[l].indexOf('F'),  //  Start x-position of the frog
       y=l,                  //  Start y-position of the frog
       i,                    //  Index-integer
       t=a[0].length()-1,    //  Length of the rows minus 1
       b;                    //  Temp integer
       y>0;                  //  Loop as long as the frog hasn't reached the other side
       y--){                 //    Jump forward once after every turn
    for(i=l;l-->1;           //   Inner loop over all the moving rows
        ;a[i]=               //     After every iteration: Change the moving row to:
         a[i].endsWith("<")? //      If the current platform moves to the left:
          a[i].substring(1,t+1)
                             //       Last part of the platform
                             //        i.e. "00101<" → "0101"
          +a[i].charAt(0     //       Appended with the first character
                             //        i.e. "00101<" → '0'
            *(x-=b))         //       We are moving left, so subtract `b` from `x`      
          +"<"               //       And append the direction "<" again
                             //        so "00101<" becomes "01010<"
         :                   //      Else (the platform moves to the right):
          a[i].charAt(t)     //       Take the last character
                             //        i.e. "00111>" → '1'
          +a[i].substring(0  //       And append the first part of the platform
                             //        i.e. "00111>" → "0011"
            *(x+=b),t)       //       We are moving right, so add `b` to `x`
          +">")              //       And append the direction "<" again
                             //        so "00111>" becomes "10011>"
      b=i==y?                //    If the frog is on the current row:
         1                   //     Set `b` to 1
        :                    //    Else:
         0;                  //     Set `b` to 0
    if(x<0|x>t               //   If the Frog is out of bounds
       ||a[y].charAt(x)<49)  //   Or jumped into the water
      return 0>1;}           //    Return false
  return 1>0;}               //  If the loop ended the frog made it to the other side,
                             //  so return true

Kevin Cruijssen
fonte