Для любого натурального числа 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и возвращает String.

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

Попробуйте онлайн!

• mявляется NOP (переменные 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. Расширяет один столбец и одну строку, чтобы освободить место для 3 делителей ( 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= где равен нулю (т.е. делится)

+⌿ сумма столбцов (т. е. дает количество делителей для каждого числа)

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

↑ mix (список строк в таблице строк)

⍉ транспонирования

⊖ перевернуть с ног на голову

Mathematica, 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 байта с помощью разнагула

Mathematica, 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-байтовый «однострочный» (ссылка на подробную версию кода) не работал бы с версией Charcoal на момент подачи вопроса: попробуйте онлайн!

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

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будет много строк пробелов до первых !s).

объяснение

Я использовал и объяснил &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со стандартного ввода.

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

Попробуй это здесь!

Wolfram Language (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$от этого максимума, до получения этого количества пробелов для каждого элемента и объединения пробелов в повторяющиеся хэши. Далее мы транспонируем и переворачиваем строки перед тем, как соединять каждую строку в новых строках. Наконец, мы выводим горизонт.