Guie o alfabeto

Dada uma matriz de direções, onde as direções são definidas da seguinte maneira:

NW  N  NE
W   .   E
SW  S  SE

Ou como índices (você pode usar esses índices para obter instruções em vez das strings acima):

0 1 2
3 . 4
5 6 7

Você pode escolher qualquer formato, pois o suporte a ambos não é exigido pelo desafio. Gere a sequência de caracteres do alfabeto correspondente que representa o caminho desenhado, começando com A. O número de direções nunca excederá 25, o que significa que nunca poderá passar Z, portanto, você não precisa lidar com esse cenário. Nenhum outro formato de entrada será aceito, a menos que você possa explicar por que esses formatos não funcionam devido a uma limitação de idioma. Isso é mais fácil de explicar usando um exemplo detalhado.

Então, vamos ver um exemplo rápido:

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

Sempre comece com A.

A

Vá para o leste até B.

A-B

Vá para o sudeste até C.

A-B 
   \
    C

Vá para o norte até D.

A-B D
   \|
    C

Volte para o sul até E, substituindo C.

A-B D
   \|
    E

Continue para o sul por 2 ciclos para F e G.

A-B D
   \|
    E
    |
    F
    |
    G

Vá para o noroeste para H.

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

Vá para o oeste para I.

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

Fim para o norte no ponto J.

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

O valor final que você retornaria é lendo o gráfico final da esquerda para a direita, de cima para baixo:

ABD
JE
IHF
G

Resultando em:

ABDJEIHFG

Isso é código-golfe , vitórias mais baixas na contagem de bytes.

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

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

Experimente no MATL Online

Explicação

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

Economizou 13 bytes, graças a Titus!
Economizou mais 7 bytes, graças ao 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]));

Como funciona

A fórmula (d += d > 3) * 9 - d % 3 * 8 - 28traduz as instruções 0..7nos seguintes deslocamentos:

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

Usamos essas compensações para mover o ponteiro ppara a matriz unidimensional re escrever as letras nas posições resultantes.

Nós iteramos em [i = 9, ...a]vez de apenas ainserir a letra inicial 'a'. Como inicializamos iao 9mesmo tempo, introduzimos um deslocamento especial de 54 (o resultado da fórmula acima para d = 9). Após a primeira iteração, pé igual 646 + 54 = 700, o que deixa espaço suficiente para suportar até 25 desloca-se para Noroeste: 25 * -28 = -700. É por isso que pé inicializado 646.

Então, apenas precisamos nos juntar à matriz para obter nossa string final. Valores indefinidos entre letras são simplesmente ignorados por join().

Oitava, 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}

Experimente Online

Graças a Suever 2 bytes salvos!

Resposta 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)')' '']

Experimente Online!

Primeira tentativa: 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}

Algumas explicações

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

economizou 2 bytes graças 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 em uma única matriz como a resposta de Kodos Johnson .
Mas isso tem tantas outras idéias que eu postei por conta própria.

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

recebe números dos argumentos da linha de comando. Corra com -nr.

movendo o 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

golfe:

$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

mesclar as atribuições não salva nada, mas melhora a legibilidade:

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

demolir

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

Isso é executado na linha de comando com o -rsinalizador e aceita um array de caracteres (string) 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="")