Намалюйте діагональні лінії тексту


46

Давши введення списку слів, виведіть слова з їх літерами, розташованими по діагоналі:

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

(Вищенаведене має бути результатом для введення даних programming puzzles and code golf.)

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

Вхід може бути наданий як окремий рядок слів, розділений рівно одним пробілом, або список / масив слів. Слова будуть складатися лише з малих літер a-z, і завжди будуть мати принаймні один символ.

Виведенням може бути одна рядок, масив рядків або масив масивів символів. Провідна або кінцева пробіли не допускається, за винятком одного останнього нового рядка.

Подальші тестові випадки:

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

Оскільки це , найкоротший код у байтах виграє!


Я відчуваю, що я маю змогу зробити програму Python для цього за 5 хвилин, але це завжди здається невдалим ...; _;
HyperNeutrino

Ого, схоже , є багато проблем , здавалося б , призначеними для Turtlèd
Destructible Lemon

Чи дозволені коди відключення терміналів? :)
Хром

Відповіді:


17

Vim, 85, 76, 66 , 52 натискання клавіш / байтів

Коли я вперше подивився на цей виклик, я подумав "Це ідеально підходить для vim!" А потім, коли я спробував це, все пішло не так. Ось він, у всьому це безладна хакі слава:

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

Спробуйте в Інтернеті, завдяки (в основному) сумісному V-перекладачу.

Пояснення:

Спочатку я думав, що можу зробити цю красиво просту версію 37 байт:

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

На жаль, це не так просто. Візьмемо це по черзі:

:se ve=all

Це дозволяє отримати функцію під назвою "віртуальне редагування". Це дозволяє курсору переходити до стовпців, які ще не існують. Ця відповідь була б в основному неможливою без цього.

Тепер нам потрібно відокремити слова на різні рядки. Таким чином, ми замінимо кожен пробіл на 3 нові рядки. Оскільки це колишня команда, ми можемо виконувати її одночасно з останньою колишньою командою :se ve=all, розділивши їх двома смужкою.

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

Тепер буфер виглядає так:

Programming


Puzzles


and


code-golf

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

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

Потім закінчуємо рекурсивний макрос за допомогою @qq@q. На даний момент у нас є всі діагоналі, нам просто потрібно трохи почистити.

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

Нічого, JavaScript на даний момент коротший, ніж Vim. Це досить рідкісне явище в наші дні ...
ETHproductions

@ETHproductions Більше. :)
DJMcMayhem

6

Turtlèd , 28 26 байт

О, я, здається, б'є мову, спеціально розроблену для гольфу. це чудовий день.

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

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

Пояснення

(запис означає означає запис у комірку на сітці, загострений знак char означає введення рядкового вказівника на)

!                         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

відзначте простір.

Для введення також потрібен простір. бачачи, як python може взяти список, це дуже схоже на те, щоб взяти список у Turtlèd


5

MATL , 28 байт

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

Введення - це масив комірок рядків із комами як необов'язкові роздільники:

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

або

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

Спробуйте в Інтернеті! Або перевірити всі тестові випадки: 1 , 2 , 3 , 4 .

Пояснення

Розглянемо такий приклад:

{'aaaa' 'bb' 'ccc'}

Ви можете переглянути часткові результати (вміст стеку), вставляючи символ коментаря %в будь-яку точку коду. Наприклад, переглянути вміст стеку після четвертої функції ( &n).

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', '', '', '', ''}

4

JavaScript (ES6), 118 109 84 байт

Вводить введення як масив слів. Повертає масив масивів символів.

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

Альтернативна версія, 109 байт

Повертає рядок.


2

Лист звичайний, 673 668 597 байт

Страшне рішення, я знаю. Я, певно, відредагую це ще після сну.

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

Використання:

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

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

Це петля над кожним словом у наданому списку та додає відповідні символи до поточного рядка. Моє використання підрозділу надає відповідне прокладка format.

Примітка: Я новачок у Common Lisp, але я знаю достатньо, щоб зрозуміти, що це могло б багато вдосконалити.


2
> :( "ppcg ... ок" !?
лимон

2

C #, 336 байт:

Гольф:

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;}

Безголівки:

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;
}

Тестування:

  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

Це з'являється для виведення пробілу пробілів на кінці рядків, що заборонено специфікацією виклику. Крім того, вимагати рядків пробілів для розділення слів у вхідному масиві не є дозволеним форматом введення.
Дверна ручка

@Doorknob На жаль, вибачте ... Виправлено, коштувало мені лише 2 байти :)
Піт Арден,

1
Компілюйте до Func<string[], string>та внесіть інші зміни на 297 байт, s=>{int i=0,x=0,y=0,r=0,l=s.Length,q=2*(s.Max().Length+l)+1,j;var a=new char[q,q];for(;i<l;i++){y=r;for(j=0;j<s[i].Length;)a[y++,x++]=s[i][j++];x=0;r+=3;}var o="";for(;x<q;x++){var t="";for(y=0;y<q;)t+=a[x,y++];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\n");}return o;};однак вам потрібно додати 18 байт дляusing System.Linq;
TheLethalCoder

@TheLethalCoder Спасибі, але я не дуже хочу прийняти все ваше рішення :)
Піт Арден

Це не моє ваше, я просто переграв частину речей, тобто переміщення thwe iта jint-декларації у верхній частині та переміщення деяких з них, ++тому вони використовуються при останньому використанні змінної
TheLethalCoder

2

Python 2, 146 байт

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

Примітка: відступи для останніх двох рядків є <space>і <tab>, що зберігає один байт, оскільки я не потребую подвійного відступу.

Введення потрібно вводити у вигляді масиву рядків так: ["hello", "world"]або ['hello', 'world']. Вихід - це масив масивів символів.

Можливо, є кращий спосіб зробити це ...

EDIT Дякуємо Дорнобу за те, що він вказав на відсутній близький квадратний кронштейн. Я розмістив його перед *k...третім рядком.


У вашому коді в третьому рядку є синтаксична помилка; є дві відкриті дужки, але лише одна закрита дужка. Однак я це виправляю (додаючи додаткову дужку закриття або видаляючи додаткову дужку відкриття), програма видає помилку при запуску.
Дверна ручка

Тепер це з'являється для виведення пробілів пробілів на кінці рядків та в кінці виводу, що заборонено специфікацією виклику.
Дверна ручка


@LeakyNun Дякую Ти просто перебираєш і граєш на всі мої відповіді? : P
HyperNeutrino

1

Математика, 146 байт

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

Я розчарований цим рахунком, але добре.

Визначає анонімну функцію, яка приймає список слів (наприклад {"this","that","these"}) і повертає двовимірний масив символів. Щоб переглянути у вигляді сітки, додайте в //Gridкінці.

Перетворює рядки в масив, додає додаткові рядки, транспонує масив, попередньо потрібні зсуви, потім знову транспонує.

Приклад результату (відформатований як сітка): Приклад результату


1

Желе , 24 байти

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

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

Як?

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

1

Python 2, 182 байт

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

Трохи довгий, але з позитивної сторони, він повертає рядок, не маючи пробілів у кожному рядку, а також немає білого пробілу або повертається в кінці; обмеження, яким деякі інші записи не дотримуються.

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

Якщо ми дозволимо прокласти пробіл у всіх рядках, крім останнього, ми можемо зробити трохи краще (163 байти):

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

1

q / kdb +, 130 109 94 90 86 84 байт

Рішення:

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

Приклади:

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

Пояснення (необережений):

Основна суть полягає в тому, щоб створити купу рядків однакової довжини з вхідного рядка, перевернути їх (повернути), а потім додати відповідний пробіл, щоб отримати щось таке:

"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     "

який знову перегортається і друкується до stdout.

Ось покрокова розбивка концепції:

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

Примітки:

Кілька способів відголити кілька (11) простих байтів, якщо ми насправді хотіли:

  • Не вдалося зберегти 2 байти, скинувши f: і залишивши як анонімну функцію
  • Не вдалося зберегти 3 байти, скинувши -1і; і повертає список рядків , а не друк на стандартний висновок
  • Не вдалося зберегти 6 байт, якби ми перейшли у список рядків, а не розділених пробілом рядків

Зміни:

  • -11 байт, використання rtrim для пошуку максимальної довжини до колодки, видалену потребу в зберіганні Cзмінної
  • -15 байт, вимикаючи max count eachфункцію лямбдаa яка створюється один раз і використовується два рази
  • -4 байти, переміщуючись razeу функцію лямбда, щоб зберегти araze each
  • -4 байти, спрощена основна лямбда-функція, яка додає пробіл
  • -2 байти, використовувати (+)як скорочення дляflip

1

Вугілля деревне , 16 9 байт

WS«P↘ιM³↓

Моя перша відповідь деревного вугілля. Завдяки @DLosc за пропозицію, а замість використання та (Jump) повернутися до початку рядка (і трьох вниз).

Спробуйте в Інтернеті (багатослівний) або Спробуйте в Інтернеті (чисто) .

Пояснення:

Цикл, поки ще є наступний рядок введення:

While(InputString()){ ... }
WS« ...

Роздрукуйте цей рядок, не переміщуючи курсор у напрямку вниз вправо:

Multiprint(:DownRight, i);
P↘ι

А потім перемістіть три позиції вниз для наступної ітерації:

Move(3, :Down);
M³↓

Коли для виклику потрібен єдиний вхід, що складається з масиву, деревне вугілля виходить з ладу, оскільки він розбиває рядок введення, приймаючи кожне слово як окремий вхід. Але у вугільному вугіллі θзмінна являє собою перший вхід, тому я просто призначаю тестовий вхід цій змінній у заголовку, а потім записую решту коду, щоб ви могли позбутися αзмінної та ітерації над розділеними елементами θ. Спробуйте в Інтернеті! (Не змагається через провідні простори.)
Чарлі

Принаймні, ніхто не скаржився, коли я використовував цю хитрість тут . :-)
Чарлі

@CarlosAlejo Я дійсно натрапив на вашу відповідь, коли шукав натхнення на існуючі відповіді на вугілля. :)
Кевін Круїссен

IDK, метод, який я зазвичай використовую, - це лише рядки + порожня рядок наприкінці, якщо такі є багаторядковими, то вводяться як масив пітонів
лише ASCII

@CarlosAlejo Минув час, але я просто використовував декілька рядків із порожньою лінією, щоб перервати час (і гольфувати на 7 байт одночасно). Бачив, що він використовувався в одній з відповідей Ніла , і тепер я бачу, що ASCII лише запропонував те саме (якось пропустив цей коментар).
Kevin Cruijssen

1

Japt -Rx, 17 16 13 байт

Вводить введення як масив слів. Якщо дозволено пробіл у кожному рядку, то останні 4 символи можна видалити, щоб зв’язати з розчином деревного вугілля.

yÈmú3)iYçÃmx1

Спробуйте або запустіть усі тестові приклади


Пояснення

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

1

К4 , 58 байт

Рішення:

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

Приклади:

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"

Пояснення:

Праві колодки для правої колодки, щоб вони були однакової довжини, переміщували, з'єднувались " ", ліву панель генерували діагоналі, потім праву колонку для виправлення довжин та переміщення назад. Бере список рядків і повертає список рядків. Напевно, гольфуючий, але все ж коротший, ніж мій q / kdb + рішення.

+(|/{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


Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.