Gegeben eine Zeichenfolge, die eine der Richtungen auf einer 16-Punkt-Kompassrose ist

Geben Sie die beiden Richtungen, die der Eingaberichtung unmittelbar benachbart sind, im Uhrzeigersinn aus.

Insbesondere müssen Sie diese (und nur diese) Eingabe / Ausgabe-Paare behandeln:

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

Die Ausgabe kann eine Zeichenfolge mit einem Trennzeichen (nicht nichts) zwischen den Richtungen oder eine Liste mit zwei Elementen sein. Die Richtung unmittelbar gegen den Uhrzeigersinn zum Eingang muss zuerst erscheinen. Sie können für die Anweisungen Kleinbuchstaben anstelle von Großbuchstaben verwenden, aber alle Eingaben und Ausgaben in der einen oder anderen Schreibweise beibehalten.

Für die Eingabe N(oder nwenn Sie Kleinbuchstaben verwenden) sind beispielsweise folgende Ausgaben gültig:

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

Einige ungültige Ausgaben sind:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

Der kürzeste Code in Bytes gewinnt.

Mathematica, 118 112 Bytes

Vielen Dank an Martin Ender für die Einsparung von 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]|>

Unbenannte Funktion (eigentlich eine Assoziation), die eine Zeichenfolge als Eingabe verwendet und ein geordnetes Zeichenfolgenpaar zurückgibt. Grundsätzlich ist die Antwort nur hartcodiert.

Jelly , 37 34 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe in Kleinbuchstaben.

-2 Danke an Jonathan Allan .
-1 da sich herausstellt, dass dies als Funktion gültig ist :)

Dank Jonathan Allan (und Dennis) können Sie jetzt die entfernen €. Das wäre hier leider nicht konkurrierend.

Detaillierte Erklärung des Algorithmus :

Normalerweise beginnen wir mit dem Erklären vom unteren (Haupt-) Link aus, aber ich halte es für angemessener, es von oben zu erklären.

Zuerst laden wir einfach die Liste hoch [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Das sieht nach Zufallszahlen aus, oder? Nun, das ist eigentlich eine Liste von Zahlen mit Basis 5-Komprimierung, also dekomprimieren wir sie mit Basis 5. Jetzt sieht es so aus [[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]]. Es sieht immer noch zufällig aus, aber dies ist eine NESWListe mit 16 Koordinaten. Wir sind also nicht weit davon entfernt, die Liste zu vervollständigen (Jelly ist 1-indiziert). Wenn wir das endgültige Mapping machen, erhalten wir [['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']], was die vollständige Liste ist, die wir wollen (Jelly Strings sind in der Form [char1, char2, char3, ...].)

Da wir jetzt die Koordinatenliste erstellt haben, arbeiten wir damit. Der Hauptlink kommt ins Spiel. Zuerst laden wir die Liste, die wir erstellt haben, und nehmen dann den Index, in dem sich die Eingabe- (als Befehlszeilenargument) -Koordinate befindet. Dann koppeln wir ihren Vorgänger und ihren Nachfolger zu einer Liste und verwenden sie als modular Indiziert in dieselbe Koordinatenliste, um die Koordinate links und rechts von der Eingabe zu nehmen. Sie würden jetzt denken, wir sind endlich fertig, aber es gibt noch eine Sache, den Separator. Dies gilt als Funktion, da 1) Sie es mit <integer>Ŀ2) aufrufen können. Sie dürfen auch andere Funktionen definieren (wie das Importieren von Modulen). Nun sind wir fertig. Als vollständiges Programm hat dies kein Trennzeichen, aber das ist in Ordnung, da es als Funktion funktioniert.

Erklärung des Link-by-Link-Codes :

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

-12 Bytes dank 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]

Probieren Sie es 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]]

Probieren Sie es 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 (Dank an Adnan)

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

Probieren Sie es 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.

Beispielausgabe:

N => [NNW,NNE]

Version, die N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWstattdessen drückt :

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

Ist auch 44-Byte, gab es 0 Grund für meinen Refactor und es gibt 0 Grund für die Aufteilung auf die 4er.

Javascript - 234 154 156 152 120 106 102 Bytes

Nur mein zweites Mal macht Code Golf !!

Letzte Überprüfung:

Vielen Dank an @ fəˈnəˈtɛk für diesen tollen Variablentrick!

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

Vorher: Okay, letzte Überarbeitung: Input ist eine Zeichenkette und Output ist eine Zeichenkette, die in den Regeln enthalten ist. Deshalb habe ich sie zu einer Funktion gemacht und mit Verkleinerungen bin ich sogar noch kleiner geworden (auch die Funktion ist anonym, was bedeutet, dass meine jetzt funktioniert) irgendwie vermascht mit den anderen js antwort hoppla! er (powelles) hatte es zuerst !!):

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

Kann verwendet werden von:

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 (nicht funktionieren) mit Ausgang - 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]);

• Beachten Sie, dass ich ursprünglich einen Fehler gemacht habe, der a.length anstelle von a.length-1 für den ersten Index entspricht. Vielen Dank an @Neil für den Hinweis, dass es bei NNW nicht funktioniert hat.

• Hinweis 2: Vielen Dank an @Neil und @ETHProductions, die mir geholfen haben, den Code zu verkürzen!

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

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

Durchläuft jedes Kompasspunktpaar und druckt eines aus, wenn das andere übereinstimmt. Zum Beispiel für einen Parameter ENE, wenn die Schleife erreicht ENE, wird die Variable senthält , NEdie gedruckt wird, dann , wenn die Schleife weiter zu E, wird die Variable senthält ENEund so Egedruckt wird. Ein Paar muss dann ein spezielles Gehäuse haben, um zu vermeiden, dass die Kompasspunkte in der falschen Reihenfolge gedruckt werden.

Haskell , 100 bis 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#)

Probieren Sie es online! Calling (s#) "N"kehrt zurück ("NNW","NNE").

sist eine unendliche Wiederholung der Liste der Anweisungen, daher müssen wir keine zusätzlichen Nund NNEähnlichen Antworten hinzufügen , um die Ränder der Liste richtig zu behandeln.

Vielen Dank an @nimi für das Speichern eines Bytes!

Jelly ,  40 38 Bytes

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

Probieren Sie es online! (Fußzeile hinzugefügt, um anzuzeigen, dass die Ausgabe eine Liste mit zwei Elementen ist) ... oder alle Fälle anzeigen .

(Ich bin nicht ganz sicher, warum 1323DRẋ4anstelle von “¢)`)’ḃ3Rim Moment nicht funktioniert.)

Wie?

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

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

Der erste Teil ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘ist eine komprimierte Zeichenfolge

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

komprimiert mit einem benutzerdefinierten Wörterbuch mit ENSW

Der Rest des Programms:

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

Ein Riff über die Antwort von Blue Okiris , nur um ein paar nette Ruby-Abkürzungen zu nutzen (die %w[]Syntax und pspeziell):

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

14 Bytes dank @ETHproductions eingespart

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

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online aus

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 mit der veralteten Funktion splitanstelle vonexplode

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

1 Byte gespart dank 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

Ich habe dies anhand meiner Javascript-Antwort ermittelt:

Neu gemacht:

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

Verwenden Sie wie gesagt

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online aus

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]

Nimmt einfach die Eingabe, sucht sie und gibt sie zurück.

JavaScript (ES6), 94 Byte

Erwartet eine Zeichenfolge in Großbuchstaben wie "ENE". Gibt eine durch Kommas getrennte Zeichenfolge zurück, z "NE,E".

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

Wie es funktioniert

Der Ausdruck 0+s+0wird beim split()Aufruf in eine Zeichenfolge umgewandelt . Wenn die Eingabe beispielsweise lautet "ENE", wird die Zeichenfolge aufgeteilt in "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Dies führt zu folgendem Array:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Auch dieses Array wird beim exec()Aufruf in eine Zeichenfolge umgewandelt . Der reguläre Ausdruck wird also tatsächlich angewendet auf:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Wir suchen nach aufeinanderfolgenden nicht numerischen Zeichen ( \D+), gefolgt von einem Komma, gefolgt von aufeinanderfolgenden nicht numerischen Zeichen. Dies gibt das Array zurück [ "NE,E" ]. Wir könnten wohl dort anhalten und genau das zurückgeben. Die Herausforderung besteht jedoch darin, entweder eine begrenzte Zeichenfolge oder ein Array mit zwei Elementen anzufordern. Also extrahieren wir den String mit [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))
)

Pyth , 39 Bytes:

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

wo nicht ❤druckbare Buchstaben darstellt.

Probieren Sie es 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. .