З огляду на прямокутну сітку тексту, розташуйте діагоналі, які йдуть зліва-вліво-вправо, у стовпці так, щоб найменші праворучні символи всіх діагоналей були на рівні. Використовуйте пробіли для відступу.

Наприклад, якщо вхідна сітка тексту є

abcd
1234
WXYZ

то ви б вибудовуватися діагоналей W, 1X, a2Y, b3z, c4, і dв колонках , даючи цей вихід:

  ab
 123c
WXYZ4d

Зауважте, що найменші правої літери всіх діагоналей, WXYZ4d , знаходяться на одному рівні.

Деталі

• Вхідна сітка тексту буде розміром не менше 1 × 1, і всі рядки будуть однакової довжини.

• Ви можете приймати вхідну сітку як багаторядкову рядок або як список рядків для рядків.

• Вхідна сітка містить лише символи для друку ASCII (включає пробіл).

• Необов'язково може бути один вихідний новий рядок, але не повинно бути інших порожніх рядків.

• У рядках виводу необов'язково можуть бути пробіли, але вони не повинні мати зайвих провідних пробілів.

Інші приклади

Порожні рядки - окремі приклади. За кожним входом безпосередньо йде його вихід.

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

~

~

Оцінка балів

Виграє найкоротший код у байтах.

J , 12 байт

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

Визначає анонімне дієслово. Спробуйте в Інтернеті!

Пояснення

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

В J, u &. v(читати: uпідv ) означає "v, потім u, то зворотне v". Поворот і транспонування - це самоперевертання, тому програма дійсно означає "перевернути, перемістити, витягнути перевернуті антидіагоналі, перемістити, повернути назад".

З прикладом введення:

abcd
1234
WXYZ

Реверс:

WXYZ
1234
abcd

Перенести:

W1a
X2b
Y3c
Z4d

Витягнути протилежні діагоналі (та прокладку з пробілами):

W  
X1 
Y2a
Z3b
4c 
d  

Перенести:

WXYZ4d
 123c 
  ab  

Реверс:

  ab  
 123c 
WXYZ4d

Желе , 11 або 10 байт

ZŒDṙLUz⁶ṚUY

Спробуйте в Інтернеті!

Досить інший алгоритм від мого іншого рішення; цей використовується вбудований, щоб дістатися до діагоналей, а не робити речі вручну.

Пояснення:

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

Діагоналі виходять, можливо, в найгіршій можливій орієнтації (вимагаючи повторних переміщень, переворотів і поворотів), і в неправильному порядку (Jelly виводить першу головну діагоналі спочатку, тому нам доведеться перемістити деякі діагоналі від кінця до початку, щоб отримати їх в порядку). Однак це все-таки виходить коротшим, ніж моє інше рішення Jelly.

CJam , 29 байт

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

Спробуйте в Інтернеті!

Пояснення

Замість того, щоб витягувати діагоналі, ми знімаємо шари з кінця, чергуючи лівий і правий. Розглянемо наступний вклад:

GFDB
EEDB
CCCB
AAAA

Якщо ми випишемо діагоналі, як того вимагає виклик, отримуємо:

   G
  EEF
 CCCDD
AAAABBB

Зауважте, що це просто (знизу вгору), самий нижній рядок, з'єднаний з найбільш правим стовпцем. Це визначення також працює, якщо вхід прямокутний.

{      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 байт

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>

Я просто хотів використати цю /.$|\n?(?!.*\n)..+/gmідею шаблону регулярних виразів . ^{( https://regex101.com/r/mjMz9i/2 )}

Аромат JavaScript-регулярного геть розчаровує, мені довелося використовувати, (?!.*\n)оскільки він не \Zреалізований, а я якось не користувався \0.

• 15 байт від спасибі @Neil.

Желе , 15 або 14 байт

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

Спробуйте в Інтернеті!

Це алгоритм, який не використовує вбудований Jelly для діагоналей. Це може скоротити її; Можливо, я б спробував це далі.

Ось як працює алгоритм. Почнемо з цього вводу:

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

Почнемо з L’⁶x;\. L’дає нам довжину введення мінус 1 (у цьому випадку 2). Потім ⁶xдає нам рядок пробілів такої довжини ( " "в даному випадку); і ;\дає нам сукупні результати при об'єднанні його (трикутник пробілів). Потім повертаємо трикутник і з'єднуємо його з лівою частиною оригіналу ( ;"об'єднує відповідні елементи списків, µнасильно викликає перерву в синтаксичному розборі і, таким чином, використовує оригінальний ввід як другий список за замовчуванням), даючи нам це:

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

Це майже рішення, яке ми хочемо, але нам потрібно перемістити елементи вниз, щоб бути нарівні з останньою рядком. Це питання транспонування ( Z), реверсування всередині кожного рядка ( U), перенесення знову ( Z) і повернення рядків (Ṛ ):

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

переносити

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

реверс у рядах

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

переносити

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

перевернути рядки

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

Нарешті, Yприєднується до нових ліній. Мені незрозуміло, чи потрібно це відповідати специфікації (яка дозволяє вводити як список рядків, але про вихід не говорить те саме), тому точний кількість байтів залежить від того, включений він чи пропущений.

Pyth, 16 байт

j_.t_M.Tm+*;l=tQ

Великий Піт :

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

Оскільки люди кажуть, що мови для гри в гольф важко читати, я створив Big Pyth, який легко читається і легко перекладається на Pyth. Зв'язаний файл переводить вхідний потік Big Pyth до Pyth. Кожен маркер Big Pyth, відокремлений пробілом, відповідає знаку Pyth, або символу, або a. слідуючим символом. Винятки становлятьimplicit лексеми, які неявні в Pyth-коді.

Я хочу побачити, наскільки хороший пояснювальний формат Big Pyth, тому я не збираюся давати жодних інших пояснень. Запитайте мене, чи хочете ви щось пояснити.

JavaScript (ES6), 140 байт

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

Вводить і виводить як масиви рядків. Також приймає вхід двовимірного масиву символів і зберігає 7 байт, якщо прийнятний двовимірний масив символів. Пояснення: Висота результату m- мінімум висотиh та ширини wвихідного масиву, тоді як ширина просто на одну меншу, ніж сума висоти та ширини вихідного масиву. Вихідний рядок для символів на головній частині результату надходить безпосередньо з відповідного рядка вихідного масиву, рахуючи знизу, тоді як на додатковій частині результату вихідний рядок переміщується вгору на один рядок для кожного додаткового стовпця. Стовпчик джерела для обох половин результату виявляється рівним стовпчику призначення, переміщеному по одному стовпчику зліва для кожного рядка джерела над дном.

Октава, 57 байт

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

Python 3, 247 байт

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 байт

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

Вводиться як список рядків.

Clojure, 194 байти

Реалізував складний спосіб, групуючи символи до, Gа потім генеруючи рядки.

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

Приймає вхідний сигнал у вигляді vecз vecS , як [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]. Приклад:

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

  ab
 c123
d4WXYZ