Diberikan string yang merupakan salah satu arah pada kompas naik 16 poin

output dua arah yang berbatasan langsung dengan arah input, dalam urutan searah jarum jam.

Khususnya, Anda perlu menangani pasangan input / output ini (dan hanya ini):

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

Output mungkin berupa string dengan pembatas (bukan tidak ada) antara arah atau daftar dua elemen. Arah segera berlawanan dengan arah input harus muncul terlebih dahulu. Anda dapat menggunakan huruf kecil untuk arah alih-alih huruf besar, tetapi simpan semua input dan output dalam satu kasus atau yang lain.

Misalnya, untuk input N(atau njika Anda menggunakan huruf kecil) beberapa output yang valid adalah:

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

Beberapa output yang tidak valid adalah:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

Kode terpendek dalam byte menang.

Jelly , 37 34 byte

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

Cobalah online!

Mengambil input huruf kecil.

Terima kasih kepada Jonathan Allan .
-1 karena ternyata ini valid sebagai fungsi :)

Terima kasih kepada Jonathan Allan (dan Dennis), sekarang Anda dapat menghapus €. Sayangnya, itu tidak akan bersaing di sini.

Penjelasan algoritma terperinci :

Kami biasanya mulai menjelaskan dari bawah (utama) tautan, turun, tapi di sini saya merasa lebih tepat untuk menjelaskan dari atas.

Pertama, kami hanya memuat daftar [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Ini terlihat seperti angka acak ya? Nah, ini sebenarnya adalah daftar angka basis-5-terkompresi, jadi kami basis-5-dekompreskan. Sekarang sepertinya [[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]]. Masih tampak acak, tapi ini sebenarnya NESWdaftar enam belas koordinat yang dipetakan, jadi kami tidak jauh dari menyelesaikan daftar (Jelly adalah indeks 1). Melakukan pemetaan akhir, kita dapatkan [['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']], yang merupakan daftar lengkap yang kita inginkan (string Jelly ada di formulir [char1, char2, char3, ...].)

Karena kami sekarang telah membangun daftar koordinat, kami bekerja dengannya. Tautan utama ikut berperan. Pertama, kita memuat daftar yang telah kita buat, dan kemudian mengambil indeks bahwa koordinat input (sebagai argumen baris perintah) berada. Kemudian, kita memasangkan pendahulunya dan penggantinya ke dalam daftar, dan kita menggunakannya sebagai modular indeks ke dalam daftar koordinat yang sama untuk mengambil koordinat ke kiri dan kanan input masing-masing. Anda sekarang berpikir kita akhirnya selesai, tetapi sebenarnya ada satu hal lagi, pemisah. Ini valid sebagai fungsi, karena 1) Anda dapat memanggilnya menggunakan <integer>Ŀ2) Anda juga diizinkan untuk mendefinisikan fungsi lain (seperti mengimpor modul). Sekarang, kita sudah selesai. Sebagai program lengkap, ini tidak memiliki pemisah, tapi tidak apa-apa, karena berfungsi sebagai fungsi.

Penjelasan kode tautan-per-tautan :

¢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 byte

Terima kasih kepada Martin Ender karena telah menghemat 6 byte!

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

Fungsi yang tidak disebutkan namanya (sebuah asosiasi, benar-benar) yang mengambil string sebagai input dan mengembalikan pasangan string yang dipesan. Pada dasarnya hanya hardcodes jawabannya.

Python 2, 116 115 103 byte

-12 byte terima kasih kepada 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]

Cobalah secara Online!

JavaScript ES6, 106 102 byte

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

Cobalah online!

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 byte (Terima kasih kepada Adnan)

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

Cobalah online!

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

Keluaran exmaple:

N => [NNW,NNE]

Versi yang mendorong N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWsebagai gantinya:

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

Juga 44-byte, ada 0 alasan untuk refactor saya dan ada 0 alasan untuk membagi pada 4's.

Javascript - 234 154 156 152 120 106 102 byte

Hanya kedua kalinya saya melakukan kode golf !!

Revisi terbaru:

Terima kasih kepada @ fəˈnɛtɪk untuk trik variabel yang rapi ini!

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

Sebelum Itu: Oke revisi terbaru: Input adalah string dan output adalah string yang ada dalam aturan, jadi saya membuatnya menjadi sebuah fungsi, dan dengan pengurangan saya menjadi lebih kecil (juga fungsi anonim, yang sekarang berarti milik saya memiliki entah bagaimana menyatu dengan jawaban js lain oops! Dia (powelles) memilikinya dulu !!):

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

Dapat digunakan oleh:

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()))

Dibuat kembali (tidak berfungsi) dengan 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]);

• Perhatikan bahwa saya membuat kesalahan pada awalnya, memiliki sama dengan a.length, bukan a.length-1 untuk indeks pertama. Terima kasih @Neil untuk menunjukkan bahwa itu tidak berfungsi untuk NNW.

• Catatan 2: Terima kasih kepada @Neil dan @ETHProductions karena membantu saya mempersingkat kodenya!

Asli:

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));

Batch, 196 byte

@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

Putar melalui masing-masing pasangan titik kompas, mencetak satu ketika yang lain cocok. Misalnya, untuk parameter ENE, ketika loop mencapai ENE, variabel sberisi NEyang dicetak, kemudian ketika loop maju E, variabel sberisi ENEdan Edicetak. Satu pasang kemudian perlu casing khusus untuk menghindari titik kompas dicetak dalam urutan yang salah.

Jelly ,  40 38 byte

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

Cobalah online! (menambahkan footer untuk menunjukkan output adalah daftar dua item) ... atau lihat semua case .

(Aku tidak yakin mengapa 1323DRẋ4menggantikannya saat “¢)`)’ḃ3Rini tidak berhasil.)

Bagaimana?

“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 byte

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#)

Cobalah online! Panggilan (s#) "N"kembali ("NNW","NNE").

sadalah pengulangan tak terhingga dari daftar arah, jadi kami tidak perlu menambahkan tambahan Ndan NNEmenyukai beberapa jawaban lain untuk menangani tepi daftar dengan benar.

Terima kasih kepada @nimi karena telah menghemat satu byte!

SOGL , 33 byte

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

Bagian pertama ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘adalah string terkompresi

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

dikompresi dengan kamus khusus dengan ENSW

Sisa program:

...‘θ,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 byte

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 Bytes

Riff pada jawaban Blue Okiris , hanya untuk mengambil keuntungan dari beberapa tulisan singkat Ruby yang bagus ( %w[]sintaksis dan pkhususnya):

->(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 byte

Disimpan 14 byte berkat produk @ETH

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

Cobalah online!

Penjelasan:

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

Cobalah online

PHP, 115 Bytes

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 Bytes menggunakan fungsi usang splitbukanexplode

PHP, 128 Bytes

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 Bytes

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 byte

Disimpan 1 byte berkat 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);

Python 3 - 112 107 byte

Saya mendasarkan ini pada jawaban Javascript saya:

Dibuat ulang:

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

Gunakan seperti kata

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()));

Asli:

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 byte

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

Cobalah online!

Penjelasan

';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 byte

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]);}

Cobalah online

Javascript (ES6), 189 byte

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]

Hanya mengambil input, mencarinya, dan mengembalikannya.

JavaScript (ES6), 94 byte

Mengharapkan string dalam huruf besar seperti "ENE". Mengembalikan string yang dipisahkan koma seperti "NE,E".

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

Bagaimana itu bekerja

Ekspresi 0+s+0dipaksa ke string ketika split()dipanggil. Misalnya, jika inputnya adalah "ENE", string akan dipecah menjadi "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Ini mengarah ke array berikut:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Sekali lagi, array ini dipaksa ke string ketika exec()dipanggil. Jadi, ekspresi reguler sebenarnya diterapkan pada:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Kami mencari karakter non-numerik berturut-turut (\D+ ) diikuti oleh koma, diikuti oleh karakter non-numerik berturut-turut. Ini mengembalikan array [ "NE,E" ]. Kita bisa berhenti di sana dan mengembalikannya. Tetapi tantangannya adalah meminta string yang dibatasi atau array dua elemen. Jadi, kami mengekstrak string dengan [0].

Demo

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 byte:

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

dimana ❤ merupakan surat yang tidak patut.

Cobalah online!

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