Dove sono adesso?

Dato una stringa d , contenente solo le lettere NSWE, determina le coordinate che ho percorso (da sinistra a destra, consumando avidamente) e le coordinate finali in cui risiedo.

Le regole per leggere le coordinate da sinistra a destra:

• Se il personaggio successivo è NoS :
  • Se il personaggio dopo No Sè un altroN oS :
    • Consuma solo il primo N o S.
    • Produzione [0,1] perN
    • Uscita [0,-1]perS
  • Se il personaggio dopo No SèW oE :
    • Consuma sia il No Sche il Wo E.
    • Output [1,1]o [-1,1]per NEe NW, rispettivamente.
    • Output [1,-1]o [-1,-1]per SEe SW, rispettivamente.
• Se il personaggio è preceduto Eo Wmeno da un SoN :
  • Consuma il Eo W.
  • Uscita [1,0]per E.
  • Uscita [-1,0]per W.

Esempio lavorato

NSWE

[0,1]   (North      N)
[-1,-1] (South-west SW)
[1,0]   (East       E)
[0,0]   (N+SW+E = Didn't actually move)

Nota che può essere in qualsiasi formato, ecco altri esempi di output valido:

[[0,1],[-1,-1],[1,0],[0,0]]


[[[0,1],[-1,-1],[1,0]],[0,0]]


"0,1\n0,-1\n-1,0\n1,0\n0,0"

Eccetera...

Altri esempi

SWSENNESWNE

[-1,-1]
[1,-1]
[0,1]
[1,1]
[-1,-1]
[1,1]
[1,0]

NNEESESSWWNW

[0,1]
[1,1]
[1,0]
[1,-1]
[0,-1]
[-1,-1]
[-1,0]
[-1,1]
[0,0]

NENENEE

[1,1]
[1,1]
[1,1]
[1,0]
[4,3]

nen

[1,1]
[0,1]
[1,2]

EEE

[1,0]
[1,0]
[1,0]
[3,0]

Regole

• È possibile produrre in qualsiasi formato conveniente che non violi le lacune.
• Devi consumare avidamente, NWEnon lo è mai N,W,E, lo è sempre NW,E.
  • Questo vale per: SW*, SE*, NW*, NE*.
  • Stai consumando da sinistra a destra, avidamente.
• Si tratta di code-golf , vince il conteggio di byte più basso.

Python 2 , 116 byte

import re
a=[(int(s,35)%5-3,('N'in s)-('S'in s))for s in re.findall('[NS][EW]?|.',input())]
print a,map(sum,zip(*a))

Provalo online!

Con output come [(3+4j), 1, -1j, …], 91 byte

lambda x:[sum(1j**(ord(c)%8%5)for c in s)for s in[x]+re.findall('[NS][EW]?|.',x)]
import re

Provalo online!

Questo lambda restituisce un elenco di numeri interi gaussiani : il primo è la coordinata finale e tutti gli altri sono i passaggi necessari per arrivarci.

Addetto , 80 byte

V#Sum##{Chop[1-ToBase[22260446188,3],2][Sum@Ords=>MatchAll[_,/"[NS][WE]|."]%11]}

Provalo online!

Questa è una funzione anonima che accetta un argomento stringa.

Spiegazione

Il primo compito è implementare la fase di analisi di questa domanda. Ho trovato più breve l'uso di un semplice Regex per analizzare l'input ( _):

MatchAll[_,/"[NS][WE]|."]

Questo corrisponde a tutte le occorrenze della regex [NS][WE]|., come si vede in molte altre risposte. Ciò produce avidamente le indicazioni richieste.

Ora applicheremo una funzione hash a ogni directory. Prendiamo i punti di codice di ogni direzione e li sommiamo. Questo dà il seguente mapping:

Direction       Ord-sum
E               69
N               78
S               83
W               87
NE              147
SE              152
NW              165
SW              170

Proveremo a mappare questi valori su un dominio più piccolo; modulo è utile per questo, e possiamo dimostrare che il modulo più piccolo che risulta in valori univoci per tutti gli input dati è 11. Ordinamento per resto, questo ci dà la seguente tabella:

Direction       Ord-sum         % 11
NW              165             0
N               78              1
E               69              3
NE              147             4
SW              170             5
S               83              6
SE              152             9
W               87              10

Ora, abbiamo una corrispondenza di input, come codifica di Sum@Ords=>[...]%11. Successivamente, dobbiamo trasformare questi resti in punti. Cercheremo di ricavare un'altra mappatura, il che significa che inserire "valori di riempimento sparsi" negli hash che non corrispondono alle direzioni sarà utile:

Direction       Hash        Coordinates
NW              0           [-1, 1]
N               1           [0, 1]
--             (2)          [0, 0]
E               3           [1, 0]
NE              4           [1, 1]
SW              5           [-1, -1]
S               6           [0, -1]
--             (7)          [0, 0]
--             (8)          [0, 0]
SE              9           [1, -1]
W               10          [-1, 0]

Al momento abbiamo una serie di punti, che possono dare un elenco indicizzabile dall'hash:

[-1, 1] [0, 1] [0, 0] [1, 0] [1, 1] [-1, -1] [0, -1] [0, 0] [0, 0] [1, -1] [-1, 0]

Ora comprimeremo questo, visto che è composto solo da -1s, 0s e 1s. Poiché l'elenco rappresenta coppie, possiamo appiattire l'elenco senza perdere dati. Quindi, se prendiamo ogni numero xe calcoliamo 1-x, otteniamo il seguente elenco:

2 0 1 0 1 1 0 1 0 0 2 2 1 2 1 1 1 1 0 2 2 1

Possiamo convertirlo in un numero di base 3:

20101101002212111102213

Conversione in base 10:

20101101002212111102213 ≡ 2226044618810

Per riassumere, abbiamo preso i nostri punti, non accoppiati, preso ogni elemento sottratto 1e convertito dalla base 3, dandoci 22260446188. Possiamo decomprimere in quanto tale:

1. Converti in base 3: ToBase[22260446188,3]
2. Prendi ogni numero sottratto da uno (autoinverso): 1-ToBase[22260446188,3]
3. Associare nuovamente l'elenco: Chop[1-ToBase[22260446188,3],2]

Questo ci dà il nostro set originale di coppie. Quindi, possiamo eseguire l'indicizzazione di cui sopra in questo modo:

(chopped value)[hashes]

Poiché, in Attache, l'indicizzazione di un array restituisce tutti gli elementi corrispondenti a tali indici. (Quindi, [1,2,3,4][ [0,0,-1,1] ] = [1,1,4,2]). Ora, abbiamo le indicazioni del percorso percorsa dall'OP. Ciò che resta è calcolare la somma.

Quindi catturiamo questo risultato in un lambda {...}e lo inseriamo come prima funzione in una composizione di funzioni ( a##b), con il secondo essere V#Sum. Questo è un fork, che, dato l'input x, si espande per essere:

V[x, Sum[x]]

Sum, quando viene fornito un array 2D, sembra sommare ogni colonna dell'array (come risultato della somma vettoriale). Quindi, questo accoppia le direzioni con la destinazione finale e abbiamo il nostro risultato finale.

JavaScript (ES6), 102 byte

Restituisce una stringa.

s=>s.replace(/[NS][EW]|./g,s=>(D=d=>!!s.match(d),x+=h=D`E`-D`W`,y+=v=D`N`-D`S`,[h,v]+`
`),x=y=0)+[x,y]

Provalo online!

MATL , 45 byte

'NS' 'WE'Z*Z{2MhX{h'eklihfmj'X{YX9\3_2&YAqts

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione (con esempio)

Considera l'input 'NSWE'come esempio.

'NS' 'WE'  % Push these two strings
           % STACK: 'NS', 'WE'
Z*         % Cartesian product. Gives a 4×2 char matrix
           % STACK: ['NW'; 'NE'; 'SW'; 'SE']
Z{         % Cell array of rows (strings)
           % STACK: {'NW', 'NE', 'SW', 'SE'}
2M         % Push again the inputs of the second-last function call
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NS', 'WE'
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NSWE'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW', 'NE', 'SW', 'SE'}, {'N', 'S', 'W', 'E'}
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}
'eklihfmj' % Push this string
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}, 'eklihfmj'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW','NE','SW','SE','N','S','W','E'},{'e','k','l','i','h','f','m','j'}
YX         % Implicit input. Regexp replace: replaces 'NW' by 'e', then 'NE' by 'k', etc.
           % Note that the two-letter combinations are replaced first, which implements
           % the greediness; and the target letters do not appear in the source, which
           % avoids unwanted interactions between replacements
           % STACK: 'hlj'
9\         % Modulo 9 (of codepoints), element-wise
           % STACK: [5, 0, 7]
3_2&YA     % Convert to base 3 with 2 digits. Gives a 2-column matrix
           % STACK: [1, 2; 0, 0; 2, 1]
q          % Subtract 1, element-wise
           % STACK: [0, -1; -1, -1; 1, 0]
tXs        % Duplicate. Sum of each column
           % STACK: [0, -1; -1, -1; 1, 0], [0, 0]
           % Implicit display

Java (JDK 10) , 171 byte

s->{var r="";int i=0,l=s.length,c,x=0,y=0,Y,X;for(;i<l;X=c>1||i<l&&(c=~-s[i]/6%4)>1&&++i>0?c*2-5:0,r+=X+","+Y+" ",x+=X,y+=Y)Y=(c=~-s[i++]/6%4)<2?1-c*2:0;return r+x+","+y;}

Provalo online!

spiegazioni

Grazie a c=~-s[i]/6%4, viene eseguita la seguente mappatura:

'N' -> ascii: 78 -> -1 = 77 -> /6 = 12 -> %4 = 0
'S' -> ascii: 83 -> -1 = 83 -> /6 = 13 -> %4 = 1
'W' -> ascii: 87 -> -1 = 86 -> /6 = 14 -> %4 = 2
'E' -> ascii: 69 -> -1 = 68 -> /6 = 11 -> %4 = 3

• NSè verificato c<2e mappato su +1/ -1usando 1-c*2;
• EWviene controllato con c>1e mappato su +1/ -1usando c*2-5.

Crediti

• almeno 9 byte salvati grazie a Kevin Cruijssen .

Retina 0.8.2 , 93 byte

.+
$&¶$&
\G[NS]?[EW]?
$&¶
G`.
W
J
%O`.
+`EJ|NS

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

Provalo online! Spiegazione:

.+
$&¶$&

Duplica l'input.

\G[NS]?[EW]?
$&¶

Dividi la prima copia in direzioni.

G`.

Rimuovere le righe vuote estranee create dal processo precedente.

W
J

Cambia Win Jmodo che sia ordinato tra Ee N. (Passare Eda Se Wfunzionerebbe anche.)

%O`.

Ordina ogni riga in ordine.

+`EJ|NS

Elimina le coppie di direzioni opposte (ciò influisce solo sull'ultima linea di rotta).

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

Conta il numero di movimenti orizzontali e verticali, aggiungendo segni dove necessario.

Quelli di voi che conoscono le differenze tra Retina 0.8.2 e Retina 1 vorranno sottolineare che posso salvare 2 byte in Retina 1 perché utilizza *invece di $*. Mentre ero lì, ho cercato di semplificare il processo di suddivisione, ma non ero in grado di ridurre ulteriormente il conteggio dei byte, ero solo in grado di eguagliarlo con questo:

L$`$(?<=(.*))|[NS]?[EW]?
$&$1

Java 10, 269 265 243 byte

s->{var r="";int x=0,y=0,t,X,Y,a;for(;!s.isEmpty();r+=X+"|"+Y+" ",s=s.substring(++t),x+=X,y+=Y){a=s.charAt(t=0);if(s.matches("[SN][WE].*")){X=s.charAt(1)<70?1:-1;Y=1-a%2*2;t++;}else{X=a<70?1:a>86?-1:0;Y=a>69&a<87?1-a%2*2:0;}}return r+x+"|"+y;}

Sicuramente non è la lingua giusta per questa sfida.

Provalo online.

Spiegazione:

s->{                  // Method with String as both parameter and return-type
  var r="";           //  Result-String, starting empty
  int x=0,            //  Ending `x`-coordinate, starting at 0
      y=0,            //  Ending `y`-coordinate, starting at 0
      t,X,Y,a;        //  Temp-integers
  for(;!s.isEmpty()   //  Loop as long as the input-String is not empty yet
      ;               //    After every iteration:
       r+=X+"|"+Y+" ",//     Append the current steps to the result-String
       s=s.substring(t),
                      //     Remove the first `t` characters from the input-String
       x+=X,y+=Y){   //      Append the ending `x`,`y` coordinates with the steps
    a=s.charAt(0);   //    Set `a` to the first character of the input-String to save bytes
    t=1;             //    Set `t` to 1
    if(s.matches("[SN][WE].*")){
                     //   Else-if the input-String starts with N/S followed by E/W:
      X=s.charAt(1)<70?1:-1;
                     //    Set `X` to 1 if 'E', -1 if 'W'
      Y=1-a%2*2;     //    Set `Y` to 1 if 'N', -1 if 'S'
      t++;}          //    Increase `t` by 1
    else{            //   Else:
      X=a<70?1:a>86?-1:0;
                     //    Set `X` to 1 if 'E', -1 if 'W', 0 if 'N' or 'S'
      Y=a>69&a<87?1-a%2*2:0;}}
                     //    Set `Y` 1 if 'N', -1 if 'S', 0 if 'E' or 'W'
  return r+x+"|"+y;} //  Append the ending coordinates, and return the result-String

Perl 5 -n , 94 byte

$x=$y=0;%X=qw/E ++ W --/;%Y=qw/N ++ S --/;s%(N|S)?(E|W)?%"say $X{$2}\$x.','.$Y{$1}\$y"if$&%gee

Provalo online!

JavaScript (ES6), 102 byte

f=
s=>s.replace(/((N)|(S))?((E)|(W))?/g,(m,v,n,s,h,e,w)=>(x+=h=!w-!e,y+=v=!s-!n,m?[h,v]+`
`:[x,y]),x=y=0)

<input oninput=o.textContent=/[^NSEW]/.test(this.value)?``:f(this.value)><pre id=o>0,0

Restituisce una stringa.

Rubino , 75 71 byte

->x{[*x.scan(/[NS][EW]?|./),x].map{|s|s.chars.sum{|c|1i**(c.ord%8%5)}}}

Provalo online!

-4 byte grazie a benj2240.

Dal momento che la restituzione di numeri complessi sembra essere un formato di output accettabile, immagino che non diventerà molto più golfoso del solo fare un porto della simpatica risposta di Lynn .

F # (Mono) , 269 byte

let f s=
 let l,h=(string s).Replace("NW","A").Replace("NE","B").Replace("SW","C").Replace("SE","D")|>Seq.map(function 'N'->0,1|'S'->0,-1|'W'-> -1,0|'E'->1,0|'A'-> -1,1|'B'->1,1|'C'-> -1,-1|'D'->1,-1)|>Seq.mapFold(fun(x,y) (s,t)->(s,t),(x+s,y+t))(0,0)
 Seq.append l [h]

Provalo online!

sed, 125

Le libertà prese con la versione in formato di output :

Il punteggio include +1 per il -rparametro su sed.

s/(N|S)(E|W)/\L\2,\1 /g
s/N|S/,& /g
s/E|W/&, /g
s/N|E/A/gi
s/S|W/a/gi
p
:
s/(\S*),(\S*) (\S*),(\S*)/\1\3,\2\4/
t
s/Aa|aA//
t

Provalo online .

L'output è il seguente:

• gli elementi delle coordinate sono separati da virgola
• ogni set di coordinate è separato da TAB
• la coordinata finale è su una nuova linea
• tutti i numeri sono in ℤ-unario:
  • una stringa di Acaratteri rappresenta il numero intero + velen(string)
  • una stringa di acaratteri rappresenta l'intero -ve-len(string)
  • la stringa vuota rappresenta 0

Per esempio:

• , è [0,0]
• ,AA è [0,2]
• aaa, è [-3,0]

sed 4.2.2 inclusa l'estensione GNU exec , 147

Il formato di output sensibile versione :

Il punteggio include +1 per il -rparametro su sed.

s/(N|S)(E|W)/\L\2 \1\n/g
s/N|S/0 &\n/g
s/E|W/& 0\n/g
s/N|E/1/gi
s/S|W/-1/gi
p
:
s/(\S+) (\S+)\n(\S+) (\S+)/\1+\3 \2+\4/
t
s/\S+/$[&]/g
s/^/echo /e

L'output è dato come coordinate separate da spazio, una per riga. C'è una nuova linea in più tra il penultimo e ultimo set di coordinate - non sono sicuro che sia problematico o meno.

Provalo online!

PHP, 153 byte

lascia che un regex faccia la divisione; scorrere tra le partite, stampare e riassumere i risultati intermedi:

preg_match_all("/[NS][EW]?|E|W/",$argn,$m);foreach($m[0]as$s){$x+=$p=strtr($s[-1],NEWS,1201)-1;$y+=$q=strtr($s[0],NEWS,2110)-1;echo"$p,$q
";}echo"$x,$y";

Esegui come pipe -nRo provalo online .

C (gcc) , 173 byte

È interessante farlo in una lingua senza supporto regex!

f(char*s){char*t="[%d,%d]\n";int x[4]={0},i;for(;*s;*x=x[1]=!printf(t,x[1],*x))for(i=-1;i<5;)if(*s=="S NW E"[++i]){x[i/3+2]+=x[i/3]=i%3-1;i+=2-i%3;s++;}printf(t,x[3],x[2]);}

Provalo online!