TL; DR: dati una matrice di caratteri e un robot in una posizione iniziale della matrice, scrivi un algoritmo che possa leggere una stringa con movimenti ( Fper "vai avanti", Rper "ruota di 90 gradi a destra" e Lper "ruota di 90 gradi sinistra ") e calcola la posizione finale del robot. Maggiori dettagli nel testo completo.

A casa abbiamo un dispositivo programmabile molto semplice per bambini: un piccolo veicolo con pulsanti per far avanzare il veicolo, girare di 90 gradi a sinistra o girare di 90 gradi a destra. Qualcosa di simile a questo:

Abbiamo anche un tappetino in schiuma con lettere come questa:

Lo scopo di tutto ciò è insegnare ai bambini sia l'alfabeto che i rudimenti della programmazione, tutto in una volta.

La sfida

Supponiamo di aver sistemato casualmente il nostro tappetino in schiuma in questo modo:

+---+---+---+---+---+---+---+
| E | R | L | B | I | X | N |
+---+---+---+---+---+---+---+
| O | A | Q | Y | C | T | G |
+---+---+---+---+---+---+---+
| F | W | H | P | D | Z | S |
+---+---+---+---+---+---+---+
    | K | V | U | M | J |   
    +---+---+---+---+---+
            |   |
            +---+

Supponiamo inoltre di aver modificato il veicolo in modo tale che quando programmiamo un comando "vai avanti", il veicolo avanzi esattamente delle dimensioni di un quadrato nel tappetino. Quindi, se il veicolo si trova nella Upiazza e va a nord, si ferma esattamente nella Ppiazza.

Tutte le istruzioni vengono fornite al veicolo prima che inizi a muoversi e queste sono:

• F: Il veicolo avanza nella casella successiva.
• R: Il veicolo gira di 90 gradi al suo posto (nessun ulteriore movimento).
• L: Il veicolo gira a 90 gradi a sinistra al suo posto (nessun ulteriore movimento).

Una volta fornite le istruzioni, è possibile premere il pulsante "GO" e inviare il veicolo in una determinata posizione poiché seguirà tutte le istruzioni in un determinato ordine. Quindi, puoi dire al bambino di inserire le istruzioni necessarie affinché il veicolo vada a una determinata lettera.

È necessario scrivere il programma / funzione più breve che elabora un string(parametro di input) con una serie di istruzioni e calcola la lettera su cui il veicolo si ferma (output string).

Dettagli:

• Il veicolo inizia sempre nella casella vuota in basso e rivolto a nord (verso la Upiazza).
• La stringa di input conterrà solo le lettere F, R, Le G(per il pulsante "go"). Se lo preferisci, puoi usare lettere minuscole per il tappetino e le istruzioni.
• L'algoritmo deve obbedire a tutte le istruzioni nella stringa prima della prima G(ogni istruzione successiva viene ignorata quando il veicolo ha iniziato a muoversi).
• Se il veicolo esce dal tappetino in qualsiasi momento (anche se la stringa di input non è stata completamente elaborata), l'algoritmo deve restituire la stringa Out of mat.
• In caso contrario, l'algoritmo deve restituire la lettera in cui il veicolo si è fermato. Il punto iniziale conta come un carattere (o una stringa vuota).

Esempi:

Input: FFG
Output: P

Input: FRFRFG
Output: Out of mat

Input: RRFFG
Output: Out of mat

Input: FFFRFFLFG
Output: X

Input: FFFRFFLF
Output:      <-- Nothing or a whitespace (the robot has not started moving)

Input: FFFRRFFFG
Output:      <-- Nothing or a whitespace (the robot has returned to the starting point)

Input: RRRRRLFFFLFFRFRFGFFRRGRFF
Output: L    (Everything after the first G is ignored)

Questo è code-golf , quindi può vincere il programma più breve per ogni lingua!

JavaScript (ES6), 194 176 169 163 byte

Alcuni byte salvati grazie a @Luke e @Arnauld.

s=>(p=35,d=3,t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11',[...s].every(i=>i=='L'?d--:i>'Q'?d++:i<'G'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:p:0)?'':t[p]||'Out of mat')

Ungolfed:

s=>(
  p=35,
  d=3,
  t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11',
  [...s].every(i=>i=='L'?d--:
                  i<'Q'?d++:
                  i<'G'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:p:
                  0
              )?'':
               t[p]||'Out of mat'
)

f=
s=>(p=35,d=3,t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11',[...s].every(i=>i=='L'?d--:i>'Q'?d++:i<'G'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:p:0)?'':t[p]||'Out of mat')

console.log(f('FFG')); //P
console.log(f('FRFRFG')); //Out of mat
console.log(f('RRFFG')); //Out of mat
console.log(f('FFFRFFLFG')); //X
console.log(f('FFFRFFLF')); //(space)
console.log(f('FFFRRFFFG')); //(space)
console.log(f('RRRRRLFFFLFFRFRFGFFRRGRFF')); //L
console.log(f('FFFFFRRFG')); //Out of mat

Python 2 , 235 byte

x=0;y=1;a=4;b=3
p='ERLBIXN','OAQYCTG','FWHPDZS','aKVUMJ','aaa '
r=''
for i in input():
 if'G'==i:r=p[a][b];break
 elif'G'>i:
  b+=x;a-=y;
  if(-1<a<5)-1or(''<p[a][b:]<'a')-1:r='Out of mat';break
 else:x,y=[[y,-x],[-y,x]][i<'R']
print r

Provalo online!

Python 3 , 226 231 241 byte

Seconda modifica; dovrebbe funzionare ora. Ancora una volta, molte ottimizzazioni da fare.

n=input();s="0ERLBIXN00OAQYCTG00FWHPDZS000KVUMJ000000 00000";d=1;c=40;i=0;w=[-1,-9,1,9]
while n[i]!="G"and c>=0:
 if n[i]=="F":c+=w[d]
 else:d=[d+[-1,3][d<0],-~d%4][n[i]=="R"]
 i+=1
print(["Out of mat",s[c]][c in range(len(s))and s[c]!="0"])

Provalo online!

Wolfram Language / Mathematica, 300 byte

p=Re[(1-7I)#[[1]]]&;d=Drop;t=Throw;s=Switch;s[#,0,"Out of mat",_,StringPart["000 0000KVUMJ0FWHPDZSOAQYCTGERLBIXN",p@#]]&@Catch@Fold[If[MemberQ[d[d[Range[4,35],{2,5}],{7}],p@#],#,t@0]&@(s[#2,"F",#+{#[[2]],0},"R",#{1,-I},"L",#{1,I},_,t[#]]&)[#1,#2]&,{4,I},If[StringFreeQ["G"]@#,{"G"},Characters@#]&@#]&

Ungolfed:

p = Re[(1 - 7 I) #[[1]]] &;
d = Drop;
t = Throw;
s = Switch;
s[#,
    0, "Out of mat",
    _, StringPart["000 0000KVUMJ0FWHPDZSOAQYCTGERLBIXN", p@#]] &@
  Catch@
  Fold[
    If[MemberQ[d[d[Range[4, 35], {2, 5}], {7}], p@#], #, 
        t@0] &@(s[#2, "F", # + {#[[2]], 0}, "R", # {1, -I}, 
          "L", # {1, I}, _, t[#]] &)[#1, #2] &,
    {4, I},
    If[StringFreeQ["G"]@#, {"G"}, Characters@#] &@#] &