Wenn Sie eine Liste von Wörtern eingegeben haben, geben Sie die Wörter mit diagonal angeordneten Buchstaben aus:

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f

(Das Obige sollte die Ausgabe für die Eingabe sein programming puzzles and code golf.)

Um genau zu sein, beginnt jedes Wort in der ersten Spalte und drei Zeilen unter dem vorherigen Wort, und jeder nachfolgende Buchstabe verschiebt eine Spalte nach rechts und eine Zeile nach unten.

Die Eingabe kann entweder als einzelne Wortfolge, die durch genau ein Leerzeichen getrennt ist, oder als Liste / Array von Wörtern erfolgen. Die Wörter bestehen nur aus Kleinbuchstaben a-zund bestehen immer aus mindestens einem Zeichen.

Die Ausgabe kann eine einzelne Zeichenfolge, ein Array von Zeilen oder ein Array von Zeichen sein. Führende oder nachfolgende Leerzeichen sind mit Ausnahme einer einzelnen nachfolgenden Zeile nicht zulässig.

Weitere Testfälle:

a bcd efgh i j

a


b
 c
  d
e
 f
  g
i  h


j

x

x

verylongword short

v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

Da es sich um Code-Golf , gewinnt der kürzeste Code in Bytes!

Vim, 85, 76, 66 , 52 Tastenanschläge / Byte

Als ich mir diese Herausforderung zum ersten Mal ansah, dachte ich: "Das ist perfekt für Vim!" Und als ich es versuchte, lief alles schief. Hier ist es, in all seiner chaotischen, hackigen Pracht:

:se ve=all|s/ /\r\r\r/g
qqGo<esc>?\<.\S
lDjP@qq@qG?.
jdG

Probieren Sie es online aus, dank des (meistens) abwärtskompatiblen V-Interpreters.

Erläuterung:

Zuerst dachte ich, ich könnte diese wunderschön einfache 37-Byte-Version machen:

:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

Leider ist es nicht so einfach. Nehmen wir es Zeile für Zeile:

:se ve=all

Dies ermöglicht eine Funktion namens "Virtuelle Bearbeitung". Es ermöglicht dem Cursor, sich zu Spalten zu bewegen, die noch nicht existieren. Diese Antwort wäre ohne sie im Grunde unmöglich.

Jetzt müssen wir die Wörter in verschiedene Zeilen unterteilen. Also ersetzen wir jedes Leerzeichen durch 3 Zeilenumbrüche. Da dies ein Ex-Befehl ist, können wir ihn gleichzeitig mit unserem letzten Ex-Befehl :se ve=allausführen, indem wir die beiden mit einem Strich trennen.

|s/ /\r\r\r/g

Nun sieht der Puffer so aus:

Programming


Puzzles


and


code-golf

Hier beginnt der Spaß. Wir richten das traditionelle rekursive Makro mit: ein qqund rufen dann Folgendes auf:

G               " Move to the last line
 o<esc>         " Append an extra newline

?               " Search backwards for
 \<.            " Any character at the beginning of a word
    \S          " Followed by a non-space character
l               " Move one character to the right
 D              " Delete eveything until the end of this line
  j             " Move down one line
   P            " Paste what we just deleted

Dann beenden wir das rekursive Makro mit @qq@q. An diesem Punkt haben wir alle Diagonalen, wir müssen nur ein wenig aufräumen.

G                   " Move to the last line
 ?.                 " Search backwards for any character
j                   " Move down one line
 dG                 " Delete until the end of the buffer

Turtlèd , 28 26 Bytes

Oh mein Gott, ich scheine eine Sprache zu schlagen, die speziell für das Golfen entwickelt wurde. Das ist ein großartiger Tag.

!_4[*.[ rd+.]ul[ ul]r;_+]_

Probieren Sie es online!

Erläuterung

(Schreiben bedeutet, dass in die Zelle im Raster geschrieben wird. Punktzeichen bedeutet, dass Zeichen in der Eingabe eingegeben wird, auf die der Zeichenfolgenzeiger zeigt.)

!                         Take string input into variable
 _                        Normally conditional, with >1 input (there will be), write ' '
  4                       set register to 4
   [*                   ] until the current cell is *
     .                    Write pointed char, initially first char
      [     ]             Until space is written on cell
        rd+.              move right, down, string pointer++, write pointed char
             ul[ ul]      Move back up to the top of the word
                    r;    Move right, down 4 (because this is register value)
                      _+  write * if end of input, else ' ', increment string pointer
                        _ will always write ' ', since it will always point at start char

Leerzeichen beachten.

Die Eingabe benötigt auch Leerzeichen am Ende. Da Python eine Liste erstellen kann, ähnelt dies in etwa der Erstellung einer Liste in Turtlèd

MATL , 28 Bytes

c!t&n:q3_*ts_b+5M4$XdZ!cZ{Zv

Die Eingabe ist ein Zellenarray von Zeichenfolgen mit Kommas als optionalen Trennzeichen:

{'programming' 'puzzles' 'and' 'code' 'golf'}

oder

{'programming', 'puzzles', 'and', 'code', 'golf'}

Probieren Sie es online! Oder überprüfen Sie alle Testfälle: 1 , 2 , 3 , 4 .

Erläuterung

Betrachten Sie die folgende Eingabe als Beispiel:

{'aaaa' 'bb' 'ccc'}

Sie können die Teilergebnisse (Stapelinhalte) anzeigen, indem Sie das Kommentarsymbol %an einer beliebigen Stelle im Code einfügen. Zeigen Sie beispielsweise den Stapelinhalt nach der vierten Funktion ( &n) an.

c        % Input cell array of strings implicitly. Convert to 2D char array,
         % right-padding with spaces
         % STACK: ['aaaa'; 'bb  '; 'ccc']
!        % Transpose
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  ']
t        % Duplicate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '],
                  ['abc'
                   'abc'
                   'a c'
                   'a  '],
&n       % Number of rows and of columns
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, 3
:q       % Range, subtract 1
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 1 2]
3_*      % Multiply by -3
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6]
ts_      % Duplicate, sum, negate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6], 9
b        % Bubble up in stack
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 9, 4
+        % Add
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13
5M       % Push second input of last function again
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13, 4
4$Xd     % Buld numerical sparse matrix from the above four arguments. The
         % columns of the first input argument will be the diagonals of the
         % result, with indices given bu the second input (negative is below
         % main diagonal). The matrix size is the third and fourth arguments
         % STACK: [97  0  0  0
                    0 97  0  0
                    0  0 97  0
                   98  0  0 97
                    0 98  0  0
                    0  0 32  0
                   99  0  0 32
                    0 99  0  0
                    0  0 99  0
                    0  0  0 32
                    0  0  0  0
                    0  0  0  0
                    0  0  0  0]
Z!c      % Convert from sparse to full, and then to char. Character 0 is
         % displayed as space
         % STACK: ['a   '
                   ' a  '
                   '  a '
                   'b  a'
                   ' b  '
                   '    '
                   'c   '
                   ' c  '
                   '  c '
                   '    '
                   '    '
                   '    '
                   '    ']
Z{       % Split into cell array, with each row in a cell
         % STACK: {'a   ', ' a  ', '  a ', 'b  a', ' b  ', '    ', 'c   ', ' c  ', '  c ', '   ', '   ', '   ', '   '}
Zv       % Deblank: remove trailing space from each string. Implicitly display,
         % each string on a different line. Empty strings do not generate
         % a newline
         % STACK: {'a   ', ' a', '  a', 'b  a', ' b', '', 'c', ' c', '  c', '', '', '', ''}

JavaScript (ES6), 118 109 84 Byte

Nimmt die Eingabe als Array von Wörtern. Gibt ein Array von Arrays von Zeichen zurück.

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill(' '))[x]=c),a=[])&&a

Alternative Version, 109 Bytes

Gibt eine Zeichenfolge zurück.

let f =

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill` `)[x]=c),a=[])&&a.map(s=>s.join``).join`
`

console.log(f(["programming", "puzzles", "and", "code", "golf"]))

Common Lisp, 673 668 597 Bytes

Schreckliche Lösung, ich weiß. Ich werde das wahrscheinlich nach ein bisschen Schlaf noch ändern.

(defun f(&rest z)(let((l)(a 0)(s)(o)(b)(c 0))(loop(setf b(length l))(setf l"")(loop for w in z for i from 0 do(if(>(+(length w)(* i 3))c)(setf c(+(length w)(* i 3))))(setf s(+(* i -3)a))(when(and(>= s 0)(< s(length w)))(setf o(format nil"~v@{~a~:*~}"s" "))(if(and(>=(- s 3)0)(not(equal i(-(length z)1))))(setf o(subseq o(- s 2))))(setf l(concatenate'string o(string(char w s))l)))(when(>= s(length w))(setf l(concatenate'string"   "l))))(if(<=(length l)b)(setf l(concatenate'string(format nil"~v@{~a~:*~}"(- b(length l)-1)" ")l)))(print(string-right-trim" "l))(if(>= b c)(return))(setf a(1+ a)))))

Verwendungszweck:

* (f "ppcg" "is" "pretty" "ok")

"p" 
" p" 
"  c" 
"i  g" 
" s" 
"" 
"p" 
" r" 
"  e" 
"o  t" 
" k  t" 
"     y" 
""
NIL

Dies durchläuft jedes Wort in der angegebenen Liste und fügt der aktuellen Zeile die entsprechenden Zeichen hinzu. Eine angemessene Polsterung ergibt sich aus meiner unterdurchschnittlichen Verwendung von format.

Hinweis: Ich bin neu in Common Lisp, aber ich weiß genug, um zu erkennen, dass dies eine Menge Verbesserung gebrauchen könnte.

C #, 336 Bytes:

Golf gespielt:

string D(string[]s){int x=0,y=0,r=0,q=2*(s.Max().Length+s.Length)+1;var a=new char[q, q];for(int i=0;i<s.Length;i++){y=r;for(int j=0;j<s[i].Length;j++){a[y,x]=s[i][j];x+=1;y+=1;}x=0;r+=3;}var o="";for(x=0;x<q;x++){var t="";for(y=0;y<q;y++)t+=a[x,y];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\r\n");}return o;}

Ungolfed:

public string D(string[] s)
{
  int x = 0, y = 0, r = 0, q = 2 * (s.Max().Length + s.Length) + 1;
  var a = new char[q, q];
  for (int i = 0; i < s.Length; i++)
  {
    y = r;
    for (int j = 0; j < s[i].Length; j++)
    {
      a[y, x] = s[i][j];
      x += 1;
      y += 1;
    }
    x = 0;
    r +=3;
  }
  var o = "";
  for (x = 0; x < q; x++)
  {
    var t = "";
    for (y = 0; y < q; y++)
      t += a[x, y];
    o += t == string.Join("", Enumerable.Repeat('\0', q)) ? "" : (t.TrimEnd('\0') + "\r\n");
  }
  return o;
}

Testen:

  var codeGolf = new DrawDiagonalLinesOfText();
  Console.WriteLine(codeGolf.E(new string[] { "programming", "puzzles", "and", "code", "golf" }));
  Console.WriteLine(codeGolf.E(new string[] { "a", "bcd", "efgh", "i", "j" }));
  Console.WriteLine(codeGolf.E(new string[] { "verylongword", "short" }));

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f


a
b
 c
  d
e
 f
  g
i  h
j


v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

Python 2, 146 Bytes

s=input()
k=max(map(len,s))
a=[k*[' ']for x in range(k+len(s)*3+3)]
for x in range(len(s)):
 for y in range(len(s[x])):a[x*3+y][y]=s[x][y]
print a

Hinweis: Die Einrückungen für die letzten beiden Zeilen sind <space>und <tab>, wodurch ein Byte gespart wird, da ich nicht doppelt einrücken muss.

Die Eingabe muss wie folgt als Array von Zeichenfolgen eingegeben werden: ["hello", "world"]oder ['hello', 'world']. Die Ausgabe ist ein Array von Arrays von Zeichen.

Es gibt wahrscheinlich einen besseren Weg, dies zu tun ...

BEARBEITEN Danke an Doorknob für den Hinweis auf eine fehlende enge eckige Klammer. Ich habe es vor *k...die dritte Zeile gestellt.

Mathematica, 146 Bytes

P=PadRight;T=Transpose;R=Riffle;Select[Rest@T@P@MapIndexed[""~Table~#2~Join~#1&,T@P@R[Characters/@#~R~{},{},3]]//.{0->"",{x__,""}->{x}},#!={""}&]&

Ich bin enttäuscht von diesem bytecount, aber na ja.

Definiert eine anonyme Funktion, die eine Liste von Wörtern (z. B. {"this","that","these"}) aufnimmt und ein zweidimensionales Array von Zeichen zurückgibt. Fügen Sie zum Anzeigen in Rasterform //Gridam Ende ein hinzu.

Konvertiert die Zeichenfolgen in ein Array, fügt zusätzliche Zeilen hinzu, transponiert das Array, stellt die erforderlichen Verschiebungen voran und transponiert dann erneut.

Beispielergebnis (als Raster formatiert):

Gelee , 24 Bytes

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷

Probieren Sie es online!

Wie?

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷ - Main link: a list of strings
z                        - transpose with filler...
 ⁶                       -     space character
  j€                     - join €ach with
    ⁾                    -     two spaces
       µ                 - monadic chain separation, call the result x
        J                - range(length(x)) [1,2,...,x]
         ’               - decrement (vectorises) [0,1,...x-1]
           ẋ             - repeat (vectorises)
          ⁶              - a space ['', ' ',...,'x spaces']
             "           - zip with
            ;            - concatenation (prefixes with the space strings)
              z          - transpose with filler...
               ⁶         -     space character
                œr€⁶     - trim spaces from the right of €ach
                    Y    - join with line feeds
                     œr⁷ - trim line feeds from the right
                         - implicit print

Python 2, 182 Bytes

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:
  i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i];k+=1
  if i==M-1:r=r.rstrip()+'\n'
 return r.strip()

Ein bisschen lang, aber auf der positiven Seite gibt es eine Zeichenfolge ohne abschließenden Leerraum in jeder Zeile und ohne abschließenden Leerraum oder am Ende zurück. Einschränkungen, denen einige andere Einträge nicht entsprechen.

Eine Liste von Wörtern wird an die Funktion übergeben. Einige 'Leerzeichen' werden in diese Liste eingefügt. Anschließend ordnet der Algorithmus ein Zeilen- / Spaltenpaar einer wordNumber- / characterNumber-Zahl in der erweiterten Liste zu. (Dies ist ein bisschen umgekehrt zu der in anderen Lösungen üblichen Strategie).

Wenn wir Leerzeichen in allen Zeilen mit Ausnahme der letzten zulassen, können wir etwas mehr erreichen (163 Bytes):

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i]+'\n'*(i==M-1);k+=1
 return r.strip()

q / kdb +, 130 109 94 90 86 84 Bytes

Lösung:

f:{-1(+)a rtrim(til(#)E){raze(x#" "),y,\:"  "}'E:(+)(a:{(max(#:)each x)$x})" "vs x;}

Beispiele:

q)f "programming puzzles and code golf"
p          
 r         
  o        
p  g       
 u  r      
  z  a     
a  z  m    
 n  l  m   
  d  e  i  
c     s  n 
 o        g
  d        
g  e       
 o         
  l        
   f 
q)f "a bcd efgh i j"
a   


b   
 c  
  d 
e   
 f  
  g 
i  h


j  
q)f (),"x"
x
q)f "verylongword short"
v           
 e          
  r         
s  y        
 h  l       
  o  o      
   r  n     
    t  g    
        w   
         o  
          r 
           d

Erklärung (ungolfed):

Der Grundgedanke besteht darin, aus der Eingabezeichenfolge eine Reihe von Zeichenfolgen gleicher Länge zu erstellen, diese umzudrehen (zu drehen) und dann ein geeignetes Leerzeichen hinzuzufügen, um etwas zu erhalten, das wie folgt aussieht:

"p  p  a  c  g   "
" r  u  n  o  o  "
"  o  z  d  d  l "
"   g  z     e  f"
"    r  l        "
"     a  e       "
"      m  s      "
"       m        "
"        i       "
"         n      "
"          g     "

das wird wieder umgedreht und auf stdout gedruckt.

Hier ist eine zeilenweise Aufschlüsselung des Konzepts:

A:"programming puzzles and code golf"; // original input
B:" " vs A;                            // split on " "
C:max count each B;                    // find length of the longest string
D:C$B;                                 // pad each string to this length
E:flip D;                              // flip (rotate) string
F:{raze(x#" "),y,\:"  "};              // appends each char with "  " and prepends an increasing number of " "
G:(til count E)F'E;                    // execute function F with each pair of 0..n and item in list E
H:max count each rtrim G;              // find longest string (ignoring right whitespace)
I:H$G;                                 // pad each of the strings to this length
J:flip I;                              // flip to get result
-1 J;                                  // print to stdout, swallow return value

Anmerkungen:

Einige Möglichkeiten, um einige (11) einfache Bytes zu entfernen, wenn wir wirklich wollten:

• Konnte 2 Bytes einsparen, indem die f:Funktion gelöscht und als anonyme Funktion verlassen wurde
• Es könnten 3 Bytes gespart werden, indem das -1und gelöscht und ;eine Liste von Zeichenfolgen zurückgegeben wird, anstatt auf stdout zu drucken
• Könnte 6 Bytes einsparen, wenn wir eine Liste von Zeichenfolgen anstatt einer durch Leerzeichen getrennten Zeichenfolge übergeben würden

Bearbeitungen:

• -11 Bytes, verwenden rtrim, um die maximale Länge zum Auffüllen zu finden, entfernt Notwendigkeit zum Speichern von CVariablen
• -15 Bytes, Ausschalten der max count eachfür eine Lambda-Funktion, adie einmal erstellt und zweimal verwendet wird
• -4 Bytes, Verschieben der razein die Lambda-Funktion, um araze each
• -4 Bytes, vereinfacht die Kern-Lambda-Funktion, die das Leerzeichen hinzufügt
• -2 Bytes, (+)als Kurzform fürflip

Kohle , 16 9 Bytes

ＷＳ«Ｐ↘ιＭ³↓

Meine erste Antwort auf Kohle. Vielen Dank an @DLosc für den Vorschlag Ｐund Ｍanstatt Ｓund Ｊ(Jump) zu verwenden, um zum Anfang der Zeile zurückzukehren (und drei nach unten).

Probieren Sie es online (ausführlich) oder online (rein) .

Erläuterung:

Schleife solange es noch einen nächsten Input-String gibt:

While(InputString()){ ... }
ＷＳ« ...

Diese Zeichenfolge drucken, ohne den Cursor nach rechts unten zu bewegen:

Multiprint(:DownRight, i);
Ｐ↘ι

Und dann drei Positionen nach unten für die nächste Iteration verschieben:

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 Bytes

Nimmt die Eingabe als Array von Wörtern. Wenn nachfolgende Leerzeichen in jeder Zeile zulässig wären, könnten die letzten 4 Zeichen entfernt werden, um die Verbindung mit der Charcoal-Lösung herzustellen.

yÈmú3)iYçÃmx1

Probieren Sie es aus oder führen Sie alle Testfälle aus

Erläuterung

y                 :Transpose
 È                :Map each word at 0-based index Y
  m               :  Map each character
   ú3             :    Right pad with spaces to length 3
     )            :  End mapping
      i           :  Prepend
       Yç         :   Space repeated Y times
         Ã        :End mapping and transpose
          m       :Map
           x1     :  Trim right
                  :Implicitly join with newlines, trim and output

K4 , 58 Bytes

Lösung:

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:

Beispiele:

q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("programming";"puzzles";"and";"code";"golf")
"p          "
" r         "
"  o        "
"p  g       "
" u  r      "
"  z  a     "
"a  z  m    "
" n  l  m   "
"  d  e  i  "
"c     s  n "
" o        g"
"  d        "
"g  e       "
" o         "
"  l        "
"   f       "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:(,"a";"bcd";"efgh";,"i";,"j")
"a   "
"    "
"    "
"b   "
" c  "
"  d "
"e   "
" f  "
"  g "
"i  h"
"    "
"    "
"j   "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("verylongword";"short")
"v           "
" e          "
"  r         "
"s  y        "
" h  l       "
"  o  o      "
"   r  n     "
"    t  g    "
"        w   "
"         o  "
"          r "
"           d"

Erläuterung:

Saiten mit dem " "rechten Pad auf die gleiche Länge bringen, transponieren, zusammenfügen, mit dem linken Pad Diagonalen erzeugen, dann mit dem rechten Pad Längen korrigieren und zurück transponieren. Nimmt eine Liste von Zeichenfolgen und gibt eine Liste von Zeichenfolgen zurück. Wahrscheinlich golffähig, aber immer noch kürzer als meine Q / KDB + -Lösung.

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:
                                                        x:      / save as variable x
                                                       $        / pad
                                             (        )         / do this together
                                                  #:'x          / count (#:) each (') x
                                                |/              / max
                                              c:                / save as variable c
                                            +                   / flip / transpose
                                           $                    / string ($)
                                    "  "/:'                     / join each with "  "
                                   $                            / pad
                      (           )                             / do this together
                                #x                              / count (#) x
                              3*                                / multiply by 3
                             +                                  / add to
                         (  )                                   / do this together
                          !c                                    / range 0..c
                       2-                                       / subtract from 2
                    x:                                          / save as x:
                   $                                            / pad
 (                )                                             / do all this together
    {         }@'x                                              / apply (@) lambda {} to each x
            ^x                                                  / null (^) x (" " is considered null)
           ~                                                    / not
          |                                                     / reverse
        |\                                                      / max (|) scan (\), maxs
     0+/                                                        / sum (+) over (/) starting with 0
  |/                                                            / max (|) over (/), max
+                                                               / transpose

Perl 6 , 73 Bytes

{my@t;for .kv ->\i,\w{for w.comb.kv {@t[3*i+$^a][$^a]=$^b}};@t »||»" "}

Probieren Sie es online!

Das Eingabeargument ist eine Liste von Wörtern. Die Ausgabe ist ein Array von Zeichen.

PHP , 100 Bytes

<?foreach($_GET as$k=>$v)for($x=0;$y=$v[$x];$t[$x++]=$y)($t=&$s[$k*3+$x])?:$t=" ";echo join("
",$s);

Probieren Sie es online!