Dla każdej liczby całkowitej k, niech d(k)oznaczają liczbę dzielników k. Na przykład, d(6)to 4, ponieważ 6ma 4dzielniki (mianowicie 1, 2, 3, 6).

Biorąc dodatnia N, wyświetli „skyline” w sztuce ASCII za pomocą stałego charakteru, tak że wysokość „budynek” znajduje się w pozycji poziomej kjest d(k)za k = 1, ..., N. Zobacz przypadki testowe poniżej.

Zasady

• Można konsekwentnie stosować dowolny znak inny niż biały, niekoniecznie #jak pokazano w przypadkach testowych.
• Algorytm powinien teoretycznie działać na dowolnie wysoki N. W praktyce dopuszczalne jest, jeśli program jest ograniczony czasem, pamięcią, rozmiarem typu danych lub rozmiarem ekranu.
• Dopuszczalne są spacje lub znaki nowej linii prowadzące poziomo lub pionowo lub końcowe.
• Dane wejściowe i wyjściowe można przyjmować dowolnymi rozsądnymi środkami .
• Programy lub funkcje są dozwolone w dowolnym języku programowania . Standardowe luki są zabronione.
• Najkrótszy kod w bajtach wygrywa.

Przypadki testowe

N = 10:

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

N = 50:

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

N = 200:

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

Galaretka , 9 bajtów

Używa 0zamiast #.

RÆD0ṁz⁶ṚY

Wypróbuj online!

C, 99 95 92 91 90 bajtów

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

Zobacz, jak to działa tutaj .

Oktawa, 41 40 32 bajtów

Dzięki @StewieGriffin zaoszczędzono 8 bajtów.

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

Wypróbuj online!

Poprzednie odpowiedzi:

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

Wypróbuj online!

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

fbierze Inti zwraca a String.

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

Wypróbuj online!

• mto NOP (zmienne Haskell muszą być pisane małymi literami).
• Skrót l=[1..m]jest używany w opisach zagnieżdżonej listy do iteracji po wszystkich wierszach, kolumnach i potencjalnych dzielnikach. Oznacza to dodatkowe początkowe wiersze wypełnione białymi spacjami.
• njest kolumna (również zaznaczona liczba), ijest wiersz.
• ['#'|0<-mod n<$>l]to lista '#'znaków o długości i liczbie dzielników n.

Oktawa, 61 bajtów

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

Wyjaśnienie:

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

Kilka rzeczy, które chciałbym podkreślić

• Pobiera dane wejściowe bezpośrednio do pętli
  • Nie przypisuje wartości wejściowej do żadnej zmiennej
• Nie inicjuje żadnej tablicy
  • Tworzy go w locie, w razie potrzeby dodając kolumny i wiersze
• Automatycznie rzutuje wartość ASCII 0 na białe znaki (ASCII-32)

Co dzieje się w pętli (załóżmy, że dane wejściowe 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. Zaczyna jako pojedynczy 35
2. Rozszerza jedną kolumnę i jeden wiersz, aby zrobić miejsce dla dwóch dzielników 2
3. Rozwija jedną kolumnę, aby zrobić miejsce na 3 (tylko dwa dzielniki)
4. Rozwija jedną kolumnę i jeden wiersz, aby zrobić miejsce dla 3 dzielników ( 1,2,4)
5. Rozwija jedną kolumnę, aby zrobić miejsce na 5
6. Rozwija jedną kolumnę i jeden wiersz, aby zrobić miejsce dla 4 dzielników ( 1,2,3,6)

Wreszcie możemy odwrócić go i konwertuje go na sznurku, zmieniając w sposób dorozumiany 0do 32:

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

Python 3 , 111 bajtów

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

Wypróbuj online!

Daje to kilka wiodących białych znaków pionowych

APL (Dyalog) , 19 bajtów

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

Wypróbuj online!

⎕ uzyskaj ocenę wejścia ( N )

⍳ 1 ... N

∘.|⍨ tabela reszty podziału z 1 ... N zarówno jako pionową, jak i poziomą osią

0= gdzie jest równa zero (tzn. dzieli się)

+⌿ zsumuj kolumny (tzn. podaje liczbę dzielników dla każdej liczby)

'#'⍴¨⍨ użyj każdej liczby, aby zmienić kształt znaku skrótu (daje listę ciągów znaków)

↑ mix (lista ciągów w tabeli wierszy)

⍉ transponować

⊖ odwróć do góry nogami

Mathematica, 59 57 bajtów

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

C #, 333 281 bajtów

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

Z podziałami linii:

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

Chociaż jestem pewien, że jest to również możliwe krócej, mam nadzieję, że wspólnie wypracujemy krótsze rozwiązanie;)

Za pomocą Raznagul uratowałeś 52 bajty

Mathematica, 99 bajtów

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

dla N = 50

Węgiel , 23 22 20 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Edycja: zapisane jeden bajt w pętli kod 0celu i-1i dodając 1wewnątrz pętlę. Zapisano kolejne dwa bajty, nie zapisując danych wejściowych w zmiennej. Wyjaśnienie:

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

Edycja: Ten 18-bajtowy „jednowierszowy” (link do pełnej wersji kodu) nie działałby z wersją Węgla drzewnego w chwili przesłania pytania: Wypróbuj online!

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

05AB1E , 12 bajtów

Kod:

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

Wyjaśnienie:

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

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Python 2 , 101 bajtów

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

Wypróbuj online!

To tworzy (dużo) wiodących białych znaków. Drukuje w sumie Nlinie, z których większość jest zwykle pusta.

Japt , 34 33 16 14 bajtów

Zaoszczędź 17 bajtów dzięki produktom @ETH

õ@'#pXâ l÷z w

Wypróbuj online!

J , 28 bajtów

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

Definiuje czasownik monadyczny. Wypróbuj online!

Wyjaśnienie

[:|:&.|.[('#',@$~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 bajtów

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]?:" ";

Wypróbuj online!

Brachylog , 34 bajty

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

Wypróbuj online!

Alice , 33 bajty

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

Wypróbuj online!

Dane wejściowe są (niestety) w postaci punktu kodowego . Przynajmniej odczytuje znak UTF-8, więc możesz użyć większych danych wejściowych niż 255, ale nadal są one ograniczone i jest to dość bolesny format wejściowy. W przypadku trzech dodatkowych bajtów możemy odczytać dziesiętną liczbę całkowitą:

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

Wypróbuj online!

Znakiem innym niż biały znak na wyjściu jest ! .

Zauważ, że rozwiązanie drukuje również masę wiodących białych znaków (zawsze zaczyna się od pustej linii, a następnie drukuje NxNsiatkę, więc dla większych N, będzie wiele linii odstępów przed pierwszymi !s.)

Wyjaśnienie

Użyłem już i wyjaśniłem &w...kbudowę (na przykład tutaj ). Jest to schludny mały idiom, który wyskakuje na liczbę całkowitą n, a następnie uruchamia kawałek kodu n + 1 razy (w związku z tym zwykle służy t&w...kdo uruchamiania pętli n razy, z tobniżaniem wartości wejściowej). Odbywa się to poprzez pracę ze stosem adresów zwrotnych (RAS). wwypycha bieżący adres IP do RAS, a jeśli go powtórzymy, &adres zostanie wypchnięty n razy. kwyskakuje jeden adres z RAS i wskakuje tam z powrotem. Jeśli RAS jest pusty, nic nie robi i pętla zostaje zakończona.

Można zauważyć, że zagnieżdżanie tych pętli nie jest trywialne, ponieważ na końcu wewnętrznej pętli stos nie jest pusty, więc knie staje się brakiem operacji . Zamiast tego IP przeskakuje z powrotem na początek zewnętrznej pętli. Ogólny sposób rozwiązania tego problemu polega na zawinięciu wewnętrznej pętli we własny podprogram. Ale jeśli możemy tak ustawić zagnieżdżoną pętlę, że zewnętrzna pętla kończy się wewnętrzną, możemy faktycznie skorzystać z tego zachowania, a nawet zaoszczędzić na jednym k!

Więc ta konstrukcja:

&wX&wYk

Jest działającą zagnieżdżoną pętlą, która uruchamia XYYYXYYYXYYY...(dla pewnej liczby Ys w każdej iteracji). To całkiem fajne, że możemy zakończyć obie pętle jednym k, ponieważ będzie pobierał adres zewnętrzny z RAS za każdym razem, gdy adresy wewnętrzne zostaną wyczerpane.

Ten idiom jest używany w programie do uruchamiania pętli nad siatką wyjściową.

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.

Właściwie 25 bajtów

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

Wypróbuj online!

Wersja 22-bajtowa z wieloma wiodącymi nowymi liniami

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

Wypróbuj online!

R, 83 82 bajtów

-1 bajt dzięki MickyT

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

Czyta Nze standardowego.

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

Wypróbuj online!

Pyth , 16 bajtów

j_.tm*\#/%LdSQ0S

Wypróbuj online!

SpecBAS - 149 bajtów

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

Tablica śledzi liczbę dzielników, a następnie drukuje odpowiednią liczbę znaków do pozycji ekranu 50.

PHP, 99 bajtów

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

drukuje jedną wiodącą przestrzeń; uruchom jako potok z php -nr '<code>'lub spróbuj online .

awaria

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 bajtów

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

Skrypt testu mniej golfowego:

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

Wynik:

True
True
True

SOGL V0.12 , 8 bajtów

∫Λ⁄╗*}⁰H

Wypróbuj tutaj!

Wolfram Language (Mathematica) , 46 44 bajtów

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

Wypróbuj online! Ale może wypróbuj to online! z ColumnForm zamiast Grid , ponieważ Gridnie działa w TIO. W Mathematica wygląda lepiej:

Trzecie rozwiązanie Mathematica ... Divisors@Range@#znajduje wszystkie dzielniki w żądanym zakresie, a następnie mnożymy 0i odejmujemy " ", dzięki czemu każdy dzielnik jest równy -" ".

PadLeftdodaje zera po lewej, tworząc boczną linię horyzontu, której orientację ustalamy za pomocą = \[Transpose]. Wreszcie, dodając " "do wszystkiego sprawia, że wszystkie wpisy albo 0albo " ".

Alternatywnie, 59-bajt ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&wytwarza ciąg znaków.

Dodaj ++ , 58 bajtów

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

Wypróbuj online!

Jak to działa

gkg$x$$1$$n$$d(x)$k pobiera listę znaków i łączy je w pojedynczy ciąg.

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$od tego maksimum, przed uzyskaniem takiej liczby spacji dla każdego elementu i konkatenacji spacji do powtarzających się skrótów. Następnie transponujemy i odwracamy rzędy, zanim dołączymy do każdej linii na nowych liniach. Na koniec generujemy linię horyzontu.