16点コンパスローズの方向の1つである文字列が与えられた場合

入力方向にすぐ隣接する2つの方向を時計回りに出力します。

具体的には、これら（およびこれらのみ）の入出力ペアを処理する必要があります。

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

出力は、方向間に区切り文字（何もしない）を含む文字列または2要素のリストです。入力のすぐ反時計回りの方向が最初に表示されなければなりません。大文字の代わりに小文字をルートに使用できますが、すべての入力と出力を1つのケースまたは別のケースに保持します。

たとえば、入力N（またはn小文字を使用している場合）の有効な出力は次のとおりです。

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

無効な出力は次のとおりです。

NNWNNE
NNE NNW
nnwNNE
NNw NNe

バイト単位の最短コードが優先されます。

Mathematica、118 112バイト

6バイトを節約してくれたMartin Enderに感謝します！

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]。これは乱数のように見えますか？さて、これは実際にはbase-5で圧縮された数字のリストなので、base-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には16の座標のマップされたリストなので、リストを完成するのにそれほど遠くありません（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つセパレーターがあります。これは関数として有効です。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バイト

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です。

ジャバスクリプト- 234の 154 156 152 120 106 102バイト

コードゴルフをするのは2回目だけです!!

最新リビジョン：

このきちんとした変数のトリックをありがとう@ 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回答おっとにメッシュ！彼（powelles）が最初にそれを持っていた!!）：

(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-1ではなくa.lengthに等しいことに注意してください。NNWで機能しなかったことを指摘してくれた@Neilに感謝します。

• 注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が印刷されます。コンパスポイントが間違った順序で印刷されないように、1つのペアを特殊なケースにする必要があります。

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に1バイトの節約をありがとう！

ゼリー、 40 38 バイト

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

オンラインでお試しください！（出力が2つの項目のリストであることを示すためにフッターを追加しました）...またはすべてのケースを参照してください。

（現在のところ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];

ルビー-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" ]。間違いなくそこで停止し、それだけを返すことができます。しかし、課題は、区切り文字列または2要素配列のいずれかを要求することです。したがって、文字列をで抽出します[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. .