Guide the Alphabet

Dada una variedad de direcciones, donde las direcciones se definen de la siguiente manera:

NW  N  NE
W   .   E
SW  S  SE

O como índices (puede usar estos índices para obtener instrucciones en lugar de las cadenas anteriores):

0 1 2
3 . 4
5 6 7

Puede elegir cualquiera de los formatos, ya que el desafío no requiere el uso de ambos. Genere la Cadena del alfabeto correspondiente que representa la ruta dibujada, comenzando con A. El número de direcciones nunca excederá de 25, lo que significa que nunca puede pasar Z, por lo que no tiene que manejar este escenario. No se aceptarán otros formatos de entrada a menos que pueda explicar por qué estos formatos no funcionan debido a una limitación de idioma. Esto es más fácil de explicar usando un ejemplo detallado.

Entonces, veamos un ejemplo rápido:

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

Siempre comienza con A.

A

Ve hacia el este hasta B.

A-B

Ve hacia el sureste hasta C.

A-B 
   \
    C

Ve hacia el norte a D.

A-B D
   \|
    C

Regrese al sur a E, sobrescribiendo C.

A-B D
   \|
    E

Continúe hacia el sur durante 2 ciclos hacia F y G.

A-B D
   \|
    E
    |
    F
    |
    G

Ir al noroeste a H.

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

Ve hacia el oeste hacia I.

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

Fin al norte en el punto J.

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

El valor final que devolvería es leyendo el gráfico final de izquierda a derecha, de arriba a abajo:

ABD
JE
IHF
G

Resultando en:

ABDJEIHFG

Este es el código de golf , el menor recuento de bytes gana.

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

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

Pruébalo en MATL Online

Explicación

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 bytes

¡Ahorró la friolera de 13 bytes, gracias a Titus!
¡Ahorré 7 bytes más, gracias 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]));

Cómo funciona

La fórmula (d += d > 3) * 9 - d % 3 * 8 - 28traduce las instrucciones 0..7en las siguientes compensaciones:

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

Utilizamos estos desplazamientos para mover el puntero pa la matriz unidimensional ry escribir las letras en las posiciones resultantes.

Repetimos en [i = 9, ...a]lugar de solo apara insertar la letra inicial 'a'. Debido a que inicializamos ial 9mismo tiempo, introducimos un desplazamiento especial de 54 (el resultado de la fórmula anterior para d = 9). Después de la primera iteración, pes igual 646 + 54 = 700, lo que deja espacio suficiente para soportar hasta 25 movimientos a North-West: 25 * -28 = -700. Por eso pse inicializa a 646.

Luego solo tenemos que unirnos a la matriz para obtener nuestra cadena final. Los valores indefinidos entre letras simplemente son ignorados por join().

Octava, 145 138 131 123 105 103 90 87 85 bytes

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

Pruébalo en línea

Gracias a Suever 2 bytes guardados!

Respuesta anterior 103 bytes:

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

¡Pruébelo en línea!

Primero prueba 145 bytes

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

Algunas explicaciones

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

ahorré 2 bytes gracias a Luis Mendo

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

PHP, 93 bytes

Operando en una sola matriz como la respuesta de Kodos Johnson .
Pero esto tiene muchas más ideas que publiqué por mi cuenta.

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

toma números de argumentos de línea de comando. Corre con -nr.

moviendo el cursor

cálculo inicial:

$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

fusionar las tareas no guarda nada, pero mejora la legibilidad:

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

Descompostura

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 bytes

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 bytes

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

Esto se ejecuta en la línea de comando con el -rindicador y toma una matriz de caracteres (cadena) de índices como argumento.

R, 160 bytes

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="")