Guide l'alphabet

Étant donné un tableau de directions, où les directions sont définies comme suit:

NW  N  NE
W   .   E
SW  S  SE

Ou comme index (vous pouvez utiliser ces indices pour les directions au lieu des chaînes ci-dessus):

0 1 2
3 . 4
5 6 7

Vous pouvez choisir l'un ou l'autre format, la prise en charge des deux n'est pas requise par le défi. Générez la chaîne d'alphabet correspondante qui représente le chemin tracé, en commençant par A. Le nombre de directions ne dépassera jamais 25, ce qui signifie qu'il ne pourra jamais passer Z, vous n'avez donc pas à gérer ce scénario. Aucun autre format d'entrée ne sera accepté sauf si vous pouvez expliquer pourquoi ces formats ne fonctionnent pas en raison d'une limitation de langue. Ceci est plus facile à expliquer en utilisant un exemple élaboré de manière verbale.

Alors, regardons un exemple rapide:

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

Commencez toujours par A.

A

Allez vers l'est jusqu'à B.

A-B

Allez vers le sud-est jusqu'à C.

A-B 
   \
    C

Allez vers le nord jusqu'à D.

A-B D
   \|
    C

Retournez au sud vers E, en écrasant C.

A-B D
   \|
    E

Continuez vers le sud pendant 2 cycles jusqu'à F et G.

A-B D
   \|
    E
    |
    F
    |
    G

Allez vers le nord-ouest jusqu'à H.

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

Allez vers l'ouest jusqu'à moi.

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

Fin au nord au point J.

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

La valeur finale que vous retourneriez est en lisant le graphique final de gauche à droite, de haut en bas:

ABD
JE
IHF
G

Résultant en:

ABDJEIHFG

Il s'agit du code-golf , le plus petit nombre de victoires d'octets.

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

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

Essayez-le sur MATL Online

Explication

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 octets

Enregistré un énorme 13 octets, grâce à Titus!
7 octets de plus enregistrés grâce à 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]));

Comment ça fonctionne

La formule (d += d > 3) * 9 - d % 3 * 8 - 28traduit les directions 0..7dans les décalages suivants:

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

Nous utilisons ces décalages pour déplacer le pointeur pdans le tableau unidimensionnel ret écrire les lettres aux positions résultantes.

Nous réitérons [i = 9, ...a]plutôt que juste apour insérer la lettre de départ «a». Parce que nous initialisons ien 9même temps, nous introduisons un décalage spécial de 54 (le résultat de la formule ci-dessus pour d = 9). Après la première itération, pégale 646 + 54 = 700, ce qui laisse juste assez d' espace pour supporter jusqu'à 25 se déplace vers le nord-ouest: 25 * -28 = -700. C'est pourquoi pest initialisé à 646.

Ensuite, nous devons simplement rejoindre le tableau pour obtenir notre chaîne finale. Les valeurs non définies entre les lettres sont simplement ignorées par join().

Octave, 145 138 131 131 123 105 103 90 87 85 octets

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

Essayez-le en ligne

Merci à Suever 2 octets enregistrés!

Réponse précédente 103 octets:

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

Essayez-le en ligne!

Essayez d'abord 145 octets

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

Quelques explications

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

enregistré 2 octets grâce à Luis Mendo

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

PHP, 93 octets

Fonctionnant sur une seule baie comme la réponse de Kodos Johnson .
Mais cela a tellement d'autres idées que j'ai publiées moi-même.

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

prend les nombres des arguments de ligne de commande. Courez avec -nr.

déplacer le curseur

calcul initial:

$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 fusion des affectations ne sauve rien, mais améliore la lisibilité:

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

panne

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 178 176 octets

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 octets

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

Cela s'exécute dans la ligne de commande avec l' -rindicateur et prend un tableau de caractères (chaîne) d'index comme argument.

R, 160 octets

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