Sumário

A tarefa é navegar no veículo espacial de Marte e informar suas coordenadas e direção finais.

Entrada:

Primeira entrada:

Primeiro, seu programa deve receber a entrada que estará no seguinte formato:

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

A direção deve ser: Nou Sou EouW (letras iniciais de norte, sul, oeste, leste)

Exemplo: 10,20,N (x = 10, y = 20, direção = N (Norte))

Segunda entrada:

A segunda entrada consiste em série de R, L,M para a direita, para a esquerda e mover respectivamente.

Para ReL (direita e esquerda), a direção do rover deve mudar de acordo.

Para M o rover deve mover 1 unidade à frente na direção em que estava antes de se mover.

Regras para o cálculo de coordenadas:

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

Resultado:

As coordenadas finais e a direção atual do veículo espacial.

Enter initial data:      1,2,N

Enter the instructions:  MRMLM

Output:                  2,4,N

As coordenadas podem ser qualquer número inteiro e podem ser negativas .

Todas as brechas padrão não são permitidas. Se for possível fornecer demonstração em sites como http://ideone.com etc., faça-o, para que eu possa verificar :)

Este é um concurso de popularidade, então seja criativo!

Seguindo o conselho de outras pessoas, decido fazer disso um código de golfe .

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

Esta solução pode ser testada aqui: https://ideone.com/C4PLdE

Observe que a solução vinculada ao ideone tem um caractere a mais (em 1.ivez da 1ilinha 3). A razão para isso é que o ideone suporta apenas o Ruby 1.9, que não permite a sintaxe abreviada de literais complexos.

Javascript ( ES6 ) 145 141 127

Edit: Removida a necessidade de uma matriz de conversão usando o método da solução C do 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]])

Sem Golfe / Comentado:

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

Com espaço em branco:

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

Como de costume no Java, cerca da metade disso é apenas analisar a entrada e formar a saída. A lógica é bastante direta.

Javascript (E6) 175

Editar bug corrigido, possivelmente fora do intervalo, retornar valor para d

139 Lógica, 36 E / S

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
}

Teste Teste no console javascript no Firefox. É mais simples testar a função F, evitando os pop-ups.

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

Resultado

[ 2, 4, "N" ]

C 164 180 186

Editar Formato de entrada fixo e strchr removido
Editar Array de deslocamento removido, calculado usando 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],"");}

Uma emenda na solução do @ edc65 para usar minha abordagem de abuso de valor ASCII.

Especificamente:

• d%8%5mapeia os caracteres ENWSpara 0,1,2,3respectivamente
• c%23se transforma Lem 7, Mem 8e Rem 13. Como d(a variável de direção) é sempre usada o mod 4, isso efetivamente Ladiciona -1 mod 4, Madiciona 0 mod 4 e Radiciona 1 mod 4.
• d&1é 1 para NSe 0 para EWinstruções.
• d&2é 2 para WSe 0 para NEinstruções.
• ~-(d&2)é 1 para WSe -1 para NEdireções.
• c%2é 1 para Me 0 para LR.

Python 3 (com gráficos de tartaruga), 251 199 bytes

Pythonistas sábios, por favor, seja gentil, pois esta é minha primeira tentativa de um programa escrito em sua linguagem refinada.

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

Esse desafio é mapeado naturalmente para gráficos de tartarugas no estilo de logotipo, para os quais o python é importante, é claro.

Lê entrada de duas linhas de STDIN.

Resultado:

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

O que mais gosto neste programa é que ele exibe graficamente o caminho do veículo espacial. Adicione exitonclick()ao final do programa para que a saída gráfica persista até o usuário clicar:

Tenho certeza de que isso pode ser jogado muito mais - qualquer sugestão bem-vinda! Estou fazendo esse CW, porque espero que a comunidade possa jogar um pouco mais.

Alterar:

• s agora é uma lista, embutida.
• Ternário usado para o corpo do loop for.
• N embutido, fatia desnecessária removida.
• Removido espaço desnecessário na declaração de importação.
• Removida a cadeia de importação para usar o método de cadeia interna
• Comutado para Python 3 para reduzir o raw_input

GolfScript, 116 98 88 84 71

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

Isto deve obter as coordenadas e as instruções de como argumentos da seguinte forma: 1 2 'N' 'MRMLM'. Os argumentos são transformados em uma sequência e empurrados para a pilha.

Se você quiser testar isso on-line, vá para web golfscript e cole um ponto-e-vírgula seguido de uma string com os argumentos (por exemplo ;"1 2 'N' 'MRMLM'") antes do código ( aqui está um link com um exemplo).

Exemplos de saída:

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

Minhas tentativas anteriores

84 caracteres:

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

88 caracteres:

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

98 caracteres:

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

116 caracteres:

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

Quando eu comecei, não era um código de golfe . Editará mais tarde.

Não é possível encontrar um compilador 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)

Esta é minha primeira tentativa real no código de golfe, parece funcionar pelo menos!

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

Também deve haver uma maneira mais elegante de fazer isso, pois não precisa do ramo depois do resto.

http://ideone.com/eD0FwD

A entrada é horrível, eu queria fazê-lo, split(',')mas me deparei com problemas de transmissão entre as entradas e as cordas. Idealmente, eu também queria adicionar a posição antiga à posição móvel ... ah, agora é código-golfe. Oh bem, seja como for, vou deixar aqui, pode dar inspiração. Outras idéias que tive foram usar o módulo 4 da direção depois de mapear o rumo inicial para um índice. Também mesclando os turnos e as matrizes de movimentação para uma, pois nenhuma das teclas colide.

mesmo assim, encurtar nomes de variáveis ​​e remover espaços é 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 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]

Na verdade, estou super orgulhosa desse.

Explicação

Primeiro, vamos limpar essa bagunça. Usei ponto e vírgula em vez de quebras de linha em muitos lugares porque acho que isso me deixa legal. Aqui está normalmente (ainda são 197 bytes, não foi totalmente destruído). Sim, ainda há um ponto e vírgula, mas esse realmente salva um 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]

Vamos começar!

q='NESW'

Primeiro, definimos qcomo a string 'NESW'. Nós o usamos duas vezes depois, e len("q='NESW';qq") < len("'NESW''NESW'").

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

Aqui, dividimos a primeira linha de entrada em cada vírgula. Nosso x coord é armazenado em x, y in ye a primeira letra de nossa direção em d.

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

Então nós apenas fazemos os coords ints. (Fiquei chocado por não conseguir pensar em uma maneira melhor de converter duas seqüências de caracteres em ints. Tentei, x,y=map(int,(x,y))mas isso acabou sendo mais longo.)

d=q.find(d)

Isso converte nossa direção em um número inteiro. 0 é norte, 1 é leste, 2 é sul e 3 é oeste.

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

Aqui é onde a diversão começa.

Quando vamos para o norte, Y aumenta em 1. Portanto, este dicionário recebe 0 e fornece a string 'y+'para "aumentar y". Ele fornece resultados semelhantes para outras direções: y ou x seguido de + ou -.

Voltaremos a isso.

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

Eu tenho a liberdade de desenterrar este aqui um pouco.

Para cada caractere na segunda linha de entrada, fazemos duas coisas. Primeiro, definimos a variável mcomo qualquer que seja o nosso dicionário anterior nos fornece a nossa direção atual. Não há razão para que isso aconteça sempre, mas é mais fácil do que fazer acontecer quando precisamos.

Em seguida, criamos uma lista com três elementos: 'd+', 'd-', e m. NOTA DO EDITOR: Eu acho que posso me safar de não usar a variável m. Eu acho que posso simplesmente colocar v[d]na lista diretamente. Isso me poupará alguns bytes, se funcionar, mas não sinto vontade de testá-lo até concluir esta explicação para que vocês possam lidar. (Sim, funcionou.)

Procuramos o caractere atual da entrada na string 'RL'. str.findretorna -1 se não encontrar o caractere; portanto, isso converte um R em 0, um L em 1 e qualquer outra coisa em -1. Obviamente, a única outra entrada que podemos ter é M, mas são menos caracteres para fazê-lo funcionar para tudo.

Usamos esse número como índice da lista que criamos. Os índices da lista Python começam no final se forem negativos, então obtemos o primeiro elemento se a entrada for R, o segundo se for L e o último se for M. Por uma questão de conveniência, estou prestes a assumir que estamos voltados para o norte, mas um princípio semelhante se aplica a outras direções.

Os possíveis valores com os quais trabalhamos são 'd+'para R, 'd-'para L e 'y+'para M. Em seguida, anexamos '=1;d=d%4'ao final de cada um. Isso significa que nossos possíveis valores são ...

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

Esse é um código python válido! Esse é um código python válido que faz exatamente o que queremos fazer para cada um desses caracteres de entrada! (A d=d%4parte apenas mantém nossas orientações sãs. Novamente, não é necessário fazer isso todas as vezes, mas são menos caracteres.)

Tudo o que precisamos fazer é executar o código que obtemos para cada caractere, imprimi-lo (convertendo nossa direção de volta para uma string) e pronto!

C - 350

Salvar como 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;}

Compilar:

gcc -o rover rover.c -lm

Exemplo de execução:

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

Testado com:

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

A entrada é lida a partir de 2 linhas de STDIN.

Resultado:

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

Não consigo jogar golfe ainda mais, o que é um pouco embaraçoso. Mas todos os hacks óbvios realmente não funcionam aqui.

Eu não posso iexa entrada porque a) N, S, Ee Wteria que ser funções para que funcione (ou eu preciso prefixo que com $e b) 1,2,Nteria que analisar oN no modo de expressão, não ser capaz de executar um comando .

A switchparece ser o caminho mais curto de fazer o movimento. A tabela de hash com blocos ou seqüências de caracteres de script não é mais curta e para todos os outros aspectos além doswitch eu teria a sobrecarga do loop explícito.

Não consigo me livrar do IndexOfporque um pipeline com? ainda é mais longo.

Também não consigo me livrar dos tipos explícitos na declaração inicial porque misturei tipos lá, portanto, um simples |%{+$_}não ajuda e todas as outras opções são mais longas.

Às vezes eu odeio manipulação de entrada no 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])

Abusos os valores ASCII de L, Me Rpara evitar o uso de quaisquer declarações condicionais.

Experimente em 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]

Coisas que mudei do original:

Alias ​​raw_input, alterou o dicionário v [d], que deveria ter sido uma lista de qualquer maneira, para alguma seleção de string, usada %=.

Editar: desempacotou a tupla e eval (raw_input ()) == input () para salvar 21 caracteres.

Muito emprestado do @undergroundmonorail, mas com muitas melhorias.

Bash / SHELF ,243 235

" SHE ll go LF " é uma biblioteca de golfe do Bash que fornece alguns aliases úteis. Esta é uma resposta válida, pois a biblioteca existia e estava no GitHub antes do lançamento do desafio.

Desculpe, não consigo fazer isso funcionar em ideone.

Como executar

Isso toma a posição inicial (separada por vírgulas conforme especificado; isso adiciona muitos caracteres ao código) como seu primeiro argumento e as instruções sobre entrada padrão.

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

Saída de amostra

2,4,N

Código

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

Explicação

dé para comparação; retorna 0 se seus dois argumentos forem iguais e 1 caso contrário, ele poderá ter outros comandos acorrentados a ele com&& e ||.

y é como tr (mas feito atravéssed ).

Y é como sed 's/.../.../g' por seus dois argumentos.

Pé echo -e -n; pé justo 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

A próxima parte é profundamente feia, com cerca de 145 caracteres em uma linha. Se o comando atual for M, transforme as vírgulas em $ o em espaços, converta em matriz e salve em $ z. Em seguida, faça um switch ... case block para o último elemento de $ z (a direção que o rover está apontando. Altere as coordenadas de acordo. Em seguida, converta $ z novamente em uma string separada por vírgula e salve em $ 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

Eu não tinha certeza de quão flexível era o formato da string de entrada e saída, por isso, certifiquei-me de que ele se parecesse exatamente com o exemplo (menos os prompts, é claro), mas isso adicionava muitos caracteres extras. Link Ideone

PHP - 224

Bem, eu tentei.

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

Entrada em STDIN, por exemplo:

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

Implementação usando o uso pesado de ifs ternários.

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)

Omitir as queixas óbvias de entrada, fornecer valores intrínsecos às seqüências de direção pode ter beneficiado o tamanho do script. No entanto, a abordagem aqui é perfeitamente funcional (então eu acredito)

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

Usamos o tipo de número complexo interno do Python para armazenar o par de coordenadas. A direção é calculada levando a unidade imaginária 1jà potência de d, que armazena a direção mod 4. A rotação é feita aumentando ou diminuindo d. A expressão 'ML'.find(c)fornece a quantidade que queremos alterar d: 1for L, 0for Me -1(o padrão para não encontrado) paraR .

O Python não tem um caminho curto para converter um número complexo em uma tupla, portanto, temos que fazer chamadas caras para .reale .imag.