Учитывая строку, которая является одним из направлений на компасной розе с 16 пунктами

выведите два направления, которые непосредственно примыкают к направлению ввода, по часовой стрелке.

В частности, вам нужно обработать эти (и только эти) пары ввода / вывода:

Input  Output
N      NNW NNE
NNE    N NE
NE     NNE ENE
ENE    NE E
E      ENE ESE
ESE    E SE
SE     ESE SSE
SSE    SE S
S      SSE SSW
SSW    S SW
SW     SSW WSW
WSW    SW W
W      WSW WNW
WNW    W NW
NW     WNW NNW
NNW    NW N

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

Например, для ввода N(или nесли вы используете строчные буквы) некоторые допустимые выходные данные:

NNW NNE
NNW-NNE
["NNW", "NNE"]
nnw-nne (if using lowercase)

Некоторые неверные выходы:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

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

Желе , 37 34 байта

“¢ ¬9£Hæz¥{çb¤S®!‘ṃ€“¡&¦»
¢iµ’,‘ị¢

Попробуйте онлайн!

Принимает строчные буквы

-2 спасибо Джонатану Аллану .
-1 так как оказывается это действует как функция :)

Благодаря Джонатану Аллану (и Деннису), теперь вы можете удалить €. К сожалению, это было бы неконкурентоспособным здесь.

Подробное объяснение алгоритма :

Обычно мы начинаем объяснение с нижней (основной) ссылки, спускаясь вниз, но здесь я чувствую, что более уместно объяснять сверху.

Сначала мы просто загружаем список [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Это похоже на случайные числа, а? Ну, на самом деле это список сжатых по основанию 5 чисел, поэтому мы распаковываем по основанию 5. Теперь это выглядит так [[1], [1, 1, 2], [1, 2], [2, 1, 2], [2], [2, 3, 2], [3, 2], [3, 3, 2], [3], [3, 3, 4], [3, 4], [4, 3, 4], [4], [4, 1, 4], [1, 4], [1, 1, 4]]. Все еще выглядит случайным образом, но на самом деле это NESWсписок из шестнадцати координат, поэтому мы недалек от его завершения (Jelly имеет индекс 1). Делая окончательное сопоставление, мы получаем [['N'], ['N', 'N', 'E'], ['N', 'E'], ['E', 'N', 'E'], ['E'], ['E', 'S', 'E'], ['S', 'E'], ['S', 'S', 'E'], ['S'], ['S', 'S', 'W'], ['S', 'W'], ['W', 'S', 'W'], ['W'], ['W', 'N', 'W'], ['N', 'W'], ['N', 'N', 'W']]полный список, который нам нужен (строки Jelly находятся в форме [char1, char2, char3, ...].)

Поскольку мы сейчас создали список координат, мы работаем с ним. Основная ссылка вступает в игру. Сначала мы загружаем список, который мы создали, а затем берем индекс, в котором находится входная координата (в качестве аргумента командной строки). Затем мы объединяем его предшественника и его преемника в список и используем их как модульные. индексы в один и тот же список координат, чтобы взять координаты слева и справа от ввода соответственно. Теперь вы думаете, что мы наконец закончили, но на самом деле есть еще одна вещь, разделитель. Это действительно как функция, так как 1) Вы можете вызывать ее, используя <integer>Ŀ2) Вы можете определять и другие функции (например, импорт модулей). Теперь мы сделали. Как полная программа, у нее нет разделителя, но это нормально, так как она работает как функция.

Объяснение кода ссылки по ссылке :

¢iµ’,‘ị¢K Main link. Arguments: z = cmd0
¢         Run the helper link niladically (i.e. load the coordinate list).
 i        Find the index of z in the list.
  µ       Start a new monadic chain. Arguments: z = list_index.
   ’      Decrement z.
     ‘    Increment z.
    ,     Pair x and y into [x, y].
       ¢  Run the helper link niladically.
      ị   Take the elements of y at the indices in x.

“¢ ¬9£Hæz¥{çb¤S®!‘ṃ€“¡&¦» Helper link. Arguments: [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]
“¢ ¬9£Hæz¥{çb¤S®!‘        Generate the integer list (the argument).
                    “¡&¦» Literal "newsy".
                  ṃ€      Base-length(y)-decompress every integer in x, then index into y.

Mathematica, 118 112 байт

Спасибо Мартину Эндеру за сохранение 6 байтов!

r=StringSplit@"N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW N NNE";<|Array[r[[#]]->r[[#+{-1,1}]]&,16,2]|>

Безымянная функция (действительно ассоциация), которая принимает строку в качестве входных данных и возвращает упорядоченную пару строк. В основном, просто жестко код ответа.

Python 2, 116 115 103 байт

-12 байт благодаря Нейлу

d='N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW'.split()
n=d.index(input())
print d[n-1],d[n-15]

Попробуйте онлайн!

JavaScript ES6, 106 102 байта

p=>[(a=`N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW`.split`|`)[i=a.indexOf(p)-1&15],a[i+2&15]]

Попробуйте онлайн!

const f = p=>[(a=`N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW`.split`|`)[i=a.indexOf(p)-1&15],a[i+2&15]]

console.log(f('N'))
console.log(f('NNE'))
console.log(f('ENE'))
console.log(f('E'))
console.log(f('ESE'))
console.log(f('SE'))
console.log(f('SSE'))
console.log(f('S'))
console.log(f('SSW'))
console.log(f('SW'))
console.log(f('WSW'))
console.log(f('W'))
console.log(f('WNW'))
console.log(f('NW'))
console.log(f('NNW'))

05AB1E , 44 43 байта (спасибо Аднану )

"ESNW4"•2ßU^]>Þ‡¾“¾&é{½‡•5BSè4¡©skD<®ès>®è)

Попробуйте онлайн!

"ESNW4"•2ßU^]>Þ‡¾“¾&é{½‡•5BSè # Push N4NNE4NE4ENE4E4ESE4SE4SSE4S4SSW4SW4WSW4W4WNW4NW4NNW
4¡©            # Split on 4's and store.
   sk          # Index of input in direction array.
     D<®è      # Element before index of input.
         s>®è  # Element after index of input.
             ) # Wrap two element to array.

Exmaple output:

N => [NNW,NNE]

Версия, которая выдвигает N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWвместо:

•17¿$Mn]6VAÆ—Dªd—•5B4LJ"NSWE"‡0¡©skD<®ès>®è)

Также 44 байта, было 0 причин для моего рефакторинга, и есть 0 причин для разделения на 4.

Javascript - 234 154 156 152 120 106 102 байта

Только мой второй раз занимаюсь гольфом кода !!

Последняя редакция:

Спасибо @ fəˈnɛtɪk за этот аккуратный трюк с переменными!

s=>[(a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `)[n=a.indexOf(s)-1&15],a[n+2&15]]

До этого: Хорошо, так последняя редакция: Input - это строка, а output - строка, которая есть в правилах, поэтому я превратил ее в функцию, а с сокращениями я стал еще меньше (функция также является анонимной, что теперь означает, что у меня есть каким-то образом запутался в другом ответе js ой! У него (пауэлл) это было первым !!)

(s,a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `,n=a.indexOf(s))=>[a[n-1&15],a[n+1&15]]

Может использоваться:

f=(s,a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `,n=a.indexOf(s))=>[a[n-1&15],a[n+1&15]]
alert(f(prompt()))

Переделано (не работает) с выводом - 120:

a="NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW".split(' ');n=a.indexOf(prompt());alert(a[n-1&15]+' '+a[n+1&15]);

• Обратите внимание, что изначально я допустил ошибку, указав для первого индекса значение a.length вместо a.length-1. Спасибо @Neil за указание, что это не работает для NNW.

• Примечание 2: Спасибо @Neil и @ETHProductions за помощь в сокращении кода!

Originial:

a="NNWN  NNENE ENEE  ESESE SSES  SSWSW WSWW  WNWNW ";l=prompt("","");n=l.length<3?l.length<2?l+'  ':l+' ':l;f=a.indexOf(n);i=f-3;j=f+3;i=i<0?a.length+--i:i;j=j+3>=a.length?j-a.length:j;alert(a.substring(i,i+3)+' '+a.substring(j,j+3));

Пакет, 196 байт

@set s=N
@if %1==N echo NNW
@for %%r in (NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW)do @call:c %1 %%r
@if %1==NNW echo N
@exit/b
:c
@if %1==%2 echo %s%
@if %1==%s% echo %2
@set s=%2

Прокручивает каждую пару точек компаса, печатая одну, когда другая совпадает. Например, для параметра ENE, когда цикл достигает ENE, переменная sсодержит, NEкоторый печатается, затем, когда цикл переходит к E, переменная sсодержит ENEи так Eпечатается. Одна пара должна быть в специальном корпусе, чтобы точки компаса не печатались в неправильном порядке.

Желе ,  40 38 байт

“NSWE”“dḍ.ƈ€ḶƘfƥ’ṃṁ
“¢)`)’ḃ3RÇṙi¥µṖṪ,Ḣ

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

(Я не совсем уверен, почему 1323DRẋ4вместо “¢)`)’ḃ3Rэтого не работает в данный момент.)

Как?

“NSWE”“dḍ.ƈ€ḶƘfƥ’ṃṁ - Link 1, rose list helper: shape array
“NSWE”              - "NSWE"
      “dḍ.ƈ€ḶƘfƥ’   - base 250 number: 1554210846733274963415
                 ṃ  - base decompress: "NNNENEENEEESESESSESSSWSWWSWWWNWNWNNW"
                  ṁ - mould like shape array

“¢)`)’ḃ3RÇṙi¥µṖṪ,Ḣ - Main link: direction string
“¢)`)’             - base 250 number: 33899292
      ḃ3           - to base 3: [1,3,2,3,1,3,2,3,1,3,2,3,1,3,2,3]
        R          - range (vectorises) [[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3]]
         Ç         - call the last link (1) as a monad: ["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
            ¥      - last two links as a dyad
          ṙ        -     rotate the list by:
           i       -         index of the direction string in the list
             µ     - monadic chain separation (call the rotated list x)
              Ṗ    - pop (x[:-1]) (removes the direction string)
               Ṫ   - tail that (i.e. x[-2])
                 Ḣ - head x (i.e. x[0])
                ,  - pair

Haskell , 100 99 байт

s=words"N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW"++s
(a:b:c:r)#x|x==b=(a,c)|1<3=r#x
(s#)

Попробуйте онлайн! Звонок (s#) "N"возвращается ("NNW","NNE").

sявляется бесконечным повторением списка направлений, поэтому нам не нужно добавлять дополнительные NиNNE как и некоторые другие ответы, чтобы правильно обрабатывать края списка.

Спасибо @nimi за сохранение одного байта!

СОГЛ , 33 байта

≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘θ,W:AHwOaIw

Первая часть ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘представляет собой сжатую строку, которая

N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW

сжатый с помощью пользовательского словаря с ENSW

Остальная часть программы:

...‘θ,W:AHwOaIw  example input: NNW
...‘             push the compressed string        ["N NNE NE ... NNW"]
    θ            split on spaces                   [["N","NNE",...,"NNW"]]
     ,W          get the index of input            [["N","NNE",...,"NNW"], 16]
       :A        save the index on variable A      [["N","NNE",...,"NNW"], 16]
         H       decrease [the index]              [["N","NNE",...,"NNW"], 15]
          wO     output that'th item of the array  [["N","NNE",...,"NNW"]]
            a    load variable A                   [["N","NNE",...,"NNW"], 16]
             I   increase [the index]              [["N","NNE",...,"NNW"], 17]
              w  get that item in the array        [["N","NNE",...,"NNW"], "N"]

PHP, 122 байта

preg_match("/([^ ]+ )$argv[1] ([^ ]+)/",'N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW N NNE',$m);
echo $m[1].$m[2];

Рубин - 94 байта

Рифф на ответ Синий Okiris в , просто чтобы воспользоваться какой - то хороший Ruby , стенографии ( %w[]синтаксис и pспециально):

->(s,d=%w[N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW],n=d.index(s)){p d[n-1],d[n-15]}

Japt , 66 52 байта

Сохранено 14 байт благодаря @ETHproductions

V=`ã@JaÀTeaÀÄsÁÁss°s°ws°°wn°n°nnw`qa [J1]£VgX+VaU

Попробуйте онлайн!

Объяснение:

V=(`...`qa) [J1]£Vg(X+VaU)
V=(       )                // Set V to:
   `...`                   //   "nanneaneaeneaeaeseaseasseasasswaswawswawawnwanwannw" (de-)compressed
        qa                 //    Split on "a", creating [n...nnw]
            [J1]           // [-1,1]
                £          // Iterate through ^, X becomes the iterative item
                 Vg(     ) //   V.Item at index:
                    X+VaU  //     X + V.indexOf(input)

CJam, 41

"NeSWN"2ew{_1<\_La*\$f+~}%:eu_ra#(m<2%2<p

Попробуйте онлайн

PHP, 115 байт

for($r=explode(_,($w=N_NNE_NE_ENE_E_ESE_SE_SSE_).strtr($w,SWNE,NESW).$w);$r[++$i]!=$argn;);echo$r[$i-1]._.$r[$i+1];

-2 байта, используя устаревшую функцию splitвместоexplode

PHP, 128 байт

for($i=2;$i--;print$i?end($e)._:$e[2])$e=explode(_,strstr(($w=N_NNE_NE_ENE_E_ESE_SE_SSE_).strtr($w,SWNE,NESW).$w,_.$argn._,$i));

PHP, 134 байта

echo($r=explode(_,N_NNE_NE_ENE_E_ESE_SE_SSE_S_SSW_SW_WSW_W_WNW_NW_NNW))[($k=array_search($argn,$r))-1<0?15:$k-1]._.$r[$k+1>15?0:$k+1];

PHP, 110 109 байт

Сохранено 1 байт благодаря Jörg Hülsermann .

echo@preg_filter("/.*?(\w+) $argn( \w+).*/",'$1$2',($s='N NNE NE ENE E ESE SE SSE ').strtr($s,NESW,SWNE).$s);

Питон 3 - 112 107 байт

Я основал это на своем ответе на Javascript:

Переделал:

lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1],s[s.index(i)-15]]

Используйте как говорят

f = lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1],s[s.index(i)-15]]
print(f(input()));

Оригинал:

lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1&15],s[s.index(i)+1&15]]

MATL , 43 байта

';evl(Z?&fWElf`gvhM'F' NESW'ZaYbtjY=fFTEq+)

Попробуйте онлайн!

объяснение

';evl(Z?&fWElf`gvhM' % Push this string
F                    % Push false
' NESW'              % Push this string
Za                   % Base conversion. This decompresses the first string from alphabet
                     % given by all printable ASCII except single quote to the alphabet
                     % ' NESW'. The result is the following string, which is pushed:
                     % 'N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW'
Yb                   % Split at spaces. Gives a cell array of strings
t                    % Duplicate
j                    % Input string
Y=                   % String comparison. Gives an array containing true at the index
                     % of the matching string
f                    % Find: index of the entry that equals true
FTEq                 % Push [-1 1] (obtained as [false true], times 2, minus 1)
+                    % Add, element-wise
)                    % Index modularly into the cell array of strings
                     % Implicitly display. Each cell is displayed on a different line

с, 222 216 211 байт

main(c,v)char**v;{char r[]="NXNNEXNEXENEXEXESEXSEXSSEXSXSSWXSWXWSWXWXWNWXNWXNNWX",*p=r,*s=r,*a[16],i=0,n;for(;*p++;)*p==88?*p=0,n=strcmp(a[i++]=s,v[1])?n:i-1,s=++p:0;printf("%s %s\n",a[n?n-1:15],a[n<15?n+1:0]);}

Попробуйте онлайн

Javascript (ES6), 189 байт

d="N.NNW NNE.NNE.N NE.NE.NNE ENE.ENE.NE E.E.ENE ESE.ESE.E SE.SE.ESE SSE.SSE.SE S.S.SSE SSW.SSW.S SW.SW.SSW WSW.WSW.SW W.W.WSW WNW.WNW.W NW.NW.WNW NNW.NNW.NW N".split`.`,f=>d[d.indexOf(f)+1]

Просто принимает входные данные, ищет их и возвращает.

JavaScript (ES6), 94 байта

Ожидается строка в верхнем регистре, такая как "ENE". Возвращает строку через запятую, например "NE,E".

s=>/\D+,\D+/.exec('NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N'.split(0+s+0))[0]

Как это работает

При вызове выражение 0+s+0приводится к строке split(). Например, если входные данные "ENE", строка будет разделена на "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Это приводит к следующему массиву:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

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

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Мы ищем последовательные нечисловые символы ( \D+), за которыми следует запятая, а затем последовательные нечисловые символы. Это возвращает массив [ "NE,E" ]. Мы могли бы остановиться на этом и вернуть именно это. Но задача состоит в том, чтобы запросить строку с разделителями или массив из двух элементов. Итак, мы извлекаем строку с[0] .

демонстрация

let f =

s=>/\D+,\D+/.exec('NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N'.split(0+s+0))[0]

;
["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
.map(
  s => console.log(s, '=>', f(s))
)

Pyth , 39 байт:

.rL]z_Bms@L"ESWN"jCd5"\"❤m❤w❤^❤\❤C❤9❤ ❤

где ❤представляет непечатные буквы.

Попробуйте онлайн!

HexDump:

0000000: 2e 72 4c 5d 51 5f 42 6d 73 40 4c 22 45 53 57 4e .rL]Q_Bms@L"ESWN
0000010: 22 6a 43 64 35 22 5c 22 09 6d 04 77 13 5e 03 5c "jCd5"\".m.w.^.\
0000020: 11 43 02 39 07 20 01                            .C.9. .