给定一个字符串，它是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

以字节为单位的最短代码获胜。

Mathematica，118112字节

感谢Martin Ender节省了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]|>

未命名函数（实际上是一个关联），将字符串作为输入并返回有序的字符串对。基本上只是硬编码答案。

果冻，37 34字节

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

在线尝试！

接受小写输入。

-2感谢Jonathan Allan。
-1，因为事实证明这是有效的功能:)

感谢Jonathan Allan（和Dennis），现在您可以删除了€。不幸的是，这在这里是不竞争的。

详细的算法说明：

我们通常从底部（主）链接开始进行解释，但是到了这里，我觉得从顶部开始进行解释更合适。

首先，我们只加载列表[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]]。看上去还是随机的东西，但这实际上是NESW16个坐标的- 映射列表，因此我们离完成列表不远（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']]，这是我们想要的完整列表（果冻字符串的形式为）[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.

Python 2，116 115 103字节

-12字节归功于Neil

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位元组（感谢Adnan）

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

示例输出：

N => [NNW,NNE]

推送的版本N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW：

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

也是44字节，我的重构有0个原因，而4分裂的原因则有0个。

使用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]]

在此之前：好的，最新修订是：输入是一个字符串，输出是规则中的字符串，因此我将其变成一个函数，经过简化，我变得更小了（函数也是匿名的，这意味着我的名字莫名其妙地陷入了其他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帮助我缩短代码！

原产地：

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。然后需要一对特殊的包装，以免罗盘点以错误的顺序打印。

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节省了一个字节！

果冻， 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

SOGL，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];

Ruby-94字节

关于Blue 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字节

@ETHproductions节省了14个字节

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字节

感谢JörgHülsermann节省了1个字节。

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

Python的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

C，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❤ ❤

其中❤代表无法打印的字母。

在线尝试！

十六进制转储：

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