भाजक क्षितिज

46

किसी भी सकारात्मक पूर्णांक के लिए k, d(k)के विभाजकों की संख्या को सूचित करें k। उदाहरण के लिए, d(6)है 4, क्योंकि 6है 4divisors (अर्थात् 1, 2, 3, 6)।

एक सकारात्मक पूर्णांक को देखते हुए N, एक निश्चित चरित्र का उपयोग करके ASCII कला में "क्षितिज" प्रदर्शित करें, जैसे कि क्षैतिज स्थिति kमें स्थित "भवन" की ऊंचाई के d(k)लिए है k = 1, ..., N। नीचे परीक्षण के मामले देखें।

नियम

  • किसी भी गैर-व्हाट्सएप चरित्र का लगातार उपयोग किया जा सकता है, जरूरी नहीं कि #जैसा कि परीक्षण के मामलों में दिखाया गया है।
  • एल्गोरिथ्म को सैद्धांतिक रूप से उच्च स्तर के लिए काम करना चाहिए N। व्यवहार में, यह स्वीकार्य है यदि कार्यक्रम समय, मेमोरी, डेटा-प्रकार के आकार या स्क्रीन के आकार तक सीमित है।
  • क्षैतिज या लंबवत रूप से अग्रणी या अनुगामी रिक्त स्थान या नईलाइनों की अनुमति है।
  • इनपुट और आउटपुट किसी भी उचित माध्यम से लिया जा सकता है ।
  • प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।
  • बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

N = 10:

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

N = 50:

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

N = 200:

                                                                                                                                                                                   #                    
                                                                                                                                                                                   #                    
                                                                                                                       #                                               #           #                    
                                                                                                                       #                       #                       #           #                    
                                                                                                                       #                       #                       #           #           #        
                                                                                                                       #                       #                       #           #           #        
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################
code-golf  math  ascii-art  number-theory  integer 
— लुइस मेंडो
स्रोत

जवाबों:

7

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

इसे यहां देखें ।

— 2501
स्रोत
7

ऑक्टेव, 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


   #
 ####
#####
— rahnema1
स्रोत
1
बहुत अच्छा तरीका!
— लुइस मेंडो
2
ऑक्टेव एकल विस्तार का प्रदर्शन करता है, इसलिए @(N)" #"(sort(~mod(k=1:N,k')+1))आपको कुछ बाइट्स बचाता है :) आपको प्रमुख न्यूलाइन्स का एक गुच्छा मिलता है, हालांकि, मुझे यकीन नहीं है कि उस संबंध में क्या नियम हैं।
— स्टीवी ग्रिफिन
1
वही बायटेकाउंट (32) @(N)['',35*sort(~mod(k=1:N,k'))]:।
— स्टीवी ग्रिफिन
@StewieGriffin धन्यवाद! मुझे उस सुविधा की जानकारी नहीं थी। है mod(1:N,(1:N).') MATLAB में स्वीकार्य?
— rahnema1
2
मुझे लगता है कि यह R2016b के रूप में संभव है , लेकिन मैं इसे दुर्भाग्य से खुद का परीक्षण नहीं कर सकता, क्योंकि मेरे पास यह नहीं है।
— स्टीवी ग्रिफिन
6

हास्केल , 71 बाइट्स

fएक लेता है Intऔर एक रिटर्न देता है String।

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

इसे ऑनलाइन आज़माएं!

  • mहै Nओ पी के (हास्केल चर लोअरकेस किया जाना चाहिए।)
  • संक्षिप्त नाम l=[1..m]का उपयोग सभी पंक्तियों, स्तंभों और संभावित विभाजकों के माध्यम से पुनरावृति के लिए नेस्टेड सूची में किया जाता है। इसका मतलब है व्हाट्सएप से भरी कुछ अतिरिक्त प्रारंभिक पंक्तियाँ।
  • nस्तंभ है (जाँची गई संख्या भी), iपंक्ति है।
  • ['#'|0<-mod n<$>l]उन '#'वर्णों की सूची है जिनकी लंबाई विभक्तों की संख्या है n।
— अर्जन जोहान्सन
स्रोत
6

ऑक्टेव, 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. 2 के दो विभाजकों के लिए जगह बनाने के लिए एक कॉलम और एक पंक्ति का विस्तार करता है
  3. 3 (केवल दो भाजक) के लिए जगह बनाने के लिए एक स्तंभ का विस्तार
  4. (, एक स्तंभ और एक पंक्ति का विस्तार 3 divisors के लिए मेकअप के कमरे में 1,2,4)
  5. एक स्तंभ का विस्तार, 5 के लिए जगह बनाने के लिए
  6. (, एक स्तंभ और पंक्ति का विस्तार 4 divisors के लिए मेकअप के कमरे में 1,2,3,6)

अंत में हम यह फ्लिप, और एक स्ट्रिंग में बदल देता है, परोक्ष बदल रहा 0करने के लिए 32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######
— स्टीवी ग्रिफिन
स्रोत
5

एपीएल (डायलॉग) , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

⎕ मूल्यांकनित इनपुट प्राप्त करें ( N )

⍳ 1 ... एन

∘.|⍨ विभाजन तालिका 1 के साथ शेष ... एन दोनों ऊर्ध्वाधर और क्षैतिज अक्ष के रूप में

0= जहां शून्य के बराबर (यानी यह विभाजित होता है)

+⌿ कॉलम का योग करें (यानी प्रत्येक संख्या के लिए भाजक की गिनती करें)

'#'⍴¨⍨ हैश वर्ण को फिर से खोलने के लिए प्रत्येक संख्या का उपयोग करें (स्ट्रिंग की सूची देता है)

↑ मिक्स (पंक्तियों की तालिका में तार की सूची)

⍉ पक्षांतरित

⊖ उल्टा हो गया

— एडम
स्रोत
5

गणितज्ञ, ५ ९ ५ by बाइट्स

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

यहाँ छवि विवरण दर्ज करें

— इयान मिलर
स्रोत
PPCG पर जवाब देने के लिए आपका स्वागत है, साथी लेगो मिनीफिग :-)
— लुइस
1
अब कोई पीछे नहीं हट रहा है ...
— लुइस मेंडो
स्वागत हे! एक और गणितज्ञ गोल्फर को देखकर अच्छा लगा। यह उत्तर पूरी तरह से मान्य नहीं है, क्योंकि आपने स्निपेट में इनपुट को हार्डकोड किया है। उत्तर पूर्ण कार्यक्रमों या कॉल करने योग्य कार्यों (जो हालांकि अनाम हो सकते हैं) होने की आवश्यकता है। तो यह और के 50साथ बदलकर किसी भी कीमत पर तय किया जा सकता है । आप कुछ बाइट्स को इन्फिक्स नोटेशन के साथ भी सहेज सकते हैं: और#&X~Table~#&0~DivisorSigma~Range@#
— मार्टिन एंडर
@MartinEnder धन्यवाद मैं उस बिट को भूल गया जब मैं परीक्षण से उत्तर देने के लिए चला गया। और infixing के बारे में संकेत के लिए धन्यवाद। इसका कुछ ऐसा नहीं है जिसे मैं सामान्य रूप से उपयोग करता हूं (जैसा कि मैं वास्तव में गोल्फ नहीं करता हूं)।
— इयान मिलर
मैंने भी यही सोचा। गाल टिप्पणी में यह अधिक जीभ था। गलतफहमी के लिए खेद है।
— इयान मिलर
5

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

हालांकि मुझे यकीन है कि यह संभव है कि कम से कम, मुझे उम्मीद है कि हम एक साथ एक छोटा सा समाधान प्राप्त करेंगे;)

राजनागुल की मदद से 52 बाइट्स को बचाया

— MetaColon
स्रोत
1
यदि आप सूची के बजाय इंट-एरे का उपयोग करते हैं, तो आप using-स्टेट से बहुत सारे बाइट्स बचा सकते हैं ।
— रज़नागुल ul ’१az
@raznagul ने इसे अपडेट किया।
— मेटाकाॅलोन
222 बाइट्स: 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("#");}};एक के लिए संकलन Action, चारों ओर वेतन वृद्धि और अन्य मामूली tweaks के एक जोड़े। मैंने इसका परीक्षण नहीं किया है, लेकिन यह काम करना चाहिए।
— TheLethalCoder
@ TheLethalCoder मैं कल इसका परीक्षण / अपडेट करूंगा / करूंगी।
— मेटाकाॅल
5

गणितज्ञ, 99 बाइट्स

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

एन = 50 के लिए

यहाँ छवि विवरण दर्ज करें

— J42161217
स्रोत
क्या वे सभी रिक्त स्थान (और newlines) कोड चलाने के लिए आवश्यक हैं? मैंने कभी भी स्वयं मैथमैटिका की प्रोग्रामिंग नहीं की है, लेकिन अधिकांश भाषाओं में आप लगभग सभी स्थानों को हटा सकते हैं।
— केविन क्रूज़सेन
यह मेरा पहला गोल्फ है। युक्तियों के लिए धन्यवाद
— J42161217
2
कोई समस्या नहीं है, और PPCG में आपका स्वागत है! यदि आपने अभी तक ऐसा नहीं किया है, आप देख सकते में गोल्फ <सभी भाषाओं> के लिए टिप्स और मेथेमेटिका में गोल्फ के लिए सुझाव दिलचस्प के माध्यम से पढ़ने के लिए। :) यहां रहने का आनंद।
— केविन क्रूज़सेन
बाहरी घुंघराले ब्रेसिज़ को आउटपुट में दिखाने से रोकने के लिए गोल कोष्ठक में बदला जा सकता है, और आप 2 बाइट्स को बचाने के लिए कुछ इनफ़िक्स / प्रीफ़िक्स सिंटैक्स का उपयोग कर सकते हैं:(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
— संख्यामान
5

चारकोल , 23 22 20 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: पाशन द्वारा सहेजी गयी 1 बाइट kसे 0करने के लिए i-1और जोड़ने 1पाश अंदर। एक चर में इनपुट का भंडारण न करके आगे के दो बाइट्स को बचाया। स्पष्टीकरण:

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

संपादित करें: यह 18-बाइट "वन-लाइनर" (लिंक कोड के वर्बोस वर्जन के लिए है) सवाल पेश किए जाने के समय चारकोल के संस्करण के साथ काम नहीं किया होगा: इसे ऑनलाइन आज़माएं!

↑Ｅ…·¹Ｎ⪫Ｅι⎇﹪ι⁺¹λω#ω
— नील
स्रोत
— ASCII-only
3

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
के ζबजाय आप का उपयोग नहीं कर सकते .Bø? इसके अलावा, चरित्र के लिए नहीं है#
— ओलिवर नी
ζवापस मौजूद नहीं था।
— मैजिक ऑक्टोपस Urn
3

पायथन 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पंक्तियों को प्रिंट करता है , जिनमें से अधिकांश आम तौर पर रिक्त होंगे।

— mathmandan
स्रोत
3

जाप , 34 33 16 14 बाइट्स

सहेजे गए 17 बाइट्स @ETHproductions की बदौलत

õ@'#pXâ l÷z w

इसे ऑनलाइन आज़माएं!

— ल्यूक
स्रोत
आप बहुत सारे बाइट्स को सिर्फ zपेडिंग करने से बचा सकते हैं :õ_â lã'#pX÷z w
— ETHproductions
पता नहीं था कि तार स्वचालित रूप से गद्देदार। धन्यवाद!
— ल्यूक
2

जे , 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.
— Zgarb
स्रोत
2

ऐलिस , 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)। यह रिटर्न एड्रेस स्टैक (आरएएस) के साथ काम करके किया जाता है । wवर्तमान IP पते को RAS पर धकेलता है, और यदि हम इसे दोहराते हैं &तो पता n बार पुश हो जाता है । kआरएएस से एक पते को पॉप करता है और वहां वापस कूदता है। यदि RAS खाली है, तो यह कुछ भी नहीं करता है और लूप बाहर निकलता है।

आप देख सकते हैं कि इन छोरों को घोंसला बनाना संभव नहीं है, क्योंकि आंतरिक लूप के अंत में, स्टैक खाली नहीं होता है, इसलिए यह kनो-ऑप बन जाता है। इसके बजाय, आईपी बाहरी लूप की शुरुआत में वापस कूद जाएगा। इसे ठीक करने का सामान्य तरीका अपने स्वयं के सबरूटीन में आंतरिक लूप को लपेटना है। लेकिन अगर हम नेस्टेड लूप की व्यवस्था कर सकते हैं ताकि बाहरी लूप आंतरिक लूप के साथ समाप्त हो जाए , हम वास्तव में इस व्यवहार का उपयोग कर सकते हैं और यहां तक ​​कि एक से भी बचा सकते हैं k!

तो यह निर्माण:

&wX&wYk

एक काम करने वाला नेस्टेड लूप होता है जो XYYYXYYYXYYY...( Yप्रत्येक पुनरावृत्ति में कुछ संख्याओं के लिए) चलता है । यह बहुत साफ-सुथरा है कि हम दोनों छोरों को एक साथ समाप्त कर सकते हैं k, क्योंकि यह आरएएस से बाहरी पते का उपभोग करेगा, हर बार आंतरिक पते समाप्त हो गए हैं।

इस मुहावरे का उपयोग प्रोग्राम में आउटपुट ग्रिड पर लूप चलाने के लिए किया जाता है।

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.
— मार्टिन एंडर
स्रोत
1
कभी एक लाइन के साथ पहला ऐलिस कार्यक्रम? :-)
— लुइस मेंडो
1
@LuisMendo नहीं, मुझे लगता है कि लियो ने कुछ कार्डिनल-ओनली प्रोग्राम लिखे हैं (और शायद मेरे पास भी ... क्वीन एंड हेलो, वर्ल्ड फॉर मिसाल)। संभवतः सबसे विस्तृत एकल-पंक्ति कार्यक्रम हालांकि। :)
— मार्टिन एंडर
हम्म, मेरा सॉल्यूशन कुछ टन बाइट्स को "टन ऑफ़ लीडिंग
— व्हॉट्सएप
2

आर, 83 82 बाइट्स

-1 बाइट मिकी के लिए धन्यवाद

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

स्टड 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

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत
1
!=0हो सकता है>0
— मिकी
1

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 तक वर्णों की सही संख्या प्रिंट करती है।

यहाँ छवि विवरण दर्ज करें

— ब्रायन
स्रोत
1

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
— टाइटस
स्रोत
1

पॉवरशेल, 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
— Mazzy
स्रोत
1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 46 44 बाइट्स

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

इसे ऑनलाइन आज़माएं! लेकिन शायद यह ऑनलाइन कोशिश! ग्रिड के बजाय ColumnForm के साथ , क्योंकि GridTIO में काम नहीं करता है। गणित में, यह बेहतर दिखता है:

Mathematica आउटपुट

एक तीसरा Mathematica solution ... Divisors@Range@#सभी विभाजक को उस श्रेणी में पाता है जिसे हम चाहते हैं, और फिर हम हर भाजक को बराबर बनाते 0और घटाते हैं ।" "-" "

PadLeftबाईं ओर शून्य जोड़ते हैं, एक बग़ल में क्षितिज बनाते हैं, जिसका अभिविन्यास हम = के साथ तय करते हैं \[Transpose]। अंत में, " "हर चीज में जोड़ने से 0या तो सभी प्रविष्टियां हो जाती हैं या " "।

एक विकल्प के रूप में, 59-बाइट ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&स्ट्रिंग आउटपुट का उत्पादन करता है।

— मिशा लावरोव
स्रोत
1

++ , 58 बाइट्स जोड़ें

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

gkgx1nd(x)k

A=[d(1),d(2),d(3),...,d(n)]#Amax(A)Aअधिकतम से, प्रत्येक तत्व के लिए रिक्त स्थान की इस संख्या को उत्पन्न करने और दोहराया हेस के लिए रिक्त स्थान को समतल करने से पहले। अगली बार, हम नई पंक्तियों में प्रत्येक पंक्ति में शामिल होने से पहले, पंक्तियों को स्थानांतरित और उलट देते हैं। अंत में, हम स्काईलाइन को आउटपुट करते हैं।

— केर्ड सिक्काहिरिंग
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.