รับสายที่เป็นหนึ่งในทิศทางบนเข็มทิศ 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, 118 112 bytes

ขอบคุณ 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]|>

ฟังก์ชัน Unnamed (การเชื่อมโยงจริงๆ) ที่รับสตริงเป็นอินพุตและส่งคืนสตริงที่สั่งซื้อ โดยทั่วไปเพียง hardcodes คำตอบ

เยลลี่ , 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-decompress [[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รายการที่แมปของพิกัดที่สิบหกดังนั้นเราจึงไม่ไกลจากการทำรายการให้เสร็จสมบูรณ์ (วุ้นคือดัชนี 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.

เอาต์พุต Exmaple:

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

ก่อนหน้านั้น: เอาล่ะการแก้ไขล่าสุด: อินพุตเป็นสตริงและเอาต์พุตเป็นสตริงที่อยู่ในกฎดังนั้นฉันจึงทำให้มันเป็นฟังก์ชั่นและด้วยการลดลงฉันก็ยิ่งเล็กลง (เช่นฟังก์ชั่นนั้นไม่ระบุชื่อ ยังไงก็เถอะ js อื่น ๆ ตอบ oops! เขา (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()))

Remade (ไม่ใช่ฟังก์ชั่น) ด้วย Output - 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มีการพิมพ์ คู่หนึ่งจะต้องมีกล่องใส่พิเศษเพื่อหลีกเลี่ยงการพิมพ์จุดตามลำดับที่ผิด

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 ไบต์

แจ๊สในคำตอบของบลู Okirisเพียงเพื่อใช้ประโยชน์จากบางดีทับทิมชวเลข (คน%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örgHülsermann

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

โดยที่❤หมายถึงตัวอักษรที่ไม่สามารถพิมพ์ได้

ลองออนไลน์!

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