Dead Frog Walking

introduzione

Jonny vuole interpretare Frogger. Tuttavia, non è molto bravo. In realtà, proverà solo ad andare avanti e solo dopo che le piattaforme si saranno mosse.

Scopri se la rana di Jonny riesce a raggiungere la fine del percorso o se muore sulla sua strada.

Sfida

Il programma riceverà come input una griglia Frogger composta da 0s e 1s, con il seguente formato:

La griglia avrà una larghezza e una lunghezza casuali e almeno 3x3
1 rappresenta le piattaforme
0 rappresenta l'acqua
F rappresenta la posizione iniziale della rana
Ogni prima e ultima riga della griglia sarà composta solo da 1s, e non si muoverà, e dalla ranaF verrà posizionata a caso sull'ultima riga
Ogni strato intermedio si muoverà sempre e avrà un <o >alla fine di ogni linea che indica se si sposta a sinistra o a destra

Sostituire questi simboli con i tuoi è permesso, purché siano tutti distinti e tu specifichi i rimpiazzi nella tua risposta.

L'input può essere in qualsiasi formato compatibile (stringa con interruzioni di riga, matrice di stringhe, matrice di caratteri, ...).

Regole della sfida

Ad ogni giro, tutte le piattaforme si sposteranno di un quadrato, in base alla direzione indicata dalla <o> segno
Le piattaforme riappaiono dall'altra parte della griglia se vengono spinte fuori dallo "schermo"
Se la rana si trova su una piattaforma mobile, si sposterà con essa
Dopodiché, la rana salterà un quadrato verso la fila superiore. La rana si muoverà ogni turno.
La rana muore se salta in acqua ( 0) o tocca il lato della griglia insieme a una piattaforma mobile

Il tuo programma deve produrre un valore veritiero se la rana sopravvive e un valore falso altrimenti.

Questo è code-golf , quindi vince la risposta più breve in byte. Si applicano scappatoie standard.

Esempi

Esempio 1

Ingresso

Produzione

1

Esecuzione

Girare 1:

Turno 2:

Girare 3:

Esempio 2

Ingresso

Produzione

0

Esecuzione

Girare 1:

Turno 2:

Girare 3:

— BgrWorker
fonte

Le linee intermedie si muoveranno sempre? Possiamo prendere un elenco di linee come input? Se una linea non si muove, possiamo supporre che termini con un carattere diverso da <o >così possiamo prendere array rettangolari come input? A proposito, bella sfida!

— dylnan,

@dylnan L'ho chiarito nel testo della sfida. I livelli intermedi si muoveranno sempre e avranno sempre <o >alla fine.

— BgrWorker,

La rana si sposta in avanti ogni turno anche quando c'è un 0fronte o aspetta il prossimo 1? Se può aspettare, andrà avanti su tutti 1o può aspettare in modo intelligente? Vale a dire con il caso di prova 11111 00001< 00011< 11F11, sarà falso perché salta in acqua ( pasta di passi ); sarà falso perché si sposta fuori dalla cornice ( pasta di passi ); o sarà vero perché attende in modo intelligente la seconda piattaforma prima di saltare in avanti ( incolla di passi )?

— Kevin Cruijssen,

@KevinCruijssen si muove ad ogni turno e si suiciderà felicemente (come ho detto, Jonny non è un giocatore molto bravo)

— BgrWorker

@BgrWorker Ok, questo rende la sfida davvero più fattibile. :) Forse modificalo nella descrizione della sfida, che la rana si sposterà in avanti ogni turno, anche se salta in a 0.

— Kevin Cruijssen,

Risposte:

Python 2 , 168 165 152 145 137 129 byte

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

Provalo online!

Il formato di input è un elenco di stringhe; caratteri che hanno significati come indicato nella dichiarazione del problema.

Spiegazione:

i è il numero di svolta (a partire dalla svolta 1); xè la posizione del frogger all'inizio di quel turno.

La riga su cui sta per calpestare il frogger è la stringa l(notare che tramite l'affettamento, questi arrivano dal basso all'ordine superiore). d=('<'in l)%-2|1i rendimenti-1 o 1dipende dalla direzione in cui si muove la riga.

Dal momento che è il iturno, quella riga si sarà spostata dalla posizione originale di ibyte; e quindi il personaggio su cui il frogger sta per saltare è l[(x-d*i)%L]dov'è Lla larghezza della riga, quindi vogliamo che quel personaggio sia uguale a'1' ; Per esempio, >'0'.

Inoltre, vogliamo verificare che il frogger non venga spostato dal bordo all'inizio del turno successivo ; questa è la funzione dell'espressione -1<x+d<L.

Queste condizioni sono concatenate (poiché '0'>-1è sempre True); e se in qualsiasi momento l'espressione risultante è falsa, kdiventerà (e poi rimarrà) 0.

In ogni caso, aggiorniamo la posizione del frogger x+=de aumentiamo il numero di riga; quindi schiumare, risciacquare, ripetere.

— Chas Brown
fonte

Python 2 , 246 245 244 242 byte

^{-3 byte grazie a Mr. Xcoder}
^{-1 byte grazie 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]

Provalo online!

Spiegazione

d è la direzione in cui si sposterà ogni strato
q è il personaggio che verrà avvolto
- [q,' '][q<'L'] lascerà cadere la rana fuori dallo schermo
sum([r[d+1:d-1],[[q,' '][q<'L']]][::d-~d],[])+r[-1:]rimuoverà l'ultimo carattere (la direzione), quindi rimuoverà il primo carattere e lo aggiungerà o rimuoverà il secondo ultimo e lo anteporrà (in base a d), e aggiungerà la direzione indietro, spostando efficacemente l'intera riga a sinistra / destra.
if'F'in r:j=r.index('F');r[j]='L';m[i-1][j]=min('F',m[i-1][j]) farà saltare la rana in avanti
min('F',m[i-1][j]) farà cadere la rana nell'acqua
Il confronto dei caratteri ( mine <) segue l'ordine' ' < '0' < '1' < 'F' < 'L'

L'ingresso sarà un elenco di un elenco di caratteri:
' '- acqua
'F'- rana
'L'- piattaforma
'0'- sposta il livello a sinistra
'1'- sposta il livello a destra

— asta
fonte

if i<len(m)-1potrebbe essere if~-len(m)>i.

— Jonathan Frech,

Java 8, 293 277 byte

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

Utilizza i caratteri predefiniti come specificato nella descrizione della sfida ( 01F<>).

Provalo online.

Spiegazione:

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