양의 정수의 경우 k, d(k)제수의 수를 나타냅니다 k. 예를 들어, d(6)이다 4때문에 6갖는 4제수 (즉 1, 2, 3, 6).

양의 정수가 주어지면, N고정 된 문자를 사용하여 ASCII 아트에서 "skyline"을 표시하여 수평 위치에있는 "building"의 높이 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


   #
 ####
#####

하스켈 , 71 바이트

f를 가져와 a Int를 반환합니다 String.

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

온라인으로 사용해보십시오!

• m는 IS N영업의 (하스켈 변수는 소문자해야합니다.)
• 약어 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. 1의 열과 1 개의 행을 확장하여 2의 제수를위한 공간을 만듭니다.
3. 3 열을위한 공간을 만들기 위해 1 열 확장
4. 3 개의 제수를위한 공간을 만들기 위해 열과 행을 하나씩 확장합니다 ( 1,2,4)
5. 열 하나를 확장하여 5를위한 공간을 만듭니다.
6. 4 개의 제수를위한 공간을 만들기 위해 열과 행을 하나씩 확장합니다 ( 1,2,3,6)

마지막으로 그것을 뒤집어 문자열로 변환하여 암시 적으로 0to를 변경합니다 32.

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

파이썬 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= 0과 같은 곳 (즉, 나누는 것)

+⌿ 열을 합산하십시오 (즉, 각 숫자에 대한 제수를 제공합니다)

'#'⍴¨⍨ 각 숫자를 사용하여 해시 문자를 재구성하십시오 (문자열 목록 제공).

↑ 믹스 (행 목록에 문자열 목록)

⍉ 바꾸어 놓다

⊖ 거꾸로 뒤집다

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

이것이 더 짧을 수도 있다고 확신하지만 더 짧은 솔루션을 함께 달성하기를 바랍니다.)

raznagul의 도움으로 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 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : 반복에서 저장 한 바이트 k로부터 0행 i-1및 추가 1루프 내부. 입력을 변수에 저장하지 않음으로써 2 바이트를 더 절약했습니다. 설명:

Ｆ…·¹Ｎ       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 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이썬 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 바이트

@ETHproductions 덕분에 17 바이트 절약

õ@'#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]?:" ";

온라인으로 사용해보십시오!

Brachylog , 34 바이트

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

온라인으로 사용해보십시오!

Alice , 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 ( Return Address Stack)를 사용하여 수행됩니다 . w현재 IP 주소를 RAS로 푸시하고 반복 &하면 주소가 n 번 푸시 됩니다. kRAS에서 하나의 주소를 팝하고 다시 점프합니다. RAS가 비어 있으면 아무 것도 수행하지 않고 루프가 종료됩니다.

내부 루프의 끝에서 스택이 비어 있지 않기 때문에 이러한 루프를 중첩하는 k것이 쉽지 않을 수 있습니다. 대신 IP는 외부 루프의 시작 부분으로 되돌아갑니다. 이를 해결하는 일반적인 방법은 내부 루프를 자체 서브 루틴으로 감싸는 것입니다. 그러나 외부 루프 가 내부 루프로 끝나 도록 중첩 루프를 배열 할 수 있다면 실제로이 동작을 사용하고 하나를 절약 할 수도 있습니다 k!

따라서이 건설 :

&wX&wYk

XYYYXYYYXYYY...( Y각 반복에서 몇 개의 s에 대해) 작동하는 중첩 된 루프입니다 . 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 바이트

MickyT 덕분에 -1 바이트

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

Nstdin에서 읽습니다 .

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로 , 이후는 GridTIO에서 작동하지 않습니다. Mathematica에서는 다음과 같이 보입니다.

세 번째 Mathematica 솔루션 Divisors@Range@#은 원하는 범위의 모든 제수를 찾은 다음 곱하고 0뺄셈 " "하여 모든 제수를와 같습니다 -" ".

PadLeft왼쪽에 0을 추가하여 측면 스카이 라인을 만들고 방향을 =로 고정 \[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$각 요소에 대해이 수의 공간을 생성하고 공간을 반복 된 해시에 연결하기 전에이 최대 값부터 다음으로 줄 바꾸기에서 각 줄을 연결하기 전에 행을 바꾸고 뒤집습니다. 마지막으로 스카이 라인을 출력합니다.