Для будь-якого натурального числа k, нехай d(k)позначає число дільників k. Наприклад, d(6)це 4, так як 6має 4дільників (а саме 1, 2, 3, 6).

Враховуючи додатне ціле число N, відобразіть "горизонт" в арт-аркуші ASCII, використовуючи фіксований символ, таким чином, щоб висота "будівлі", розташованої в горизонтальному положенні, kбула d(k)для k = 1, ..., N. Дивіться тестові приклади нижче.

Правила

• Будь-який символ без пробілу може послідовно використовуватися, не обов'язково, #як показано в тестових випадках.
• Алгоритм теоретично повинен працювати для довільно високого рівня N. На практиці це прийнятно, якщо програма обмежена часом, пам’яттю, розміром типу даних або розміром екрана.
• Допускаються горизонтально або вертикально провідні або кінцеві проміжки або нові рядки.
• Введення та вихід можна приймати будь-якими розумними засобами .
• Програми або функції дозволені на будь- якій мові програмування . Стандартні лазівки заборонені.
• Виграє найкоротший код у байтах.

Тестові справи

N = 10:

     # # #
   # # ###
 #########
##########

N = 50:

                                               #  
                                   #           #  
                       #     #     #   # #     #  
                       #     #     #   # #     #  
           #     # #   #   # # #   #   # # ##  # #
           #   # # #   #   # # #   #   # # ##  # #
     # # # # ### # ### # ### # ##### ### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ###
 #################################################
##################################################

N = 200:

                                                                                                                                                                                   #                    
                                                                                                                                                                                   #                    
                                                                                                                       #                                               #           #                    
                                                                                                                       #                       #                       #           #                    
                                                                                                                       #                       #                       #           #           #        
                                                                                                                       #                       #                       #           #           #        
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################

Желе , 9 байт

Використовує 0замість #.

RÆD0ṁz⁶ṚY

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

C, 99 95 92 91 90 байт

c,l,i,j;f(n){for(j=n;j--;puts(""))for(i=0;i<n;c=!putchar(32|c>j))for(l=++i;l;c+=i%l--<1);}

Дивіться, як це працює тут .

Октава, 41 40 32 байт

Завдяки @StewieGriffin збережено 8 байт.

@(N)" #"(sort(~mod(k=1:N,k'))+1)

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

Попередні відповіді:

@(N)" #"(sort(~bsxfun(@mod,k=1:N,k')+1))

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

@(N)" #"(sort(ismember((k=1:N)./k',k))+1)

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

Пояснення:

N=5;
d = (1:N)./(1:N)'    %divide each of numbers from 1 to N by 1 to N 
                     %a [N by N] matrix created
d =

   1.00   2.00   3.00   4.00   5.00
   0.50   1.00   1.50   2.00   2.50
   0.33   0.66   1.00   1.33   1.66
   0.25   0.50   0.75   1.00   1.25
   0.20   0.40   0.60   0.80   1.00

m = ismember(d,1:N)      %find divisors of each number
m =

  1  1  1  1  1
  0  1  0  1  0
  0  0  1  0  0
  0  0  0  1  0
  0  0  0  0  1

idx = sort(m)                  %sort the matrix

idx =

  0  0  0  0  0
  0  0  0  0  0
  0  0  0  1  0
  0  1  1  1  1
  1  1  1  1  1

" #"(idx+1)     %replace 0 and 1 with ' ' and '#' respectively


   #
 ####
#####

Haskell , 71 байт

fбере Intі повертає a String.

f m|l<-[1..m]=unlines[[last$' ':drop(m-i)['#'|0<-mod n<$>l]|n<-l]|i<-l]

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

• mє NОП (змінні Haskell повинні бути малими літерами.)
• Абревіатура l=[1..m]використовується в розумінні вкладеного списку для повторення через всі рядки, стовпці та потенційні подільники. Це означає кілька додаткових початкових рядків, заповнених пробілом.
• nє стовпець (також номер перевірений), iце рядок.
• ['#'|0<-mod n<$>l]- це список '#'знаків, довжина яких становить кількість дільників n.

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

for i=1:input(''),p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']

Пояснення:

for i=1:input('')         % Loop, for i from 1 to the input value
 p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']   
% Breakdown:
         ~rem(i,1:i)      % Return true if the remainder of i divided by any of the values
                          % in the vector 1 - i
     nnz(~rem(i,1:i))     % Check how many of them are non-zero
 p(1:nnz(~rem(i,1:i)),i)=35;end   % Assign the value 35 (ASCII for #) to rows 1
                                  % to the number of divisors of i, in column i
end,              % End loop
[flip(p),'']      % Flip the matrix, and concatenate it with the empty string

Я хочу виділити кілька речей

• Здійснює введення безпосередньо в цикл
  • Не присвоює вхідне значення жодній змінній
• Не ініціалізує жоден масив
  • Він створює його на льоту, додаючи стовпчики та рядки за потребою
• Автоматично передає значення ASCII 0 у пробіли (ASCII-32)

Що відбувається всередині циклу (припустимо, вхід 6)

p =  35
p =
   35   35
    0   35
p =
   35   35   35
    0   35   35
p =
   35   35   35   35
    0   35   35   35
    0    0    0   35
p =
   35   35   35   35   35
    0   35   35   35   35
    0    0    0   35    0
p =
   35   35   35   35   35   35
    0   35   35   35   35   35
    0    0    0   35    0   35
    0    0    0    0    0   35

1. Починається як єдиний 35
2. Розгортає один стовпчик і один ряд, щоб звільнити два дільника на 2
3. Розширює один стовпчик, щоб звільнити місце для 3 (лише два дільника)
4. Розширює один стовпчик і один ряд, щоб звільнити місця для трьох дільниць ( 1,2,4)
5. Розгортає одну колонку, щоб звільнити місце для 5
6. Розширює один стовпчик і один ряд, щоб звільнити 4 дільника ( 1,2,3,6)

Нарешті ми перевертаємо його та перетворюємо на рядок, неявно змінюючи 0на 32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######

Python 3 , 111 байт

lambda n:'\n'.join([*map(''.join,zip(*['#'*sum(x%-~i==0for i in range(x))+n*' 'for x in range(1,n+1)]))][::-1])

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

Це створює кілька провідних вертикальних пробілів

APL (Dyalog) , 19 байт

⊖⍉↑'#'⍴¨⍨+⌿0=∘.|⍨⍳⎕

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

⎕ отримати оцінений вхід ( N )

⍳ 1 ... N

∘.|⍨ таблиця залишку ділення з 1 ... N як вертикальної, так і горизонтальної осі

0= де дорівнює нулю (тобто він ділиться)

+⌿ підсумовуйте стовпці (тобто дає кількість дільників для кожного числа)

'#'⍴¨⍨ використовувати кожне число, щоб змінити хеш-символ (дає список рядків)

↑ мікс (список рядків у таблиці рядків)

⍉ переносити

⊖ перевернути догори дном

Математика, 59 57 байт

Rotate[Grid@Map[X~Table~#&,0~DivisorSigma~Range@#],Pi/2]&

C #, 333 281 байт

using System.Linq;using C=System.Console;class P{static void Main(){var n=int.Parse(C.ReadLine());var v=new int[n];for(var k=2;k<=n;k++)for(var i=1;i<k;i++)if(k%i==0)v[k-1]++;for(var i=0;i<v.Length;i++)for(var u=v.Max()-v[i];u<v.Max();u++){C.SetCursorPosition(i,u);C.Write("#");}}}

З розривами рядків:

using System.Linq;
using C = System.Console;

class P
{
    static void Main()
    {
        var n = int.Parse(C.ReadLine());
        var v = new int[n];
        for (var k = 2; k <= n; k++)
            for (var i = 1; i < k; i++)
                if (k % i == 0)
                    v[k - 1]++;
        for (var i = 0; i < v.Length; i++)
            for (var u = v.Max() - v[i]; u < v.Max(); u++)
            {
                C.SetCursorPosition(i, u);
                C.Write("#");
            }
    }
}

Хоча я впевнений, що це можливо і коротше, сподіваюся, що ми разом досягнемо коротшого рішення;)

Збережено 52 байти за допомогою рознагалу

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

{T=DivisorSigma[0,Range@#];Row[Column/@Table[Join[Table[,Max[T]-T[[i]]],$~Table~T[[i]]],{i,1,#}]]}&

для N = 50

Вугілля , 23 22 20 байт

Ｆ…·¹Ｎ«Ｊι⁰Ｆι¿¬﹪ι⁺κ¹↑#

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Редагувати: Збережено 1 байт шляхом циклічного перегляду kвід 0до i-1та додавання 1всередині циклу. Збережено ще два байти, не зберігаючи вхід у змінній. Пояснення:

Ｆ…·¹Ｎ       for (i : InclusiveRange(1, InputNumber()))
«           {
 Ｊι⁰         JumpTo(i, 0);
 Ｆι          for (k : Range(i))
  ¿¬﹪ι⁺κ¹     if (!(i % (k + 1)))
   ↑#          Print(:Up, "#");
            }

Редагувати: Цей 18-байтовий "однолінійний" (посилання на багатослівну версію коду) не працював би з версією деревного вугілля на момент подання питання: Спробуйте його в Інтернеті!

↑Ｅ…·¹Ｎ⪫Ｅι⎇﹪ι⁺¹λω#ω

05AB1E , 12 байт

Код:

LÑ€g'#×.BøR»

Пояснення:

L             # Create the range 1 .. input
 Ñ            # Get the list of divisors of each
  €g          # Get the length of each element
    '#        # Push a hash tag character
      ×       # String multiply
       .B     # Squarify, make them all of equal length by adding spaces
         ø    # Transpose
          R   # Reverse the array
           »  # Join by newlines

Використовує кодування 05AB1E . Спробуйте в Інтернеті!

Python 2 , 101 байт

N=input();r=range
for i in r(N,0,-1):print''.join('# '[i>sum(x%-~p<1for p in r(x))]for x in r(1,1+N))

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

Це створює (безліч) вертикально провідних пробілів. Він друкує загальну кількість Nрядків, велика частина яких зазвичай буде порожньою.

Japt , 34 33 16 14 байт

Збережено 17 байт завдяки @ETHproductions

õ@'#pXâ l÷z w

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

J , 28 байт

[:|:&.|.[('#',@$~1+_&q:)@-i.

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

Пояснення

[:|:&.|.[('#',@$~1+_&q:)@-i.  Input is y.
                          i.  Range from 0 to y-1
        [                -    subtracted from y (gives range from y to 1).
         (             )@     For each of the numbers:
                   _&q:         Compute exponents in prime decomposition,
                 1+             add 1 to each,
          '#'  $~               make char matrix of #s with those dimensions,
             ,@                 and flatten into a string.
                              The resulting 2D char matrix is padded with spaces.
[:|:&.|.                      Reverse, transpose, reverse again.

PHP, 126 байт

for(;$n++<$argn;)for($c=$d=0;$d++<$n;)$n%$d?:$r[$n]=++$c;for($h=max($r);$h--;print"
")for($n=0;$n++<$argn;)echo$h<$r[$n]?:" ";

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

Брахілог , 34 байти

⟦fᵐlᵐgDh⌉⟦↔gᵐ;D↔z{z{>₁∧0ṫ|∧Ṣ}ᵐcẉ}ᵐ

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

Аліса , 33 байти

I.!.t&w?t!aot&wh.Bdt.?-ex' +o&;k@

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

Введення (на жаль) у вигляді кодової точки . Принаймні, він читає символ UTF-8, тому ви можете використовувати більші введення, ніж 255, але вони все ще обмежені, і це досить болісний формат введення. Для трьох додаткових байтів ми можемо прочитати десятковий ціле число:

/
ki@/.!.t&w?t!aot&wh.Bdt.?-ex' +o&;

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

Символ без пробілів у висновку є !.

Зауважте, що рішення також друкує тону провідного пробілу (воно завжди починається з порожнього рядка, а потім друкується NxNсіткою, щоб збільшити розмір N, перед першими !с. Буде багато рядків ).

Пояснення

Я раніше використовував і пояснював &w...kконструкцію (наприклад, тут ). Це акуратний маленький ідіом, який спливає ціле число n, а потім запускає фрагмент коду n + 1 раз (отже, зазвичай він використовується t&w...kдля запуску циклу n разів, tзменшуючи вхідне значення). Це робиться за допомогою роботи зі стеком зворотних адрес (RAS). wнатискає поточну IP-адресу до RAS, і якщо ми повторимо її, &то адреса буде натиснуто n разів. kвискакує одну адресу з RAS і стрибає туди. Якщо RAS порожній, він взагалі нічого не робить, і цикл закінчується.

Ви можете помітити, що не можна тривільно вкладати ці петлі, тому що в кінці внутрішньої петлі стек не порожній, тому kне стає не-оп. Натомість IP буде переходити до початку зовнішньої петлі. Загальний спосіб виправити це передбачає загортання внутрішньої петлі у власну підпрограму. Але якщо ми можемо влаштувати вкладений цикл таким чином, що зовнішній цикл закінчується внутрішнім циклом, ми можемо реально скористатися такою поведінкою і навіть заощадити на одному k!

Отже ця конструкція:

&wX&wYk

Це робочий вкладений цикл, який виконує XYYYXYYYXYYY...(для деякої кількості Ys у кожній ітерації). Досить акуратно, що ми можемо закінчити обидві петлі одиницею k, оскільки вона буде споживати зовнішню адресу від RAS кожного разу, коли внутрішні адреси вичерпуються.

Ця ідіома використовується в програмі для запуску циклу по вихідній сітці.

I         Read a character and push its code point as input N.
.!        Store a copy on the tape.
.         Make another copy.
t&w       Run this outer loop N times. This loops over the lines of the
          output, so the current iteration corresponds to a divisor count
          no more than i (i counting down from N).
  ?t!       Decrement the value on the tape. That means we'll actually have
            i-1 on the tape during the iteration.
  ao        Print a linefeed. Doing this now leads to the weird leading linefeed, 
            but it's necessary for the &w...&w...k pattern.
  t&w       Remember that we still have a copy of N on the stack. We'll also
            ensure that this is the case after each loop iteration. So this
            also runs the inner loop N times. This iterates over the columns
            of the output grid so it's j that goes from 1 to N and corresponds
            to the number whose divisors we want to visualise.
              At this point the stack will always be empty. However, operating
              on an empty stack works with implicit zeros at the bottom of
              the stack. We'll use the top zero to keep track of j.
    h         Increment j.
    .B        Duplicate j and push all of its divisors.
    dt        Push the stack depth minus 1, i.e. the divisor count of j.
    .         Duplicate the divisor count.
    ?-        Retrieve i-1 from the tape and subtract it. So we're computing
              d(j)-i+1. We want to output a non-whitespace character iff this
              value is positive (i.e. if i is no greater than d(j)).
    ex        Extract the most significant bit of this value. This is 1 for
              all positive values and 0 for non-positive ones. It's the shortest
              way (I believe) to determine if a value is positive.
    ' +       Add this to the code point of a space. This gives a 33, or '!',
              if the cell is part of the skyline.
    o         Output the character.
    &;        We still have all the divisors and the divisor count on the stack.
              We pop the divisor count to discard that many values (i.e. to
              get rid of the divisors again).
k         Return to the appropriate loop beginning to run the continue the
          nested loop.
@         Terminate the program.

Власне , 25 байт

R♂÷♂l;M' *╗⌠'#*╜@+⌡M┬♂ΣRi

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

22-байтна версія з великою кількістю провідних новинок

;╗R⌠÷l'#*╜' *@+⌡M┬♂ΣRi

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

R, 83 82 байт

-1 байт завдяки MickyT

N=scan();m=matrix('#',N,N);for(i in 1:N)m[i,1:sum(i%%1:N>0)]=' ';write(m,'',N,,'')

Читає Nвід stdin.

N=scan()                        # read N
m=matrix('#',N,N)               # make an NxN matrix of '#' characters
for(i in 1:N)                   # for each integer in the range
    m[i,1:sum(i%%1:N!=0)]=' '   # set the first n-d(n) columns of row i to ' '
write(m,'',N,,'')               # print to console with appropriate formatting

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

Pyth , 16 байт

j_.tm*\#/%LdSQ0S

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

SpecBAS - 149 байт

1 INPUT n: DIM h(n)
2 FOR i=1 TO n
3 FOR j=1 TO i
4 h(i)+=(i MOD j=0)
5 NEXT j
6 NEXT i
7 FOR i=1 TO n
8 FOR j=51-h(i) TO 50
9  ?AT j,i;"#"
10 NEXT j
11 NEXT i

Масив відстежує кількість дільників, після чого виводить потрібну кількість символів до положення 50.

PHP, 99 байт

for(;$d<$k?:$k++<$argn+$d=$n=0;)$k%++$d?:$r[--$n]=str_pad($r[$n],$k).H;ksort($r);echo join("
",$r);

друкує один провідний простір; запустіть як трубу php -nr '<code>'або спробуйте в Інтернеті .

зламатися

for(;$d<$k?:                    # inner: loop $d from 1 to $k
    $k++<$argn+$d=$n=0;)        # outer: loop $k from 1 to $argn, reset $d and $n
    $k%++$d?:                       # if $d divides $k
        $r[--$n]=str_pad($r[$n],$k).H;  # add one store to building $k
ksort($r);echo join("\n",$r);   # reverse and print resulting array

PowerShell, 101 байт

((($d=1.."$args"|%{($x=$_)-(1..$_|?{$x%$_}).Count})|sort)[-1])..1|%{$l=$_;-join($d|%{' #'[$_-ge$l]})}

Менш тестовий сценарій для гольфу:

$f = {

$d=1.."$args"|%{
    ($x=$_)-(1..$_|?{$x%$_}).Count
}                                     # $d is the Divisor count array
$maxHeight=($d|sort)[-1]
$maxHeight..1|%{
    $l=$_
    -join($d|%{' #'[$_-ge$l]})
}

}

@(
    ,(10, 
    "     # # #",
    "   # # ###",
    " #########",
    "##########")

    ,(50, 
    "                                               #  ",
    "                                   #           #  ",
    "                       #     #     #   # #     #  ",
    "                       #     #     #   # #     #  ",
    "           #     # #   #   # # #   #   # # ##  # #",
    "           #   # # #   #   # # #   #   # # ##  # #",
    "     # # # # ### # ### # ### # ##### ### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ###",
    " #################################################",
    "##################################################")

    ,(200,
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                       #                                               #           #                    ",
    "                                                                                                                       #                       #                       #           #                    ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #",
    "                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #",
    "                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #",
    " #######################################################################################################################################################################################################",
    "########################################################################################################################################################################################################")


) | % {
    $n,$expected = $_
    $result = &$f $n
    "$result"-eq"$expected"
    #$result    # uncomment this to enjoy the view of the Divisor skyline
}

Вихід:

True
True
True

SOGL V0.12 , 8 байт

∫Λ⁄╗*}⁰H

Спробуйте тут!

Мова Вольфрама (Mathematica) , 46 44 байти

Grid[PadLeft[0Divisors@Range@#-" "]+" "]&

Спробуйте в Інтернеті! Але, можливо, спробуйте в Інтернеті! з ColumnForm замість Grid , оскільки Gridне працює в TIO. У Mathematica це виглядає краще:

Третє рішення Mathematica ... Divisors@Range@#знаходить усі дільники в потрібному нам діапазоні, а потім множимо на 0і віднімаємо " ", роблячи кожен дільник рівним -" ".

PadLeftдодає нулі зліва, створюючи бічний горизонт, орієнтацію якого ми фіксуємо за допомогою = \[Transpose]. Нарешті, додавання " "до всього робить усі записи або 0або " ".

Як альтернатива, 59-байт ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&виробляє рядок виводу.

Додайте ++ , 58 байт

D,g,@,FL1+
D,k,@~,J
L,R€gd"#"€*$dbM€_32C€*z£+bUBcB]bR€kbUn

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

Як це працює

gkg$x$$1$$n$$d(x)$k

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$від цього максимуму, перш ніж отримати цю кількість пробілів для кожного елемента і об'єднати пробіли в повторні хеші. Далі перекладаємо і перевертаємо рядки, перш ніж приєднуватися до кожного рядка в нових рядках. Нарешті, ми виводимо горизонт.