Rana muerta caminando

Introducción

Jonny quiere jugar a Frogger. Sin embargo, no es muy bueno. De hecho, solo intentará avanzar, y solo después de que las plataformas se hayan movido.

Averigua si la rana de Jonny logra llegar al final del camino o si muere en su camino.

Desafío

El programa se recibe como entrada una rejilla Frogger compuesta por 0s y 1s, con el siguiente formato:

La cuadrícula tendrá un ancho y largo aleatorio, y al menos 3x3
1 representa plataformas
0 representa agua
F representa la posición inicial de la rana
Cada primera y última línea de la cuadrícula estará compuesta solo por 1s, y no se moverá, y la rana Fse colocará al azar en la última línea
Cada capa intermedia siempre se moverá y tendrá un <o >al final de cada línea que indica si se mueve hacia la izquierda o hacia la derecha

Está permitido reemplazar estos símbolos con los suyos, siempre que sean distintos y especifique los reemplazos en su respuesta.

La entrada puede estar en cualquier formato compatible (cadena con saltos de línea, matriz de cadenas, matriz de caracteres, ...).

Reglas de desafío

Cada turno, todas las plataformas se moverán una casilla, según la dirección indicada por el signo <o>
Las plataformas reaparecen en el otro lado de la cuadrícula si se las empuja fuera de la "pantalla"
Si la rana está en una plataforma en movimiento, se moverá junto con ella
Después de eso, la rana saltará un cuadrado hacia la fila superior. La rana se moverá cada turno.
La rana muere si salta al agua ( 0) o toca el costado de la cuadrícula junto con una plataforma móvil

Su programa tiene que generar un valor verdadero si la rana sobrevive y un valor falso de lo contrario.

Este es el código de golf , por lo que gana la respuesta más corta en bytes. Se aplican lagunas estándar.

Ejemplos

Ejemplo 1

Entrada

Salida

1

Ejecución

Turno 1:

Vuelta 2:

Turno 3:

Ejemplo 2

Entrada

Salida

0

Ejecución

Turno 1:

Vuelta 2:

Turno 3:

— BgrWorker
fuente

¿Las líneas intermedias siempre se moverán? ¿Podemos tomar una lista de líneas como entrada? Si una línea no se mueve, ¿podemos suponer que termina con un carácter distinto de <o >así podemos tomar matrices rectangulares como entrada? Por cierto, ¡buen desafío!

— dylnan

@dylnan lo aclaré en el texto del desafío. Las capas intermedias siempre se moverán y siempre tendrán una <o >al final.

— BgrWorker

¿La rana se mueve hacia adelante cada turno incluso cuando hay un 0frente, o esperará al siguiente 1? Si puede esperar, ¿avanzará cada vez 1o puede esperar inteligentemente? Es decir, con el caso de prueba 11111 00001< 00011< 11F11, ¿será falsey porque salta al agua ( pastebin de pasos ); será falsey porque se mueve fuera del marco ( pastebin de pasos ); ¿O será sincero porque espera de manera inteligente la segunda plataforma antes de saltar ( pegar pasos )?

— Kevin Cruijssen

@KevinCruijssen se mueve cada turno y felizmente se suicidará (como dije, Jonny no es un muy buen jugador)

— BgrWorker

@BgrWorker Ok, eso hace que el desafío sea más factible. :) Tal vez edítelo en la descripción del desafío, que la rana avanzará cada turno, incluso si saltara a un 0.

— Kevin Cruijssen

Respuestas:

Python 2 , 168 165 152 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

Pruébalo en línea!

El formato de entrada es una lista de cadenas; caracteres que tienen significados como se dan en el enunciado del problema.

Explicación:

ies el número de turno (comenzando con el Turno 1); xes la posición del frogger al comienzo de ese turno.

La fila sobre la que está a punto de pisar el frogger es la cadena l(tenga en cuenta que a través del corte, estos vienen en orden de abajo hacia arriba). d=('<'in l)%-2|1cede -1o 1depende de la dirección en que se mueve la fila.

Como este es el iturno th, esa fila se habrá desplazado de su posición original en ibytes; y entonces el personaje sobre el que está a punto de saltar el frogger es l[(x-d*i)%L]donde Lestá el ancho de la fila, por lo que queremos que ese personaje sea igual a '1'; es decir, >'0'.

Además, queremos comprobar que el frogger no se moverá del borde al comienzo del siguiente turno; esa es la función de la expresión -1<x+d<L.

Estas condiciones están encadenadas (como '0'>-1siempre True); y si en algún momento la expresión resultante es falsa, kse convertirá (y luego se mantendrá) 0.

En cualquier caso, actualizamos la posición del frogger x+=dy topamos el número de fila; luego haga espuma, enjuague, repita.

— Chas Brown
fuente

Python 2 , 246 245 244 242 bytes

^{-3 bytes gracias al Sr. Xcoder}
^{-1 bytes gracias 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]

Pruébalo en línea!

Explicación

d es la dirección en que se moverá cada capa
q es el personaje que se envolverá
- [q,' '][q<'L'] soltará la rana fuera de la pantalla
sum([r[d+1:d-1],[[q,' '][q<'L']]][::d-~d],[])+r[-1:]eliminará el último carácter (la dirección), luego eliminará el primer carácter y lo agregará o eliminará el segundo último y lo antepondrá (según d), y agregará la dirección hacia atrás, moviendo efectivamente toda la fila hacia la izquierda / derecha.
if'F'in r:j=r.index('F');r[j]='L';m[i-1][j]=min('F',m[i-1][j]) hará que la rana salte hacia adelante
min('F',m[i-1][j]) hará que la rana caiga al agua
La comparación de caracteres ( miny <) sigue el orden' ' < '0' < '1' < 'F' < 'L'

La entrada será una lista de caracteres:
' '- agua
'F'- rana
'L'- plataforma
'0'- mover la capa a la izquierda
'1'- mover la capa a la derecha

— varilla
fuente

if i<len(m)-1posiblemente podría 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;}

Utiliza los caracteres predeterminados como se especifica en la descripción del desafío ( 01F<>).

Pruébalo en línea.

Explicación:

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
fuente