एक नंबर n को देखते हुए , इस पैटर्न के पहले n कॉलम तैयार करें:

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################ ...

(1-अनुक्रमित) n पर कॉलम की ऊंचाई n के बाइनरी प्रतिनिधित्व 0में प्लसिंग बिट्स की संख्या है , प्लस एक। नतीजतन, नीचे की परत में हर कॉलम भरा होता है, दूसरी परत हर दूसरे कॉलम में, तीसरी परत हर चौथे कॉलम में होती है, आदि।

नियम

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

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

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

7
   #   
 # # # 
#######

32
                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

कुछ बड़े परीक्षण मामले यहां देखे जा सकते हैं ।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf ascii-art

— ETHproductions
स्रोत

2

पायथन 2 , 54 बाइट्स

i=n=input()
while i:i-=1;print((' '*~-2**i+'#')*n)[:n]

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

कई प्रमुख व्हाट्सएप के साथ प्रिंट। प्रत्येक पंक्ति iसे नीचे की गिनती nका एक पैटर्न दोहराता 2**i-1रिक्त स्थान एक के बाद #। यह पैटर्न शासक की चौड़ाई तक दोहराया जाता है, जो इनपुट है n। यह पैटर्न स्ट्रिंग को गुणा करके nऔर पहले nपात्रों को साथ लेकर किया जाता है [:n]।

पैटर्न एक समान लंबाई विकल्प के लिए स्ट्रिंग प्रारूपण द्वारा बनाया जा सकता है।

i=n=input()
while i:i-=1;print('%%%ds'%2**i%'#'*n)[:n]

एक प्यारा टुकड़ा करने की विधि लंबी है।

n=input();s=~-2**n*' '+'#'
exec"s=s[1::2]*2;print s[:n];"*n

— XNOR
स्रोत

क्या ~ -1 या +1 है?

— स्टेन स्ट्रम

कोई बात नहीं, यह (-x) - 1

— स्टेन स्ट्रम

10

पायथन 3 , 74 बाइट्स

n=int(input())
a=1
while a<n:a*=2
while a:print(("%%%dd"%a%4*n)[:n]);a//=2

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

— लीक नन
स्रोत

वाह, मुझे यह जानने में थोड़ा समय लगा कि पंक्तियाँ कैसे उत्पन्न होती हैं। बहुत बढ़िया।

— ETHproductions

2

a=2**len(bin(n))72 बाइट्स के लिए

— Ovs

2

यह मेमोरी त्रुटियों को जल्दी से हिट करेगा, और अतिरिक्त सफेद स्थान (अनुमत) का एक गुच्छा प्रिंट करेगा - लेकिन आप कर सकते हैं पायथन 2 का उपयोग करके 54 कर ।

— जोनाथन एलन

9

वी , 17 , 16 बाइट्स

é#Àñä}Är {ñÎÀlD

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

Hexdump:

00000000: e923 c0f1 e416 7dc4 7220 7bf1 cec0 6c44  .#....}.r {...lD

एक बाइट को बचाने के लिए @KritiiLithos को धन्यवाद!

यह एल्गोरिथ्म बहुत ही अयोग्य है, लेकिन इसे किसी भी आकार के इनपुट के लिए सिद्धांत रूप में काम करना चाहिए।

यह निम्नलिखित पैटर्न के पहले n पुनरावृत्तियों को उत्पन्न करके काम करता है :

#

 #
##

   #
 # #
####

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

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

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

और फिर सभी एन कॉलम को काट दिया । इस प्रकार, यह एक टन प्रमुख व्हाट्सएप का उत्पादन करेगा, लेकिन ओपी ने कहा:

आउटपुट में व्हॉट्सएप की कोई भी राशि हो सकती है, जब तक कि पैटर्न बरकरार है

स्पष्टीकरण:

é#                      " Insert an '#'
  Àñ           ñ        " 'N' times:
    ä<C-v>}             "   Duplicate every line blockwise (duplicating horizontally instead of vertically)
           Ä            "   Duplicate the top line. This conveniently puts us on the first non-whitespace character (that is, '#')
            r           "   Replace this character with a space
              {         "   Move to the beginning of the buffer
                Î       " On every line:
                 Àl     "   Move 'N' characters to the right ('l' for right, makes sense, right?)
                   D    "   And delete everything after the cursor

— DJMcMayhem
स्रोत

मुझे पूरा यकीन नहीं है, लेकिन मुझे लगता है कि आप इसे हटा सकते हैं |।

— क्रिति लिथोस

@ कृतिलिथोस अहा! अधूरेपन में, यह बहुत स्पष्ट है! पारितोषिक के लिए धन्यवाद। :)

— DJMcMayhem

5

जावास्क्रिप्ट (ईएस 6), 61 58 बाइट्स

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

@ बाइट्स के लिए 1 बाइट की बदौलत बचा, फिर 2 और बाइट्स जब मैंने देखा कि किसी भी कैरेक्टर का इस्तेमाल किया जा सकता है।

एक पुनरावर्ती समाधान।

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

कोड स्निपेट दिखाएं

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

console.log(f(32));
console.log(f(1));  
console.log(f(5));  
console.log(f(7));

Expand snippet

एनिमेशन:

कोड स्निपेट दिखाएं

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

for(let i = 1 ; i < 64 ; i++) {
  setTimeout(_=>document.querySelector('pre').textContent=f(i), i*40);
}

<pre>

Expand snippet

— रिक हिचकॉक
स्रोत

1

बहुत बढ़िया। आप एक बाइट को बचाने के c/2|0लिए बदल सकते हैं c>>1।

— ETHproductions

अच्छा, मुझे अपने बिटवाइज़ ऑपरेटरों पर ब्रश करने की आवश्यकता है।

— रिक हिचकॉक

4

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

'# '[1+⊖0⍪∨⍀⊖2⊥⍣¯1⍳⎕]

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

'# '[… `] स्ट्रिंग को इंडेक्स करें

⎕ इनपुट प्राप्त करें

⍳ वह कई मैं ntegers

2⊥⍣¯1 बाइनरी में कनवर्ट करें, आवश्यकतानुसार कई अंकों का उपयोग करके (प्रत्येक कॉलम में एक संख्या )

⊖ उल्टा हो गया

∨⍀ ऊर्ध्वाधर संचयी या कमी

0⍪ शीर्ष पर ज़ीरोसेट

⊖ उल्टा फ्लिप (यानी फिर से वापस)

1+ एक जोड़ें (1-आधारित अनुक्रमण के लिए)

— एडम
स्रोत

3

जेली , 11 10 बाइट्स

Rọ2‘4ẋz⁶ṚY

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

1 बाइट ने ओपी को बचाने के बाद छूट दी कि चरित्र होना जरूरी नहीं है #।

— लीक नन
स्रोत

2

ऑक्टेव, 45 बाइट्स

@(n)[[sort(cummin(de2bi(g=0:n)'));g|1]+32 '']

पहनकर देखो ऑक्टेव ऑनलाइन !

'#'प्रिंट के बजाय '!'।

— rahnema1
स्रोत

2

PHP , 139 बाइट्स

for($f=array_fill(0,$l=1+log($a=$argn,2)," ");$n++<$a;)for($h=1+strspn(strrev(decbin($n)),$i=0);$i<$h;)$f[$l-++$i][$n]=3;echo join("
",$f);

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

— जार्ग हुल्सरमन
स्रोत

2

जाप , 20 17 बाइट्स

3 बाइट्स @Shaggy और @ETHproductions की बदौलत सहेजे गए

õ_¤q1 o Ä çoÃ·z w

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

स्पष्टीकरण:

इनपुट: ५

õ_¤q1 o Ä çoÃ·z w
õ           Ã       // Create a range [1...Input] [1,2,3,4,5]
 _                  // Map; At each item:
  ¤                 //   Convert to binary        ["1","10","11","100","101"]
   q1               //   Split on "1"             [["",""],["","0"],["","",""],["","00"],["","0",""]]
      o             //   Get the last item        ["","0","","00",""]
        Ä           //   Add 1                    [["1","01","1","001","1"]]
          ço        //   Fill with "o"            ["o","oo","o","ooo","o"]
             ·      // Join with new-lines        ["o\noo\no\nooo\no"]
              z     // Rotate 90 degrees          ["ooooo\n o o \n o   "]
                w   // Reverse                    ["   o \n o o \nooooo"]

— ओलिवर
स्रोत

20 बाइट्स

— झबरा

@ शैगी दरअसल, आपको जरूरत नहीं हैl

— ETHproductions

@ETHproductions: हाँ, बस समझ से बाहर है। 18 बाइट्स

— झबरा

17 बाइट्स

— झबरा

बिटवाइज ऑपरेटरों के साथ एक अच्छी चाल n&-nकेवल अंतिम 1और सभी अनुगामी 0एस को पकड़ने के लिए है n। यकीन नहीं होता कि यह मदद करेगा, लेकिन यह एक शॉट के लायक है ...

— ETHproductions

2

सी, 84 74 बाइट्स

f(i,l,m){putchar(32+3*!(i&m));i<l?f(i+1,l,m):m?putchar(10),f(1,l,m>>1):1;}

Ungolfed:

void f(int counter, int length, int mask) {
    putchar((counter&mask) ? ' ' : '#');
    if(counter<length) {
        f(counter+1, length, mask);
    } else if(mask) {
        putchar('\n');
        f(1, length, mask>>1);
    }
}

इसके साथ टेस्ट करें:

int main() {
    f(1, 32, 1023);
    putchar('\n');
    f(1, 1, 1023);
    putchar('\n');
    f(1, 999, 1023);
    putchar('\n');
}

व्याख्या

एक बार फिर, पुनरावृत्ति C से पुनरावृत्ति की तुलना में कम वर्ण लेता है, इसलिए दो लूप को दो पुनरावर्ती इनवोकेशन के रूप में व्यक्त किया जाता है।

इसके अलावा, बूलियन अभिव्यक्ति के साथ चालें खेलने के लिए सी एक शानदार भाषा है, यह निर्णय लेने की अनुमति देता है कि क्या एक खाली या #अभिव्यक्ति द्वारा व्यक्त किया जाना है 32+3*!(i&m)। एक स्पेस में ASCII का मान 32 है, #ASCII 35 है, इसलिए अगर मास्क में बिट्स में से कोई भी सेट किया जाता है तो हम खाली हो जाते हैं i।

— cmaster - पुनः स्थापित मोनिका
स्रोत

क्या आपको भी इसकी आवश्यकता है int i,l,m?

— जचारि

@ZacharyT नहीं, पता चला है कि मैं नहीं था। उन 10 बाइट्स को बचाने के लिए धन्यवाद :-)

— cmaster - reicaate monica

2

अजगर , 15 बाइट्स

j_.tm*Nhx_.Bd1S

कोशिश करो!

व्याख्या

j_.tm*Nhx_.Bd1S
    m         SQ   # map over the numbers from 0 to the implicit input (lambda variable: d)
          .Bd      # Convert d to a binary string: (12 -> 1100)
         _         # reverse: (1100 -> 0011)
        x    1     # get the location of the first 1 ( 2 )
     *Nh           # make one more than that " quotation marks (""")
 _.t               # transpose the list of quotation mark strings and reverse it
j                  # join on newline

— KarlKastor
स्रोत

@ जैसन यह पायथन पर आधारित एक गोल्फ भाषा है! मैंने अब अजगर के जीथब को जोड़ा । मैंने सोचा कि यह कोशिश करो! ऑनलाइन एक्ज़ीक्यूटिव का लिंक पर्याप्त होगा।

— कार्लकस्टर

2

पायथन 2 , 47 बाइट्स

f=lambda n:n and' '.join(f(n/2))+'\n'+n*'#'or''

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

— एंडर्स कसीगोर
स्रोत

1

जावास्क्रिप्ट (ईएस 8), 71 बाइट्स

PadStart () समारोह ECMAScript 2017 में पेश किया गया था!

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)

कोड स्निपेट दिखाएं

f=
N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)

console.log(f(+prompt()))

Expand snippet

जावास्क्रिप्ट (ईएस 6), 77 बाइट्स

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

कोड स्निपेट दिखाएं

f=
N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

console.log(f(+prompt()))

Expand snippet

— darrylyeo
स्रोत

1

@RickHitchcock फिक्स्ड।

— darrylyeo

1

मैथेमेटिका, 69 बाइट्स

Rotate[Grid["#"~Table~#&/@(IntegerExponent[2*#,2]&/@Range[#])],Pi/2]&

— J42161217
स्रोत

1

( WESRRMICGSE ): 237 बाइट्स

IF(ROW()<=FLOOR(LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2),1)+2,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2)-ROW()+2),1)-1) &"#",COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),"")

ठीक है। 'बंटवारे का समय।

सबसे पहले, इनपुट के लिए, COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1बस के साथ हर जगह [i]। टोकन कोशिकाओं की संख्या को गिनता है, न कि स्वयं को शामिल करता है, जिसमें एक सूत्र होता है, और फिर एक को जोड़ता है, खुद को शामिल करने के लिए। चूंकि WESRRMICGSE आपके द्वारा दिए गए इनपुट के अनुसार एक फॉर्मूला ड्रग करता है, इस टोकन से इनपुट में परिणाम होता है।

हमारे पास है:

IF(ROW()<=FLOOR(LOG([i],2),1)+3,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG([i],2)-ROW()+2),1)-1) &"#",[i]),[i]),"")

यह बहुत अधिक पठनीय है। आप FLOOR(LOG([i],2),1)बहुत सारे टोकन देख सकते हैं , जिसका सीधा सा मतलब है कि 2 की निकटतम शक्ति लें जो इनपुट ( [i]) संख्या से कम है । उदाहरण के लिए: 4->4, 5->4, 6->4, 7->4, 8->8 ...etc। मैं उस के साथ बदल दूँगाGS[[i]]

IF(ROW()<=GS[[i]]+3,LEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i]),"")

बेहतर। यदि खंड बंद हो रहा है, तो हम परीक्षण कर रहे हैं कि क्या पंक्ति से कम या बराबर है GS[[i]]+3, क्योंकि सभी शासकों की ऊंचाई GS [[i]] + 1 के बराबर है, यह उन पंक्तियों का चयन करता है जो ऊंचाई के बराबर हैं शासक। +11-अनुक्रमणिका पंक्तियों के लिए, और +1WESRRMICGSE ऑफ़सेट के लिए फिर से।

FALSEपरिणाम एक खाली सेल ( ""), और एक सच्चे परिणाम पैदावार पैदावारLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

वर्तमान में संपादन, अभी भी बने रहें

— tuskiomi
स्रोत

1

हास्केल , 64 62 बाइट्स

l m=([2..2^m]>>" ")++'#':l m
f n=unlines$take n.l<$>[n,n-1..0]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: f 10।

— Laikoni
स्रोत

1

k, 33 बाइट्स

`0:|" #"{(1+!x){~y!x}/:(x>)(2*)\1}

यह केवल AW के दुभाषिया में काम करने लगता है ।

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

`0:|" #"{(1+!x){~y!x}/:{x>y}[x](2*)\1}

— zgrep
स्रोत

1

सी #, 174 बाइट्स

इस विधि में दो पैरामीटर हैं, शासक की लंबाई के लिए एक इनपुट, और एक आउटपुट जो स्ट्रिंग के रूप में शासक है।

golfed:

void R(int n,out string s){var l=new int[++n];int i,x=n,y=0;for(s="";x-->1;)for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y);for(y++;y-->0;s+='\n')for(x=0;++x<n;s+=y<l[x]?'#':' ');}

इंडेंट:

void R(int n,out string s){                       // Return the result in an out parameter.
    var l=new int[++n];                           // Use a 1-based array.
    int i,x=n,y=0;                                //
    for(s="";x-->1;)                              // For each number x on the ruler
        for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y) // ... find lowest set bit of x, counting the maximum value.
            ;                                     //
    for(y++;y-->0;s+='\n')                        // Count down each line.
        for(x=0;++x<n;s+=y<l[x]?'#':' ')          // Output # for numbers that are tall enough.
            ;                                     //
}

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

— हाथ-ए-खाना
स्रोत

Func<int, string>आप कुछ बाइट्स को बचाने के लिए परिवर्तित करना चाहते हैं?

— द लीथेलकोडर

1

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

↶Ｆ…·¹Ｎ«Ｊι⁰#Ｗ¬﹪ι²«Ａ÷ι²ι#

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: 4 बाइट्स पर स्विच करके सहेजा गया JumpTo।

— नील
स्रोत

यह अभी भी निरपेक्ष है, बस अब इसे JumpTo(क्षमा करें) कहा जाता है

— केवल

@ ASCII- केवल आह, विकी अपडेट के साथ कर सकता है। (या मुझे लगता है कि मैं यह कर सकता हूं कि क्या आप मुझे अनुमति देना चाहते हैं ...)

— नील

@ ASCII- केवल हू, मुझे याद रखना चाहिए कि codegolf.stackexchange.com/a/119904 से ...

— नील

क्या आपके पास GitHub खाता है?

— केवल

@ASCII-only I have two... I can't decide which one is more appropriate...

— Neil

1

J, 38 bytes

3 :'|.|:''#''#~,.(1+|.i.1:)@#:"0>:i.y'

Not great. Lmk if the byte count is off -- I'm on my phone.

— cole
स्रोत

Looks like 38 to me, unless the 3 at the beginning is input...

— ETHproductions

@ETHproductions thanks, shame switching from a tacit definition didn't save any bytes...

— cole

1

28 bytes with 0|.@|:'#'#"0~1#.2~:/\i.#:@,]

— miles

0

Java (OpenJDK 8), 91 bytes

n->{int i=10,j;String s="";for(;i-->0;s+="\n")for(j=0;j++<n;)s+=j>>i<<i<j?' ':35;return s;}

Try it online!

Ungolfed:

n->{
    int i=10,j; // Since we are allowed extra whitespace, set columns always to 10
    String s = "";
    for(;i-->0;s+="\n")      // Every iteration add a newline, i=9..0
        for(j=0;j++<n;)      // j=1..n+1
            s+= j>>i<<i<j    // if j has less than i trailing 0s in binary form
                ?' '         // add a space else
                :35          // # (java handles ternary return types weirdly)
}

— PunPun1000
स्रोत

0

CJam, 34 bytes

ri{2bW%0+0#)}%_'#f*\:e>f{Se]}zW%N*

Meh.

— Esolanging Fruit
स्रोत

0

C (gcc), 70 bytes

f(x,l,n){for(l=512;l/=2;)for(n=0;n++<=x;)putchar(n^x+1?n%l?32:35:10);}

Try it online!

— Giacomo Garabello
स्रोत

Suggest n+~x instead of n^x+1

— ceilingcat

0

Perl 5, 60 + 1 (-n) = 61 bytes

$n=0|1+(log)/log 2;say(($"x(2**$n-1),X)x($_/2**$n))while$n--

Try it online!

— Xcali
स्रोत

एक बाइनरी शासक बनाएँ

नियम

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

स्कोरिंग

पायथन 2 , 54 बाइट्स

पायथन 3 , 74 बाइट्स

वी , 17 , 16 बाइट्स

जावास्क्रिप्ट (ईएस 6), 61 58 बाइट्स

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

जेली , 11 10 बाइट्स

ऑक्टेव, 45 बाइट्स

PHP , 139 बाइट्स

जाप , 20 17 बाइट्स

स्पष्टीकरण:

सी, 84 74 बाइट्स

Ungolfed:

इसके साथ टेस्ट करें:

व्याख्या

अजगर , 15 बाइट्स

व्याख्या

पायथन 2 , 47 बाइट्स

जावास्क्रिप्ट (ईएस 8), 71 बाइट्स

जावास्क्रिप्ट (ईएस 6), 77 बाइट्स

मैथेमेटिका, 69 बाइट्स

( WESRRMICGSE ): 237 बाइट्स

हास्केल , 64 62 बाइट्स

k, 33 बाइट्स

सी #, 174 बाइट्स

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

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

J, 38 bytes

Java (OpenJDK 8), 91 bytes

CJam, 34 bytes

C (gcc), 70 bytes

Perl 5, 60 + 1 (-n) = 61 bytes