Dada uma corda que é uma das direções em uma rosa dos ventos de 16 pontos

emita as duas direções imediatamente adjacentes à direção de entrada, no sentido horário.

Especificamente, você precisa manipular estes (e somente estes) pares de entrada / saída:

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

A saída pode ser uma sequência com algum delimitador (não nada) entre as direções ou uma lista de dois elementos. A direção imediatamente no sentido anti-horário da entrada deve aparecer primeiro. Você pode usar letras minúsculas para as direções em vez de maiúsculas, mas mantenha todas as entradas e saídas em um ou outro caso.

Por exemplo, para entrada N(ou nse você estiver usando letras minúsculas), algumas saídas válidas são:

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

Algumas saídas inválidas são:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

O código mais curto em bytes vence.

Geléia , 37 34 bytes

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

Experimente online!

Recebe entrada em minúscula.

-2 graças a Jonathan Allan .
-1, pois isso é válido como uma função :)

Graças a Jonathan Allan (e Dennis), agora você pode remover o €. Infelizmente, isso não seria competitivo aqui.

Explicação detalhada do algoritmo :

Geralmente começamos a explicar a partir do link inferior (principal), descendo, mas aqui acho que é mais apropriado explicar a partir do topo.

Primeiro, simplesmente carregamos a lista [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Parece números aleatórios né? Bem, na verdade, essa é uma lista de números compactados com base 5, portanto, descompactamos com base 5. Agora parece [[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]]. Ainda são coisas de aparência aleatória, mas essa é realmente uma NESWlista mapeada das dezesseis coordenadas, por isso não estamos longe de concluir a lista (Jelly é indexada em 1). Ao fazer o mapeamento final, obtemos [['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']], que é a lista completa que queremos (as strings Jelly estão no formulário [char1, char2, char3, ...]).

Como agora criamos a lista de coordenadas, trabalhamos com ela. O link principal entra em jogo. Primeiro, carregamos a lista que construímos e, em seguida, pegamos o índice no qual a entrada (como argumento da linha de comando) reside. Em seguida, associamos seu predecessor e seu sucessor a uma lista e os usamos como modulares na mesma lista de coordenadas para levar a coordenada à esquerda e à direita da entrada, respectivamente. Você pensaria agora que finalmente terminamos, mas na verdade há mais uma coisa, o separador. Isso é válido como uma função, pois 1) Você pode chamá-lo usando <integer>Ŀ2) Você também pode definir outras funções (como importar módulos). Agora terminamos. Como um programa completo, isso não tem um separador, mas tudo bem, pois funciona como uma função.

Explicação do código link a 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.

Mathematica, 118 112 bytes

Agradecemos a Martin Ender por economizar 6 bytes!

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

Função sem nome (uma associação, na verdade) que recebe uma string como entrada e retorna um par ordenado de strings. Basicamente, apenas codifica a resposta.

Python 2, 116 115 103 bytes

-12 bytes graças 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]

Experimente Online!

JavaScript ES6, 106 102 bytes

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

Experimente 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 bytes (Agradecimentos a Adnan)

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

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

Saída exemplar:

N => [NNW,NNE]

Versão que empurra N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW:

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

Também tem 44 bytes, houve 0 motivo para o meu refator e 0 motivo para divisão nos 4's.

Javascript - 234 154 156 152 120 106 106 102 bytes

Apenas minha segunda vez fazendo código de golfe !!

Revisão mais recente:

Obrigado a @ fəˈnɛtɪk por este puro truque de variável!

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

Antes disso: Ok, a revisão mais recente: Input é uma string e output é uma string que está nas regras, então eu a transformei em uma função e, com reduções, fiquei ainda menor (também a função é anônima, o que agora significa que a minha de alguma forma, mesclado com o outro js answer oops! Ele (powelles) teve primeiro !!):

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

Pode ser usado por:

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

Reformado (não funciona) com Saída - 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]);

• Observe que cometi um erro originalmente, tendo o mesmo a.length em vez de a.length-1 no primeiro índice. Obrigado @Neil por apontar que não funcionou para a NNW.

• Nota 2: Obrigado a @Neil e @ETHProductions por me ajudarem a reduzir o código!

Original:

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

Lote, 196 bytes

@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 por cada par de pontos da bússola, imprimindo um quando o outro corresponde. Por exemplo, para um parâmetro de ENE, quando o loop atinge ENE, a variável scontém o NEque é impresso, quando o loop avança para E, a variável scontém ENEe, portanto, Eé impressa. Um par precisa ser de caixa especial para evitar que os pontos da bússola sejam impressos na ordem errada.

Geléia ,  40 38 bytes

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

Experimente online! (adicionado o rodapé para mostrar a saída é uma lista de dois itens) ... ou veja todos os casos .

(Não sei ao certo por que, 1323DRẋ4no lugar de “¢)`)’ḃ3R, não funciona no momento.)

Quão?

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

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

Experimente online! Chamando (s#) "N"retornos ("NNW","NNE").

sé uma repetição infinita da lista de direções; portanto, não precisamos adicionar um extra Ne, NNEcomo algumas das outras respostas, para lidar corretamente com as bordas da lista.

Agradecemos a @nimi por salvar um byte!

SOGL , 33 bytes

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

A primeira parte ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘é uma string compactada que é

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

compactado com um dicionário personalizado com ENSW

O restante do programa:

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

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

Um riff na resposta de Blue Okiris , apenas para tirar proveito de uma boa abreviação de Ruby (a %w[]sintaxe e pespecificamente):

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

Economizou 14 bytes graças a @ETHproductions

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

Experimente online!

Explicação:

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

Experimente 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 usando a função reprovada em splitvez deexplode

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 bytes

Guardado 1 byte graças 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 bytes

Baseei isso na minha resposta Javascript:

Remade:

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

Use como diz

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

Original:

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 bytes

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

Experimente online!

Explicação

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

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

Experimente online

Javascript (ES6), 189 bytes

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]

Apenas pega a entrada, procura e retorna.

JavaScript (ES6), 94 bytes

Espera uma sequência em maiúsculas, como "ENE". Retorna uma string separada por vírgula, como "NE,E".

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

Como funciona

A expressão 0+s+0é coagida a uma string quando split()é chamada. Por exemplo, se a entrada for "ENE", a sequência será dividida em "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Isso leva à seguinte matriz:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Novamente, esse array é coagido a uma string quando exec()é chamado. Portanto, a expressão regular é realmente aplicada em:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Procuramos caracteres não numéricos consecutivos ( \D+) seguidos por vírgula, seguidos por caracteres não numéricos consecutivos. Isso retorna a matriz [ "NE,E" ]. Sem dúvida, poderíamos parar por aí e retornar exatamente isso. Mas o desafio é solicitar uma sequência delimitada ou uma matriz de dois elementos. Então, extraímos a string com [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))
)

Pitão , 39 bytes:

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

onde ❤representa letras imprimíveis.

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