Guida l'alfabeto

Dato un array di direzioni, in cui le direzioni sono definite come segue:

NW  N  NE
W   .   E
SW  S  SE

O come indici (puoi usare questi indici per le indicazioni invece delle stringhe sopra):

0 1 2
3 . 4
5 6 7

Puoi scegliere uno dei formati, supportando entrambi non è richiesto dalla sfida. Genera la stringa dell'alfabeto corrispondente che rappresenta il percorso tracciato, iniziando con A. Il numero di direzioni non supererà mai 25, il che significa che non potrà mai andare oltre Z, quindi non devi gestire questo scenario. Non saranno accettati altri formati di input a meno che tu non possa spiegare perché questi formati non funzionano a causa di una limitazione della lingua. Questo è più facile da spiegare usando un esempio elaborato verbalmente.

Quindi, diamo un'occhiata a un esempio veloce:

[E,SE,N,S,S,S,NW,W,N] or [4,7,1,6,6,6,0,3,1]

Inizia sempre con A.

A

Vai a est verso B.

A-B

Vai a sud-est verso C.

A-B 
   \
    C

Vai a nord verso D.

A-B D
   \|
    C

Torna a sud verso E, sovrascrivendo C.

A-B D
   \|
    E

Continuare verso sud per 2 cicli verso F e G.

A-B D
   \|
    E
    |
    F
    |
    G

Vai a nord-ovest verso H.

A-B D
   \|
    E
    |
  H F
   \|
    G

Vai a ovest verso I.

A-B D
   \|
    E
    |
I-H F
   \|
    G

Fine a nord al punto J.

A-B D
   \|
J   E
|   |
I-H F
   \|
    G

Il valore finale che vorresti restituire è leggendo il grafico finale da sinistra a destra, dall'alto verso il basso:

ABD
JE
IHF
G

Con il risultato di:

ABDJEIHFG

Questo è code-golf , vince il conteggio di byte più basso.

MATL , 64 58 57 50 46 40 37 36 35 30 byte

O'!":<TUV '59-G)hYsIH$6#u64+c!

Provalo su MATL Online

Spiegazione

O           % Push the number 0 to the stack
'!":<TUV '  % String literal
59-         % Converts this string literal into [-26 -25 -1 1 25 26 27 -27]. These
            % are deltas for the linear indexes into the matrix corresponding to each
            % of the directions. Note that the -27 is at the end since a 0 index wraps
            % around to the end
i)          % Grab the input and use it to index into the delta array 
h           % Horizontally concatenate this with the 0 (our starting point)
Ys          % Take the cumulative sum to get the absolute linear index (location) of
            % each successive letter
IH$6#u      % Find the index of the last (sorted) occurrence of each location
64+         % Add 64 to this index to create ASCII codes
c!          % Convert to character, transpose, and display

JavaScript (ES6), 108 107 94 87 byte

Risparmiato un enorme 13 byte, grazie a Titus!
Salvati altri 7 byte, grazie a edc65!

let f =

a=>[i=9,...a].map(d=>r[p+=(d+=d>3)*9-d%3*8-28]=(++i).toString(36),r=[],p=646)&&r.join``

console.log(f([4,7,1,6,6,6,0,3,1]));

Come funziona

La formula (d += d > 3) * 9 - d % 3 * 8 - 28traduce le direzioni 0..7nei seguenti offset:

0   1   2       -28 -27 -26
3   x   4  -->   -1  x   +1
5   6   7       +26 +27 +28

Usiamo questi offset per spostare il puntatore pnella matrice unidimensionale re scrivere le lettere nelle posizioni risultanti.

Ripetiamo [i = 9, ...a]piuttosto che semplicemente aper inserire la lettera iniziale "a". Poiché si inizializza ia 9allo stesso tempo, si introduce un offset di 54 speciale (il risultato della formula sopra per d = 9). Dopo la prima iterazione, ppari 646 + 54 = 700, che lascia spazio appena sufficiente per supportare fino a 25 si sposta verso Nord-Ovest: 25 * -28 = -700. Ecco perché pè inizializzato a 646.

Quindi non ci resta che unire l'array per ottenere la nostra stringa finale. I valori non definiti tra le lettere vengono semplicemente ignorati join().

Ottava, 145 138 131 123 105 103 90 87 85 byte

@(a){[~,k]=unique(cumsum([1 fix((z=a+(a>3))/3);1 mod(z,3)]'-1),'rows');[k'+64 '']}{2}

Provalo online

Grazie a Suever 2 byte salvati!

Risposta precedente 103 byte:

@(a)[nonzeros(accumarray(cumsum([1 fix((z=a+(a>3))/3);1 mod(z,3)]'-1)+30,65:nnz(++a)+65,[],@max)')' '']

Provalo online!

Prima prova 145 byte

@(a){[x y]=find(~impad(1,1,1));c=cumsum([0 0;([y x]-2)(++a,:)]);c=c-min(c)+1;n=nnz(a);[nonzeros(sparse(c(:,1),c(:,2),65:n+65,'unique')')' '']}{5}

Alcune spiegazioni

@(a){
    [x y]=find([1 0 1]|[1;0;1]);                            %generate 2d coordinates corresponding to 1d input indices
    XY = [y x]-2;
    c=cumsum([0 0;XY(++a,:)]);                              %cumulative sum of coordinates to find position of characters
    c=c-min(c)+1;n=nnz(a);
    [nonzeros(sparse(c(:,1),c(:,2),65:n+65,'unique')')' ''] %using sparse matrix to place characters at specified positions
    }{5}

MATLAB, 87 85 byte

salvato 2 byte grazie a Luis Mendo

function a=f(s);i='()*BD\]^'-67;[~,a]=unique([0 cumsum(i(s+1))],'last');a=[a'+64,''];

PHP, 93 byte

Operando su un singolo array come la risposta di Kodos Johnson .
Ma questo ha tante altre idee che ho pubblicato da solo.

for($r=[$c=A];""<$d=$argv[++$i];)$r[$p+=($d+=$d>3)*9-$d%3*8-28]=++$c;ksort($r);echo join($r);

accetta numeri dagli argomenti della riga di comando. Corri con -nr.

muovendo il cursore

calcolo iniziale:

$d+=$d>3;           // if $d>3, add 1
$p+= ($d/3-1|0)*26  // add/subtract 26 for line change
    +$d%3-1;        // add/substract 1 for column change

golf:

$d+=$d>3;$p+=($d/3-1|0)*27+$d%3-1;          // +0: multiple of 3 instead of 26
$d+=$d>3;$p+=($d/3|0)*27-27+$d%3-1;         // +1: distribute `line-1`
$d+=$d>3;$p+=($d/3)*27-$d%3/3*27-27+$d%3-1; // +8: distribute `|0`
$d+=$d>3;$p+=$d*9-$d%3*9-27+$d%3-1;         // -8: `/3*27` -> `*9`
$d+=$d>3;$p+=$d*9-$d%3*8-28;                // -7: combine duplicates

la fusione dei compiti non salva nulla, ma migliora la leggibilità:

for(init;input loop;$p=$d...)$d+=$d>3;
for(init;input loop;)$p=($d+=$d>3)...;

abbattersi

for($r=[$c=A];                  // init result, init letter
    ""<$d=$argv[++$i];)         // loop through command line arguments
    $r[
        $p+=($d+=$d>3)*9-$d%3*8-28  // move cursor
    ]=++$c;                         // increment letter, plot
ksort($r);                      // sort result by index
echo join($r);                  // print result

Python 2, 180 178 176 176 byte

def f(d,a=[[""]*26 for _ in[1]*26],x=0,y=0,j=66):
 a[0][0]="A"
 for i in d:y+=(i>4)-(i<3);x+=(`i`in'247')-(`i`in'035');a[y][x]=chr(j);j+=1
 return"".join("".join(i)for i in a)

PHP, 121 byte

$r[0]=chr(65);for(;($n=$argv[1][$i])!=null;)$r[$c+=[-27,-26,-25,-1,1,25,26,27][$n]]=chr($i+++66);ksort($r);echo join($r);

Questo viene eseguito nella riga di comando con il -rflag e accetta un array di caratteri (stringa) di indici come argomento.

R, 160 byte

a=scan()
e=f=26
x=matrix(0,51,51)
x[e,f]="A"
for(i in a){g=function(q)grepl(q,i)
T=T+1
f=f-g("N")+g("S")
e=e-g("W")+g("E")
x[e,f]=LETTERS[T]}
cat(x[x>0],sep="")