Ordnen Sie die Diagonalen, die von links oben nach rechts unten verlaufen, in Spalten mit einem rechteckigen Textraster so an, dass sich die Zeichen ganz rechts unten aller Diagonalen auf einer Ebene befinden. Verwenden Sie Leerzeichen zum Einrücken.

Zum Beispiel, wenn das Eingaberaster von Text ist

abcd
1234
WXYZ

dann würden Sie die Diagonalen in einer Reihe aufstellen W, 1X, a2Y, b3z, c4, undd in den Spalten dieser Ausgabe geben:

  ab
 123c
WXYZ4d

Beachten Sie, dass die am weitesten rechts liegenden Zeichen aller Diagonalen WXYZ4d auf derselben Ebene befinden.

Einzelheiten

• Das Eingabegitter für Text hat eine Größe von mindestens 1 × 1 und alle Zeilen haben dieselbe Länge.

• Sie können das Eingaberaster als mehrzeilige Zeichenfolge oder als Liste einzeiliger Zeichenfolgen verwenden.

• Das Eingaberaster enthält nur druckbare ASCII-Zeichen (einschließlich Leerzeichen).

• Die Ausgabe kann optional eine nachgestellte neue Zeile enthalten, es sollten jedoch keine weiteren leeren Zeilen vorhanden sein.

• Die Zeilen der Ausgabe können optional nachgestellte Leerzeichen enthalten, sollten jedoch keine unnötigen führenden Leerzeichen enthalten.

Andere Beispiele

Leerzeilen trennen Beispiele. Jedem Eingang folgt direkt sein Ausgang.

123
456
789

  1
 452
78963

123.?!
456??!
789!!!

  123.
 456???
789!!!!!

**@
@  

 **
@  @


/\/\
\/ /
/ /\
\/\/

   /
  \/\
 / / /
\/\/\/\

12
34
56
78
90

 7531
908642

Code

Code

G
O
L
F

FLOG

~

~

Wertung

Der kürzeste Code in Bytes gewinnt.

J , 12 Bytes

|./.&.|:&.|.

Definiert ein anonymes Verb. Probieren Sie es online!

Erläuterung

|./.&.|:&.|.
|.            Reversed
  /.          anti-diagonals
    &.        under
      |:      transpose
        &.    under
          |.  reversal

In J u &. v(lese: uunterv ) "v, dann u, dann invers zu v". Umkehrung und Transponierung sind Selbstumkehrungen, daher bedeutet das Programm "umkehren, transponieren, umgekehrte Antidiagonalen extrahieren, transponieren, umkehren".

Mit Beispieleingabe:

abcd
1234
WXYZ

Umkehren:

WXYZ
1234
abcd

Transponieren:

W1a
X2b
Y3c
Z4d

Umgekehrte Antidiagonalen (und Block mit Leerzeichen) extrahieren:

W  
X1 
Y2a
Z3b
4c 
d  

Transponieren:

WXYZ4d
 123c 
  ab  

Umkehren:

  ab  
 123c 
WXYZ4d

Jelly , 11 oder 10 Bytes

ZŒDṙLUz⁶ṚUY

Probieren Sie es online!

Ein ziemlich anderer Algorithmus als meine andere Lösung; Dieser verwendet ein eingebautes Werkzeug, um an die Diagonalen heranzukommen, anstatt die Dinge manuell zu erledigen.

Erläuterung:

ZŒDṙLUz⁶ṚUY
Z           transpose
 ŒD         diagonals, main diagonal first
    L       number of lines in the original array
   ṙ        rotate list (i.e. placing the short diagonal first)
     U      reverse inside lines
      z⁶    transpose, padding with spaces
        ṚU  rotate matrix 180 degrees
          Y (possibly unnecessary) join on newlines

Die Diagonalen werden möglicherweise in der schlechtestmöglichen Ausrichtung (die wiederholte Transpositionen, Umkehrungen und Rotationen erfordert) und in der falschen Reihenfolge ausgegeben (Jelly gibt die Hauptdiagonale zuerst aus, daher müssen wir einige Diagonalen vom Ende zum Anfang verschieben, um sie zu erhalten in Ordnung). Dies ist jedoch immer noch kürzer als meine andere Jelly-Lösung.

CJam , 29 Bytes

qN/{)\z}h]2/{~W%+}%eeSf.*W%N*

Probieren Sie es online!

Erläuterung

Anstatt die Diagonalen zu extrahieren, ziehen wir abwechselnd links und rechts Schichten vom Ende ab. Betrachten Sie die folgende Eingabe:

GFDB
EEDB
CCCB
AAAA

Wenn wir die Diagonalen so aufschreiben, wie es die Herausforderung erfordert, erhalten wir:

   G
  EEF
 CCCDD
AAAABBB

Beachten Sie, dass dies einfach (von unten nach oben) die unterste Zeile ist, die mit der Spalte ganz rechts verkettet ist. Diese Definition funktioniert auch, wenn die Eingabe rechteckig ist.

{      e# Run this loop while there are still lines left in the input.
  )    e#   Pull off the bottom-most row.
  \    e#   Swap with the remaining rows.
  z    e#   Transpose the grid so that the next iteration pulls off the last
       e#   column instead. However, it should be noted that transposing
       e#   effectively reverses the column, so the second half of each output
       e#   line will be the wrong way around. We'll fix that later.
}h     e# When the loop is done, we'll have all the individual layers on the
       e# stack from bottom to top, alternating between horizontal and vertical
       e# layers. There will be an empty string on top.
]      e# Wrap all those strings in a list.
2/     e# Split into pairs. There may or may not be a trailing single-element
       e# list with the empty string.
{      e# Map this block over each pair...
  ~    e#   Dump the pair on the stack.
  W%   e#   Reverse the second element.
  +    e#   Append to first element.
       e#   If there was a trailing single-element list, this will simply
       e#   add the empty string to the previous pair, which just removes
       e#   the empty string.
}%
ee     e# Enumerate the list, which pairs each string (now containing both halves)
       e# of an output line from bottom to top) with its index.
Sf.*   e# Turn those indices X into strings of X spaces, to get the correct
       e# indentation.
W%     e# Reverse the list of strings so the longest line ends up on the bottom.

JavaScript, 116 101 Bytes

f=(s,r='$&',l='',z=s.replace(/.$|\n?(?!.*\n)..+/gm,x=>(l=x+l,'')))=>l?f(z,r+' ')+l.replace(/\n?/,r):l


G.onclick=()=>O.textContent=f(I.value);

<textarea id=I style=height:100px>/\/\
\/ /
/ /\
\/\/</textarea><button id=G>Go</button><pre id=O></pre>

Ich wollte nur diese Regex-Muster- /.$|\n?(?!.*\n)..+/gmIdee verwenden. ^{( https://regex101.com/r/mjMz9i/2 )}

JavaScript Regex-Geschmack ist enttäuschend, ich musste es verwenden, (?!.*\n)weil es nicht \Zimplementiert wurde, und irgendwie konnte ich es nicht verwenden \0.

• 15 Bytes weg danke @Neil.

Gelee , 15 oder 14 Bytes

L’⁶x;\Ṛ;"µZUZṚY

Probieren Sie es online!

Dies ist ein Algorithmus, der Jellys eingebaute Diagonalen nicht verwendet. Dadurch könnte es kürzer werden. Das könnte ich wohl als nächstes versuchen.

So funktioniert der Algorithmus. Beginnen wir mit dieser Eingabe:

["abc",
 "def",
 "ghi"]

Wir beginnen mit L’⁶x;\. L’gibt uns die Länge der Eingabe minus 1 (in diesem Fall 2). Dann erhalten ⁶xwir eine Folge von Räumen dieser Länge ( " "in diesem Fall); und ;\gibt uns die kumulativen Ergebnisse bei der Verkettung (ein Dreieck von Räumen). Wir kehren dann das Dreieck um und verknüpfen es mit der linken Seite des Originals ( ;"verknüpft die entsprechenden Elemente der Listen, µverursacht zwangsweise eine Unterbrechung des Parsings und verwendet daher standardmäßig die Originaleingabe als zweite Liste).

["  abc",
 " def",
 "ghi"]

Dies ist fast die Lösung, die wir wollen, aber wir müssen die Elemente nach unten verschieben, um bündig mit der letzten Zeichenfolge zu sein. Das ist eine Frage des Transponierens ( Z), Umkehrens innerhalb jeder Zeile ( U), erneuten Transponierens ( Z) und Umkehrens der Zeilen ( Ṛ):

["  abc",
 " def",
 "ghi"]

transponieren

["  g",
 " dh",
 "aei",
 "bf",
 "c"]

innerhalb von Zeilen umkehren

["g  ",
 "hd ",
 "iea",
 "fb",
 "c"]

transponieren

["ghifc",
 " deb",
 "  a"]

Vertausche die Reihen

["  a",
 " deb",
 "ghifc"]

Endlich Yschließt sich auf Newlines. Es ist mir unklar, ob dies erforderlich ist, um der Spezifikation zu entsprechen (die die Eingabe als Liste von Zeichenfolgen erlaubt, aber nicht das Gleiche über die Ausgabe sagt), sodass die genaue Anzahl der Bytes davon abhängt, ob sie enthalten oder weggelassen wird.

Pyth, 16 Bytes

j_.t_M.Tm+*;l=tQ

Big Pyth :

join-on-newline
reverse transpose-and-fill-with-spaces reverse func-map transpose-justified
map
  plus
    times innermost-var
      length assign tail input
    implicit-innermost-var
  implicit-input

Da die Leute sagen, Golfsprachen seien schwer zu lesen, habe ich Big Pyth entworfen, das sowohl leicht lesbar als auch leicht in Pyth übersetzbar ist. Die verknüpfte Datei übersetzt einen Eingabestream von Big Pyth in Pyth. Jedes durch Leerzeichen getrennte Big Pyth-Token entspricht einem Pyth-Token, entweder einem Zeichen oder einem .gefolgt von einem Zeichen. Die Ausnahmen sind dieimplicit Token, die im Pyth-Code enthalten sind.

Ich möchte sehen, wie gut ein erklärendes Format für Big Pyth ist, deshalb werde ich keine andere Erklärung geben. Fragen Sie mich, ob Sie etwas erklärt haben möchten.

JavaScript (ES6), 140 Byte

a=>[...Array(m=(h=a.length)<(w=a[0].length)?h:w)].map((_,i)=>[...Array(h+w-1)].map((_,j)=>(a[x=i+h-m-(++j>w&&j-w)]||``)[x+j-h]||` `).join``)

Nimmt Ein- und Ausgabe als Arrays von Strings. Akzeptiert auch eine zweidimensionale Zeichenfeld-Eingabe und spart 7 Bytes, wenn eine zweidimensionale Zeichenfeld-Ausgabe akzeptabel ist. Erläuterung: Die Höhe des Ergebnisses mist das Minimum der Höhe hund Breite wdes ursprünglichen Arrays, während die Breite einfach um eins geringer ist als die Summe der Höhe und Breite des ursprünglichen Arrays. Die Quellzeile für die Zeichen im Hauptteil des Ergebnisses stammt direkt aus der entsprechenden Zeile des ursprünglichen Arrays und wird von unten nach oben gezählt, während die Quellzeile im zusätzlichen Teil des Ergebnisses für jede weitere Spalte um eine Zeile nach oben verschoben wird. Die Quellenspalte für beide Hälften des Ergebnisses entspricht der Zielspalte, die für jede Quellenspalte um eine Spalte über dem unteren Rand nach links verschoben wurde.

Oktave, 57 Bytes

@(A){B=spdiags(A),C=B>0,D='  '(C+1),D(sort(C))=B(C),D}{5}

Python 3, 247 Bytes

def a(s):
 s=s.split('\n')
 for i,l in enumerate(s):r=len(s)-i-1;s[i]=' '*r+l+' '*(len(s)-r-1)
 print(*[''.join(i) for i in list(zip(*[''.join(a).rstrip([::-1].ljust(min(len(s),len(s[0])))for a in zip(*[list(i)for i in s])]))[::-1]],sep='\n')`

Python 2, 150 Bytes

def f(l):w=len(l[0]);h=len(l);J=''.join;R=range;print'\n'.join(map(J,zip(*['%%-%ds'%h%J(l[h+~i][j-i]for i in R(h)if-w<i-j<1)for j in R(h-~w)]))[::-1])

Übernimmt die Eingabe als Liste von Zeichenfolgen.

Clojure, 194 Bytes

Implementiert auf die harte Tour durch Gruppieren von Zeichen zu Gund anschließendes Generieren von Zeilen.

#(let[n(count %)m(count(% 0))G(group-by first(for[i(range n)j(range m)][(min(- n i)(- m j))((% i)j)]))](apply str(flatten(for[k(reverse(sort(keys G)))][(repeat(dec k)" ")(map last(G k))"\n"]))))

Nimmt Eingaben als vecvon vecs wie [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]. Beispiel:

(def f #( ... ))
(print (str "\n" (f (mapv vec(re-seq #".+" "abcd\n1234\nWXYZ")))))

  ab
 c123
d4WXYZ