TL; DR: étant donné un tableau de caractères et un robot dans une position de départ du tableau, écrivez un algorithme qui peut lire une chaîne avec des mouvements ( Fpour "aller de l'avant", Rpour "tourner de 90 degrés à droite" et Lpour "tourner de 90 degrés" gauche ") et calculer la position finale du robot. Plus de détails dans le texte complet.

Nous avons chez nous un appareil programmable très simple pour les enfants: un petit véhicule avec des boutons pour faire avancer le véhicule, tourner à 90 degrés à gauche ou à 90 degrés à droite. Quelque chose de similaire à ceci:

Nous avons également un tapis en mousse avec des lettres comme celle-ci:

Le but de tout cela est d'enseigner aux enfants à la fois l'alphabet et les rudiments de la programmation.

Le défi

Supposons que nous ayons disposé notre tapis en mousse de façon aléatoire:

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

Supposons également que nous ayons modifié le véhicule de sorte que lorsque nous programmons une commande "aller de l'avant", le véhicule avance exactement de la taille d'un carré dans le tapis. Donc, si le véhicule est sur la Uplace et va vers le nord, il s'arrête exactement sur la Pplace.

Les instructions sont toutes données au véhicule avant qu'il ne commence à se déplacer, à savoir:

• F: Le véhicule avance dans la case suivante.
• R: Le véhicule tourne à 90 degrés à sa place (pas de mouvement supplémentaire).
• L: Le véhicule tourne à 90 degrés à gauche à sa place (pas de mouvement supplémentaire).

Une fois les instructions données, vous pouvez appuyer sur le bouton "GO" et envoyer le véhicule à une position donnée car il suivra toutes les instructions dans l'ordre donné. Ainsi, vous pouvez dire à l'enfant d'insérer les instructions nécessaires pour que le véhicule se rende à une lettre donnée.

Vous devez écrire le programme / la fonction la plus courte qui traite un string(paramètre d'entrée) avec un ensemble d'instructions et calcule la lettre sur laquelle le véhicule s'arrête (sortie string).

Détails:

• Le véhicule démarre toujours au carré blanc en bas, et face au nord (vers le Ucarré).
• La chaîne d'entrée ne contiendra que les lettres F, R, Let G(pour le bouton « go »). Vous pouvez utiliser des lettres minuscules pour le tapis et les instructions, si vous préférez.
• L'algorithme doit obéir à toutes les instructions de la chaîne avant la première G(chaque instruction suivante est ignorée car le véhicule a commencé à se déplacer).
• Si le véhicule sort du tapis à un moment donné (même si la chaîne d'entrée n'a pas été complètement traitée), l'algorithme doit renvoyer la chaîne Out of mat.
• Sinon, l'algorithme doit renvoyer la lettre où le véhicule s'est arrêté. Le point de départ compte comme un caractère (ou une chaîne vide).

Exemples:

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)

C'est du golf de code , alors le programme le plus court pour chaque langue peut gagner!

JavaScript (ES6), 194 176 169 169 163 octets

Enregistré quelques octets grâce à @Luke et @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')

Non 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 octets

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

Essayez-le en ligne!

Python 3 , 226 231 241 octets

Deuxième montage; devrait fonctionner maintenant. Encore une fois, beaucoup d'optimisation à faire.

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

Essayez-le en ligne!

Wolfram Language / Mathematica, 300 octets

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

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