Data una griglia rettangolare di testo, allinea le diagonali che vanno da in alto a sinistra a in basso a destra in colonne in modo tale che i caratteri più in basso a destra di tutte le diagonali siano su un livello. Usa gli spazi per il rientro.

Ad esempio, se la griglia di input del testo è

abcd
1234
WXYZ

allora si sarebbe allineare le diagonali W, 1X, a2Y, b3z, c4, e din colonne che danno questo output:

  ab
 123c
WXYZ4d

Si noti che i caratteri più in basso a destra di tutte le diagonali WXYZ4dsono allo stesso livello.

Dettagli

• La griglia di input del testo avrà una dimensione minima di 1 × 1 e tutte le righe avranno la stessa lunghezza.

• È possibile prendere la griglia di input come stringa multilinea o come elenco di stringhe a riga singola.

• La griglia di input contiene solo caratteri ASCII stampabili (include spazio).

• L'output può facoltativamente avere una nuova riga finale ma non dovrebbero esserci altre righe vuote.

• Le linee dell'output possono avere opzionalmente spazi finali ma non dovrebbero avere spazi iniziali non necessari.

Altri esempi

Le righe vuote separano esempi. Ogni input è seguito direttamente dal suo output.

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

~

~

punteggio

Vince il codice più breve in byte.

J , 12 byte

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

Definisce un verbo anonimo. Provalo online!

Spiegazione

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

In J, u &. v(leggi: usotto v) significa "v, quindi u, quindi inversa di v". L'inversione e la trasposizione sono auto-inverse, quindi il programma in realtà significa "inversione, trasposizione, estrazione di anti-diagonali inverse, trasposizione, inversione".

Con input di esempio:

abcd
1234
WXYZ

Inverso:

WXYZ
1234
abcd

Trasporre:

W1a
X2b
Y3c
Z4d

Estrai anti-diagonali inverse (e pad con spazi):

W  
X1 
Y2a
Z3b
4c 
d  

Trasporre:

WXYZ4d
 123c 
  ab  

Inverso:

  ab  
 123c 
WXYZ4d

Gelatina , 11 o 10 byte

ZŒDṙLUz⁶ṚUY

Provalo online!

Un algoritmo abbastanza diverso dall'altra mia soluzione; questo usa un builtin per raggiungere le diagonali, piuttosto che fare le cose manualmente.

Spiegazione:

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

Le diagonali escono probabilmente con il peggior orientamento possibile (richiedono ripetute trasposizioni, inversioni e rotazioni) e nell'ordine sbagliato (Jelly emette prima la diagonale principale, quindi dobbiamo spostare alcune diagonali dalla fine all'inizio per ottenerle In ordine). Tuttavia, questo risulta ancora più breve della mia altra soluzione Jelly.

CJam , 29 byte

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

Provalo online!

Spiegazione

Invece di estrarre le diagonali, stacciamo i livelli dall'estremità, alternando sinistra e destra. Considera il seguente input:

GFDB
EEDB
CCCB
AAAA

Se scriviamo le diagonali come richiesto dalla sfida, otteniamo:

   G
  EEF
 CCCDD
AAAABBB

Si noti che questo è semplicemente (dal basso verso l'alto), la riga più in basso, concatenata con la colonna più a destra. Questa definizione funziona anche se l'input è rettangolare.

{      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 byte

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>

Volevo solo usare questa /.$|\n?(?!.*\n)..+/gmidea di modello regex . ^{( https://regex101.com/r/mjMz9i/2 )}

Il sapore regex di JavaScript è deludente, ho dovuto usarlo (?!.*\n)perché non è stato \Zimplementato e in qualche modo non sono riuscito a usarlo \0.

• 15 byte di sconto grazie @Neil.

Gelatina , 15 o 14 byte

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

Provalo online!

Questo è un algoritmo che non utilizza il Jelly incorporato per le diagonali. Ciò potrebbe ridurlo; Potrei benissimo provarlo dopo.

Ecco come funziona l'algoritmo. Cominciamo con questo input:

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

Iniziamo con L’⁶x;\. L’ci dà la lunghezza dell'input meno 1 (in questo caso, 2). Quindi ⁶xci fornisce una stringa di spazi di quella lunghezza ( " "in questo caso); e ;\ci dà i risultati cumulativi quando lo concateniamo (un triangolo di spazi). Quindi invertiamo il triangolo e lo concateniamo sul lato sinistro dell'originale ( ;"concatena gli elementi corrispondenti degli elenchi, µprovoca forzatamente un'interruzione nell'analisi e quindi utilizza l'input originale come secondo elenco per impostazione predefinita), dandoci questo:

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

Questa è quasi la soluzione che vogliamo, ma dobbiamo spostare gli elementi verso il basso per essere allineati con l'ultima stringa. È una questione di trasposizione ( Z), inversione all'interno di ogni riga ( U), trasposizione di nuovo ( Z) e inversione delle righe ( Ṛ):

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

trasporre

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

indietro tra le file

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

trasporre

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

invertire le file

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

Infine, si Yunisce a newline. Non mi è chiaro se questo sia necessario o meno per conformarsi alla specifica (che consente l'input come un elenco di stringhe, ma non dice lo stesso sull'output), quindi il conteggio esatto dei byte dipende dal fatto che sia incluso o omesso.

Pyth, 16 byte

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

Dato che la gente dice che le lingue del golf sono difficili da leggere, ho progettato Big Pyth, che è sia facilmente leggibile che facilmente traducibile in Pyth. Il file collegato traduce un flusso di input di Big Pyth in Pyth. Ogni token Big Pyth separato da spazi bianchi corrisponde a un token Pyth, un carattere o un. seguito da un personaggio. Le eccezioni sono i implicittoken, che sono impliciti nel codice Pyth.

Voglio vedere quanto è buono un formato esplicativo di Big Pyth, quindi non ho intenzione di dare altre spiegazioni. Chiedimi se vuoi qualcosa spiegato, comunque.

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

Accetta input e output come matrici di stringhe. Accetta anche un input di array di caratteri bidimensionali e salva 7 byte se è accettabile un output di array di caratteri bidimensionali. Spiegazione: L'altezza del risultato mè il minimo dell'altezza he della larghezza wdell'array originale, mentre la larghezza è semplicemente una in meno della somma dell'altezza e della larghezza dell'array originale. La riga di origine per i caratteri sulla parte principale del risultato proviene direttamente dalla riga appropriata dell'array originale, contando dal basso verso l'alto, mentre sulla parte aggiuntiva del risultato la riga di origine si sposta di una riga per ogni colonna aggiuntiva. La colonna di origine per entrambe le metà del risultato risulta essere uguale alla colonna di destinazione spostata di una colonna a sinistra per ciascuna riga di origine sopra la parte inferiore.

Ottava, 57 byte

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

Python 3, 247 byte

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 byte

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

Accetta input come elenco di stringhe.

Clojure, 194 byte

Implementato nel modo più duro raggruppando i caratteri Ge quindi generando linee.

#(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"]))))

Accetta input come a vecof vecs like [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]. Esempio:

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

  ab
 c123
d4WXYZ