Horizon diviseur

46

Pour tout entier positif k, d(k)notons le nombre de diviseurs de k. Par exemple, d(6)est 4, parce que 6a 4diviseurs ( à savoir 1, 2, 3, 6).

Avec un nombre entier positif N, affichez un "horizon" dans la technique ASCII en utilisant un caractère fixe, de sorte que la hauteur du "bâtiment" situé en position horizontale ksoit définie d(k)par k = 1, ..., N. Voir les cas de test ci-dessous.

Règles

  • Tout caractère non-blanc peut être utilisé de manière cohérente, pas nécessairement #comme le montrent les cas de test.
  • L'algorithme devrait théoriquement fonctionner arbitrairement haut N. En pratique, il est acceptable que le programme soit limité par le temps, la mémoire, la taille du type de données ou la taille de l'écran.
  • Les espaces ou les nouvelles lignes sont précédés ou suivis horizontalement ou verticalement.
  • L'entrée et la sortie peuvent être prises par n'importe quel moyen raisonnable .
  • Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites.
  • Le code le plus court en octets gagne.

Cas de test

N = 10:

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

N = 50:

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

N = 200:

                                                                                                                                                                                   #                    
                                                                                                                                                                                   #                    
                                                                                                                       #                                               #           #                    
                                                                                                                       #                       #                       #           #                    
                                                                                                                       #                       #                       #           #           #        
                                                                                                                       #                       #                       #           #           #        
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################
Luis Mendo
la source

Réponses:

12

Gelée , 9 octets

Utilise 0au lieu de #.

RÆD0ṁz⁶ṚY

Essayez-le en ligne!

Fuite Nun
la source
2
5 minutes et 10 secondes :-)
Luis Mendo
13
Je lisais d'autres choses entre-temps ... Je serai plus rapide la prochaine fois.
Leaky Nun
7

C, 99 95 92 91 90 octets

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

Voir le travail ici .

2501
la source
7

Octave, 41 40 32 octets

Merci à @StewieGriffin sauvé 8 octets.

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

Essayez-le en ligne!

Réponses précédentes:

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Explication:

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
la source
1
Très belle approche!
Luis Mendo
2
Octave effectue implicitement l'expansion du singleton, donc @(N)" #"(sort(~mod(k=1:N,k')+1))vous évite quelques octets.
Stewie Griffin
1
Même bytecount (32): @(N)['',35*sort(~mod(k=1:N,k'))].
Stewie Griffin
@StewieGriffin Merci! Je ne connaissais pas cette fonctionnalité. Est-ce mod(1:N,(1:N).') acceptable dans MATLAB?
rahnema1
2
Je pense que c'est possible à partir de R2016b , mais je ne peux pas le tester moi-même malheureusement, car je ne l'ai pas.
Stewie Griffin
6

Haskell , 71 octets

fprend un Intet retourne un String.

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

Essayez-le en ligne!

  • mest le Nde l'OP (les variables Haskell doivent être en minuscules.)
  • L'abréviation l=[1..m]est utilisée dans les interprétations de liste imbriquées pour parcourir toutes les lignes, les colonnes et les diviseurs potentiels. Cela signifie quelques lignes initiales supplémentaires remplies d'espaces.
  • nest la colonne (également le nombre vérifié), iest la ligne.
  • ['#'|0<-mod n<$>l]est une liste de '#'caractères avec la longueur du nombre de diviseurs de n.
Ørjan Johansen
la source
6

Octave, 61 octets

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

Explication:

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

Quelques points à souligner

  • Prend l'entrée directement dans la boucle
    • N'attribue la valeur d'entrée à aucune variable
  • N'initialise aucun tableau
    • Il le crée à la volée, en ajoutant des colonnes et des lignes si nécessaire
  • Convertit automatiquement la valeur ASCII 0 en espaces (ASCII-32)

Que se passe-t-il à l'intérieur de la boucle (supposons une entrée 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. Commence comme un seul 35
  2. Agrandit une colonne et une rangée pour faire de la place pour les deux diviseurs de 2
  3. Développe une colonne pour faire de la place pour 3 (seulement deux diviseurs)
  4. Agrandit une colonne et une rangée pour faire de la place pour les 3 diviseurs ( 1,2,4)
  5. Agrandit une colonne pour faire de la place pour 5
  6. Agrandit une colonne et une ligne pour faire de la place pour les 4 diviseurs ( 1,2,3,6)

Enfin, nous le retournons et le convertissons en une chaîne, en modifiant implicitement le 0à 32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######
Stewie Griffin
la source
5

Python 3 , 111 octets

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

Essayez-le en ligne!


Cela produit des espaces blancs verticaux

ovs
la source
5

APL (Dyalog) , 19 octets

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

Essayez-le en ligne!

 obtenir une entrée évaluée ( N )

 1 ... N

∘.|⍨ division reste table avec 1 ... N à la fois comme axe vertical et horizontal

0= où égal à zéro (c'est à dire qu'il divise)

+⌿ additionner les colonnes (c'est-à-dire donner le nombre de diviseurs pour chaque nombre)

'#'⍴¨⍨ utiliser chaque nombre pour remodeler le caractère de hachage (donne la liste des chaînes)

 mix (liste de chaînes dans un tableau de lignes)

 transposer

 retourner à l'envers

Adam
la source
5

Mathematica, 59 57 octets

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

entrez la description de l'image ici

Ian Miller
la source
Bienvenue à répondre sur PPCG, camarade Lego minifig :-)
Luis Mendo
1
Maintenant, il n'y a pas de retour en arrière ...
Luis Mendo
Bienvenue! Heureux de voir un autre golfeur Mathematica. Cette réponse n'est toutefois pas entièrement valide car vous avez codé en dur l'entrée dans l'extrait de code. Les réponses doivent être des programmes complets ou des fonctions appelables (qui peuvent toutefois ne pas être nommées). Donc, ceci peut être corrigé gratuitement en remplaçant 50par #et en ajoutant &. Vous pouvez également enregistrer des octets avec la notation infixe: X~Table~#&et0~DivisorSigma~Range@#
Martin Ender
@MartinEnder Merci. J'avais oublié ce truc quand je suis passé de test en réponse. Et merci pour l'allusion sur l'infixation. Ce n’est pas quelque chose que j’utilise normalement (car je ne joue pas vraiment au golf).
Ian Miller
C'est ce que je pensais. C'était plus un commentaire dans la langue. Désolé pour la confusion.
Ian Miller
5

C #, 333 281 octets

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

Avec des sauts de ligne:

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

Bien que je sois sûr que cela soit possible plus rapidement, j'espère que nous parviendrons ensemble à une solution plus courte;)

52 octets sauvés avec l'aide de raznagul

MetaColon
la source
1
Si vous utilisez un int-array au lieu d'une liste, vous pouvez enregistrer de nombreux octets à partir de using-statement.
raznagul
@raznagul l'a mis à jour.
MetaColon
222 octets: 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("#");}};compilez en un Action, déplacez les incréments et quelques autres modifications mineures. Je n'ai pas testé ça mais ça devrait marcher.
TheLethalCoder
@TheLethalCoder Je vais le tester / mettre à jour ma réponse demain.
MetaColon
5

Mathematica, 99 octets

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

pour N = 50

entrez la description de l'image ici

J42161217
la source
Tous ces espaces (et nouvelles lignes) sont-ils nécessaires à l'exécution du code? Je n'ai jamais programmé Mathematica moi-même, mais dans la plupart des langues, vous pouvez supprimer presque tous ces espaces.
Kevin Cruijssen
c'est mon premier golf. merci pour les conseils
J42161217
2
Pas de problème, et bienvenue chez PPCG! Si vous ne l'avez pas encore fait, vous pouvez trouver des astuces pour le golf dans <toutes les langues> et des astuces pour le golf dans Mathematica intéressantes à lire. :) Profitez de votre séjour.
Kevin Cruijssen
Les accolades extérieures peuvent être remplacées par des crochets arrondis pour les empêcher de s'afficher dans la sortie. Vous pouvez également utiliser une syntaxe infixe / préfixe pour sauvegarder 2 octets:(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
numbermaniac
5

Charbon de bois , 23 22 20 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: 1 octet enregistrées par bouclage à kpartir 0de i-1et en ajoutant à l' 1intérieur de la boucle. Enregistré deux octets supplémentaires en ne stockant pas l'entrée dans une variable. Explication:

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

Edit: Ce "one-liner" de 18 octets (lien vers version du code verbeuse) n'aurait pas fonctionné avec la version de Charcoal au moment où la question a été soumise: essayez-le en ligne!

↑E…·¹N⪫Eι⎇﹪ι⁺¹λω#ω
Neil
la source
meilleure explication : P
ASCII uniquement
3

05AB1E , 12 octets

Code:

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

Explication:

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

Utilise le codage 05AB1E . Essayez-le en ligne!

Adnan
la source
Tu ne peux pas utiliser ζau lieu de .Bø? En outre, le personnage n'a pas à être#
Oliver Ni
ζn'existait pas à l'époque.
Urne magique Octopus
3

Python 2 , 101 octets

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

Essayez-le en ligne!

Cela produit (beaucoup) d’espaces blancs verticalement. Il imprime un total de Nlignes dont la grande majorité sera généralement vierge.

Mathmandan
la source
3

Japt , 34 33 16 14 octets

17 octets sauvés grâce à @ETHproductions

õ@'#pXâ l÷z w

Essayez-le en ligne!

Luke
la source
Vous pouvez économiser beaucoup d'octets en laissant zsimplement le rembourrage:õ_â lã'#pX÷z w
ETHproductions
Je ne savais pas que les cordes étaient automatiquement rembourrées. Merci!
Luc
2

J , 28 octets

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

Définit un verbe monadique. Essayez-le en ligne!

Explication

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

PHP, 126 octets

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

Essayez-le en ligne!

Jörg Hülsermann
la source
2

Alice , 33 octets

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

Essayez-le en ligne!

L'entrée est (malheureusement) sous la forme d'un point de code . Au moins, il lit un caractère UTF-8, vous pouvez donc utiliser des entrées plus grandes que 255, mais elles sont toujours limitées et le format d’entrée est très pénible. Pour trois octets supplémentaires, on peut lire un entier décimal:

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

Essayez-le en ligne!

Le caractère non-blanc de la sortie est !.

Notez que la solution imprime également une tonne d'espaces de premier plan (elle commence toujours par une ligne vide, puis une NxNgrille; ainsi, pour les plus grandes N, il y aura plusieurs lignes d'espaces avant les premières !.)

Explication

J'ai déjà utilisé et expliqué la &w...kconstruction (par exemple ici ). C'est un joli petit idiome qui fait apparaître un entier n puis exécute un morceau de code n + 1 fois (par conséquent, il est généralement utilisé t&w...kpour exécuter une boucle n fois en tdécrémentant la valeur d'entrée). Cela est fait en travaillant avec la pile d'adresses de retour (RAS). wtransmet l'adresse IP actuelle au serveur d'accès à distance et si nous la répétons avec, &l'adresse sera poussée n fois. kaffiche une adresse du serveur d'accès à distance et y retourne. Si le RAS est vide, il ne fait rien du tout et la boucle est sortie.

Vous remarquerez peut-être qu'il n'est pas trivial d'imbriquer ces boucles, car à la fin de la boucle interne, la pile n'est pas vide et kne devient donc pas un non-op. Au lieu de cela, l'IP reviendrait au début de la boucle externe. La solution générale consiste à envelopper la boucle interne dans son propre sous-programme. Mais si nous pouvons organiser la boucle imbriquée de telle sorte que la boucle externe se termine par la boucle interne, nous pouvons en fait utiliser ce comportement et même en économiser un k!

Donc cette construction:

&wX&wYk

C'est une boucle imbriquée fonctionnelle qui exécute le XYYYXYYYXYYY...(pour un certain nombre de Ys dans chaque itération). Il est intéressant de pouvoir terminer les deux boucles par une seule k, car elle consomme une adresse externe du serveur d'accès à distance chaque fois que les adresses internes sont épuisées.

Cet idiome est utilisé dans le programme pour exécuter la boucle sur la grille de sortie.

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
la source
1
Premier programme Alice avec une seule ligne? :-)
Luis Mendo
1
@LuisMendo Non, je pense que Leo a écrit quelques programmes exclusivement pour Cardinal (et peut-être que j'ai aussi ... le quine et le Hello, World par exemple). Probablement le programme monoligne le plus élaboré. :)
Martin Ender
Hmm, ma solution pourrait économiser quelques octets avec astuce "tonne de grands espaces"
quintopia
2

En fait , 25 octets

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

Essayez-le en ligne!

Version de 22 octets avec beaucoup de nouvelles lignes principales

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

Essayez-le en ligne!

Fuite Nun
la source
D'accord, le fichier Lisez-moi sur le github devrait être mis à jour pour inclure ÷ l en tant que fonction de comptage de diviseur standard ...
quintopia
2

R, 83 82 octets

-1 octet grâce à MickyT

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

Lit Nde stdin.

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

Essayez-le en ligne!

Giuseppe
la source
1
!=0can be>0
MickyT
1

SpecBAS - 149 octets

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

Un tableau conserve le nombre de diviseurs, puis affiche le nombre correct de caractères jusqu'à la position 50.

entrez la description de l'image ici

Brian
la source
1

PHP, 99 octets

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

imprime un premier espace; courir comme pipe php -nr '<code>'ou essayer en ligne .

panne

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
Titus
la source
1

PowerShell, 101 octets

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

Script de test moins joué:

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

Sortie:

True
True
True
mazzy
la source
1

Wolfram Language (Mathematica) , 46 44 octets

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

Essayez-le en ligne! Mais peut-être l' essayer en ligne! avec ColumnForm au lieu de Grid , car Gridne fonctionne pas dans TIO. Dans Mathematica, cela a l'air mieux:

Sortie Mathematica

Une troisième solution Mathematica ... Divisors@Range@#recherche tous les diviseurs dans la plage que nous voulons, puis multiplie 0et soustrayons " ", rendant chaque diviseur égal à -" ".

PadLeftajoute des zéros à gauche, créant une ligne d'horizon latérale, dont nous corrigeons l'orientation avec = \[Transpose]. Enfin, ajouter " "à tout fait que toutes les entrées sont 0soit " ".

Au lieu de cela, le 59 octets ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&produit une sortie chaîne.

Misha Lavrov
la source
1

Ajouter ++ , 58 octets

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

Essayez-le en ligne!

Comment ça fonctionne

gkgx1nd(x)k

A=[d(1),d(2),d(3),...,d(n)]#Amax(A)Aà partir de ce maximum, avant de céder ce nombre d'espaces pour chaque élément et de concaténer les espaces aux hachages répétés. Ensuite, nous transposons et inversons les lignes avant de joindre chaque ligne aux nouvelles lignes. Enfin, nous sortons la ligne d'horizon.

caird coinheringaahing
la source