Підсумок

Завдання полягає в навігації на марсоході і повідомляє його кінцеві координати та напрямок.

Вхід:

Перший вхід:

Спочатку ваша програма повинна взяти вклад, який буде у наступному форматі:

[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 тощо, можливо, будь ласка, зробіть це, щоб я міг перевірити :)

Це конкурс популярності, тому будьте креативними!

Дотримуючись порад інших, я вирішу зробити це кодом-гольф .

Рубін ≥ 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]])

Безголів / Прокоментував:

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 Логіка, 36 вводу / виводу

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

C 164 180 186

Редагувати фіксований формат введення та видалено strchr
Редагувати Видалений масив зміщення, вирахування за допомогою бітів

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

Безумовно

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

Налаштування рішення @ edc65 для використання мого підходу щодо зловживання значеннями ASCII.

Конкретно:

• d%8%5відображає символи ENWSз 0,1,2,3відповідно
• c%23перетворюється Lв 7, Mв 8і Rв 13. Оскільки d(змінна напрямок) завжди використовується мод 4, це ефективно робить Lдодавання -1 мод 4, Mдодавання 0 мод 4 та Rдодавання 1 мода 4.
• d&1 є 1 для NS і 0 дляEW напрямків.
• d&2дорівнює 2 для WSі 0 дляNE напрямків.
• ~-(d&2)дорівнює 1 для WSі -1 дляNE напрямків.
• c%2дорівнює 1 для 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)])

Цей виклик цілком природно відображає графіку черепах у стилі логотипу, для якої, звичайно, імпорт має пітон.

Читає дані з двох рядків від 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=

Delphi (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.

Безумовно

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 байт, він взагалі не був знятий з вогню). Так, все ще є крапка з комою, але цей фактично зберігає байт.

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)

Тоді ми просто робимо коорди вставки. (Я був шокований, що не міг придумати кращого способу перетворення двох рядків у ints. Я спробував, 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

Ідеон

Безголівки:

#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в режимі вираження, не будучи в змозі виконати команду .

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

Пітон 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. Потім зробіть блок перемикання ... випадок блоку для останнього елемента $ 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.