Dada una cuerda que es una de las direcciones en una rosa de los vientos de 16 puntos

genera las dos direcciones que están inmediatamente adyacentes a la dirección de entrada, en el sentido de las agujas del reloj.

Específicamente, debe manejar estos (y solo estos) pares de entrada / salida:

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

La salida puede ser una cadena con algún delimitador (no nada) entre las direcciones o una lista de dos elementos. La dirección inmediatamente en sentido antihorario hasta la entrada debe aparecer primero. Puede usar letras minúsculas para las direcciones en lugar de mayúsculas, pero mantenga todas las entradas y salidas en un caso u otro.

Por ejemplo, para la entrada N(o nsi está usando minúsculas) algunas salidas válidas son:

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

Algunas salidas inválidas son:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

El código más corto en bytes gana.

Jalea , 37 34 bytes

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

Pruébalo en línea!

Toma entrada en minúsculas.

-2 gracias a Jonathan Allan .
-1 ya que resulta que esto es válido como una función :)

Gracias a Jonathan Allan (y Dennis), ahora puedes eliminar el €. Desafortunadamente, eso sería no competir aquí.

Explicación detallada del algoritmo :

Por lo general, comenzamos a explicar desde el enlace inferior (principal), bajando, pero aquí siento que es más apropiado explicar desde arriba.

Primero, simplemente cargamos la lista [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Esto parece números aleatorios, ¿eh? Bueno, esta es en realidad una lista de números comprimidos en base 5, por lo que lo descomprimimos en base 5. Ahora 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]]. Todavía tiene un aspecto aleatorio, pero en realidad es una NESWlista mapeada de las dieciséis coordenadas, por lo que no estamos lejos de completar la lista (Jelly está indexada en 1). Al hacer el mapeo final, obtenemos [['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 es la lista completa que queremos (las cadenas Jelly están en el formulario [char1, char2, char3, ...]).

Como ahora hemos creado la lista de coordenadas, trabajamos con ella. El enlace principal entra en juego. Primero, cargamos la lista que hemos construido, y luego tomamos el índice en el que reside la coordenada de entrada (como argumento de línea de comando). Luego, emparejamos su predecesor y su sucesor en una lista, y los usamos como modulares índices en la misma lista de coordenadas para tomar la coordenada a la izquierda y derecha de la entrada respectivamente. Ahora pensarías que finalmente hemos terminado, pero de hecho hay una cosa más, el separador. Esto es válido como función, ya que 1) Puede llamarlo usando <integer>Ŀ2) También puede definir otras funciones (como importar módulos). Ahora hemos terminado. Como programa completo, esto no tiene un separador, pero está bien, ya que funciona como una función.

Explicación del código de enlace por enlace :

¢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

¡Gracias a Martin Ender por guardar 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]|>

Función sin nombre (una asociación, realmente) que toma una cadena como entrada y devuelve un par ordenado de cadenas. Básicamente, solo codifica la respuesta.

Python 2, 116 115 103 bytes

-12 bytes gracias 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]

Pruébalo en línea!

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

Pruébalo en línea!

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 (Gracias a Adnan)

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

Pruébalo en línea!

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

Salida de ejemplo:

N => [NNW,NNE]

Versión que empuja en su N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWlugar:

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

También es de 44 bytes, había 0 razones para mi refactor y hay 0 razones para dividir en los 4.

Javascript - 234 154 156 152 120 106 102 bytes

¡Solo mi segunda vez haciendo código golf!

Última revisión:

¡Gracias a @ fəˈnɛtɪk por este ingenioso truco variable!

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 de eso: Ok, última revisión: la entrada es una cadena y la salida es una cadena que está en las reglas, por lo que la convertí en una función, y con las reducciones me he vuelto aún más pequeña (también la función es anónima, lo que ahora significa que la mía tiene de alguna manera se mezcló con las otras respuestas js ¡Uy! ¡Él (powelles) lo tuvo primero!):

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

Puede ser utilizado 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()))

Rehecho (no funciona) con Salida - 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]);

• Tenga en cuenta que originalmente cometí un error, que tiene una longitud igual a. Gracias @Neil por señalar que no funcionó para NNW.

• Nota 2: ¡Gracias a @Neil y @ETHProductions por ayudarme a acortar el 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

Recorre cada par de puntos de la brújula, imprimiendo uno cuando el otro coincide. Por ejemplo, para un parámetro de ENE, cuando el bucle alcanza ENE, la variable scontiene lo NEque se imprime, luego, cuando el bucle avanza E, la variable scontiene ENEy así Ese imprime. Luego, un par debe tener una carcasa especial para evitar que los puntos de la brújula se impriman en el orden incorrecto.

Jalea ,  40 38 bytes

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

Pruébalo en línea! (se agregó el pie de página para mostrar que la salida es una lista de dos elementos) ... o ver todos los casos .

(No estoy muy seguro de por qué 1323DRẋ4en lugar de “¢)`)’ḃ3Rno funciona en este momento).

¿Cómo?

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

Pruébalo en línea! Llamadas (s#) "N"devueltas ("NNW","NNE").

ses una repetición infinita de la lista de direcciones, por lo tanto, no tenemos que agregar un extra Ny dar me NNEgusta a algunas de las otras respuestas para manejar correctamente los bordes de la lista.

¡Gracias a @nimi por guardar un byte!

SOGL , 33 bytes

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

La primera parte ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘es una cadena comprimida que es

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

comprimido con un diccionario personalizado con ENSW

El resto del 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];

Rubí: 94 bytes

Un riff en la respuesta de Blue Okiris , solo para aprovechar una buena taquigrafía de Ruby (la %w[]sintaxis y pespecíficamente):

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

Ahorró 14 bytes gracias a @ETHproductions

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

Pruébalo en línea!

Explicación:

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

Pruébalo en línea

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 que usan la función obsoleta split lugar 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 gracias 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

Basé esto en mi respuesta de Javascript:

Rehecho:

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

Usar como decir

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea

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]

Simplemente toma la entrada, la busca y la devuelve.

JavaScript (ES6), 94 bytes

Espera una cadena en mayúsculas como "ENE". Devuelve una cadena separada por comas como "NE,E".

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

Cómo funciona

La expresión 0+s+0se convierte en una cadena cuando split()se llama. Por ejemplo, si la entrada es "ENE", la cadena se dividirá en "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Esto lleva a la siguiente matriz:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Nuevamente, esta matriz se coacciona a una cadena cuando exec()se llama. Entonces, la expresión regular se aplica realmente a:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Buscamos caracteres no numéricos consecutivos ( \D+) seguidos de una coma, seguidos de caracteres no numéricos consecutivos. Esto devuelve la matriz [ "NE,E" ]. Podríamos parar allí y regresar solo eso. Pero el desafío es pedir una cadena delimitada o una matriz de dos elementos. Entonces, extraemos la cadena con [0].

Manifestación

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

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

donde ❤representa letras no imprimibles.

Pruébalo en línea!

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