38

इनपुट के रूप में एक सकारात्मक पूर्णांक n लें , और आउटपुट (कुछ) दशमलव संख्या जो n बिट्स का उपयोग करके बनाई जा सकती हैं , निम्न तरीके से क्रमबद्ध हैं:

पहले उन सभी नंबरों को सूचीबद्ध करें जो केवल एक के साथ बनाए जा सकते हैं 1, और बाकी 0बाइनरी प्रतिनिधित्व (सॉर्ट किए गए) में, फिर सभी संख्याएँ जो लगातार दो 1, शेष के साथ बनाई जा सकती हैं 0, फिर तीन लगातार 1 और इसी तरह।

आइए देखें कि यह कैसा दिखता है n = 4 के लिए :

0001  -  1
0010  -  2
0100  -  4
1000  -  8
0011  -  3
0110  -  6
1100  -  12
0111  -  7
1110  -  14
1111  -  15

तो, n = 4 के लिए आउटपुट है: 1, 2, 4, 8, 3, 6, 12, 7, 14, 15 (वैकल्पिक आउटपुट स्वरूप)।

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

n = 1
1

n = 2
1 2 3

n = 3
1, 2, 4, 3, 6, 7

n = 8
1, 2, 4, 8, 16, 32, 64, 128, 3, 6, 12, 24, 48, 96, 192, 7, 14, 28, 56, 112, 224, 15, 30, 60, 120, 240, 31, 62, 124, 248, 63, 126, 252, 127, 254, 255

n = 17
1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 3, 6, 12, 24, 48, 96, 192, 384, 768, 1536, 3072, 6144, 12288, 24576, 49152, 98304, 7, 14, 28, 56, 112, 224, 448, 896, 1792, 3584, 7168, 14336, 28672, 57344, 114688, 15, 30, 60, 120, 240, 480, 960, 1920, 3840, 7680, 15360, 30720, 61440, 122880, 31, 62, 124, 248, 496, 992, 1984, 3968, 7936, 15872, 31744, 63488, 126976, 63, 126, 252, 504, 1008, 2016, 4032, 8064, 16128, 32256, 64512, 129024, 127, 254, 508, 1016, 2032, 4064, 8128, 16256, 32512, 65024, 130048, 255, 510, 1020, 2040, 4080, 8160, 16320, 32640, 65280, 130560, 511, 1022, 2044, 4088, 8176, 16352, 32704, 65408, 130816, 1023, 2046, 4092, 8184, 16368, 32736, 65472, 130944, 2047, 4094, 8188, 16376, 32752, 65504, 131008, 4095, 8190, 16380, 32760, 65520, 131040, 8191, 16382, 32764, 65528, 131056,16383, 32766, 65532, 131064, 32767, 65534, 131068, 65535, 131070, 131071

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

अच्छी व्याख्याओं को अत्यधिक प्रोत्साहित किया जाता है , "नियमित भाषाओं" में समाधान के लिए भी!

— स्टीवी ग्रिफिन
स्रोत

Codegolf.stackexchange.com/q/98322/61904 का एक हिस्सा ?

— टसेपेल्लिन

2

@zeppelin मैंने पहले भी ऐसा सोचा था, लेकिन यह बहुत अलग है।

— ETHproductions

1

सम्बंधित। (थोड़ा सा।)

— मार्टिन एंडर

6

बेसिन रूपांतरण के किसी भी रूप में (सादे पुराने गणित का उपयोग करके) अगर कोई ऐसा करता है तो काल्पनिक बोनस।

— स्टीवी ग्रिफ़िन

यह लिखा जो दो के बीच एक मिश्रण है मुझे लगता है कि यह ऑनलाइन कोशिश करो!

— प्रिंसपोलका

38

पायथन , 53 बाइट्स

f=lambda n,i=1:n*[f]and[i]+f(n-1,2*i)+i%2*f(n-1,i-~i)

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

पुनरावर्ती कार्य इस पेड़ के नीचे पूर्व-क्रम के रूप में क्रमबद्ध सूची बनाता है (उदाहरण के साथ n=4):

      1
     / \
    2   3
   /   / \
  4   6   7
 /   /   / \
8   12  14  15

1 2 4 8 3 6 12 7 14 15

बायां शाखाएं मूल्य को दोगुना करती हैं, और दाईं शाखाएं i->i*2+1केवल विषम के लिए मौजूद होती हैं i। तो, गैर-पत्तियों के लिए पूर्व-क्रम चलना है T(i)=[i]+T(i*2)+i%2*T(i*2+1)।

वृक्ष गहराई पर समाप्त होता है n, जहां nइनपुट है। यह nप्रत्येक चरण के साथ घटाकर और 0 होने पर रुककर प्राप्त किया जाता है।

एक वैकल्पिक रणनीति मानों पर समाप्त करने के लिए किया जाएगा iसे अधिक है 2**n, बल्कि ट्रैकिंग गहराई से। मैंने पाया कि यह एक बाइट से अधिक लंबा है:

f=lambda n,i=1:2**n/i*[f]and[i]+f(n,2*i)+i%2*f(n,i-~i)
f=lambda n,i=1:[f][i>>n:]and[i]+f(n,2*i)+i%2*f(n,i-~i)

— XNOR
स्रोत

4

वाह। न केवल यह एक बहुत अच्छा / चालाक चाल है, बल्कि यह बहुत प्रभावी है। +1, वास्तव में अच्छा जवाब!

— DJMcMayhem

2

[f]एक मनोरंजक स्पर्श है, यह नहीं कह सकते कि मैं पहले देखा है।

— FryAmTheEggman

18

जेली , 6 बाइट्स

Ḷ2*ẆS€

यह काल्पनिक बोनस के लिए योग्य है ।

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

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

Ḷ2*ẆS€  Main link. Argument: n

Ḷ       Unlength; yield [0, ..., n-1].
 2*     Yield [2**0, ..., 2**(n-1)].
   Ẇ    Sliding window; yield all subarrays of consecutive elements.
        The subarrays are sorted by length, then from left to right.
    S€  Map the sum atom over the substrings.

— डेनिस
स्रोत

1

Ẇइस चुनौती के लिए एक आदर्श बिल्ट-इन है, और इसे लागू किया गया है ताकि परिणाम इस चुनौती के लिए सही क्रम में हों। अच्छी तरह से किया :-)

— ETHproductions

क्या यह 12 बाइट्स (कम से कम UTF-8 में) नहीं है?

— गैरेथ

1

@ गैरेथ हां, लेकिन जेली एक एकल बाइट चरित्र सेट का भी समर्थन करती है , जिसमें केवल 256 प्रतीक हैं जो इसे समझता है।

— डेनिस

9

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

Join@@Table[2^j(2^i-1),{i,#},{j,0,#-i}]&

वांछित सूची में प्रत्येक संख्या 2 की दो शक्तियों का अंतर है, इसलिए हम बस उन्हें उपयोग करने के लिए उत्पन्न करते हैं Tableऔर फिर सूची को समतल करते हैं। मुझे लगता है कि यह स्टीवी ग्रिफिन के काल्पनिक बोनस की कमाई है :)

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

Tr/@Rest@Subsequences[2^Range@#/2]&

डेनिस की जेली एल्गोरिथ्म का एक बंदरगाह । मैं Subsequencesइस से पहले नहीं जानता था ! (मैंने यह भी नहीं देखा कि मीलों ने इस सटीक उत्तर को पोस्ट किया था ... इसे बढ़ाएं!)

— ग्रेग मार्टिन
स्रोत

1

नोट: यह समाधान @GileMartin के संपादन से 5 घंटे पहले @mile के Mathematica कोड के समान है । हालाँकि, प्रति मेटा सहमति के अनुसार , यह उत्तर अभी भी मान्य है।

— जंगहवां मिन

ऊ, मैंने यह नहीं देखा - इसे इंगित करने के लिए धन्यवाद।

— ग्रेग मार्टिन

8

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

for(q=prompt(n=1);p=q--;n-=~n)for(m=n;p--;m*=2)alert(m)

एक पूरा कार्यक्रम जो एक संकेत के माध्यम से इनपुट लेता है और उत्तराधिकार में प्रत्येक नंबर को सचेत करता है। यह काल्पनिक बोनस के लिए भी योग्य है ।

टेस्ट स्निपेट

(नोट: console.logइसके बजाय उपयोग करता है alert)

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

for(q=prompt(n=1);p=q--;n-=~n)for(m=n;p--;m*=2)console.log(m)

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

सुझाव ("अब और पॉपअप न दिखाएं" जांचने के बाद): टेस्ट स्निपेट के लिए कंसोल.लॉग में बदलें।

— तेजस काले

@TejasKale अच्छा विचार, धन्यवाद!

— ETHproductions

7

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

पूर्णांक की एक अलग-अलग सूची लौटाता है।

n=>(F=k=>k>>n?--j?F(k>>j|1):'':k+' '+F(k*2))(1,j=n)

काल्पनिक बोनस के अनुकूल।

प्रारूपित और टिप्पणी की गई

n => (                    // main function, takes n as input
  F = k =>                // recursive function, takes k as input
    k >> n ?              // if k is greater or equal to 1 << n:
      --j ?               //   decrement j ; if j is > 0:
        F(k >> j | 1)     //     do a recursive call with an additional bit set
      :                   //   else
        ''                //     stop recursion
    :                     // else
      k + ' ' + F(k * 2)  //   append k to output and do a recursive call with k * 2
  )(1, j = n)             // start the recursion with k = 1 and j = n

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

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

let f =

n=>(F=k=>k>>n?--j?F(k>>j|1):'':k+' '+F(k*2))(1,j=n)

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(8))
console.log(f(17))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

6

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

^{-3 बाइट्स डेनिस की बदौलत}

n=2**input()
j=i=1
while j<n:
 print i;i*=2
 if i/n:i=j=2*j+1

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

— छड़ी
स्रोत

6

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

Tr/@Rest@Subsequences[2^Range@#/2]&

— मील की दूरी पर
स्रोत

5

पायथन 2 , 65 63 58 बाइट्स

lambda n:[(2<<k/n)-1<<k%n for k in range(n*n)if k/n+k%n<n]

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

— डेनिस
स्रोत

1

मैंने उस सूत्र के साथ आने में अभी एक घंटा बिताया है (2<<i)-1<<j... और आपने पहले ही इसका पता लगा लिया है। अच्छा काम! इसके अलावा, डबल रेंज से छुटकारा पाने में अच्छी नौकरी

— TheNumberOne

5

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

f n=[2^b-2^(b-a)|a<-[1..n],b<-[a..n]]

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

— XNOR
स्रोत

4

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

f n=[1..n]>>= \b->take(n-b+1)$iterate(2*)$2^b-1

प्रयोग उदाहरण: f 4-> [1,2,4,8,3,6,12,7,14,15]। इसे ऑनलाइन आज़माएं! ।

यह कैसे काम करता है: प्रत्येक संख्या bके लिए [1..n], इसके साथ शुरू करें 2^b-1और बार-बार मूल्य को दोगुना करें और n-b+1इस सूची से तत्व लें ।

— nimi
स्रोत

4

05AB1E , 6 बाइट्स

L<oŒéO

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

डेनिस 'जेली उत्तर में दिखाए गए के अनुसार सबलिस्ट-सम ट्रिक का उपयोग करता है

L       # range [1 ... input]
 <      # decrement each
  o     # raise 2 to each power
   Œ    # get all sublists
    é   # sort by length
     O  # sum

— Emigna
स्रोत

4

ग्रूवी, 90 89 बाइट्स

{(0..<2**it).collect{0.toBinaryString(it)}.sort{it.count("1")}.collect{0.parseInt(it,2)}}

द्विआधारी रूपांतरण ग्रूवी में इतना गूंगा है।

-1 गुरुपद ममदापुर को धन्यवाद

— जादू ऑक्टोपस Urn
स्रोत

3

28 बाइट्स बाइनरी रूपांतरण बॉयलरप्लेट, इतना दर्दनाक।

— मैजिक ऑक्टोपस Urn

1

{(1..<2**it)...एक बाइट बचाता है।

— गुरुपाद ममदापुर

3

पायथ, 7 बाइट्स

sM.:^L2

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

डेनिस के एल्गोरिथ्म का उपयोग करता है।

— PurkkaKoodari
स्रोत

3

बैश + यूनिक्स उपयोगिताओं, 51 बाइट्स

dc<<<2i`seq -f%.f $[10**$1-1]|grep ^1*0*$|sort -r`f

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

इनपुट n को एक तर्क में पारित किया गया है।

N या कम अंकों वाले सभी नंबरों को प्रिंट करने के लिए seq का उपयोग करें। (ये बेस -10 नंबर हैं, इसलिए यहां बहुत सारी अतिरिक्त संख्याएं हैं। यह बेकार और समय लेने वाली है, लेकिन यह एक मंच गोल्फ है!)

Grep के लिए कॉल केवल उन संख्याओं को रखता है जो 1s के ठीक बाद में 0s से मिलकर बनता है।

फिर क्रमबद्ध -r का उपयोग करके इनको उल्टे क्रमबद्ध क्रम में क्रमबद्ध करें।

अंत में, dc को 2 इनपुट बेस पर सेट किया गया है - यह एक स्टैक पर सॉर्ट किए गए नंबरों को धकेलता है और फिर स्टैक को ऊपर से नीचे तक प्रिंट करता है। (यह अंतिम आइटम को पहले धकेलता है, आदि, यही वजह है कि मैं सिर्फ सॉर्ट के बजाय सॉर्ट-आर का उपयोग कर रहा हूं।)

बग को ठीक किया गया: मैंने विकल्प -f% .f को seq में छोड़ दिया था, जो 2000000 से पूर्णांक गणना के लिए आवश्यक है। (यह इंगित करने के लिए @TobySpeight का धन्यवाद कि कोई समस्या थी।)

— मिशेल स्पेक्टर
स्रोत

" व्यर्थ और समय लेने वाली " ... और चतुर ! इसके लिए धन्यवाद - गोल्फिंग करते समय कम्प्यूटेशनल दक्षता को जानबूझकर अनदेखा करना एक अच्छा अनुस्मारक है। यह वास्तव में कठिन है जब आप अपने बाकी दिनों को तेज और स्पष्ट कोड लिखने में खर्च करते हैं ...

— टोबे स्पीट

कुछ मान गायब हैं: dc<<<2i`seq $[10**7-1]|grep ^1*0*$|sort -r`f | wc -केवल 12 मानों की रिपोर्ट करता है। मुझे लगता है कि आप grep ^1[01]*$इसके बजाय चाहते हैं।

— स्पाइट

@TobySpeight धन्यवाद - एक बग था, जिसे मैंने ठीक कर लिया है। समस्या रेगेक्स के साथ नहीं थी; मुद्दा यह था कि seq को एक विकल्प की आवश्यकता थी। (मुझे यकीन नहीं है कि आप केवल 12 आउटपुट मान क्यों प्राप्त कर रहे थे - भले ही गलत संस्करण ने 21 आउटपुट मानों को सही 28 तक पहुंचाया। यदि आप इसे टीआईओ पर चला रहे थे, तो यह टीआईओ की 1 मिनट की समय सीमा से अधिक हो सकता है। ।) मैंने इसे अब लिनक्स और ओएस एक्स दोनों पर परीक्षण किया है।

— मिशेल स्पेक्टर

1

असल में, मैंने सवाल को गलत समझा - महत्वपूर्ण शब्द "लगातार" वहां किसी तरह सीधे मेरे अतीत में चला गया!

— टोबे स्पाइट

2

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

{0,1}~Tuples~#~SortBy~Count@1/.n:{a=0...,1..,a}:>Print@Fold[#+##&,n]&

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

— जंगवान मिन
स्रोत

2

पर्ल 6 , 38 बाइट्स

->\n{map {|(2**$_-1 X+<0..n-$_)},1..n}

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

->\n{                                }  # A lambda with argument n.
                                 1..n   # Numbers from 1 to n.
     map {                     },       # Replace each one with a list:
            2**$_-1                     #   2 to that power minus 1,
                    X+<                 #   bit-shifted to the left by each element of
                       0..n-$_          #   the range from 0 to n minus the number.
          |(                  )         #   Slip the list into the outer list.

यानी यह संख्याओं का निर्माण इस प्रकार करता है:

1 2 4 8 = (2^1)-1 bit-shifted to the left by 0 1 2 3 places
3 6 12  = (2^2)-1 bit-shifted to the left by 0 1 2   places
7 14    = (2^3)-1 bit-shifted to the left by 0 1     places
15      = (2^4)-1 bit-shifted to the left by 0       places     ← n rows
             ↑                                     ↑
             n                                     n-1

कोड:

पर्ल 6 , 44 बाइट्स

->\n{map {|(2**$_-1,* *2...^*>2**n-1)},1..n}

इससे पहले कि मैं (वास्तव में सरल) बिट-शिफ्ट समाधान के बारे में सोचने से पहले यह मेरा पहला दृष्टिकोण था।

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

->\n{                                      }  # A lambda with argument n.
                                       1..n   # Numbers from 1 to n.
     map {                           }        # Replace each one with:
            2**$_-1                              # 2 to that power minus 1,
                   ,* *2                         # followed by the result of doubling it,
                        ...^                     # repeated until (but not including)
                            *>2**n-1             # it's larger than 2^n-1.
          |(                        )            # Slip the list into the outer list.

यानी यह संख्याओं का निर्माण इस प्रकार करता है:

1 2 4 8 = (2^1)-1, times 2, times 2, times 2
3 6 12  = (2^2)-1, times 2, times 2
7 14    = (2^3)-1, times 2
15      = (2^4)-1                                ← n rows
             ↑                       ↑
             n                       as many columns as possible in
                                     each row without exceeding (2^n)-1

— SMLS
स्रोत

2

हास्केल 59 46 बाइट्स

मैंने साथ शुरू किया f n=[0..n]>>= \b->take(n-b).iterate(*2).sum.map(2^)$[0..b]

ऊपर से निम्मी के उत्तर से अंतर्दृष्टि प्राप्त हुई जिसे sum.map(2^)$[0..x]नीचे संक्षेपित किया जा सकता है2^x-1

के साथ समाप्त हो रहा है

e n=[1..n]>>= \x->map(\y->2^y*(2^x-1))[0..n-x]

[1..n] - लगातार बिट की संख्या के साथ सूची जिसे हम `के माध्यम से चक्रित करना चाहते हैं

>> = - सूची में प्रत्येक तत्व के लिए बाईं ओर अनुवादित किया गया है जो इसे दाईं ओर फ़ंक्शन में पास करता है और सभी परिणामों को संक्षिप्त करता है

\ x -> - एक तर्क के साथ लंबोदर फ़ंक्शन की घोषणा

नक्शा xy - सूची y के सभी सदस्यों के लिए फ़ंक्शन x लागू करता है

हमारे मामले में x = (\ y-> 2 ^ y * (2 ^ x-1)) - एक और लंबो फंक्शन 2 ^ y * (2 ^ x-1))। यह सूत्र द्विआधारी में एक शून्य से दाएं जोड़कर गुणा से उत्पन्न होता है (उदाहरण 0001 से 0010)। 2 ^ x - 1 बिट्स की संख्या है जिसके साथ हम काम कर रहे हैं। तो 11 के लिए हमारे पास 2 ^ 0 * 3 (यानी बिल्कुल भी शिफ्ट नहीं) == 0011, फिर 2 ^ 1 * 3 = 0110 तो 2 ^ 2 * 3 - 1100।

[0..nx] कितनी बार हम बिट्स शिफ्ट कर सकते हैं की सूची बनाता है। यदि हम एक एकल के साथ काम कर रहे हैं तो 0001 को देखते हुए हम 3 बार (4-1) शिफ्ट करना चाहते हैं। अगर हम दो 11 काम कर रहे हैं तो हम 4-2 और इसी तरह चाहते हैं।

— ब्रांडर
स्रोत

2

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

नोट: यह स्वतंत्र रूप से ओवन्स और डेनिस के समाधानों से बना था, भले ही यह दोनों के लिए बहुत समान हो।

lambda n:[(2<<i)-1<<j for i in range(n)for j in range(n-i)]

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

for i in range(n)for j in range(n-i)  # Iterate over number of ones, then number of places
                                      # shifted over. i = ones, j = shifts

(2<<i)                                # Create a one followed by i zeroes
      -1                              # Subtract one from above to get i ones.
        <<j                           # Shift j places.

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

टिप्स (कोडिंग और कैश दोनों) का हमेशा स्वागत है!

— नंबर एक
स्रोत

2

जाप , 11 बाइट्स

o@o!²ãXÄ mx

इसे ऑनलाइन टेस्ट करें!

व्याख्या

यह बहुत ज्यादा @ डेनिस के दृष्टिकोण का उपयोग करता है:

o@ o!²  ãXÄ  mx
oX{o!p2 ãX+1 mx}
                  // Implicit: U = input integer
oX{            }  // Create the range [0...U) and map each item X by this function:
   o              //   Create the range [0...U)
    !p2           //     and map each item Z to 2.p(Z); that is, 2**Z.
                  //     (p2 would map each item Z to Z.p(2); ! reverses the arguments.)
        ãX+1      //   Get all overlapping slices of length X + 1.
             mx   //   Map each of these slices Z through Z.x(); that is, sum each slice.
                  // Implicit: output result of last expression

— ETHproductions
स्रोत

2

पायथन , 61 59 बाइट्स

lambda n:[2**-~i-1<<j for i in range(n)for j in range(n-i)]

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

— OVS
स्रोत

2

PHP, 59 56 53 बाइट्स

for(;$p>($k*=2)?:($p=1<<$argn)>$k=$i+=$i+1;)echo$k,_;

STDIN से इनपुट लेता है; साथ चलाना -R।

टूट - फूट

for(;$p>($k*=2)         // 3. inner loop: shift-0 $k while $k<$p (false in first iteration)
    ?:
    ($p=1<<$argvn)      // 1. init $p=2^N, outer loop:
    >$k=$i+=$i+1        // 2. shift-1 $i while $i<$p, init $k to new $i
;)
    echo$k,_;           // 4. print $k

— टाइटस
स्रोत

आप $argnबहुत अच्छे विचार का उपयोग कर सकते हैं । इस सवाल को पढ़ने के बाद मेरे सिर में 200 से अधिक बाइट्स के साथ एक समाधान है

— Jörg Hülsermann

@ JörgHülsermann ने मुझे STDIN की याद दिलाने के लिए धन्यवाद दिया। मुझे सिर्फ लूप्स मिलाना पसंद है।

— टाइटस

1

जे , 19 बाइट्स

(0-.~&,>:+/\2&^)@i.

यह @ डेनिस के समाधान में उसी विधि का उपयोग करता है ।

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

व्याख्या

(0-.~&,>:+/\2&^)@i.  Input: integer n
                 i.  Range [0, 1, ..., n-1]
(              )@    Operate on that range
            2&^        Compute 2^x for each x in that range
       >:              Increment each in that range
           \           For each overlapping sublist of size (previous) in powers of 2
         +/              Reduce by addition
 0                     The constant 0
     &,                Flatten each
  -.~                  Remove zeroes

— मील की दूरी पर
स्रोत

1

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

a=int(input())
print(*[int('1'*-~b,2)<<c for b in range(a)for c in range(a-b)],sep=', ')

पूर्ण कार्यक्रम, अल्पविराम + स्पेस अलग आउटपुट के साथ, जैसा कि निर्दिष्ट है।

स्पष्टीकरण:

स्टार अंकन सूचियों को अनपैक करता है। तो print(*[1,2,3])जैसा है वैसा ही है print(1,2,3)। int()कंस्ट्रक्टर को लगातार 1 'की स्ट्रिंग पास करें ।

-~bका मूल्यांकन करता है b+1, लेकिन स्ट्रिंग को गुणा करते समय आपको इसे कोष्ठक के साथ घेरना नहीं पड़ता है।

उत्पादित पूर्णांक को कई बार बढ़ती संख्या में बिट्सफ़्ट करें। print()वैकल्पिक सेप तर्क है, स्ट्रिंग को एक अनपैक सूची में प्रत्येक आइटम के बीच रखने के लिए निर्दिष्ट करता है।

— mypetlion
स्रोत

2

आप सूची को प्रिंट कर सकते हैं। आउटपुट स्वरूप इतना सख्त नहीं है।

— mbomb007

1

जावा 7, 108 बाइट्स

static void x(int i){int a=0,t=1<<i,b;while((a=(a<<1)+1)<t){b=a;do System.out.println(b);while((b<<=1)<t);}}

जब तक परिणाम छोटा होता है, तब तक प्रारंभिक मूल्य को दोगुना कर देता है 2^n। बाद में, होने के लिए प्रारंभिक मूल्य को अपडेट करता है (initial_value * 2) + 1और वहां से फिर से शुरू होता है जब तक यह अंततः नहीं पहुंचता (2^n)-1।

उदाहरण के लिए n=4:

0001 -> init
0010
0100
1000
return, double init and add one
0011 -> init
0110
1100
return, double init and add one
0111 -> init
1110
return, double init and add one
1111 -> init
done

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

— QBrute
स्रोत

1

रूबी, 50 बाइट्स

->r{1.upto(r){|x|p a=2**x-1;p a while(a*=2)<2**r}}

मैंने कुछ "चतुर" तरीकों की कोशिश की, लेकिन यह सबसे छोटा प्रतीत होता है (निर्देशों का अक्षरशः पालन करें)

स्पष्टीकरण:

प्रत्येक पुनरावृत्ति 2 ^ n-1 से शुरू होती है और ऊपरी सीमा तक पहुंचने तक 2 से गुणा करती है। कुछ भी नहीं फैंसी, बस बुनियादी गणित।

— जीबी
स्रोत

1

QBIC , 37 बाइट्स - काल्पनिक बोनस = अभी भी 37 बाइट्स ...

:[a|e=2^b-1┘while e<2^a┘?e┘e=e*2┘wend

शर्म की बात है मैंने while-wendQBIC में अभी तक निर्माण नहीं किया है ... स्पष्टीकरण:

:       Get N from the command line
[a|     For b = 1 to N; The sequence is reset N times
e=2^b-1 Set the first number of this sub-sequence (yields 1, 3, 7, 15 ...)
┘       Line-break - syntactic separation of commands because there's no command for WHILE yet.
while   Pure QBasic code - lower-case is not (really) interpreted by QBIC
e<2^a   Continue as long as we don't exceed the maximum value
┘?e     Print the number in the sequence
┘e=e*2  Double the number
┘wend   And loop as long as we're not exceeding maximum, reset the sequence otherwise.
        FOR loop auto-closed by QBIC

संपादित करें: QBIC के लिए अब समर्थन है WHILE:

:[a|e=2^b-1≈e<2^a|?e┘e=e*2

यह केवल 26 बाइट्स है! यहाँ है WHILE:

≈e<2^a|          ≈ = WHILE, and the TRUE condition is everything up to the |
       ...       Loop code goes here
          ]      Close construct: adds a WEND instruction
                 In the program above, this is done implicitly because of EOF.

— steenbergh
स्रोत

1

MATL, 19 18 बाइट्स

1 बाईट ने @Luis को धन्यवाद दिया

:q2w^XJfP"J@YC2&sv

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

— Suever
स्रोत

1

@LuisMendo बहुत चतुर! धन्यवाद

— Suever

1

आर , 69 48 46 बाइट्स

n=scan();for(i in 1:n)print((2^i-1)*2^(i:n-i))

i in 1..nबाइनरी सिस्टम में लोगों की संगत प्रत्येक दशमलव संख्या को दो (1, 2, 4, ...) की 2^(0..n-i)पहली n-i+1शक्तियों से गुणा किया जाता है ।

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

— रॉबर्ट हैकेन
स्रोत

1

स्टैक्स , 9 बाइट्स

übg▓}╥é►╪

भागो और डिबग ऑनलाइन!

व्याख्या

बेसिन रूपांतरण के किसी भी रूप में (सादे पुराने गणित का उपयोग करके) अगर कोई ऐसा करता है तो काल्पनिक बोनस।

वैसे, यहाँ कोई आधार रूपांतरण नहीं हैं।

समझाने के लिए अनपैक्ड संस्करण (10 बाइट्स) का उपयोग करता है।

m|2vx_-DQH
m             For input=`n`, loop over `1..n`
 |2v          Power of two minus one
    x_-D      Do `n-j` times, where `j` is the current 1-based loop index
        Q     Output the current value
         H    And double it

— वीजुन झोउ
स्रोत

0

बैच, 92 - 0 = 92 बाइट्स

@for /l %%i in (1,1,%1)do @for /l %%j in (%%i,1,%1)do @cmd/cset/a"(1<<%%i)-1<<%%j-%%i"&echo(

@ StewieGriffin के काल्पनिक बोनस के लिए 0 घटाना।

— नील
स्रोत

2 ^ n-1 तक आउटपुट संख्या, "सॉर्ट किया गया"

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

पायथन , 53 बाइट्स

जेली , 6 बाइट्स

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

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

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

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

टेस्ट स्निपेट

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

प्रारूपित और टिप्पणी की गई

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

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

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

पायथन 2 , 65 63 58 बाइट्स

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

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

05AB1E , 6 बाइट्स

ग्रूवी, 90 89 बाइट्स

पायथ, 7 बाइट्स

बैश + यूनिक्स उपयोगिताओं, 51 बाइट्स

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

पर्ल 6 , 38 बाइट्स

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

पर्ल 6 , 44 बाइट्स

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

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

जाप , 11 बाइट्स

व्याख्या

पायथन , 61 59 बाइट्स

PHP, 59 56 53 बाइट्स

जे , 19 बाइट्स

व्याख्या

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

जावा 7, 108 बाइट्स

रूबी, 50 बाइट्स

स्पष्टीकरण:

QBIC , 37 बाइट्स - काल्पनिक बोनस = अभी भी 37 बाइट्स ...

MATL, 19 18 बाइट्स

आर , 69 48 46 बाइट्स

स्टैक्स , 9 बाइट्स

व्याख्या

बैच, 92 - 0 = 92 बाइट्स