Biorąc pod uwagę sznurek, który jest jednym z kierunków 16-punktowej róży kompasu

wyprowadzaj dwa kierunki, które są bezpośrednio przylegające do kierunku wprowadzania, w kolejności zgodnej z ruchem wskazówek zegara.

W szczególności musisz obsługiwać te (i tylko te) pary wejścia / wyjścia:

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

Dane wyjściowe mogą być łańcuchem z pewnym ogranicznikiem (a nie niczym) między kierunkami lub listą dwóch elementów. Najpierw musi pojawić się kierunek bezpośrednio w kierunku przeciwnym do ruchu wskazówek zegara do wejścia. Możesz używać małych liter jako wskazówek zamiast wielkich liter, ale zachowaj wszystkie dane wejściowe i wyjściowe w jednym lub drugim przypadku.

Na przykład dla danych wejściowych N(lub njeśli używasz małych liter) niektóre prawidłowe dane wyjściowe to:

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

Niektóre nieprawidłowe dane wyjściowe to:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

Najkrótszy kod w bajtach wygrywa.

Mathematica, 118 112 bajtów

Dzięki Martin Ender za oszczędność 6 bajtów!

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

Nienazwana funkcja (naprawdę skojarzenie), która pobiera ciąg wejściowy i zwraca uporządkowaną parę ciągów. Zasadniczo po prostu koduje odpowiedź.

Galaretka , 37 34 bajtów

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

Wypróbuj online!

Pobiera małe litery.

-2 dzięki Jonathan Allan .
-1, ponieważ okazuje się, że jest to poprawne jako funkcja :)

Dzięki Jonathanowi Allanowi (i Dennisowi) możesz teraz usunąć €. Niestety byłoby to tutaj niekonkurencyjne.

Szczegółowe wyjaśnienie algorytmu :

Zazwyczaj zaczynamy wyjaśniać od dolnego (głównego) linku, schodząc w dół, ale tutaj wydaje mi się, że lepiej jest wyjaśnić od góry.

Po pierwsze, po prostu ładujemy listę [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. To wygląda na przypadkowe liczby, co? To właściwie jest lista liczb skompresowanych w bazie 5, więc dekompresujemy ją w bazie 5. Teraz to wygląda [[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]]. Nadal wyglądają losowo, ale tak naprawdę jest to NESWmapowana szesnaście współrzędnych, więc nie jesteśmy daleko od uzupełnienia listy (galaretka ma indeks 1). Robiąc ostateczne mapowanie, otrzymujemy [['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']]pełną listę, której chcemy (łańcuchy galaretki są w formie [char1, char2, char3, ...]).

Ponieważ zbudowaliśmy teraz listę współrzędnych, pracujemy z nią. W grę wchodzi główny link. Najpierw ładujemy listę, którą zbudowaliśmy, a następnie bierzemy indeks, w którym znajduje się współrzędna wejściowa (jako argument wiersza poleceń). Następnie łączymy jej poprzednika i jego następcę z listą i używamy ich jako modułów indeksy do tej samej listy współrzędnych, aby wziąć współrzędną odpowiednio z lewej i prawej strony wejścia. Można by pomyśleć, że w końcu skończyliśmy, ale tak naprawdę jest jeszcze jedna rzecz, separator. Jest to ważne jako funkcja, ponieważ 1) Możesz wywołać to za pomocą <integer>Ŀ2) Możesz także definiować inne funkcje (np. Importowanie modułów). Teraz skończymy. Jako pełny program nie ma separatora, ale jest w porządku, ponieważ działa jako funkcja.

Objaśnienie kodu link-by-link :

¢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 bajtów

-12 bajtów dzięki Neilowi

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]

Wypróbuj online!

JavaScript ES6, 106 102 bajtów

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

Wypróbuj 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 bajty (dzięki Adnan)

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

Wypróbuj 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.

Przykładowy wynik:

N => [NNW,NNE]

Wersja, która N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWzamiast tego wypycha :

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

Ma również 44 bajty, mój refaktor miał 0 powodów i nie ma 4 powodów podziału na 4.

JavaScript - 234 154 156 152 120 106 106 102 bajtów

Tylko mój drugi raz robię kod golfa !!

Ostatnie poprawki:

Dziękuję @ fəˈnɛtɪk za tę zgrabną zmienną sztuczkę!

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

Wcześniej: Dobra, więc najnowsza wersja: Dane wejściowe to ciąg znaków, a dane wyjściowe to ciąg znaków, który jest zgodny z regułami, więc przekształciłem go w funkcję, a dzięki redukcjom stałem się jeszcze mniejszy (również funkcja jest anonimowa, co oznacza, że ​​moja ma jakoś wplątał się w odpowiedź innego js. Oops! On (powelles) miał go pierwszy !!):

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

Może być używany przez:

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 (nie działa) z wyjściem - 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]);

• Zauważ, że początkowo popełniłem błąd, mając dla pierwszego indeksu równą a.length zamiast a.length-1. Dzięki @Neil za zwrócenie uwagi, że to nie działa dla NNW.

• Uwaga 2: Dziękuję @Neil i @ETHProductions za pomoc w skróceniu kodu!

Pierwotny:

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

Partia, 196 bajtów

@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

Pętle przechodzą przez każdą parę punktów kompasu, drukując jeden, gdy drugi pasuje. Na przykład dla parametru ENE, kiedy pętla osiąga ENE, zmienna szawiera NEto, co jest drukowane, a następnie, gdy pętla przesuwa się do przodu E, zmienna szawiera ENEi tak Ejest drukowana. Następnie jedna para musi być w specjalnej obudowie, aby uniknąć drukowania punktów kompasu w niewłaściwej kolejności.

Haskell , 100 99 bajtów

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

Wypróbuj online! Połączenia (s#) "N"zwrotne ("NNW","NNE").

sto nieskończone powtarzanie listy kierunków, dlatego nie musimy dodawać dodatkowych Ni NNEpodobnie jak niektóre inne odpowiedzi, aby poprawnie obsługiwać krawędzie listy.

Dzięki @nimi za uratowanie jednego bajtu!

Galaretka ,  40 38 bajtów

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

Wypróbuj online! (dodano stopkę pokazującą, że wynikiem jest lista dwóch elementów) ... lub zobacz wszystkie przypadki .

(Nie jestem do końca pewien, dlaczego 1323DRẋ4w miejscu “¢)`)’ḃ3Rnie działa w tej chwili.)

W jaki sposób?

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

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

Pierwsza część ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘to skompresowany ciąg znaków

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

skompresowany za pomocą niestandardowego słownika za pomocą ENSW

Reszta programu:

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

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

Rubin - 94 bajtów

Riff na odpowiedź Blue Okiris , aby skorzystać z ładnego skróconego Rubiego ( %w[]składnia i pkonkretnie):

->(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 bajtów

Zaoszczędź 14 bajtów dzięki @ETHproductions

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

Wypróbuj online!

Wyjaśnienie:

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

Wypróbuj online

PHP, 115 bajtów

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 bajty za pomocą przestarzałej funkcji splitzamiastexplode

PHP, 128 bajtów

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 bajtów

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 bajtów

Oszczędność 1 bajtu dzięki Jörgowi Hülsermannowi .

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 bajtów

Oparłem to na mojej odpowiedzi Javascript:

Przerobić:

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

Użyj jak powiedz

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

Oryginalny:

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 bajty

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

Wypróbuj online!

Wyjaśnienie

';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 bajtów

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

Wypróbuj online

JavaScript (ES6), 189 bajtów

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]

Po prostu pobiera dane wejściowe, sprawdza je i zwraca.

JavaScript (ES6), 94 bajty

Oczekuje łańcucha pisanego wielkimi literami, takiego jak "ENE". Zwraca ciąg oddzielony przecinkami, taki jak "NE,E".

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

Jak to działa

0+s+0Wywołanie wyrażenia jest wymuszane na ciąg znaków split(). Na przykład, jeśli dane wejściowe są "ENE", ciąg zostanie podzielony na "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Prowadzi to do następującej tablicy:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Ponownie, ta tablica jest wymuszana na ciąg, gdy exec()jest wywoływana. Wyrażenie regularne jest zatem stosowane do:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Szukamy kolejnych znaków nienumerycznych ( \D+), po których następuje przecinek, a następnie kolejnych znaków nienumerycznych. Zwraca tablicę [ "NE,E" ]. Prawdopodobnie moglibyśmy się tam zatrzymać i zwrócić właśnie to. Ale wyzwanie polega na zapytaniu o łańcuch rozdzielany lub tablicę dwuelementową. Tak więc wyodrębniamy ciąg [0].

Próbny

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 bajtów:

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

gdzie ❤reprezentuje niezadrukowane litery.

Wypróbuj 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. .