Rana muerta caminando

17

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 , por lo que gana la respuesta más corta en bytes. Se aplican lagunas estándar.

Ejemplos

Ejemplo 1

Entrada

11111
00111>
00101<
1F111

Salida

1

Ejecución

Turno 1:

11111
10011
01010
1F111

11111
10011
0F010
11111

Vuelta 2:

11111
11001
F0100
11111

11111
F1001
10100
11111

Turno 3:

11111
1F100
01001
11111

1F111
11100
01001
11111

Ejemplo 2

Entrada

11111
00100<
00100<
1F111

Salida

0

Ejecución

Turno 1:

11111
01000
01000
1F111

11111
01000
0F000
11111

Vuelta 2:

11111
10000
F0000
11111

11111
F0000
10000
11111

Turno 3:

11111
00001
00001
11111
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:

4

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
1

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
0

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