Sommario

Il compito è di navigare sul rover su Marte e dire le sue coordinate e direzione finali.

Ingresso:

Primo input:

Per prima cosa il tuo programma deve prendere l'input che sarà nel seguente formato:

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

La direzione deve essere: Noppure Soppure Eoppure W(lettere iniziali di nord, sud, ovest, est)

Esempio: 10,20,N(x = 10, y = 20, direction = N (North))

Secondo input:

Il secondo ingresso è costituito da serie di R, L, Mper destra, sinistra e spostare rispettivamente.

Per Re L(destra e sinistra) la direzione del rover deve cambiare di conseguenza.

Perché Mil rover deve muovere 1 unità in avanti nella direzione in cui era prima di muoversi.

Regole per il calcolo delle coordinate:

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

Produzione:

Le coordinate finali e la direzione corrente del rover.

Enter initial data:      1,2,N

Enter the instructions:  MRMLM

Output:                  2,4,N

Le coordinate possono essere qualsiasi numero intero e possono essere negative .

Non sono ammesse tutte le scappatoie standard. Se è possibile fornire demo su siti come http://ideone.com ecc., Quindi, per favore, in modo che io possa verificare :)

Questo è un concorso di popolarità, quindi sii creativo!

Seguendo il consiglio degli altri, decido di renderlo un codice-golf .

Rubino ≥ 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]]*?,

Questa soluzione può essere testata qui: https://ideone.com/C4PLdE

Nota che la soluzione collegata su ideone è più lunga di un carattere ( 1.ianziché 1inella riga 3). La ragione di ciò è che ideone supporta solo Ruby 1.9, che non consente la sintassi abbreviata per letterali complessi.

Javascript ( ES6 ) 145 141 127

Modifica: rimossa la necessità di un array di traduzione usando il metodo dalla soluzione C di edc65

[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 / Commentato:

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]);}}

Con spazi bianchi:

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]);
    }
}

Come al solito con Java, circa la metà di questo sta semplicemente analizzando l'input e formando l'output. La logica è piuttosto semplice.

Javascript (E6) 175

Modifica bug risolto, eventualmente fuori valore di ritorno per d

139 Logica, 36 I / O

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

Ungolfed di base

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 nella console JavaScript in Firefox. È più semplice testare la funzione F evitando i popup.

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

Produzione

[ 2, 4, "N" ]

C 164 180 186

Modifica Formato di input fisso e strchr rimosso
Modifica Offset array rimosso, calc usando i bit

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],"");}

Una modifica della soluzione di @ edc65 per utilizzare il mio approccio di abuso di valore ASCII.

In particolare:

• d%8%5mappe i personaggi ENWSdi 0,1,2,3, rispettivamente,
• c%23si trasforma Lin 7, Min 8e Rin 13. Poiché d(la variabile di direzione) viene sempre utilizzata la mod 4, ciò fa effettivamente Laggiungere -1 mod 4, Maggiungere 0 mod 4 e Raggiungere 1 mod 4.
• d&1è 1 per NSe 0 per le EWdirezioni.
• d&2è 2 per WSe 0 per le NEdirezioni.
• ~-(d&2)è 1 per WSe -1 per le NEdirezioni.
• c%2è 1 per Me 0 per LR.

Python 3 (con grafica tartaruga), 251 199 byte

Pitonisti saggi, per favore sii gentile, perché questo è il mio primo tentativo in assoluto di un programma scritto nella tua lingua.

Tartarughe su Marte!

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

Questa sfida si associa in modo abbastanza naturale alla grafica tartaruga in stile logo, per la quale Python ha un'importanza, ovviamente.

Legge l'input da due righe da STDIN.

Produzione:

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

Quello che mi piace particolarmente di questo programma è che mostra graficamente il percorso del rover. Aggiungi exitonclick()alla fine del programma in modo che l'output grafico persista fino a quando l'utente non fa clic:

Sono abbastanza sicuro che questo può essere giocato a golf in modo molto più - qualsiasi suggerimento benvenuto! Sto realizzando questo CW, perché spero che la community possa giocarci ancora un po '.

I cambiamenti:

• s è ora un elenco, in linea.
• Ternario usato per body of for loop.
• Inline n, rimosso porzione non necessaria.
• Rimosso spazio non necessario nell'istruzione import.
• Rimossa la stringa di importazione per utilizzare il metodo stringa incorporato
• Passato a Python 3 per abbreviare raw_input

GolfScript, 116 98 88 84 71

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

Questo dovrebbe ottenere le coordinate e le istruzioni come argomenti nel modo seguente:1 2 'N' 'MRMLM' . Gli argomenti vengono trasformati in una stringa e inseriti nello stack.

Se vuoi testarlo online, vai sul web golfscript e incolla un punto e virgola seguito da una stringa con gli argomenti (es. ;"1 2 'N' 'MRMLM'") Prima del codice ( ecco un link con un esempio).

Esempi di output:

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

I miei tentativi precedenti

84 caratteri:

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

88 caratteri:

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

98 caratteri:

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

116 caratteri:

[~])\~"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=

Delfi (819)

Quando ho iniziato non era ancora un gioco da golf . Modificherà più tardi.

Tuttavia, non riesco a trovare un compilatore online.

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)

Questo è il mio primo vero tentativo di code golf, sembra funzionare almeno!

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

Ci deve essere anche un modo più elegante per farlo, non ha bisogno del ramo dopo l'altro.

http://ideone.com/eD0FwD

L'input è terribile, volevo farlo split(',')ma ho riscontrato problemi di casting tra gli ints e gli archi. Idealmente, volevo anche aggiungere la vecchia posizione con la posizione in movimento ... oh, adesso è code-golf. Vabbè, lo lascerò qui, potrebbe dare ispirazione. Altre idee che avevo erano di usare il modulo 4 della direzione dopo aver mappato il rilevamento iniziale su un indice. Unendo anche i turni e spostando le matrici su una poiché nessuna delle chiavi si scontra.

anche così, accorciando i nomi delle variabili e rimuovendo gli spazi è 263:

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 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():exec['d+','d-',v[d]]['RL'.find(c)]+'=1;d=d%4'
print`x`+','+`y`+','+q[d]

Sono davvero super orgoglioso di questo.

Spiegazione

Per prima cosa, puliamo questo casino. Ho usato i punti e virgola anziché le interruzioni di riga in molti punti perché penso che mi renda cool. Qui è normalmente (questo è ancora 197 byte, non è stato affatto non salvato). Sì, c'è ancora un punto e virgola, ma quello effettivamente salva un 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]

Cominciamo!

q='NESW'

Per prima cosa definiamo qla stringa 'NESW'. Lo usiamo due volte dopo, e len("q='NESW';qq") < len("'NESW''NESW'").

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

Qui dividiamo la prima riga di input in ogni virgola. Il nostro x coord è memorizzato in x, y in ye la prima lettera della nostra direzione in d.

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

Quindi facciamo solo le coordinate. (Sono rimasto scioccato dal fatto che non riuscivo a pensare a un modo migliore per convertire due stringhe in ints. Ci ho provato x,y=map(int,(x,y))ma questo risulta essere più lungo.)

d=q.find(d)

Questo converte la nostra direzione in un numero intero. 0 è nord, 1 è est, 2 è sud e 3 è ovest.

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

È qui che inizia il divertimento.

Quando andiamo a nord, Y aumenta di 1. Quindi questo dizionario prende 0 e fornisce la stringa 'y+', per "aumentare y". Fornisce risultati simili per altre direzioni: y o x seguito da + o -.

Torneremo su questo.

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

Sono andato alla libertà di liberare leggermente questo.

Per ogni personaggio nella seconda riga di input, facciamo due cose. Innanzitutto, impostiamo la variabile msu qualunque cosa il nostro dizionario di prima ci dia per la nostra direzione attuale. Non c'è motivo per cui abbiamo bisogno che ciò accada ogni volta, ma è più semplice che farlo accadere quando ne abbiamo bisogno.

Successivamente, creiamo una lista con tre elementi: 'd+', 'd-', e m. NOTA DELL'EDITOR: Penso di poter fare a meno di non usare affatto la variabile m. Penso di poter semplicemente inserire v[d]la lista direttamente. Questo mi farà risparmiare un paio di byte se funziona, ma non ho voglia di provarlo fino a quando non avrò fatto questa spiegazione in modo che tutti voi possiate occuparvi. (Sì, ha funzionato.)

Cerchiamo il carattere corrente dell'input nella stringa 'RL'. str.findrestituisce -1 se non trova il carattere, quindi converte una R in 0, una L in 1 e qualsiasi altra cosa in -1. Ovviamente, l'unico altro input che possiamo avere è M, ma sono meno i caratteri a farlo funzionare per tutto.

Usiamo quel numero come indice per l'elenco che abbiamo creato. Gli indici dell'elenco Python iniziano alla fine se sono negativi, quindi otteniamo il primo elemento se l'input è R, il secondo se è L e l'ultimo se è M. Per comodità, sto per supporre che siamo rivolti a nord, ma un principio simile si applica per altre direzioni.

I possibili valori con cui stiamo lavorando sono 'd+'per R, 'd-'per L e 'y+'per M. Quindi, assegniamo '=1;d=d%4'alla fine di ognuno. Ciò significa che i nostri possibili valori sono ...

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

Questo è un codice Python valido! Questo è un codice Python valido che fa esattamente quello che vogliamo fare per ciascuno di quei caratteri di input! (La d=d%4parte mantiene sane le nostre indicazioni. Ancora una volta, non è necessario farlo ogni volta, ma sono meno personaggi.)

Tutto quello che dobbiamo fare è eseguire il codice che otteniamo per ogni personaggio, stamparlo (riconvertendo la nostra direzione in una stringa) e il gioco è fatto!

C - 350

Salva come 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;}

Compilare:

gcc -o rover rover.c -lm

Esecuzione di esempio:

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

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)

Testato con:

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

Bash + coreutils, 159 byte

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`

L'ingresso viene letto da 2 righe di STDIN.

Produzione:

$ { 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]

Non riesco a giocare a golf più in basso, il che è un po 'imbarazzante. Ma tutti gli hack ovvi non funzionano davvero qui.

Non posso iexall'ingresso perché a) N, S, Ee Wdovrebbe essere funzioni che di lavoro (o avrei bisogno di prefisso che con $e b) 1,2,Navrebbe dovuto analizzare la Nmodalità di espressione, non essendo in grado di eseguire un comando .

L' switchsembra essere la via più breve di fare del movimento. La tabella di hash con blocchi di script o stringhe non è neanche più breve e, a parte il contrario, switchavrei il sovraccarico del ciclo esplicito.

Non riesco a liberarmene IndexOfperché una pipeline con ?è più lunga, ancora.

Inoltre, non posso liberarmi dei tipi espliciti nella dichiarazione iniziale perché ho tipi misti lì, quindi un semplice |%{+$_}non aiuta e ogni altra opzione è più lunga.

A volte odio la gestione degli input 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])

Abusi i valori ASCII di L, Me Rper evitare l'uso di eventuali istruzioni condizionali.

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

Cose che ho cambiato dall'originale:

Alias ​​raw_input, ha modificato il dizionario v [d], che avrebbe comunque dovuto essere un elenco, in una selezione di stringhe, utilizzata %=.

Modifica: usato tuple unpacking and eval (raw_input ()) == input () per salvare 21 caratteri.

Molto preso in prestito da @undergroundmonorail, ma con molti miglioramenti.

Bash / SHELF ,243 235

" SHE ll go LF " è una biblioteca di golf per Bash che fornisce alcuni alias utili. Questa è una risposta valida in quanto esisteva la libreria ed era su GitHub prima che la sfida fosse pubblicata.

Mi dispiace, non riesco a farlo funzionare su ideone.

Come correre

Questo prende la posizione iniziale (separata da virgole come specificato; questo aggiunge molti caratteri al codice) come primo argomento e le istruzioni sull'input standard.

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

Uscita campione

2,4,N

Codice

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

Spiegazione

dè per confronto; restituisce 0 se i suoi due argomenti sono uguali e 1 altrimenti, può quindi avere altri comandi concatenati con &&e ||.

yè come tr(ma fatto attraverso sed).

Yè come sed 's/.../.../g'per i suoi due argomenti.

Pè echo -e -n; pè giusto 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

Il prossimo passo è profondamente brutto, con circa 145 caratteri su una riga. Se il comando corrente è M, trasforma le virgole in $ o in spazi, converti in array e salva in $ z. Quindi, fai un interruttore ... blocco maiuscole per l'ultimo elemento di $ z (la direzione indicata dal rover. Cambia le coordinate di conseguenza, quindi converti $ z in una stringa separata da virgola e salva 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

Non ero sicuro di quanto fosse flessibile il formato della stringa di input e output, quindi mi sono assicurato che fosse esattamente come nell'esempio (meno i prompt, ovviamente), ma ciò ha aggiunto molti caratteri extra. Collegamento Ideone

PHP - 224

Beh, ci ho provato.

$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)));

Inserire in STDIN, ad es .:

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

Implementazione usando un uso intenso di if ternari.

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)

Se si omettono gli ovvi input di input, il valore intrinseco delle stringhe di direzione può aver beneficiato delle dimensioni dello script. Tuttavia, l'approccio qui è perfettamente funzionale (quindi credo)

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

Usiamo il tipo di numero complesso incorporato di Python per memorizzare la coppia di coordinate. La direzione viene calcolata portando l'unità immaginaria 1jalla potenza di d, che memorizza la direzione mod 4. La rotazione viene eseguita aumentando o decrementando d. L'espressione 'ML'.find(c)indica la quantità che vogliamo modificare d: 1for L, 0for Me -1(impostazione predefinita per non trovata) per R.

Python non ha un modo breve per convertire un numero complesso in una tupla, quindi dobbiamo effettuare chiamate costose a .reale .imag.