Резюме

Задача состоит в том, чтобы перемещаться по марсоходу и сообщать его окончательные координаты и направление.

Входные данные:

Первый вход:

Сначала ваша программа должна принять входные данные в следующем формате:

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

Направление должно быть: Nили Sили EилиW (начальные буквы севера, юга, запада, востока)

Пример: 10,20,N(x = 10, y = 20, направление = N (север))

Второй вход:

Второй вход состоит из серии из R, L, Mдля вправо, влево и двигаться соответственно.

Для Rи L(вправо и влево) направление ровера должно измениться соответственно.

Для Mровера необходимо двигаться на 1 единицу вперед в том направлении, в котором он находился до движения.

Правила расчета координат:

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

Выход:

Окончательные координаты и текущее направление движения ровера.

Enter initial data:      1,2,N

Enter the instructions:  MRMLM

Output:                  2,4,N

Координаты могут быть любым целым числом и могут быть отрицательными .

Все стандартные лазейки не допускаются. Если возможно размещение демонстрации на таких сайтах, как http://ideone.com и т. Д., Сделайте это, чтобы я мог проверить :)

Это конкурс популярности, так что будьте креативны!

Следуя советам других, я решил сделать этот код-гольф .

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

Это решение можно проверить здесь: https://ideone.com/C4PLdE

Обратите внимание, что решение, связанное с ideone, на один символ длиннее ( 1.iвместо 1iстроки 3). Причиной этого является то, что ideone поддерживает только Ruby 1.9, который не допускает краткий синтаксис для сложных литералов.

Javascript ( ES6 ) 145 141 127

Изменить: Устранена необходимость в массиве перевода с использованием метода из решения C 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 / Комментарий:

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

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

С пробелами:

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

Как и в случае с Java, примерно половина из этого просто анализирует ввод и формирует вывод. Логика довольно проста.

Javascript (E6) 175

редактировать Исправлена ​​ошибка, возможно выходящая за пределы диапазона возвращаемого значения для d

139 Logic, 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()))

Основной негольфированный

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
}

Тест Тест в консоли javascript в Firefox. Проще протестировать функцию F, избегая всплывающих окон.

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

Выход

[ 2, 4, "N" ]

С 164 180 186

Edit Исправлен формат ввода и удален strchr.
Edit Удален массив смещений, рассчитан с использованием битов.

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

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

Доработка решения @ edc65 для использования моего подхода к злоупотреблению ценностями ASCII.

В частности:

• d%8%5сопоставляет персонажей ENWSс0,1,2,3 соответственно
• c%23превращается Lв 7, Mв 8и Rв 13. Поскольку d(переменная направления) всегда используется мод 4, это эффективно Lдобавляет -1 мод 4, M0 мод 4 и R1 мод 4.
• d&11 для NSи 0 для EWнаправлений.
• d&22 для WSи 0 для NEнаправлений.
• ~-(d&2)1 для WSи -1 для NEнаправлений.
• c%21 для Mи 0 для LR.

Python 3 (с графикой черепахи), 251 199 байт

Мудрые питонисты, пожалуйста, будьте вежливы, потому что это моя первая попытка программы, написанной на вашем хорошем языке.

Черепахи на Марсе!

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

Эта задача вполне естественно сопоставляется с графикой черепах в стиле логотипа, для которой, конечно, имеет значение python.

Читает ввод из двух строк из STDIN.

Выход:

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

Что мне особенно нравится в этой программе, так это то, что она графически отображает путь ровера. Добавьте exitonclick()в конец программы, чтобы графический вывод сохранялся до нажатия пользователем:

Я уверен, что это может быть значительно больше - любые предложения приветствуются! Я делаю это CW, потому что я надеюсь, что сообщество может еще немного поиграть в гольф.

Изменения:

• s теперь список, встроенный.
• Используется троичный для тела для петли.
• Подчеркнул, удалил ненужный ломтик.
• Удалено ненужное место в операторе импорта.
• Удалена строка импорта для использования встроенного метода строк
• Переключился на Python 3 для сокращения raw_input

GolfScript, 116 98 88 84 71

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

Это должно получить координаты и инструкции в качестве аргументов следующим образом:1 2 'N' 'MRMLM' . Аргументы превращаются в строку и помещаются в стек.

Если вы хотите проверить это в Интернете, перейдите к веб-сценарию гольфа и вставьте точку с запятой, за которой следует строка с аргументами (например ;"1 2 'N' 'MRMLM'") перед кодом ( здесь приведена ссылка с примером).

Примеры вывода:

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

Мои предыдущие попытки

84 символа:

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

88 символов:

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

98 символов:

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

116 символов:

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

Дельфы (819)

Когда я начинал, это был еще не код-гольф . Буду редактировать позже.

Не могу найти компилятор онлайн, хотя.

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)

Это моя первая настоящая попытка кода в гольф, кажется, работает по крайней мере!

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

Питон (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))

Должен быть более элегантный способ сделать это, ему не нужна ветвь после остального.

http://ideone.com/eD0FwD

Вход ужасный, я хотел сделать это с split(',') но столкнулся с проблемами приведения между строками и строками. В идеале я также хотел добавить старую позицию с движущейся позицией ... о, теперь это код-гольф. Ну да ладно, я оставлю это здесь, это может дать вдохновение. Другие идеи, которые у меня были, заключались в использовании по модулю 4 направления после сопоставления исходного ориентира с индексом. Также объединяйте повороты и перемещайте массивы в один, поскольку ни одна из клавиш не сталкивается.

несмотря на это, сокращение имен переменных и удаление пробелов это 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 байта

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]

Я на самом деле очень горжусь этим.

объяснение

Во-первых, давайте исправим этот беспорядок. Я использовал точки с запятой вместо разрывов строк во многих местах, потому что я думаю, что это делает меня крутым. Здесь это обычно (это - все еще 197 байтов, это не было ungolfed вообще). Да, еще есть точка с запятой, но она на самом деле сохраняет байт.

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]

Давайте начнем!

q='NESW'

Сначала мы определяем qкак строку 'NESW'. Мы используем это дважды позже, и len("q='NESW';qq") < len("'NESW''NESW'").

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

Здесь мы разделяем первую строку inpupt на каждую запятую. Наша координата x хранится в x, y в y, и первая буква нашего направления в d.

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

Тогда мы просто делаем координаты. (Я был шокирован, что не мог придумать лучшего способа преобразования двух строк в целые. Я пытался, x,y=map(int,(x,y))но это оказалось дольше.)

d=q.find(d)

Это преобразует наше направление в целое число. 0 север, 1 восток, 2 юг и 3 запад.

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

Здесь начинается самое интересное.

Когда мы идем на север, Y увеличивается на 1. Таким образом, этот словарь берет 0 и дает строку 'y+'для «увеличения y». Он дает аналогичные результаты для других направлений: y или x, за которыми следует + или -.

Мы вернемся к этому.

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

Я позволил себе немного развеять это.

Для каждого символа во второй строке ввода мы делаем две вещи. Во-первых, мы устанавливаем переменную равной mтому, что наш словарь дает нам для нашего текущего направления. Нет причин, по которым нам нужно, чтобы это происходило каждый раз, но это проще, чем просто делать это, когда нам это нужно.

Далее мы создаем список из трех элементов: 'd+', 'd-', и m. ПРИМЕЧАНИЕ РЕДАКТОРА: Я думаю, что могу обойтись без использования переменной mвообще. Я думаю, что я могу просто внести v[d]в список напрямую. Это сэкономит мне пару байтов, если это сработает, но я не испытываю желание испытать это, пока я не закончу это объяснение, чтобы вы могли справиться. (Да, это сработало.)

Мы ищем текущий символ ввода в строке 'RL'. str.findвозвращает -1, если не находит символ, поэтому он преобразует R в 0, L в 1 и все остальное в -1. Конечно, единственный другой вход, который мы можем иметь, это M, но меньше символов, чтобы он работал для всего.

Мы используем это число в качестве индекса для списка, который мы создали. Индексы списка Python начинаются в конце, если они отрицательные, поэтому мы получаем первый элемент, если входное значение R, второй, если это L, и последний, если это M. Для удобства, я собираюсь предположить, что мы стоим на севере, но аналогичный принцип применим и для других направлений.

Возможные значения, с которыми мы работаем, 'd+'для R, 'd-'для L и 'y+'для M. Затем мы присоединяем '=1;d=d%4'к концу каждого из них. Это означает, что наши возможные ценности ...

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

Это действительный код Python! Это правильный код Python, который делает именно то, что мы хотим сделать для каждого из этих входных символов! (Эта d=d%4часть просто держит наши указания в здравом уме. Опять же, не нужно делать это каждый раз, но это меньше символов.)

Все, что нам нужно сделать, это выполнить код, который мы получаем для каждого символа, распечатать его (преобразовав наше направление обратно в строку), и все готово!

С - 350

Сохранить как 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;}

Обобщение:

gcc -o rover rover.c -lm

Образец прогона:

$ 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 байт

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)

Протестировано с:

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

Bash + coreutils, 159 байт

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`

Ввод читается из 2 строк STDIN.

Выход:

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

Казалось бы, дальше не удаётся играть в гольф, что немного смущает. Но все очевидные хаки здесь не работают.

Я не могу iexвход , потому что а) N, S, Eи Wдолжны быть функции для того , чтобы работать (или я должен был бы префикс, с$ и б) 1,2,Nпридется разбораN в режиме выражения, не будучи в состоянии выполнить команду ,

switch, Кажется, самый короткий способ сделать движение. Хеш-таблица с блоками или строками скрипта тоже не короче и для всех остальных способов, кромеswitch меня есть издержки явного цикла.

Я не могу избавиться от IndexOf потому что трубопровод с? более длинным, все же.

Я также не могу избавиться от явных типов в первоначальном объявлении, потому что у меня там смешанные типы, поэтому просто |%{+$_} не помогает, а все остальные варианты длиннее.

Иногда я ненавижу обработку ввода в PowerShell.

Питон, 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])

Злоупотребления значения ASCII из L, MиR избегать использования любых условных операторов.

Попробуйте это в 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]

Вещи, которые я изменил с оригинала:

Aliased raw_input, изменил словарь v [d], который в любом случае должен был быть списком, на какой-то выбор строки, используемый %= .

Редактировать: используется распаковка кортежей и eval (raw_input ()) == input () для сохранения 21 символа.

Сильно позаимствовано у @undergroundmonorail, но с большим количеством улучшений.

Bash / SHELF ,243 235

« SHE ll go LF » - это библиотека для игры в гольф для Bash, которая предоставляет несколько полезных псевдонимов. Это верный ответ, поскольку библиотека существовала и была на GitHub до публикации заявки.

Извините, я не могу заставить это работать на ideone.

Как бегать

Он принимает начальную позицию (разделенную запятыми, как указано; это добавляет много символов в код) в качестве первого аргумента и инструкции по стандартному вводу.

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

Образец вывода

2,4,N

Код

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

объяснение

dдля сравнения; он возвращает 0, если два его аргумента равны, и 1, в противном случае он может затем связать другие команды с помощью &&и ||.

yэто как tr(но сделано через sed).

Yэто как sed 's/.../.../g'для двух своих аргументов.

Pесть echo -e -n; pэто просто 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

Следующий бит глубоко уродлив, с около 145 символов на одной строке. Если текущей командой является M, поверните запятые в $ o в пробелы, преобразуйте в массив и сохраните в $ z. Затем выполните блок switch ... case для последнего элемента $ z (направление, на которое указывает ровер. Соответственно измените координаты, затем преобразуйте $ z в строку через запятую и сохраните в $ 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

Хаскелл, 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

Я не был уверен, насколько гибким был формат строки ввода и вывода, поэтому я позаботился о том, чтобы он выглядел точно так же, как в примере (за исключением подсказок, конечно), но это добавило много дополнительных символов. Идеальная ссылка

PHP - 224

Ну, я попробовал.

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

Ввод в STDIN, например:

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

Реализация с использованием интенсивного использования троичных 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)

Пропуск очевидного ввода ворчит, придание внутренним значениям строк направления могло бы помочь размеру скрипта. Тем не менее, подход здесь совершенно функциональный (так что я считаю)

Питон 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

Мы используем встроенный в Python комплексный тип чисел для хранения пары координат. Направление вычисляется путем взятия мнимой единицы 1jв степень d, в которой хранится направление mod 4. Вращение осуществляется путем увеличения или уменьшения d. Выражение 'ML'.find(c)дает сумму, которую мы хотим изменить d: 1для L, 0для Mи -1(по умолчанию для не найден) для R.

В Python нет короткого способа преобразования комплексного числа в кортеж, поэтому мы должны делать дорогостоящие вызовы .realи .imag.