Cho một chuỗi là một trong những hướng trên một la bàn 16 điểm

xuất ra hai hướng liền kề với hướng đầu vào, theo thứ tự chiều kim đồng hồ.

Cụ thể, bạn cần xử lý các cặp đầu vào / đầu ra (và chỉ những) này:

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

Đầu ra có thể là một chuỗi có một số dấu phân cách (không phải không có gì) giữa các hướng hoặc danh sách hai phần tử. Hướng ngay lập tức ngược chiều kim đồng hồ với đầu vào phải xuất hiện đầu tiên. Bạn có thể sử dụng chữ cái viết thường cho chỉ đường thay vì chữ hoa nhưng giữ tất cả đầu vào và đầu ra trong trường hợp này hoặc trường hợp khác.

Ví dụ: đối với đầu vào N(hoặc nnếu bạn đang sử dụng chữ thường), một số đầu ra hợp lệ là:

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

Một số đầu ra không hợp lệ là:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

Mã ngắn nhất tính bằng byte thắng.

Toán học, 118 112 byte

Cảm ơn Martin Ender vì đã tiết kiệm 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]|>

Hàm không tên (một hiệp hội, thực sự) lấy một chuỗi làm đầu vào và trả về một cặp chuỗi được đặt hàng. Về cơ bản chỉ cần mã hóa câu trả lời.

Thạch , 37 34 byte

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

Hãy thử trực tuyến!

Đưa đầu vào chữ thường.

-2 cảm ơn Jonathan Allan .
-1 vì hóa ra đây là hợp lệ như một hàm :)

Nhờ Jonathan Allan (và Dennis), bây giờ bạn có thể xóa €. Thật không may, điều đó sẽ không cạnh tranh ở đây.

Giải thích thuật toán chi tiết :

Chúng tôi thường bắt đầu giải thích từ liên kết dưới cùng (chính), đi xuống, nhưng ở đây tôi cảm thấy như nó thích hợp hơn để giải thích từ đầu.

Đầu tiên, chúng tôi chỉ cần tải lên danh sách [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Cái này trông giống số ngẫu nhiên nhỉ? Chà, đây thực sự là một danh sách các số được nén 5 cơ sở, vì vậy chúng tôi đã giải nén nó. Bây giờ nó trông như thế [[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]]. Vẫn là những thứ có vẻ ngẫu nhiên, nhưng đây thực sự là một NESWdanh sách gồm mười sáu tọa độ, vì vậy chúng ta không còn xa để hoàn thành danh sách (Jelly là 1 chỉ mục). Thực hiện ánh xạ cuối cùng, chúng tôi nhận được [['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']], đó là danh sách đầy đủ mà chúng tôi muốn (chuỗi Jelly có dạng [char1, char2, char3, ...].)

Vì hiện tại chúng tôi đã xây dựng danh sách tọa độ, chúng tôi làm việc với nó. Các liên kết chính đi vào chơi. Đầu tiên, chúng tôi tải lên danh sách mà chúng tôi đã tạo và sau đó lấy chỉ mục mà tọa độ đầu vào (dưới dạng đối số dòng lệnh) nằm trong. Sau đó, chúng tôi ghép nối người tiền nhiệm và người kế nhiệm của nó vào danh sách và chúng tôi sử dụng chúng làm mô-đun các chỉ số vào cùng một danh sách tọa độ để lấy tọa độ ở bên trái và bên phải của đầu vào tương ứng. Bây giờ bạn nghĩ rằng cuối cùng chúng ta đã hoàn thành, nhưng thực tế có một điều nữa, đó là dải phân cách. Đây là một hàm hợp lệ, vì 1) Bạn có thể gọi nó bằng <integer>Ŀ2) Bạn cũng được phép xác định các hàm khác (như nhập mô-đun). Bây giờ, chúng ta đã hoàn thành. Là một chương trình đầy đủ, điều này không có dấu phân cách, nhưng không sao, vì nó hoạt động như một chức năng.

Giải thích mã liên kết :

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

-12 byte nhờ 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]

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

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 (Cảm ơn Adnan)

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

Hãy thử trực tuyến!

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

Đầu ra exmaple:

N => [NNW,NNE]

Phiên bản đẩy N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWthay thế:

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

Cũng là 44 byte, có 0 lý do cho bộ tái cấu trúc của tôi và có 0 lý do để chia tách trên 4.

Javascript - 234 154 156 152 120 106 102 byte

Chỉ lần thứ hai tôi chơi golf mã !!

Sửa đổi mới nhất:

Cảm ơn bạn @ fəˈnɛtɪk vì thủ thuật biến gọn gàng này!

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

Trước đó: Được rồi, bản sửa đổi mới nhất: Đầu vào là một chuỗi và đầu ra là một chuỗi theo quy tắc, vì vậy tôi đã biến nó thành một hàm và với các mức giảm tôi đã đi nhỏ hơn (cũng là hàm ẩn danh, giờ đây có nghĩa là của tôi có bằng cách nào đó nối vào các câu trả lời của js khác! Anh ấy (powelles) đã có nó trước !!):

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

Có thể được sử dụng bởi:

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

Làm lại (không phải chức năng) với Đầu ra - 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]);

• Lưu ý rằng tôi đã tạo ra một lỗi ban đầu, có nó bằng a.length thay vì a.length-1 cho chỉ mục đầu tiên. Cảm ơn @Neil vì đã chỉ ra rằng nó không hoạt động cho NNW.

• Lưu ý 2: Cảm ơn bạn @Neil và @ETH Productstions đã giúp tôi rút ngắn mã!

Nguồn gốc:

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

Mẻ, 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

Vòng lặp qua từng cặp điểm la bàn, in một lần khi các điểm khác khớp. Ví dụ, đối với một tham số của ENE, khi vòng lặp đạt tới ENE, biến schứa chứa NEđược in, sau đó khi vòng lặp tiến tới E, biến schứa ENEvà do đó Eđược in. Sau đó, một cặp cần phải được đặt đặc biệt để tránh các điểm la bàn bị in sai thứ tự.

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

Hãy thử trực tuyến! Gọi (s#) "N"trả lại ("NNW","NNE").

slà sự lặp lại vô hạn của danh sách các hướng, do đó chúng ta không phải thêm một phần phụ Nvà NNEgiống như một số câu trả lời khác để xử lý chính xác các cạnh của danh sách.

Cảm ơn @nimi vì đã tiết kiệm một byte!

Thạch ,  40 38 byte

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

Hãy thử trực tuyến! (đã thêm chân trang để hiển thị đầu ra là danh sách hai mục) ... hoặc xem tất cả các trường hợp .

(Tôi không chắc tại sao 1323DRẋ4tại chỗ “¢)`)’ḃ3Rkhông hoạt động vào lúc này.)

Làm sao?

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

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

Phần đầu tiên ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘là một chuỗi nén

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

được nén với một từ điển tùy chỉnh với ENSW

Phần còn lại của chương trình:

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

Một câu riff về câu trả lời của Blue Okiris , chỉ để tận dụng một số tốc ký tốt đẹp của Ruby ( %w[]cú pháp và pcụ thể):

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

Đã lưu 14 byte nhờ @ETHproductions

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

Hãy thử trực tuyến!

Giải trình:

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

Dùng thử trực tuyến

PHP, 115 byte

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 byte sử dụng hàm không dùng nữa splitthay vìexplode

PHP, 128 byte

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 byte

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

Đã lưu 1 byte nhờ 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

Tôi dựa trên câu trả lời Javascript này:

Làm lại:

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

Sử dụng như nói

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

Nguyên:

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

Hãy thử trực tuyến!

Giải trình

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

Dùng thử trực tuyến

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]

Chỉ cần lấy đầu vào, tìm kiếm nó và trả lại nó.

JavaScript (ES6), 94 byte

Mong đợi một chuỗi trong chữ hoa như "ENE". Trả về một chuỗi được phân tách bằng dấu phẩy như "NE,E".

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

Làm thế nào nó hoạt động

Biểu thức 0+s+0được ép buộc thành một chuỗi khi split()được gọi. Chẳng hạn, nếu đầu vào là "ENE", chuỗi sẽ được tách ra "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Điều này dẫn đến mảng sau:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Một lần nữa, mảng này bị ép buộc thành một chuỗi khi exec()được gọi. Vì vậy, biểu thức chính quy thực sự được áp dụng trên:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Chúng tôi tìm kiếm các ký tự không phải là số liên tiếp ( \D+) theo sau là dấu phẩy, theo sau là các ký tự không phải là số liên tiếp. Điều này trả về mảng [ "NE,E" ]. Chúng tôi có thể dừng lại ở đó và trở lại như vậy. Nhưng thách thức là yêu cầu một chuỗi phân tách hoặc một mảng hai phần tử. Vì vậy, chúng tôi trích xuất chuỗi với [0].

Bản giới thiệu

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

trong đó ❤đại diện cho các chữ cái không thể in.

Hãy thử trực tuyến!

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