Panoramę dzielnika

46

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:

                                                                                                                                                                                   #                    
                                                                                                                                                                                   #                    
                                                                                                                       #                                               #           #                    
                                                                                                                       #                       #                       #           #                    
                                                                                                                       #                       #                       #           #           #        
                                                                                                                       #                       #                       #           #           #        
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################
Luis Mendo
źródło

Odpowiedzi:

12

Galaretka , 9 bajtów

Używa 0zamiast #.

RÆD0ṁz⁶ṚY

Wypróbuj online!

Leaky Nun
źródło
2
5 minut i 10 sekund :-)
Luis Mendo
13
W międzyczasie czytałem inne rzeczy ... Następnym razem będę szybszy.
Leaky Nun
7

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 .

2501
źródło
7

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


   #
 ####
#####
rahnema1
źródło
1
Bardzo fajne podejście!
Luis Mendo,
2
Oktawa dokonuje domyślnej ekspansji singletonu, więc @(N)" #"(sort(~mod(k=1:N,k')+1))oszczędza ci kilka bajtów :) Dostajesz jednak kilka wiodących nowych linii, nie jestem pewien, jakie są reguły w tym zakresie.
Stewie Griffin
1
Sama bytecount (32) @(N)['',35*sort(~mod(k=1:N,k'))].
Stewie Griffin
@StewieGriffin Thanks! Nie wiedziałem o tej funkcji. Czy jest mod(1:N,(1:N).') akceptowalny w MATLAB?
rahnema1
2
Myślę, że jest to możliwe od wersji R2016b , ale nie mogę go niestety przetestować, ponieważ nie mam go.
Stewie Griffin
6

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.
Ørjan Johansen
źródło
6

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 =
     #
   # #
 #####
######
Stewie Griffin
źródło
5

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

ovs
źródło
5

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

Adám
źródło
5

Mathematica, 59 57 bajtów

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

wprowadź opis zdjęcia tutaj

Ian Miller
źródło
Witamy w odpowiedzi na PPCG, koleżanka Lego :-)
Luis Mendo
1
Teraz już nie ma odwrotu ...
Luis Mendo
Witamy! Miło widzieć innego golfistę Mathematica. Ta odpowiedź nie jest jednak w pełni poprawna, ponieważ zapisałeś dane wejściowe we fragmencie. Odpowiedzi muszą być pełnymi programami lub funkcjami wywoływalnymi (które mogą być nienazwane). Więc to może być ustalona bez kosztów poprzez zastąpienie 50ze #i dopisywania &. Możesz także zapisać niektóre bajty z zapisem infix: X~Table~#&oraz0~DivisorSigma~Range@#
Martin Ender
@MartinEnder Thanks. Zapomniałem o tym, kiedy przeszedłem z testowania na odpowiadanie. I dzięki za podpowiedź na temat naprawiania. Nie jest to coś, z czego zwykle korzystam (ponieważ tak naprawdę nie gram w golfa).
Ian Miller
Tak myślałem. To był raczej język w komentarzu na policzku. Przepraszam za zamieszanie.
Ian Miller
5

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

MetaColon
źródło
1
Jeśli użyjesz tablicy wewnętrznej zamiast listy, możesz zapisać wiele bajtów z using-statement.
raznagul
@raznagul zaktualizował go.
MetaColon
222 bajty: using System.Linq;using C=System.Console;n=>{var v=new int[n];for(var k=1,i;++k<=n;)for(i=1;i<k;)if(k%i++==0)v[k-1]++;for(var i=0,u;i<v.Length;i++)for(u=v.Max()-v[i];u<v.Max();){C.SetCursorPosition(i, u++);C.Write("#");}};Kompiluj do Action, przesuwaj przyrosty i kilka innych drobnych poprawek. Nie testowałem tego, ale powinno działać.
TheLethalCoder
@TheLethalCoder Przetestuję to / zaktualizuję swoją odpowiedź jutro.
MetaColon
5

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

wprowadź opis zdjęcia tutaj

J42161217
źródło
Czy wszystkie te spacje (i znaki nowej linii) są niezbędne do uruchomienia kodu? Nigdy sam nie programowałem Mathematiki, ale w większości języków można usunąć prawie wszystkie te spacje.
Kevin Cruijssen
to mój pierwszy golf. dzięki za wskazówki
J42161217
2
Nie ma problemu, witamy w PPCG! Jeśli jeszcze tego nie zrobiłeś, możesz przeczytać Porady dotyczące gry w golfa w <wszystkich językach> i Porady dotyczące gry w golfa w Mathematica . :) Miłego pobytu.
Kevin Cruijssen
Zewnętrzne nawiasy klamrowe można zmienić na okrągłe nawiasy klamrowe, aby zapobiec ich wyświetlaniu na wyjściu, i można użyć składni (T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
infix
5

Węgiel , 23 22 20 bajtów

F…·¹N«Jι⁰Fι¿¬﹪ι⁺κ¹↑#

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:

F…·¹N       for (i : InclusiveRange(1, InputNumber()))
«           {
 Jι⁰         JumpTo(i, 0);
 Fι          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!

↑E…·¹N⪫Eι⎇﹪ι⁺¹λω#ω
Neil
źródło
lepsze wyjaśnienie : P
tylko ASCII
3

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!

Adnan
źródło
Nie możesz użyć ζzamiast .Bø? Ponadto postać nie musi być#
Oliver Ni
ζwtedy nie istniało.
Magic Octopus Urn
3

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.

Mathmandan
źródło
3

Japt , 34 33 16 14 bajtów

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

õ@'#pXâ l÷z w

Wypróbuj online!

Łukasz
źródło
Możesz zaoszczędzić wiele bajtów, po prostu pozwalając zna wypełnienie:õ_â lã'#pX÷z w
ETHproductions
Nie wiedziałem, że automatycznie wypełnia sznurki. Dzięki!
Łukasz
2

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.
Zgarb
źródło
2

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!

Jörg Hülsermann
źródło
2

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.
Martin Ender
źródło
1
Pierwszy program Alice z jedną linią? :-)
Luis Mendo
1
@LuisMendo Nie, myślę, że Leo napisał kilka programów tylko dla Kardynałów (a może mam też ... na przykład quine i Hello, World). Prawdopodobnie najbardziej rozbudowany program jednowierszowy. :)
Martin Ender
Hmm, moje rozwiązanie może zaoszczędzić trochę bajtów dzięki sztuczce „tony wiodących białych znaków”
kwintopia
2

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!

Leaky Nun
źródło
Okej, Readme na githubie powinien zostać zaktualizowany, aby zawierał ÷ l jako standardową funkcję liczenia dzielników ...
kwintopia
2

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!

Giuseppe
źródło
1
!=0może być>0
MickyT,
1

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.

wprowadź opis zdjęcia tutaj

Brian
źródło
1

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
Tytus
źródło
1

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
mazzy
źródło
1

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:

Wyjście matematyczne

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.

Misza Ławrow
źródło
1

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

gkgx1nre(x)k pobiera listę znaków i łączy je w pojedynczy ciąg.

ZA=[re(1),re(2)),re(3)),...,re(n)]#ZAmax(ZA)ZAod 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.

Cairney Coheringaahing
źródło