Olumlu bir tamsayı için k, d(k)bölenlerin sayısını belirtelim k. Örneğin, d(6)bir 4, çünkü 6sahip 4bölenler (yani 1, 2, 3, 6).

Pozitif bir tam sayı verilen N, yatay konumda bulunan "yapı" yüksekliği, bir sabit karakteri kullanılarak ASCII teknolojide, bir "ufuk çizgisi" görüntüler kolduğu d(k)için k = 1, ..., N. Aşağıdaki test durumlarına bakın.

kurallar

• Herhangi bir boşluk içermeyen karakter, mutlaka #test durumlarında gösterildiği gibi kullanılmayabilir .
• Algoritma teorik olarak keyfi yüksek çalışmalıdır N. Uygulamada, programın zaman, hafıza, veri tipi boyutu veya ekran boyutu ile sınırlı olup olmadığı kabul edilebilir.
• Yatay veya dikey olarak önde gelen veya arkadaki boşluklara veya yeni satırlara izin verilir.
• Giriş ve çıkış herhangi bir makul yoldan alınabilir .
• Herhangi bir programlama dilinde programlara veya fonksiyonlara izin verilir . Standart boşluklar yasaktır.
• Bayt cinsinden en kısa kod kazanır.

Test durumları

N = 10:

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

N = 50:

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

N = 200:

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

Jöle , 9 bayt

Kullanımları 0yerine #.

RÆD0ṁz⁶ṚY

Çevrimiçi deneyin!

C, 99 95 92 91 90 bayt

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

O bkz burada çalışmak .

Octave, 41 40 32 bayt

@StewieGriffin sayesinde 8 bayt kurtardı.

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

Çevrimiçi deneyin!

Önceki cevaplar:

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

fbir alır Intve bir döndürür String.

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

Çevrimiçi deneyin!

• mbir NOP (Haskell değişkenler küçük harf gerekmektedir.)
• Kısaltma l=[1..m], iç içe geçmiş listede, tüm satırları, sütunları ve potansiyel bölenleri yinelemek için kullanılır. Bu, boşlukla dolu bazı ekstra başlangıç ​​satırları anlamına gelir.
• nsütun (ayrıca sayı kontrol edilir), isatırdır.
• ['#'|0<-mod n<$>l]'#'bölenlerin sayısı uzunluğundaki karakterlerin listesidir n.

Oktav, 61 bayt

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

Açıklama:

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

Vurgulamak istediğim birkaç şey

• Girişi doğrudan döngünün içine alır
  • Giriş değerini herhangi bir değişkene atamaz
• Herhangi bir dizi başlatmıyor
  • Gerektiğinde sütun ve satır ekleyerek anında oluşturur
• Otomatik olarak ASCII-0 değerini boşluk bırakarak atıyor (ASCII-32)

Döngünün içinde ne olur (varsayalım 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. Tek bir 35 olarak başlar
2. 2 iki bölen için yer açmak için bir sütun ve bir satır genişletir
3. 3'e yer açmak için bir sütunu genişletir (yalnızca iki bölen)
4. 3 bölene ( 1,2,4) yer açmak için bir sütun ve bir satır genişletir
5. 5'e yer açmak için bir sütunu genişletir
6. 4 bölene ( 1,2,3,6) yer açmak için bir sütun ve bir satır genişletir

Nihayet biz onu çevirmek ve örtük değişen bir dizeye dönüştürür 0için 32:

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

Python 3 , 111 bayt

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

Çevrimiçi deneyin!

Bu, bazı önde gelen dikey boşluklar üretir

APL (Dyalog) , 19 bayt

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

Çevrimiçi deneyin!

⎕ değerlendirilmiş girdi almak ( N )

⍳ 1 ... N

∘.|⍨Hem dikey hem de yatay eksen olarak  1 ... N ile bölme kalan tablosu

0= sıfıra eşit olduğunda (yani ayrılır)

+⌿ sütunları topla (yani her sayı için bölenlerin sayısını verir)

'#'⍴¨⍨ karma karakterini yeniden şekillendirmek için her sayıyı kullanın (dizelerin listesini verir)

↑ mix (satır tablosuna dizelerin listesi)

⍉ devrik

⊖ ters çevir

Mathematica, 59 57 bayt

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

C #, 333 281 Bayt

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

Satır sonları ile:

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

Bunun da daha kısa olabileceğinden emin olmakla birlikte, birlikte daha kısa bir çözüm elde edeceğimizi umuyorum;)

Raznagul yardımıyla 52 bayt kaydedildi

Mathematica, 99 bayt

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

N = 50 için

Kömür , 23 22 20 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: ilmeklemeyle Kaydedilen 1 bayt kgelen 0etmek i-1ve ekleme 1döngü içinde. Girdiyi bir değişkende saklamaksızın iki bayt daha kaydedildi. Açıklama:

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

Düzenleme: Bu 18-byte "tek-liner" (bağlantı, kodun ayrıntılı versiyonuna yöneliktir), soru gönderildiği sırada Kömür versiyonu ile çalışmadı: Çevrimiçi deneyin!

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

05AB1E , 12 bayt

Kod:

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

Açıklama:

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 kodlamasını kullanır . Çevrimiçi deneyin!

Python 2 , 101 bayt

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

Çevrimiçi deneyin!

Bu, dikey olarak önde gelen beyaz boşluklar üretir (çok fazla). NBüyük çoğunluğu genellikle boş olacak olan toplam satır sayısını yazdırır .

Japt , 34 33 16 14 bayt

@ETHproductions sayesinde 17 bayt kaydedildi

õ@'#pXâ l÷z w

Çevrimiçi deneyin!

J , 28 bayt

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

Monadik bir fiili tanımlar. Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Brachylog , 34 bayt

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

Çevrimiçi deneyin!

Alice , 33 bayt

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

Çevrimiçi deneyin!

Giriş (maalesef) bir kod noktası şeklindedir . En azından bir UTF-8 karakteri okuyor, bu nedenle 255'ten daha büyük girişler kullanabilirsiniz, ancak yine de sınırlıdır ve oldukça acı verici bir giriş biçimidir. Üç ek bayt için ondalık bir tamsayı okuyabiliriz:

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

Çevrimiçi deneyin!

Çıktıdaki boşluk olmayan karakter !.

Çözümün ayrıca bir ton önde gelen beyaz boşluk da yazdırdığını unutmayın (her zaman boş bir çizgiyle başlar ve daha sonra bir NxNızgarayı yazdırır, böylece daha büyükler için N, ilk lerden önce birçok boşluk satırı olacaktır !.)

açıklama

Daha önce &w...kyapıyı kullandım ve açıkladım (örneğin burada ). Bir tamsayı n'yi açan ve sonra n + 1 kez bir kod parçasını çalıştıran temiz küçük bir deyimdir (sonuç olarak, genellikle giriş değerini azaltmak için n kez t&w...kbir döngü çalıştırmak için kullanılır ). Bu, dönüş adres yığını (RAS) ile çalışılarak yapılır . geçerli IP adresini RAS'a iter ve eğer tekrarlarsak adres n defa itilir . RAS'tan bir adres çıkar ve oraya atlar. RAS boşsa, hiçbir şey yapmaz ve döngü çıkar.tw&k

Bu döngüleri iç içe geçirmenin önemsiz bir şekilde mümkün olmadığını fark edebilirsiniz, çünkü iç döngünün sonunda, yığın boş değildir, bu nedenle işlem kyapılmaz. Bunun yerine IP, dış döngünün başına geri döner. Bunu düzeltmenin genel yolu, iç halkayı kendi alt yordamına sarmayı içerir. Ancak iç içe döngüyü dış döngü iç döngü ile bitecek şekilde düzenleyebilirsek, aslında bu davranıştan yararlanabilir ve hatta birinden tasarruf edebiliriz k!

Yani bu inşaat:

&wX&wYk

Çalışan (iç içe geçme bir döngü XYYYXYYYXYYY...( Yher bir yinelemede s sayısı için ). Her iki döngüyü de tek olarak sonlandırabiliriz k, çünkü iç adresler her tükendiğinde RAS'tan bir dış adres tüketir.

Bu deyim, programda döngüyü çıktı ızgarasının üzerinde çalıştırmak için kullanılır.

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.

Aslında , 25 bayt

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

Çevrimiçi deneyin!

Önde gelen birçok yeni satır olan 22 bayt sürümü

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

Çevrimiçi deneyin!

R, 83 82 bayt

MickyT sayesinde -1 bayt

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

Stdin'den okur 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

Çevrimiçi deneyin!

Pyth , 16 bayt

j_.tm*\#/%LdSQ0S

Çevrimiçi deneyin!

SpecBAS - 149 bayt

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

Bir dizi bölen sayısını takip eder, ardından doğru sayıda karakteri ekran konumuna (50) kadar yazdırır.

PHP, 99 bayt

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

bir tane önde alan yazdırır; pipe olarak çalıştır php -nr '<code>'veya çevrimiçi dene .

Yıkmak

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 bayt

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

Daha az golf oynadığı test senaryosu:

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

Çıktı:

True
True
True

SOGL V0.12 , 8 bayt

∫Λ⁄╗*}⁰H

Burada dene!

Wolfram Dili (Mathematica) , 46 44 bayt

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

Çevrimiçi deneyin! Ama belki çevrimiçi deneyebilirsin! yerine Grid ColumnForm ile beri GridTIO çalışmaz. Mathematica'da daha iyi görünüyor:

Üçüncü bir Mathematica çözümü ... Divisors@Range@#istediğimiz aralıktaki tüm bölenleri bulur ve ardından her bölücüyü eşit yaparak, çarparak 0çıkarırız ." "-" "

PadLeftsoluna sıfır ekler, yönünü belirlediğimiz = yanlamasına ufuk çizgisi oluşturur \[Transpose]. Son olarak, " "her şeyi eklemek , tüm girişleri ya 0da yapar " ".

Alternatif olarak, 59 bayt ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&dize çıktı üretir.

++ , 58 bayt ekle

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

Çevrimiçi deneyin!

Nasıl çalışır

gkg$x$$1$$n$$d(x)$k değerini , bir karakter listesi alır ve bunları tek bir dizgede birleştirir.

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$bu maksimum değerden, her eleman için bu boşluk sayısını vermeden ve boşlukları tekrarlanan karmaları birleştirmeden önce. Ardından, satırları her satırda yeni satırlara eklemeden önce satırları dönüştürür ve tersine çeviririz. Sonunda ufuk çizgisini çıkardık.