TL; DR: Dada una matriz de caracteres y un robot en una posición inicial de la matriz, escriba un algoritmo que pueda leer una cadena con movimientos ( Fpara "avanzar", Rpara "girar 90 grados a la derecha" y Lpara "girar 90 grados izquierda ") y calcular la posición final del robot. Más detalles en el texto completo.

Tenemos en casa un dispositivo programable muy simple para niños: un pequeño vehículo con botones para que el vehículo avance, gire 90 grados a la izquierda o gire 90 grados a la derecha. Algo similar a esto:

También tenemos una alfombra de espuma con letras como esta:

El propósito de todo esto es enseñar a los niños el alfabeto y los rudimentos de la programación, todo a la vez.

El reto

Supongamos que hemos dispuesto al azar nuestra alfombra de espuma de esta manera:

+---+---+---+---+---+---+---+
| 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 |   
    +---+---+---+---+---+
            |   |
            +---+

Supongamos que también hemos modificado el vehículo para que cuando programemos un comando de "avance", el vehículo avance exactamente el tamaño de un cuadrado en el tapete. Entonces, si el vehículo está en la Uplaza y va hacia el norte, se detiene exactamente en la Pplaza.

Todas las instrucciones se dan al vehículo antes de que comience a moverse, y son:

• F: El vehículo avanza hacia la siguiente casilla.
• R: El vehículo gira 90 grados a la derecha en su lugar (sin movimiento adicional).
• L: El vehículo gira 90 grados a la izquierda en su lugar (sin movimiento adicional).

Una vez que se dan las instrucciones, puede presionar el botón "IR" y enviar el vehículo a una posición dada, ya que seguirá todas las instrucciones en el orden dado. Entonces, puede decirle al niño que inserte las instrucciones necesarias para que el vehículo vaya a una letra determinada.

Debe escribir el programa / función más corto que procesa un string(parámetro de entrada) con un conjunto de instrucciones y calcula la letra sobre la que se detiene el vehículo (salida string).

Detalles:

• El vehículo siempre comienza en el cuadrado en blanco en la parte inferior y mirando hacia el norte (hacia el Ucuadrado).
• La cadena de entrada contendrá sólo las letras F, R, Ly G(para el botón "ir"). Puede usar letras minúsculas para el tapete y las instrucciones, si así lo prefiere.
• El algoritmo debe obedecer todas las instrucciones de la cadena antes de la primera G(cada instrucción posterior se ignora cuando el vehículo ha comenzado a moverse).
• Si el vehículo se sale del tapete en un momento dado (incluso si la cadena de entrada no se ha procesado completamente), el algoritmo debe devolver la cadena Out of mat.
• De lo contrario, el algoritmo debe devolver la letra que el vehículo ha detenido. El punto de partida cuenta como un carácter (o una cadena vacía).

Ejemplos:

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)

Este es el código de golf , ¡así que puede ganar el programa más corto para cada idioma!

JavaScript (ES6), 194 176 169 163 bytes

Ahorré algunos bytes gracias a @Luke y @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')

Sin golf:

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 bytes

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

Pruébalo en línea!

Python 3 , 226 231 241 bytes

Segunda edición Debería funcionar ahora. Nuevamente, mucha optimización por hacer.

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"])

Pruébalo en línea!

Wolfram Language / Mathematica, 300 Bytes

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@#]&@#]&

Sin golf:

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@#] &@#] &