TL; DR: Wenn sich ein Array von Zeichen und ein Roboter an einer Startposition des Arrays befinden, schreiben Sie einen Algorithmus, der eine Zeichenfolge mit Bewegungen lesen kann ( Ffür "Vorwärts", Rfür "90 Grad nach rechts drehen" und Lfür "90 Grad drehen") left ") und berechnen Sie die Endposition des Roboters. Weitere Details im vollständigen Text.

Wir haben zu Hause ein sehr einfaches programmierbares Gerät für Kinder: ein kleines Fahrzeug mit Knöpfen, mit denen das Fahrzeug vorwärts, um 90 Grad nach links oder um 90 Grad nach rechts gedreht werden kann. Ähnliches:

Wir haben auch eine Schaumstoffmatte mit folgenden Buchstaben:

Ziel ist es, den Kindern das Alphabet und die Grundlagen des Programmierens auf einmal beizubringen.

Die Herausforderung

Angenommen, wir haben unsere Schaumstoffmatte wie folgt zufällig angeordnet:

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

Nehmen wir an, wir haben das Fahrzeug so modifiziert, dass das Fahrzeug beim Programmieren eines "Vorwärts" -Befehls genau die Größe eines Quadrats auf der Matte vorwärts fährt. Wenn sich das Fahrzeug also auf dem UPlatz befindet und nach Norden fährt, hält es genau auf dem PPlatz an.

Alle Anweisungen werden dem Fahrzeug gegeben, bevor es sich in Bewegung setzt. Dies sind:

• F: Das Fahrzeug fährt geradeaus auf den nächsten Platz.
• R: Das Fahrzeug dreht sich an seiner Stelle um 90 Grad nach rechts (keine weitere Bewegung).
• L: Das Fahrzeug dreht sich an seiner Stelle um 90 Grad nach links (keine weitere Bewegung).

Sobald die Anweisungen erteilt wurden, können Sie die Taste "GO" drücken und das Fahrzeug an eine bestimmte Position schicken, da alle Anweisungen in der angegebenen Reihenfolge befolgt werden. So können Sie dem Kind sagen, dass es die erforderlichen Anweisungen für das Fahrzeug eingeben soll, um zu einem bestimmten Brief zu gelangen.

Sie müssen das kürzeste Programm / die kürzeste Funktion, die einen string(Eingabeparameter) verarbeitet, mit einer Reihe von Anweisungen schreiben und den Buchstaben berechnen, bei dem das Fahrzeug stehen bleibt (Ausgabe string).

Einzelheiten:

• Das Fahrzeug startet immer auf dem leeren Feld unten und zeigt nach Norden (in Richtung des UFeldes).
• Die Eingabezeichenfolge enthält nur die Buchstaben F, R, Lund G(für die „Go“ -Taste). Sie können für die Matte und die Anweisungen auch Kleinbuchstaben verwenden, wenn Sie dies bevorzugen.
• Der Algorithmus muss jede Anweisung in der Zeichenfolge vor der ersten befolgen G(jede Anweisung danach wird ignoriert, wenn sich das Fahrzeug in Bewegung gesetzt hat).
• Wenn das Fahrzeug zu einem bestimmten Zeitpunkt die Matte verlässt (auch wenn die Eingabezeichenfolge nicht vollständig verarbeitet wurde), muss der Algorithmus die Zeichenfolge zurückgeben Out of mat.
• Wenn nicht, muss der Algorithmus den Brief zurückgeben, bei dem das Fahrzeug stehen geblieben ist. Der Startpunkt zählt als ein Zeichen (oder eine leere Zeichenfolge).

Beispiele:

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)

Das ist Code-Golf , also kann das kürzeste Programm für jede Sprache gewinnen!

JavaScript (ES6), 194 176 169 163 Bytes

Dank @Luke und @Arnauld wurden einige Bytes gespeichert.

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

Probieren Sie es online!

Python 3 , 226 231 241 Bytes

Zweite Bearbeitung; sollte jetzt funktionieren. Auch hier muss noch viel optimiert werden.

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

Probieren Sie es online!

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

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