Führen Sie das Alphabet

Gegeben eine Reihe von Richtungen, wobei die Richtungen wie folgt definiert sind:

NW  N  NE
W   .   E
SW  S  SE

Oder als Indizes (Sie können diese Indizes anstelle der obigen Zeichenfolgen für Richtungen verwenden):

0 1 2
3 . 4
5 6 7

Sie können eines der beiden Formate auswählen. Die Unterstützung beider Formate ist für die Challenge nicht erforderlich. Generieren Sie die entsprechende alphabetische Zeichenfolge, die den gezeichneten Pfad darstellt, beginnend mit A. Die Anzahl der Richtungen überschreitet niemals 25, was bedeutet, dass er niemals überschritten werden kann Z, sodass Sie dieses Szenario nicht bearbeiten müssen. Andere Eingabeformate werden nur akzeptiert, wenn Sie erklären können, warum diese Formate aufgrund einer Spracheinschränkung nicht funktionieren. Dies lässt sich leichter anhand eines ausführlich ausgearbeiteten Beispiels erklären.

Schauen wir uns also ein kurzes Beispiel an:

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

Beginnen Sie immer mit A.

A

Gehe nach Osten nach B.

A-B

Gehe nach Südosten nach C.

A-B 
   \
    C

Gehe nach Norden zu D.

A-B D
   \|
    C

Gehe zurück nach Süden zu E und überschreibe C.

A-B D
   \|
    E

Fahren Sie 2 Zyklen lang nach Süden, bis Sie F und G erreichen.

A-B D
   \|
    E
    |
    F
    |
    G

Gehe nach Nordwesten zu H.

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

Gehe nach Westen zu I.

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

Bei Punkt J nach Norden enden.

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

Der endgültige Wert, den Sie zurückgeben würden, ist das Lesen des endgültigen Diagramms von links nach rechts von oben nach unten:

ABD
JE
IHF
G

Ergebend:

ABDJEIHFG

Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt.

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

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

Probieren Sie es bei MATL Online aus

Erläuterung

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

Dank Titus konnten satte 13 Bytes eingespart werden!
Dank edc65 7 weitere Bytes gespart!

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

Wie es funktioniert

Die Formel (d += d > 3) * 9 - d % 3 * 8 - 28übersetzt die Richtungen 0..7in die folgenden Offsets:

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

Wir verwenden diese Offsets, um den Zeiger pin das eindimensionale Array zu bewegen rund die Buchstaben an den resultierenden Positionen zu schreiben.

Wir iterieren weiter, [i = 9, ...a]anstatt nur aden Anfangsbuchstaben 'a' einzufügen. Weil wir initialisieren , ium 9in der gleichen Zeit, führen wir eine spezielle Offset von 54 (das Ergebnis der oben genannten Formel für d = 9). Nach der ersten Iteration, pgleich 646 + 54 = 700, was gerade genug Raum lässt , um 25 bewegt sich nach Nordwesten zur Unterstützung von bis: 25 * -28 = -700. Deshalb pwird zu initialisiert 646.

Dann müssen wir uns nur noch dem Array anschließen, um unsere endgültige Zeichenfolge zu erhalten. Undefinierte Werte zwischen Buchstaben werden einfach von ignoriert join().

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

Probieren Sie es online

Dank Suever 2 Bytes gespart!

Vorherige Antwort 103 Bytes:

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

Probieren Sie es online!

Versuchen Sie zuerst 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}

Einige Erklärungen

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

2 Bytes gespart dank Luis Mendo

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

PHP, 93 Bytes

Betrieb auf einem einzelnen Array wie die Antwort von Kodos Johnson .
Aber das hat so viele weitere Ideen, die ich selbst gepostet habe.

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

Nimmt Zahlen aus Befehlszeilenargumenten. Laufen Sie mit -nr.

Bewegen Sie den Cursor

Anfangsberechnung:

$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

Golfen:

$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

Das Zusammenführen der Zuordnungen speichert nichts, verbessert jedoch die Lesbarkeit:

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

Nervenzusammenbruch

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

Dies wird in der Befehlszeile mit dem -rFlag ausgeführt und verwendet ein char-Array (String) von Indizes als Argument.

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