Если кто-то, смотрящий на север в точке A в этой сетке, хотел, чтобы направления следовали по зеленой траектории (поскольку они могут следовать только по линиям сетки) до точки B, вы можете сказать им:

Go North, North, West, East, East, South, East, East.

или эквивалентно

Go Forward, Forward, Left, Back, Forward, Right, Left, Forward.
(Если команда « Вправо» , « Влево» или « Назад» неявно означает поворот в этом направлении, а затем движение вперед.)

Напишите функцию с одним аргументом, которая переводит между этими абсолютными и относительными направлениями по одному и тому же пути , а не только в одну и ту же точку. Предположим, что направленный человек всегда начинает смотреть на север.

Если аргумент является строкой букв NSEW, вернуть эквивалентные относительные направления.
например, f("NNWEESEE")возвращает строку FFLBFRLF.

Если аргумент является строкой букв FBLR, вернуть эквивалентные абсолютные направления.
например, f("FFLBFRLF")возвращает строку NNWEESEE.

Пустая строка возвращает себя. Не предполагайте никаких других входных случаев.

Если ваш язык не имеет функций или строк, используйте то, что кажется наиболее подходящим.

Самый короткий код в байтах побеждает.

CJam, 57 53 49

{"NESW""FRBL"_3$&!!:Q$:R^^f#0\{{+0\}Q*_@-R=\}%);}

Предыдущая версия

{"NESW""FRBL"_3$0=#W>:Q{\}*:R;f#0\{{+0\}Q*_@-R=\}%);}

Пример:

{"NESW""FRBL"_3$0=#W>:Q{\}*:R;f#0\{{+0\}Q*_@-R=\}%);}:T;
"NNWEESEE"T
N
"FFLBFRLF"T

Выход:

FFLBFRLF
NNWEESEE

Как это устроено

{
  "NESW""FRBL"             " Push the two strings. ";
  _3$0=#W>                 " Check if the first character is in FRBL. ";
  :Q                       " Assign the result to Q. ";
  {\}*                     " Swap the two strings if true. ";
  :R;                      " Assign the top string to R and discard it. ";
  f#                       " Find each character of the input in the string. ";
  0\                       " Push a 0 under the top of the stack. ";
  {                        " For each item (index of character): ";
    {                      " If Q: ";
      +0\                  " A B -> 0 (A+B) ";
    }Q*
    _@-                    " C D -> D (D-C) ";
    R=                     " E -> E-th character in R ";
    \                      " Swap the top two items. ";
  }%
  );                       " Discard the last item in the list. ";
}

С ++, 99 97

Следующее форматируется как лямбда-выражение. Он принимает один char*аргумент и перезаписывает его.

[](char*s){for(int d=0,n=0,c=*s*9%37&4;*s;d+=n)c?n=*s%11/3-d:n+=*s%73%10,*s++="NESWFRBL"[c|n&3];}

Для тех, кто не знаком с этой функцией (как я 1 час назад), используйте ее следующим образом:

#include <iostream>

int main()
{
    char s[] = "NNWEESEE";
    auto x = [](char*s){for(int d=0,n=0,c=*s*9%37&4;*s;d+=n)c?n=*s%11/3-d:n+=*s%73%10,*s++="NESWFRBL"[c|n&3];};

    x(s); // transform from absolute to relative
    std::cout << s << '\n';

    x(s); // transform from relative to absolute
    std::cout << s << '\n';
}

Некоторые объяснения:

• При использовании кода наподобие flag ? (x = y) : (x += z)второй пары скобок требуется в C. Поэтому я использовал C ++ вместо этого!
• C ++ требует указания возвращаемого типа для функции. Если я не использую лямбда-выражение, то есть! Дополнительный бонус: мне не нужно тратить 1 символ на название функции.
• Код *s*9%37&4тестирует первый байт; результат 4, если он один из NESW; 0 иначе
• Код *s%11/3преобразует байты NESWв 0, 1, 2, 3
• Код *s%73%10преобразует байты FRBLв 0, 9, 6, 3 (это 0, 1, 2, 3 по модулю 4)
• При преобразовании относительных направлений в абсолютные, мне не нужна dпеременная. Я попытался изменить код, чтобы полностью устранить его, но это кажется невозможным ...

JavaScript (E6) 84 86 88 92 104

Редактировать: используя & вместо%, другой приоритет оператора (меньше скобок) и лучше работает с отрицательными числами
Edit2: | вместо + снова укажите приоритет, -2. Спасибо DocMax
Edit3: понимание массива на 2 символа короче, чем map (), для строк

F=p=>[o+=c[d=n,n=c.search(i),n<4?4|n-d&3:n=n+d&3]for(i of n=o='',c='NESWFRBL',p)]&&o

Тест в консоли FireFox / FireBug

console.log(F('NNWEESEE'),F('FFLBFRLF'))

Выход

FFLBFRLF NNWEESEE

APL, 72

{^/⍵∊A←'NESW':'FRBL'[1+4|-2-/4,3+A⍳⍵]⋄A[1+4|+\'RBLF'⍳⍵]}

Если конфигурации переводчика могут быть изменены без штрафа, то оценка 66 , изменив ⎕IOна 0:

{^/⍵∊A←'NESW':'FRBL'[4|-2-/0,A⍳⍵]⋄A[4|+\'FRBL'⍳⍵]}

Питон, 171 139

Не так близко, как другие решения, но я думаю, что это должно быть относительно хорошо для того, что можно сделать с помощью Python:

def f(i):a,b='NWSE','FLBR';I=map(a.find,'N'+i);return''.join((b[I[k+1]-I[k]],a[sum(map(b.find,i)[:k+1])%4])[-1in I]for k in range(len(i)))

Расширенная версия для немного лучшей читаемости:

def f(i):
    a, b = 'NWSE', 'FLBR'
    I = map(a.find,'N'+i)     # translate to numbers assuming abs. directions
    J = map(b.index,i)        # translate to numbers assuming rel. directions
    if not -1 in I:
        o = [b[I[k+1]-I[k]] for k in range(len(i))]    # rel. dir. is differences of abs. dir.
    else:
        o = [a[sum(J[:k+1])%4] for k in range(len(i))] # abs. dir. is sum of all rel. dir. so far
    return ''.join(o)

Go, 201

type q string;func F(s q)q{d,z:=byte(0),make([]byte,len(s));for i,c:=range[]byte(s){if(c^4)*167%3<2{c=c*156%5;z[i],d="LBRF"[(d-c)%4],c-1;}else{c=(c^43)*3%7-1;d=(d+c)%4;z[i]="NESW"[d];};};return q(z);}

Читаемая версия:

func F(s string) string {
    d, z, R, A := 0, make([]byte, len(s)), "LBRFLBR", "NESW"
    for i, c := range []byte(s) {
        switch c {
        case 'N': c = R[d+3]; d = 0
        case 'E': c = R[d+2]; d = 1
        case 'S': c = R[d+1]; d = 2
        case 'W': c = R[d]; d = 3
        case 'F': c = A[d]
        case 'R': d = (d + 1) % 4; c = A[d]
        case 'B': d = (d + 2) % 4; c = A[d]
        case 'L': d = (d + 3) % 4; c = A[d]
        }
        z[i] = c
    }
    return string(z)
}

GNU sed, 356 байт

Задача требует простого преобразования потока символов. sed, редактор потоков - очевидный выбор языка ;-)

/[FRBL]/bx                                     # Jump to label x if relative
:y                                             # label y (start of abs->rel loop)
/[FRBL]$/q                                     # quit if string ends in rel char
s/(^|[FRBL])N/\1F/;ty                          # Substitute next abs char with
s/(^|[FRBL])E/\1R/;tr                          #     rel char, then jump to
s/(^|[FRBL])S/\1B/;tb                          #     relevant rotation label if
s/(^|[FRBL])W/\1L/;tl                          #     a match was found
by                                             # loop back to y
:r;y/NESW/WNES/;by                             # Rotation labels: transform then
:b;y/NESW/SWNE/;by                             #     loop back to y
:l;y/NESW/ESWN/;by
:x                                             # label x (start of rel->abs loop)
/^[NESW]/q                                     # quit if string starts w/ abs char
/F([NESW]|$)/s/F([NESW]|$)/N\1/                # Matches for each direction:
/R([NESW]|$)/y/NESW/ESWN/;s/R([NESW]|$)/E\1/   #     rotate, then substitute
/B([NESW]|$)/y/NESW/SWNE/;s/B([NESW]|$)/S\1/
/L([NESW]|$)/y/NESW/WNES/;s/L([NESW]|$)/W\1/
bx                                             # loop back to x

(Комментарии и пробелы удалены для целей подсчета очков в гольф)

Выход:

$ sed -rf absrel.sed <<< NNWEESEE
FFLBFRLF
$ sed -rf absrel.sed <<< FFLBFRLF
NNWEESEE
$ 

Объяснение:

Идея в том, что когда мы меняем систему отсчета, всегда существует прямое отображение между {N, E, S, W}и {F, R, B, L}.

В случае абсолютного и относительного мы работаем вперед по строке. Для каждого символа мы карта , {N, E, S, W}чтобы {F, R, B, L}, затем повернуть остальные [NESW]символы в соответствии с характером , мы просто отображенным, а затем перейти к следующему символу.

Для случая относительно абсолютного мы делаем обратное. Мы работаем в обратном направлении через строку, вращая все последующие [NESW]символы в соответствии с символом непосредственно перед. Тогда мы отображаем этот символ {N, E, S, W}к {F, R, B, L}, пока не дойдут до начала строки.

Хаскелл, 224

import Data.Function
i=flip(\x->length.takeWhile(/=x))
r=['F','R','B','L']
a=['N','E','S','W']
f s@(x:_)|elem x a=map((r!!).(`mod`4).(4-))$zipWith((-)`on`(i a))('N':s)(s)|True=tail$map((a!!).(`mod`4)).scanl(+)(0)$map(i r) s

Это назначает числа вращения относительным направлениям и числа ориентации абсолютным направлениям, затем либо находит повороты между последовательными ориентациями, либо ориентации после последовательных вращений. iФункция находит индекс в пределах двух легенды.