Étant donné une grille rectangulaire de texte, alignez les diagonales qui vont du coin supérieur gauche au coin inférieur droit dans des colonnes de sorte que les caractères les plus à droite de toutes les diagonales soient au même niveau. Utilisez des espaces pour l'indentation.

Par exemple, si la grille de saisie de texte est

abcd
1234
WXYZ

alors vous aligner les diagonales W, 1X, a2Y, b3z, c4et ddans les colonnes donnant cette sortie:

  ab
 123c
WXYZ4d

Notez que les caractères les plus à droite de toutes les diagonales,, WXYZ4dsont au même niveau.

Détails

• La grille de saisie du texte aura une taille minimale de 1 × 1 et toutes les lignes auront la même longueur.

• Vous pouvez prendre la grille d'entrée comme une chaîne multiligne ou comme une liste de chaînes de ligne unique.

• La grille d'entrée ne contiendra que des caractères ASCII imprimables (espace compris).

• La sortie peut éventuellement avoir une nouvelle ligne de fin, mais il ne doit pas y avoir d'autres lignes vides.

• Les lignes de la sortie peuvent éventuellement avoir des espaces de fin mais ne doivent pas avoir d'espaces de début inutiles.

Autres exemples

Les lignes vides séparent les exemples. Chaque entrée est directement suivie de sa sortie.

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

~

~

Notation

Le code le plus court en octets gagne.

J , 12 octets

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

Définit un verbe anonyme. Essayez-le en ligne!

Explication

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

En J, u &. v(lire: usous v) signifie "v, puis u, puis inverse de v". L'inversion et la transposition sont auto-inverses, donc le programme signifie vraiment "inverser, transposer, extraire les anti-diagonales inversées, transposer, inverser".

Avec un exemple d'entrée:

abcd
1234
WXYZ

Sens inverse:

WXYZ
1234
abcd

Transposer:

W1a
X2b
Y3c
Z4d

Extraire les anti-diagonales inversées (et pad avec des espaces):

W  
X1 
Y2a
Z3b
4c 
d  

Transposer:

WXYZ4d
 123c 
  ab  

Sens inverse:

  ab  
 123c 
WXYZ4d

Gelée , 11 ou 10 octets

ZŒDṙLUz⁶ṚUY

Essayez-le en ligne!

Un algorithme assez différent de mon autre solution; celui-ci utilise une fonction intégrée pour accéder aux diagonales, plutôt que de faire les choses manuellement.

Explication:

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

Les diagonales sortent peut-être dans la pire orientation possible (nécessitant des transpositions, des inversions et des rotations répétées) et dans le mauvais ordre (Jelly sort d'abord la diagonale principale, nous devons donc déplacer certaines diagonales de la fin au début pour les obtenir). en ordre). Cependant, cela sort toujours plus court que mon autre solution Jelly.

CJam , 29 octets

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

Essayez-le en ligne!

Explication

Au lieu d'extraire les diagonales, nous décollons les couches de l'extrémité en alternant gauche et droite. Tenez compte de l'entrée suivante:

GFDB
EEDB
CCCB
AAAA

Si nous écrivons les diagonales requises par le défi, nous obtenons:

   G
  EEF
 CCCDD
AAAABBB

Notez qu'il s'agit simplement (de bas en haut), de la ligne la plus basse, concaténée avec la colonne la plus à droite. Cette définition fonctionne également si l'entrée est rectangulaire.

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

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>

Je voulais juste utiliser cette /.$|\n?(?!.*\n)..+/gmidée de motif regex . ^{( https://regex101.com/r/mjMz9i/2 )}

La saveur regex JavaScript est décevante, j'ai dû l'utiliser (?!.*\n)car elle n'a pas été \Zimplémentée, et je n'ai pas pu l'utiliser \0.

• 15 octets de réduction merci @Neil.

Gelée , 15 ou 14 octets

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

Essayez-le en ligne!

Il s'agit d'un algorithme qui n'utilise pas la fonction intégrée de Jelly pour les diagonales. Faire cela pourrait le raccourcir; Je pourrais bien essayer ça ensuite.

Voici comment fonctionne l'algorithme. Commençons par cette entrée:

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

Nous commençons avec L’⁶x;\. L’nous donne la longueur de l'entrée moins 1 (dans ce cas, 2). Puis ⁶xnous donne une chaîne d'espaces de cette longueur ( " "dans ce cas); et ;\nous donne les résultats cumulatifs lors de la concaténation (un triangle d'espaces). Nous inversons ensuite le triangle et le concaténons sur le côté gauche de l'original ( ;"concatène les éléments correspondants des listes, µprovoque de force une interruption de l'analyse et utilise donc l'entrée d'origine comme deuxième liste par défaut), ce qui nous donne ceci:

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

C'est presque la solution que nous voulons, mais nous devons déplacer les éléments vers le bas pour affleurer la dernière chaîne. Il s'agit de transposer ( Z), d'inverser l'intérieur de chaque ligne ( U), de transposer à nouveau ( Z) et d'inverser les lignes ( Ṛ):

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

transposer

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

inverser dans les rangées

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

transposer

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

inverser les rangées

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

Enfin, Yrejoint sur les nouvelles lignes. Il n'est pas clair pour moi si cela est nécessaire pour se conformer à la spécification (qui autorise l'entrée sous forme de liste de chaînes, mais ne dit pas la même chose à propos de la sortie), donc le nombre d'octets exact dépend de s'il est inclus ou omis.

Pyth, 16 octets

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

Comme les gens disent que les langues de golf sont difficiles à lire, j'ai conçu Big Pyth, qui est à la fois facilement lisible et facilement traduisible en Pyth. Le fichier lié traduit un flux d'entrée de Big Pyth en Pyth. Chaque jeton Big Pyth séparé par des espaces correspond à un jeton Pyth, soit un caractère, soit un .suivi d'un caractère. Les exceptions sont les implicitjetons, qui sont implicites dans le code Pyth.

Je veux voir à quel point un format explicatif Big Pyth est bon, donc je ne vais pas donner d'autre explication. Demandez-moi cependant si vous voulez quelque chose.

JavaScript (ES6), 140 octets

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

Prend l'entrée et la sortie sous forme de tableaux de chaînes. Accepte également une entrée de tableau de caractères à deux dimensions et économise 7 octets si une sortie de tableau de caractères à deux dimensions est acceptable. Explication: La hauteur du résultat mest le minimum de la hauteur het de la largeur wdu tableau d'origine, tandis que la largeur est simplement inférieure de un à la somme de la hauteur et de la largeur du tableau d'origine. La ligne source pour les caractères de la partie principale du résultat provient directement de la ligne appropriée du tableau d'origine, en comptant à partir du bas, tandis que sur la partie supplémentaire du résultat, la ligne source monte d'une ligne pour chaque colonne supplémentaire. La colonne source pour les deux moitiés du résultat s'avère être égale à la colonne de destination déplacée d'une colonne vers la gauche pour chaque ligne source au-dessus du bas.

Octave, 57 octets

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

Python 3, 247 octets

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 octets

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

Prend l'entrée comme liste de chaînes.

Clojure, 194 octets

Implémenté à la dure en regroupant les personnages Gpuis en générant des lignes.

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

Prend entrée en tant que vecde vecs comme [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]. Exemple:

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

  ab
 c123
d4WXYZ