Zusammenfassung

Die Aufgabe besteht darin, den Marsrover zu navigieren und seine endgültigen Koordinaten und Richtungen anzugeben.

Eingang:

Erste Eingabe:

Zuerst muss Ihr Programm die Eingabe in folgendem Format vornehmen:

[X-Coordinate],[Y-Coordinate],[Direction]

Die Richtung muss sein: Noder Soder Eoder W(Anfangsbuchstaben von Nord, Süd, West, Ost)

Beispiel: 10,20,N(x = 10, y = 20, Richtung = N (Nord))

Zweiter Eingang:

Der zweite Eingang besteht aus Reihe von R, L, Mfür rechts, links und jeweils bewegen.

Für Rund L(rechts und links) muss sich die Richtung des Rovers entsprechend ändern.

Denn Mder Rover muss 1 Einheit in der Richtung vorausfahren, in der er sich vor der Bewegung befand.

Regeln zur Koordinatenberechnung:

N = Y + 1
E = X + 1
S = Y - 1
W = X - 1

Ausgabe:

Die endgültigen Koordinaten und die aktuelle Richtung des Rovers.

Enter initial data:      1,2,N

Enter the instructions:  MRMLM

Output:                  2,4,N

Die Koordinaten können eine beliebige Ganzzahl sein und können negativ sein .

Alle Standardlücken sind nicht erlaubt. Wenn die Bereitstellung einer Demo auf Websites wie http://ideone.com usw. möglich ist, tun Sie dies bitte, damit ich dies überprüfen kann :)

Dies ist ein Beliebtheitswettbewerb, also sei kreativ!

Nach den Ratschlägen anderer entscheide ich mich, dies zu einem Code-Golf zu machen .

Rubin ≥ 2,0, 101

E,N,W,S=*0..3
x,y,i=eval"a="+gets
gets.bytes{|c|x+=c%2*1i**i=i+1-c&3}
$><<[(x+y.i).rect,"NWSE"[i]]*?,

Diese Lösung kann hier getestet werden: https://ideone.com/C4PLdE

Beachten Sie, dass die auf ideone verknüpfte Lösung ein Zeichen länger ist ( 1.ianstatt 1iin Zeile 3). Der Grund dafür ist, dass ideone nur Ruby 1.9 unterstützt, was die Kurzsyntax für komplexe Literale nicht zulässt.

Javascript ( ES6 ) 145 141 127

Bearbeiten: In der C-Lösung von edc65 wurde die Notwendigkeit für ein Übersetzungsarray mithilfe der Methode beseitigt

[x,y,d]=(p=prompt)(s='NESW').split(','),[...p(d=s.search(d))].map(c=>c!='M'?(d+=c>'M'||3,d%=4):d%2?x-=d-2:y-=d-1),p([x,y,s[d]])

Ungolfed / Kommentiert:

s='NESW' // initialize variable for direction mapping
[x,y,d]=prompt().split(',') // get first input, split by commas, map to variables x,y,d
d=s.search(d) // get numeric value for direction
[...prompt()].map(c=> // get second input, map a function to every character in it
    c!='M'? // if char is not M
        (d+=c>'M'||3, // increment d by 1 if char greater than M, otherwise 3 
         d%=4) // modulo by 4 to wrap direction
    : // else
        d%2? // if odd direction
            x-=d-2 // move x position
        : // else
            y-=d-1 // move y position
)
prompt([x,y,s[d]]) // output result

Java - 327

class R{public static void main(String[]a){char c,e=a[2].charAt(0),z[]={78,69,83,87};Integer x=Integer.valueOf(a[0]),y=x.valueOf(a[1]),d=e<70?1:e==83?2:e>86?3:0,i=0;for(;i<a[3].length();d=c>81?(d+1)%4:c<77?(d+3)%4:d){c=a[3].charAt(i++);if(c==77){x=d==1?x+1:d>2?x-1:x;y=d<1?y+1:d==2?y+1:y;}}System.out.print(x+","+y+","+z[d]);}}

Mit Leerzeichen:

class R{
    public static void main(String[]a){
        char c,e=a[2].charAt(0),z[]={78,69,83,87};
        Integer x=Integer.valueOf(a[0]),y=x.valueOf(a[1]),d=e<70?1:e==83?2:e>86?3:0,i=0;
        for(;i<a[3].length();d=c>81?(d+1)%4:c<77?(d+3)%4:d){
            c=a[3].charAt(i++);
            if(c==77){
                x=d==1?x+1:d>2?x-1:x;
                y=d<1?y+1:d==2?y+1:y;
            }
        }
        System.out.print(x+","+y+","+z[d]);
    }
}

Wie bei Java üblich, analysiert etwa die Hälfte davon nur die Eingabe und bildet die Ausgabe. Die Logik ist ziemlich einfach.

Javascript (E6) 175

Edit Behobener Fehler, möglicherweise außerhalb des Bereichs liegender Rückgabewert für d

139 Logik, 36 E / A

F=(x,y,d,m,D='NESW')=>(d=D.search(d),[...m].map(s=>({M:_=>(y-=[-1,0,1,0][d],x-=[0,-1,0,1][d]),R:_=>d+=1,L:_=>d+=3}[s](),d%=4)),[x,y,D[d]]);
p=prompt,p(F(...p().split(','),p()))

Basic ungolfed

function F(x,y,d,m) // In golf code use arrow sintax instead of 'function'
{
  var D='NESW';
  d = D.search(d); // map from letters to offset position 0..3
  var driver = { // driver object, each function map one of  command letters M,R,L
    M: function() { 
      y -= [-1, 0, 1, 0][d]; // subtract to be sure to have a numeric and not string result 
      x -= [0, -1, 0, 1][d]; // subtract to be sure to have a numeric and not string result 
    },
    R: function() {
       d += 1;
    },
    L: function() {
       d += 3; // with modulo 4 will be like -= 1
    }
  }
  m = [...m]; // string to array, to use iteration function 
  m.forEach(  // array scan, in golf versione use map do nearly the same and is shorter
    function (s) {
      driver[s](); // call driver function
      d = d % 4;   // restrict value to modulo 4
    }
  );  // in golf version, use comma separated expression to avoid 'return'
  return [x,y, D[d]] // return last status
}

Test Test in der Javascript-Konsole in Firefox. Es ist einfacher, die Funktion F zu testen und Popups zu vermeiden.

F(1,2,'N','MRMLM')

Ausgabe

[ 2, 4, "N" ]

C 164 180 186

Edit Festes Eingabeformat und entferntes strchr
Edit Entferntes Offset-Array, berechnet mit Bits

p,x,y;main(){char c,d,l[100];scanf("%d,%d,%c%s",&x,&y,&d,l);for(d=d<83?d&1:d>>2&1|2;c=l[p++];d&=3)c-77?d+=c+1:d&1?x+=d-2:(y+=1-d);printf("%d %d %c",x,y,"NESW"[d]);}

Ungolfed

p, x, y;
main()
{
  char c, d, l[100];
  scanf("%d,%d,%c%s",&x,&y,&d,l);
  for (d = d<'S'?d&1:d>>2&1|2; c = l[p++]; d &= 3)
    c-'M'
    ? d += c+1
    : d & 1 ? x+=d-2 : (y+=1-d);
  printf("%d %d %c", x, y, "NESW"[d]);
} 
/*
M 77
R 82 0101 0010 R&3+1==3
L 76 0100 1100 L&3+1==1 
*/

C 148, 150, 151

p,x[2];main(){char c,d,l[99],*j="%d,%d,%c%s";scanf(j,x,x+1,&d,l);for(d=d%8%5;c=l[p++];d-=c%23)x[d&1]-=c%2*~-(d&2);printf(j,*x,x[1],"ENWS"[d&3],"");}

Eine Optimierung der @ edc65-Lösung, um meinen ASCII-Wertmissbrauchsansatz zu verwenden.

Speziell:

• d%8%5ordnet die Zeichen ENWSauf 0,1,2,3jeweils
• c%23verwandelt sich Lin 7, Min 8und Rin 13. Da d(die Richtungsvariable) immer Mod 4 verwendet wird, bewirkt dies effektiv, dass LSie -1 Mod 4 Mhinzufügen, 0 Mod 4 Rhinzufügen und 1 Mod 4 hinzufügen.
• d&1ist 1 für NSund 0 für EWRichtungen.
• d&2ist 2 für WSund 0 für NERichtungen.
• ~-(d&2)ist 1 für WSund -1 für NERichtungen.
• c%2ist 1 für Mund 0 für LR.

Python 3 (mit Schildkrötengrafiken), 251 199 Bytes

Weise Pythonisten, bitte seien Sie vorsichtig, denn dies ist mein allererster Versuch, ein Programm zu entwickeln, das in Ihrer feinen Sprache geschrieben ist.

Schildkröten auf dem Mars!

from turtle import*
p="NESW"
mode("logo")
x,y,d=input().split(',')
setx(int(x))
sety(int(y))
seth(p.find(d)*90)
for c in input():fd(1)if c=="M"else[lt,rt][c>'L'](90)
print(pos(),p[int(heading()/90)])

Diese Herausforderung lässt sich ganz natürlich auf Schildkrötengrafiken im Logo-Stil übertragen, für die Python natürlich von Bedeutung ist.

Liest die Eingabe von zwei Zeilen aus STDIN.

Ausgabe:

$ { echo 1,2,N; echo MRMLM; } | python ./rover.py 
(2.00,4.00) N
$ 

Was ich an diesem Programm besonders mag, ist, dass es den Weg des Rovers grafisch darstellt. Fügen Sie exitonclick()am Ende des Programms hinzu, damit die grafische Ausgabe so lange erhalten bleibt, bis der Benutzer auf Folgendes klickt:

Ich bin mir ziemlich sicher, dass dies deutlich mehr golfen werden kann - Anregungen sind willkommen! Ich mache dieses CW, weil ich hoffe, dass die Community noch mehr Golf spielen kann.

Änderungen:

• s ist jetzt eine Liste, inline.
• Benutzt ternary für body of for loop.
• Inline n, unnötige Scheibe entfernt.
• Unnötiger Speicherplatz in der Importanweisung entfernt.
• Import-String wurde entfernt, um die eingebaute String-Methode zu verwenden
• Auf Python 3 umgestellt, um raw_input zu verkürzen

GolfScript, 116 98 88 84 71

~'NESW':^@?:&;{4%[{&(4%:&;}{&[{)}{\)\}{(}{\(\}]=~}{&)4%:&;}]=~}/]`&^1/=

Dies sollte die Koordinaten und die Anweisungen als Argumente die folgende Weise erhalten: 1 2 'N' 'MRMLM'. Die Argumente werden in eine Zeichenfolge umgewandelt und in den Stapel verschoben.

Wenn Sie dies online testen möchten, gehen Sie zu Webgolfscript und fügen Sie ein Semikolon gefolgt von einer Zeichenfolge mit den Argumenten (z. B. ;"1 2 'N' 'MRMLM'") vor dem Code ein ( hier ein Link mit einem Beispiel).

Beispiele für die Ausgabe:

1 2 'N' 'MRMLM'                    -> [2 4]N  
5 6 'E' 'MMLMRMRRMMML'             -> [5 7]S
1 2 'N' 'MMMMRLMRLMMRMRMLMRMRMMRM' -> [1 8]N

Meine bisherigen Versuche

84 Zeichen:

~:i;'NESW':k\?:d;{i(\:i;4%[{d(4%:d;}{d[{)}{\)\}{(}{\(\}]=~}{d)4%:d;}]=~i}do]`d k 1/=

88 Zeichen:

~:i;'NESW':k\?:d;{i(\:i;'MRL'?[{d[{)}{\)\}{(}{\(\}]=~}{d)4%:d;}{d(4%:d;}]=~i}do]`d k 1/=

98 Zeichen:

 ~1/:i;:d;{'NESW'd?}:k;{k[{)}{\)\}{(}{\(\}]=~}:M;{k'ESWN'1/=:d;}:R;{k'WNES'1/=:d;}:L;{i(\:i;~i}do d

116 Zeichen:

[~])\~"NESW":k 1/:d?{d(1/+:d;}:f*:y;:x;{("MRL"?[{k d 0=?[{y):y}{x):x}{y(:y}{x(:x}]=~;}{f}{d)1/\+:d;}]=~.}do x y d 0=

Delphi (819)

Als ich anfing, war es noch kein Code-Golf . Wird später bearbeitet.

Ich kann jedoch keinen Compiler online finden.

uses SysUtils;type TDirection = (dNorth, dEast, dSouth, dWest);var x,y:int64;dir:TDirection;input:string;c:char;function gd(C:Char):TDirection;var o:integer;begin o:=ord(dir);if C='L'then o:=o-1else if c='R'then o:=o+1else if c='N'then exit(dNorth)else if c='E'then exit(dNorth)else if c='S'then exit(dNorth)else if c='W'then exit(dNorth);if o>3 then exit(dNorth);if o<0 then exit(dWest);exit(TDirection(o))end;function DirLetter:string;begin if dir=dNorth then exit('N');if dir=dEast then exit('E');if dir=dSouth then exit('S');if dir=dWest then exit('W');end;begin Readln(x,y,input);dir := gd(Input[1]);readln(Input);Input:=UpperCase(Input);for C in Input do begin if C<>'M' then dir:=gd(C)else case dir of dNorth:y:=y+1;dEast:x:=x+1;dSouth:y:=y-1;dWest:x:=x-1;end;end;writeln(Format('%d,%d,%s',[x,y,DirLetter]));end.

Ungolfed

uses
  SysUtils;
type
  TDirection = (dNorth, dEast, dSouth, dWest);

var
  x,y:int64;
  dir:TDirection;
  input:string;
  c:char;

  function gd(C:Char):TDirection;
  var
    o:integer;
  begin
    o:=ord(dir);
    if C='L' then
      o:=o-1
    else if c='R' then
      o:=o+1
    else if c='N' then
      exit(dNorth)
    else if c='E' then
      exit(dNorth)
    else if c='S' then
      exit(dNorth)
    else if c='W' then
      exit(dNorth);

    if o>3 then exit(dNorth);
    if o<0 then exit(dWest);
    exit(TDirection(o))
  end;
  function DirLetter:string;
  begin
    if dir=dNorth then exit('N');
    if dir=dEast then exit('E');
    if dir=dSouth then exit('S');
    if dir=dWest then exit('W');
  end;
begin
  Readln(x,y,input);
  dir := gd(Input[1]);
  readln(Input);
  Input:=UpperCase(Input);
  for C in Input do
  begin
    if C<>'M' then
      dir:=gd(C)
    else
      case dir of
        dNorth:y:=y+1;
        dEast:x:=x+1;
        dSouth:y:=y-1;
        dWest:x:=x-1;
      end;
  end;
  writeln(Format('%d,%d,%s',[x,y,DirLetter]));
end.

Javascript (353)

Dies ist mein erster wirklicher Versuch, Code Golf zu spielen, scheint zumindest zu funktionieren!

var xx=[0,1,0,-1];var yy=[1,0,-1,0];var d=["N","E","S","W"];var e=0;var x,y=0;function sa(p){q=p.split(",");x=+q[0];y=+q[1];e=+d.indexOf(q[2]);}function sb(t){var g=t.split(",");for(var u=0;u<g.length;u++){if(g[u]=='R'){e++;if(e>3)e=0;}if(g[u]=='L'){e--;if(e<0)e=3;}if(g[u]=='M'){x+=+xx[e];y+=+yy[e];}}alert(x+","+y+","+d[e]);}sa(prompt());sb(prompt());

Python (263)

input =  raw_input("Initial: ")
input2 = raw_input("Command: ")

position = [int(input[0]), int(input[2]), input[4]]

bearings = "NESW"
turns = {"L" : -1, "M": 0, "R" : 1}
move = {"N" : [0, 1], "E" : [1, 0], "S" : [0, -1], "W" : [-1, 0]}

for c in input2:
    turn = turns[c];
    if (turn == 0):
        position[0] += move[position[2]][0]
        position[1] += move[position[2]][1]
    else:
        position[2] = bearings[(bearings.index(position[2]) + turn)%4]

print "Output: ", ','.join((str(s) for s in position))

Es muss auch eine elegantere Art geben, es braucht nicht den Zweig nach dem anderen.

http://ideone.com/eD0FwD

Die Eingabe ist schrecklich, ich wollte es tun split(','), stieß aber auf Casting-Probleme zwischen Ints und Strings. Idealerweise wollte ich auch die alte Position mit der Bewegungsposition hinzufügen ... oh, es ist jetzt Code-Golf. Na ja, was auch immer, ich werde es hier lassen, könnte Inspiration geben. Andere Ideen, die ich hatte, waren Modulo 4 der Richtung, nachdem ich die anfängliche Peilung einem Index zugeordnet hatte. Verschmelzen Sie auch die Runden und verschieben Sie die Arrays zu einer, da keiner der Schlüssel kollidiert.

Trotzdem ist es 263, Variablennamen zu verkürzen und Leerzeichen zu entfernen:

i=raw_input()
j=raw_input()
p=[int(i[0]),int(i[2]),i[4]]
b="NESW"
m={"N":[0,1],"E":[1,0],"S":[0,-1],"W":[-1,0],"L":-1,"M":0,"R":1}
for c in j:
    if (m[c]==0):
        p[0]+=m[p[2]][0]
        p[1]+=m[p[2]][1]
    p[2] = b[(b.index(p[2])+m[c])%4]
print ','.join(str(s) for s in p)

Python 2.7 - 197 192 Bytes

q='NESW';x,y,d=raw_input().split(',');x=int(x);y=int(y);d=q.find(d);v={0:'y+',1:'x+',2:'y-',3:'x-'}
for c in raw_input():exec['d+','d-',v[d]]['RL'.find(c)]+'=1;d=d%4'
print`x`+','+`y`+','+q[d]

Ich bin wirklich super stolz auf diesen.

Erläuterung

Lassen Sie uns zuerst dieses Durcheinander beseitigen. Ich habe an vielen Stellen Semikolons anstelle von Zeilenumbrüchen verwendet, weil ich denke, das macht mich cool. Hier ist es normalerweise (das sind immer noch 197 Bytes, es wurde überhaupt nicht ungolfed). Ja, es gibt immer noch ein Semikolon, aber dieses speichert tatsächlich ein Byte.

q='NESW'
x,y,d=raw_input().split(',')
x=int(x)
y=int(y)
d=q.find(d)
v={0:'y+',1:'x+',2:'y-',3:'x-'}
for c in raw_input():m=v[d];exec['d+','d-',m]['RL'.find(c)]+'=1;d=d%4'
print`x`+','+`y`+','+q[d]

Lass uns anfangen!

q='NESW'

Zuerst definieren wir qals die Zeichenfolge 'NESW'. Wir verwenden es zweimal später und len("q='NESW';qq") < len("'NESW''NESW'").

x,y,d=raw_input().split(',')

Hier teilen wir die erste Zeile der Eingabe an jedem Komma. Unsere x-Koordinate ist in x, y in yund der erste Buchstabe unserer Richtung in gespeichert d.

x=int(x)
y=int(y)

Dann machen wir einfach die Koordinaten. (Ich war schockiert darüber, dass ich mir keine bessere Möglichkeit vorstellen konnte, zwei Zeichenfolgen in Ints umzuwandeln. Ich habe es versucht, x,y=map(int,(x,y))aber das wird länger.)

d=q.find(d)

Dies wandelt unsere Richtung in eine ganze Zahl um. 0 ist Norden, 1 ist Osten, 2 ist Süden und 3 ist Westen.

v={0:'y+',1:'x+',2:'y-',3:'x-'}

Hier beginnt der Spaß.

Wenn wir nach Norden gehen, erhöht sich Y um 1. Also nimmt dieses Wörterbuch 0 und gibt die Zeichenfolge 'y+'für " Y erhöhen ". Es gibt ähnliche Ergebnisse für andere Richtungen: y oder x gefolgt von + oder -.

Wir werden darauf zurückkommen.

for c in raw_input():
    m=v[d]
    exec['d+','d-',m]['RL'.find(c)]+'=1;d=d%4'

Ich bin in die Freiheit gegangen, diese ein wenig zu entgolfen.

Für jedes Zeichen in der zweiten Eingabezeile machen wir zwei Dinge. Zuerst setzen wir die Variable mauf das, was uns unser Wörterbuch für unsere aktuelle Richtung vorgibt. Es gibt keinen Grund, warum wir das jedes Mal brauchen, aber es ist einfacher, als es nur dann zu tun, wenn wir es brauchen.

Als nächstes haben wir eine Liste mit drei Elementen erstellen: 'd+', 'd-', und m. Anmerkung des Herausgebers: Ich denke, ich kann davonkommen, wenn ich die Variable müberhaupt nicht benutze . Ich denke, ich kann es einfach v[d]direkt in die Liste aufnehmen. Das spart mir ein paar Bytes, wenn es funktioniert, aber ich habe keine Lust, es zu testen, bis ich mit dieser Erklärung fertig bin, damit Sie damit umgehen können. (Ja, es hat funktioniert.)

Wir suchen das aktuelle Zeichen der Eingabe in der Zeichenfolge 'RL'. str.findGibt -1 zurück, wenn das Zeichen nicht gefunden wird. Dadurch wird ein R in eine 0, ein L in eine 1 und alles andere in -1 konvertiert. Die einzige andere Eingabe, die wir haben können, ist natürlich M, aber es sind weniger Zeichen, damit es für alles funktioniert.

Wir verwenden diese Nummer als Index für die von uns erstellte Liste. Python-Listenindizes beginnen am Ende, wenn sie negativ sind. Daher erhalten wir das erste Element, wenn die Eingabe R ist, das zweite, wenn es L ist, und das letzte, wenn es M ist. Der Einfachheit halber gehe ich davon aus Wir sind nach Norden ausgerichtet, aber ein ähnliches Prinzip gilt für andere Richtungen.

Die möglichen Werte, mit denen wir arbeiten, sind 'd+'für R, 'd-'für L und 'y+'für M. Dann hängen wir an '=1;d=d%4'das Ende jedes einzelnen an. Das heißt, unsere möglichen Werte sind ...

d+=1;d=d%4
d-=1;d=d%4
y+=1;d=d%4

Das ist gültiger Python-Code! Das ist gültiger Python-Code, der genau das tut, was wir für jedes dieser Eingabezeichen tun wollen! (Der d=d%4Teil hält unsere Anweisungen einfach in Ordnung. Wieder muss er nicht jedes Mal ausgeführt werden, aber es sind weniger Zeichen.)

Alles, was wir tun müssen, ist, den Code auszuführen, den wir für jedes Zeichen erhalten, ihn auszudrucken (unsere Richtung zurück in eine Zeichenkette umzuwandeln) und fertig!

C - 350

Speichern als rover.c:

#include<stdio.h>
#include<string.h>
#include<math.h>
int main(){char c,*C="NWSE-WN";float x,y,d,k=M_PI/2;scanf("%f,%f,%c",&x,&y,&c);d=(strchr(C,c)-C)*k;do{switch(getchar()){case'R':d+=k;break;case'L':d-=k;break;case'M':x+=sin(d);y+=cos(d);break;case EOF:printf("%g,%g,%c\n",x,y,C[(int)(sin(d)+2*cos(d)+4.5)]);}}while(!feof(stdin));return 0;}

Kompilieren:

gcc -o rover rover.c -lm

Probelauf:

$ echo 1,2,N MRMLM | ./rover
2,4,N

Ideone

Ungolfed:

#include <stdio.h>
#include <string.h>
#include <math.h>

int main()
{
    /* String is used for input and output, pi/2 == 90 degrees */
    char c, *C = "NWSE-WN";
    float x, y, d, k = M_PI/2;

    /* Get starting parameters */
    scanf("%f,%f,%c", &x, &y, &c);

    /* Convert the direction NWSE into radians */
    d = (strchr(C, c) - C) * k;

    /* Process each character */
    do
    {
        /* Recognize R(ight), L(eft), M(ove) or EOF */
        switch (getchar())
        {
            case 'R':
                /* Turn right 90 degrees */
                d += k;
                break;

            case 'L':
                /* Turn left 90 degrees */
                d -= k;
                break;

            case 'M':
                /* Advance 1 unit in the direction specified */
                x += sin(d);
                y += cos(d);
                break;

            case EOF:
                /* Output - formula is specially crafted so that S,E,W,N
                    map to indices 2,3,5,6 to reuse part of string */
                printf("%g,%g,%c\n", x, y, C[(int)(sin(d) + 2*cos(d) + 4.5)]);
        }
    }
    while (!feof(stdin));

    return 0;
}

Haskell - 412 Bytes

import Text.Parsec
import Text.Parsec.String
n='N'
s='S'
e='E'
w='W'
d(x,y,c)'M'|c==n=(x,y+1,c)|c==s=(x,y-1,c)|c==e=(x+1,y,c)|c==w=(x-1,y,c)
d(x,y,c)e=(x,y,i c e)
i 'N''R'=e
i 'N''L'=w
i 'S''R'=w
i 'S''L'=e
i 'E''R'=s
i 'E''L'=n
i 'W''R'=n
i 'W''L'=s
f=many digit
g=char ','
o=oneOf
main=interact(\s->show$parse(do x<-f;g;y<-f;g;c<-o"NSEW";newline;b<-many$o"MRL";return$foldl(\x c->d x c)(read x,read y,c)b)""s)

Getestet mit:

$ printf "1,2,N\nMRMLM" | ./rv
Right (2,4,'N')

Bash + Coreutils, 159 Bytes

t()(tr $2 0-3 $1<<<$d)
IFS=, read x y d
d=`t '' NESW`
for s in `fold -1`;{
[ $s = M ]&&((`t yxyx;t ++-`=1))||d=$[(d`tr LR -+<<<$s`1+4)%4]
}
echo $x,$y,`t NESW`

Die Eingabe wird aus 2 Zeilen STDIN gelesen.

Ausgabe:

$ { echo 1,2,N; echo MRMLM; } | ./rover.sh
2,4,N
$

PowerShell, 170 167 166

[int]$x,[int]$y,$e,$m="$input"-split'\W'
$d='NESW'.indexof($e)
switch([char[]]$m){'R'{$d++}'L'{$d--}'M'{iex(-split'$y++ $x++ $y-- $x--')[$d%4]}}
"$x,$y,"+'NESW'[$d%4]

Kann nicht scheinen, dieses unten weiter zu golfen, das ein bisschen peinlich ist. Aber all die offensichtlichen Hacks funktionieren hier nicht wirklich.

Ich kann nicht iexder Eingang , weil a) N, S, Eund Wmußten Funktionen werden für das zu arbeiten (oder ich Präfix brauchen würde , dass mit $und b) 1,2,Nmüßte die Parsen Nin der Expression - Modus nicht in der Lage zu sein , einen Befehl auszuführen .

Dies switchscheint der kürzeste Weg zu sein, die Bewegung auszuführen. Hash-Tabelle mit Skriptblöcken oder Strings ist auch nicht kürzer und für jeden anderen Weg, abgesehen vom switchOverhead der expliziten Schleife.

Ich kann das nicht loswerden, IndexOfweil eine Pipeline mit ?immer noch länger ist.

Ich kann die expliziten Typen in der anfänglichen Deklaration auch nicht loswerden, weil ich dort gemischte Typen habe, also |%{+$_}hilft ein einfaches nicht und jede andere Option ist länger.

Manchmal hasse ich die Eingabe in PowerShell.

Python, 135 137 138

S,W,N,E=0,1,2,3;a,b,d=input();v=[b,a]
for c in map(ord,raw_input()):d+=c%23;v[d&1]+=c%2*~-(d&2)
print'%d,%d,%s'%(v[1],v[0],'SWNE'[d&3])

Mißbräuche die ASCII - Werte L, Mund Rzu vermeiden alle bedingten Anweisungen.

Probieren Sie es in ideone .

Python 2.7, 170 149

N,E,S,W=q='NESW'
x,y,d=input()
d=q.find(d)
for c in raw_input():exec['d+','d-','yx'[d%2]+'+-'[d/2]]['RL'.find(c)]+'=1;d%=4'
print`x`+','+`y`+','+q[d]

Dinge, die ich vom Original geändert habe:

Mit Alias ​​raw_input wurde das v [d] -Wörterbuch, das sowieso eine Liste sein sollte, in eine Zeichenfolgenauswahl geändert %= .

Bearbeiten: Tupel entpacken und auswerten (raw_input ()) == input (), um 21 Zeichen zu speichern.

Stark von @undergroundmonorail ausgeliehen, aber mit vielen Verbesserungen.

Bash / SHELF ,243 235

" SHE ll go LF " ist eine Golfbibliothek für Bash, die einige nützliche Aliase bietet. Dies ist eine gültige Antwort, da die Bibliothek vorhanden war und sich vor dem Posten der Herausforderung auf GitHub befand.

Tut mir leid, ich kann das nicht auf ideone anwenden.

Wie läuft man?

Dies übernimmt die Anfangsposition (wie angegeben durch Kommas getrennt; dies fügt dem Code viele Zeichen hinzu) als erstes Argument und die Anweisungen zur Standardeingabe.

source shelf.sh #you must load SHELF first
source rover.sh 1,2,N<<<MRMLM #now run the script via source so it has access to SHELF

Beispielausgabe

2,4,N

Code

o=$1
D(){ o=`y NESW $1<<<$o`;}
for x in `Y . '& '`;{
d $x R&&D ESWN
d $x L&&D WNES
d $x M&&z=(`y , \ <<<$o`)&&case ${z[2]} in N) z[1]=$[z[1]+1];;S) z[1]=$[z[1]-1];;W) z[0]=$[z[0]-1];;E) z[0]=$[z[0]+1];;esac&&o=`P ${z[@]}|y \  ,`
}
p $o

Erläuterung

dist zum Vergleich; Es gibt 0 zurück, wenn die beiden Argumente gleich sind, und 1, andernfalls können andere Befehle mit &&und verkettet werden ||.

yist wie tr(aber fertig durch sed).

Yist wie sed 's/.../.../g'für seine zwei Argumente.

Pist echo -e -n; pist einfach echo -e.

o=$1 #save first argument to variable
D(){ o=`y NESW $1<<<$o`;} #define an alias to turn R or L
for x in `Y . '& '`;{ #add a space after every character on stdin and loop for each one
d $x R&&D ESWN #turn R using alias
d $x L&&D WNES #turn L using alias

Das nächste bisschen ist zutiefst hässlich, mit etwa 145 Zeichen in einer Zeile. Wenn der aktuelle Befehl M ist, setzen Sie die Kommas in $ o in Leerzeichen, konvertieren Sie sie in ein Array und speichern Sie sie in $ z. Dann machen Sie einen switch ... case-Block für das letzte Element von $ z (die Richtung, in die der Rover zeigt. Ändern Sie die Koordinaten entsprechend, konvertieren Sie dann $ z zurück in einen durch Kommas getrennten String und speichern Sie ihn in $ o.

d $x M&&z=(`y , \ <<<$o`)&&case ${z[2]} in N) z[1]=$[z[1]+1];;S) z[1]=$[z[1]-1];;W) z[0]=$[z[0]-1];;E) z[0]=$[z[0]+1];;esac&&o=`P ${z[@]}|y \  ,`
} #end loop
p $o #print output

Haskell, 291

data D=W|S|E|N deriving(Show,Read,Enum)
main=interact$(\(x,y)->tail$map show y++[show(toEnum x::D)]>>=(',':)).(\(a:b:_)->foldl(\(f,j@[g,h])i->case i of 'M'->(f,[g+rem(f-1)2,h+rem(f-2)2]);'L'->(mod(f+1)4,j);'R'->(mod(f-1)4,j))((\(c,d,e)->(fromEnum(e::D),[c::Int,d]))$read('(':a++")"))b).lines

Ich war mir nicht sicher, wie flexibel das Eingabe- und Ausgabeformat für Zeichenfolgen war, und stellte daher sicher, dass es genau wie im Beispiel aussah (natürlich ohne Eingabeaufforderungen), aber das fügte eine Menge zusätzlicher Zeichen hinzu. Ideone-Link

PHP - 224

Nun, ich habe es versucht.

$n=explode(",",$argv[1]);$d=($e=$n[2])==W?0:($e==N?1:($e==E?2:3));for(;$i<strlen($n[3]);)if(($o=$n[3][$i++])==M)$n[$d%2]+=$d>1?-1:1;else$d=$o==R?($d+1)%4:($d==0?3:$d-1);echo"{$n[0]},{$n[1]},".($d==1?N:($d==2?E:($d==3?S:W)));

Eingabe in STDIN, zB:

$ php mars_rover.php 1,2,N,MMMRRRRRMM
-1,5,E
$ php mars_rover.php 1,2,N,MMMMRLMRLMMRMRMLMRMRMMRM
1,8,N
$ php mars_rover.php 3,-2,W,MMMMLM
7,-3,S

Python3 (288)

Implementierung unter starkem Einsatz von ternären ifs.

m=['N','E','S','W']
cords=[int(n) for n in input().split()] + [input()] #Convert first inputs to integers and retrieve third
for n in input(): #Get instructions
    if n=='M':
        i=[1,0][cords[2] in m[1:3]] #See if vertical or horizontal
        j=[-1,1][cords[2] in m[0:2]] #See if negative or positive
        cords[i]+=j
    else:
        i=[-1,1][n=='R'] #Translate turn to numerals
        cords[2]=m[m.index(cords[2])+i] #Change direction relative to current orientation
print(cords)

Das Weglassen der offensichtlichen Eingabeprobleme und die Angabe der Richtungszeichenfolgen als Eigenwerte haben möglicherweise zu einer Verbesserung der Skriptgröße geführt. Der Ansatz hier ist jedoch vollkommen funktional (so glaube ich)

Python 3 (143)

I=input
a,b,D=I().split(',')
w='ENWS'
d=w.find(D)
x=int(a)+int(b)*1j
for c in I():x+=(c=='M')*1j**d;d+='ML'.find(c)
print(x.real,x.imag,w[d%4])

http://ideone.com/wYvt7J

Wir verwenden den in Python integrierten komplexen Zahlentyp, um das Koordinatenpaar zu speichern. Die Richtung wird bestimmt , indem die imaginäre Einheit berechnet 1jdie Kraft d, die die Richtung speichert 4. Rotierende mod erfolgt durch Inkrementieren oder Dekrementieren d. Der Ausdruck 'ML'.find(c)gibt den Betrag an, den wir ändern möchten d: 1für L, 0für Mund -1(der Standardwert für nicht gefunden) für R.

Python hat keine kurze Möglichkeit, eine komplexe Zahl in ein Tupel umzuwandeln, daher müssen wir teure Anrufe bei .realund tätigen .imag.