Data una stringa che è una delle direzioni su una rosa dei venti a 16 punti

emette le due direzioni che sono immediatamente adiacenti alla direzione di ingresso, in senso orario.

In particolare, è necessario gestire queste (e solo queste) coppie input / output:

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

L'output può essere una stringa con delimitatore (non nulla) tra le direzioni o un elenco di due elementi. La direzione immediatamente in senso antiorario all'ingresso deve apparire per prima. È possibile utilizzare lettere minuscole per le direzioni anziché maiuscole, ma conservare tutti gli input e output in un caso o nell'altro.

Ad esempio, per l'input N(o nse si utilizza la minuscola) alcuni output validi sono:

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

Alcuni output non validi sono:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

Vince il codice più breve in byte.

Gelatina , 37 34 byte

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

Provalo online!

Accetta input in minuscolo.

-2 grazie a Jonathan Allan .
-1 poiché risulta che questo è valido come funzione :)

Grazie a Jonathan Allan (e Dennis), ora puoi rimuovere il file € . Sfortunatamente, qui non sarebbe in competizione.

Spiegazione dettagliata dell'algoritmo :

Di solito iniziamo a spiegare dal link in basso (principale), andando in basso, ma qui mi sento più appropriato spiegare dall'alto.

Innanzitutto, carichiamo semplicemente l'elenco [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Sembra numeri casuali eh? Bene, questo è in realtà un elenco di numeri compressi in base 5, quindi lo decomprimiamo in base 5. Ora sembra [[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]]. Ancora roba dall'aspetto casuale, ma questo è in realtà un NESWelenco composto da sedici coordinate, quindi non siamo lontani dal completare l'elenco (Jelly è 1-indicizzata). Facendo la mappatura finale, otteniamo[['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']] , che è l'elenco completo che vogliamo (le stringhe Jelly sono nel modulo [char1, char2, char3, ...].)

Dato che ora abbiamo creato l'elenco delle coordinate, lavoriamo con esso. Entra in gioco il link principale. Innanzitutto, cariciamo l'elenco che abbiamo creato, quindi prendiamo l'indice in cui risiede la coordinata dell'input (come argomento della riga di comando). Quindi, accoppiamo il suo predecessore e il suo successore in un elenco e li usiamo come modulari indici nella stessa lista di coordinate per prendere le coordinate rispettivamente a sinistra e a destra dell'input. Ora penseresti che abbiamo finalmente finito, ma in realtà c'è un'altra cosa, il separatore. Questo è valido come funzione, poiché 1) Puoi chiamarlo usando<integer>Ŀ 2) Puoi anche definire altre funzioni (come importare moduli). Ora abbiamo finito. Come programma completo, questo non ha un separatore, ma va bene, dal momento che funziona come una funzione.

Spiegazione del codice collegamento per collegamento :

¢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

Grazie a Martin Ender per aver salvato 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]|>

Funzione senza nome (un'associazione, in realtà) che accetta una stringa come input e restituisce una coppia ordinata di stringhe. Fondamentalmente codifica semplicemente la risposta.

Python 2, 116 115 103 byte

-12 byte grazie a 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]

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

Provalo 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 (grazie ad Adnan)

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

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

Esempio di output:

N => [NNW,NNE]

Versione che spinge N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWinvece:

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

Ha anche 44 byte, c'era 0 motivo per il mio refactor e c'era 0 motivo per dividere sui 4.

Javascript - 234 154 156 152 120 106 102 byte

Solo la mia seconda volta facendo il golf a codice !!

Ultima revisione:

Grazie a @ fəˈnɛtɪk per questo trucco variabile pulito!

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

Prima di quello: va bene l'ultima revisione: l'input è una stringa e l'output è una stringa che è nelle regole, quindi l'ho trasformata in una funzione e con le riduzioni sono diventata ancora più piccola (anche la funzione è anonima, il che significa che il mio ha in qualche modo si intrecciava nelle altre js answer oops! Lui (Powelles) ce l'aveva prima !!):

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

Può essere utilizzato da:

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 (non funzione) con 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]);

• Nota che inizialmente ho fatto un errore, avendo uguale a.length invece di a.length-1 per il primo indice. Grazie @Neil per aver sottolineato che non ha funzionato per NNW.

• Nota 2: Grazie a @Neil e @ETHProductions per avermi aiutato ad abbreviare il codice!

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

Lotto, 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

Passa attraverso ogni coppia di punti cardinali, stampandone uno quando l'altro corrisponde. Ad esempio, per un parametro di ENE, quando il ciclo raggiunge ENE, la variabile scontiene NEquale viene stampato, quindi quando il ciclo avanza E, la variabile scontiene ENEe così Eviene stampata. Una coppia deve quindi essere racchiusa in un involucro speciale per evitare che i punti cardinali vengano stampati nell'ordine sbagliato.

Gelatina ,  40 38 byte

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

Provalo online! (aggiunto il piè di pagina per mostrare che l'output è un elenco di due elementi) ... o vedere tutti i casi .

(Non sono del tutto sicuro del motivo 1323DRẋ4per cui al posto di “¢)`)’ḃ3Rnon funziona al momento.)

Come?

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

Provalo online! Chiamata (s#) "N"ritorna ("NNW","NNE").

sè una ripetizione infinita dell'elenco delle direzioni, quindi non è necessario aggiungere un extra NeNNE come alcune delle altre risposte per gestire correttamente i bordi dell'elenco.

Grazie a @nimi per aver salvato un byte!

SOGL , 33 byte

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

La prima parte ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘è una stringa compressa che è

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

compresso con un dizionario personalizzato con ENSW

Il resto del programma:

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

Rubino - 94 byte

Un riff sulla risposta di Blue Okiris , solo per approfittare della bella stenografia di Ruby (la %w[]sintassi e in pparticolare):

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

Salvato 14 byte grazie a @ETHproductions

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

Provalo online!

Spiegazione:

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

Provalo online

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 utilizzando la funzione obsoleta splitanziché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

Salvato 1 byte grazie a 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

Ho basato questo sulla mia risposta Javascript:

rifatto:

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

Usa come dire

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

Originale:

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

Provalo online!

Spiegazione

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

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

Prende solo l'input, lo cerca e lo restituisce.

JavaScript (ES6), 94 byte

Si aspetta una stringa in maiuscolo come "ENE" . Restituisce una stringa separata da virgola come "NE,E".

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

Come funziona

L'espressione 0+s+0viene forzata su una stringa quando split()viene chiamata. Ad esempio, se l'input è"ENE" , la stringa verrà suddivisa in "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Questo porta al seguente array:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Ancora una volta, questo array è costretto a una stringa quando exec() viene chiamato. Quindi, l'espressione regolare viene effettivamente applicata su:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Cerchiamo caratteri non numerici consecutivi (\D+ ) seguiti da una virgola, seguiti da caratteri non numerici consecutivi. Questo restituisce l'array [ "NE,E" ]. Potremmo probabilmente fermarci qui e restituire proprio questo. Ma la sfida è chiedere una stringa delimitata o una matrice a due elementi. Quindi, estraiamo la stringa con[0] .

dimostrazione

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

dove ❤ rappresenta lettere non stampabili.

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