POPCORN क्रम में 0 से 2 ^ n - 1 तक

Question

... आह क्षमा करें, यहाँ कोई पॉपकॉर्न नहीं है, बस POPCNT है।

सबसे छोटे प्रोग्राम या फ़ंक्शन को लिखें जो संख्याओं में लेता है nऔर संख्याओं के द्विआधारी प्रतिनिधित्व (पॉपकाउंट) में 1 बिट्स की संख्या के आरोही क्रम में सभी पूर्णांकों को 0 से 2 ^एन - 1 तक आउटपुट करता है । कोई डुप्लिकेट की अनुमति नहीं है।

समान पॉपकाउंट वाली संख्याओं का क्रम कार्यान्वयन-परिभाषित है।

उदाहरण के लिए, n = 3इन सभी आउटपुट मान्य हैं:

0, 1, 2, 4, 3, 5, 6, 7
[0, 4, 1, 2, 5, 3, 6, 7]
0 4 2 1 6 5 3 7 

इनपुट और आउटपुट प्रारूप कार्यान्वयन-परिभाषित है जो कोड को आगे बढ़ाने के लिए भाषा सुविधाओं के उपयोग की अनुमति देता है। आउटपुट पर कुछ प्रतिबंध हैं:

• दशमलव प्रारूप में संख्याओं का आउटपुट होना चाहिए।

• आउटपुट में संख्याओं के बीच एक उचित विभाजक होना चाहिए (अनुगामी विभाजक अनुमत है, लेकिन अग्रणी नहीं है)।

  लाइन फ़ीड ( \n), टैब ( \t), अंतरिक्ष, ,, ., ;, |, -, _, /काफी उचित विभाजक हैं। मैं सुंदर मुद्रण के लिए अतिरिक्त स्थान नहीं रखता, लेकिन विभाजक के रूप में अक्षर या अंकों का उपयोग नहीं करता।

• संख्या और विभाजक से घिरा हो सकता है [ ], { }या किसी भी सरणी या सूची संकेतन।
• ऊपर बताई गई किसी और चीज़ को न छापें।

बक्शीश

यदि आपका समाधान मक्खी पर संख्या उत्पन्न कर सकता है, तो अपने स्कोर को 0.5 से गुणा करें । इस बोनस की भावना यह है कि यदि आप सीधे अपने मुद्रण समाधान को एक जनरेटर में परिवर्तित करते हैं, तो जनरेटर केवल सबसे अधिक O (n) मेमोरी का उपयोग करता है जहां n ऊपर बिट्स की संख्या है जैसा कि ऊपर परिभाषित किया गया है। (आपको वास्तव में अपने समाधान को जनरेटर में बदलना नहीं है)। ध्यान दें कि जब मैं n <= 28 लगाता हूं, तो सभी नंबरों को स्टोर करने के लिए आवश्यक मेमोरी अभी भी तेजी से बढ़ती है, और एक भोली सॉर्टिंग समाधान n = 28 पर कम से कम 4 जीबी मेमोरी बढ़ाएगा।

कृपया इस बोनस का दावा करने से पहले यह बताएं कि आपका समाधान कैसे काम करता है।

Comments

ऐसा लगता है कि यह चुनौती काफी उबाऊ है और इसके परिणामस्वरूप उत्तर छांटने होंगे। मैं चुनौती को और दिलचस्प बनाने के लिए कुछ बोनस जोड़ना चाहूंगा। "मक्खी पर संख्या उत्पन्न करने" की रेखा के साथ कुछ। यदि आप इसके साथ ठीक हैं, तो कृपया इस टिप्पणी को बढ़ाएं, फिर मैं इसे प्रश्न में जोड़ दूंगा।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

यदि आप असहमत हैं, तो कृपया इस टिप्पणी को आगे बढ़ाएं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

कृपया सैंडबॉक्स का उपयोग किसी प्रश्न पर आगे के सुझाव के लिए पूछने से पहले करें।

— जॉन ड्वोरक

@JDDvorak: यह एक महीने के लिए सैंडबॉक्स पर था।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

मुझे लगता है कि इस सवाल के लिए बहुत देर हो चुकी है। आम तौर पर, सवाल जहां आपको गैर-तुच्छ एल्गोरिथ्म का पता लगाना पड़ता है, मेरी राय में कोड गोल्फ के लिए अच्छी तरह से अनुकूल नहीं हैं। इसके बजाय उन्हें एक कोड चुनौती दें और अपनी ज़रूरत की सभी बाधाओं को रोकें।

— फ़ूजएक्सएक्सएल

Answer 1

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

osjN2U^2Q

oद्वारा rder sआधार 2 प्रतिनिधित्व (की उम jN2) सीमा पर ( Uके) 2 ^ Q।

( Q=)eval(input()) )।

इसे यहाँ आज़माएँ।

Answer 2

पायथन 2, 75 * 0.5 = 37.5

N=2**input()-1
v=N-~N
while v:t=1+(v|~-v);v=N&t|~-(t&-t)/(v&-v)/2;print v^N

बार-बार अगला उच्चतम उत्पन्न करता है v इस बिट- ट्विडलिंग एल्गोरिथ्म द्वारा एक ही POPCOUNT के साथ है ।

दरअसल, पॉप-काउंट घटने में उन्हें उत्पन्न करना आसान हो गया, फिर इसे बढ़ाने के लिए पूरक प्रिंट करें। इस तरह, फिर vओवरफ्लो होता है 2**n, हम बस कहाँ से सभी लेकिन nबिट्स निकालते हैं&NN=2**n-1 , और यह सबसे छोटी संख्या को एक पॉपकाउंट कम देता है। इस तरह, हम सिर्फ एक लूप कर सकते हैं। शायद एक बेहतर समाधान है जो सीधे अगले निचले नंबर को उसी POPCOUNT से ढूंढता है।

एक बाड़पोस्ट मुद्दे के कारण, हमें इसके साथ शुरुआत करने की आवश्यकता है v=2**(n+1)-1 ताकि ऑपरेशन v=N-1पहले लूप पर पैदा हो ।

इसके लिए आउटपुट 4:

0
8
4
2
1
12
10
9
6
5
3
14
13
11
7
15

Comments

बढ़ती आबादी के लिए समान पॉपकॉइन के साथ संख्या की कोई आवश्यकता नहीं है। आदेश कार्यान्वयन-परिभाषित है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n @h ,a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ मैं जागरूक हूं, लेकिन मैं यह नहीं देखती कि पात्रों को अलग तरीके से करने से कैसे बचा जाए।

— xnor

एक भोली 3 छोरों विधि के साथ, मैं लगभग जेएस ( console.log()बनाम print) होने में स्कोर करता हूं । शायद बिट चाल बहुत भारी है।

— edc65

एक बाइट की बचत:v=N-~N

— Sp3000

Answer 3

जे, 19 अक्षर, कोई बोनस नहीं।

[:(/:+/"1@#:)@i.2^]

• 2 ^ y- की शक्ति को दो y।
• i. 2 ^ y- से पूर्णांकों 0के लिए (2 ^ y) - 1।
• #: i. 2 ^ y - इनमें से प्रत्येक पूर्णांक आधार दो में दर्शाया गया है।
• +/"1 #: i. 2 ^ y - प्रत्येक प्रतिनिधित्व के योग
• (i. 2 ^ y) /: +/"1 #: i. 2 ^ y- वेक्टर i. 2 ^ yपिछले वेक्टर के आइटम के क्रम से क्रमबद्ध होता है, हमारा उत्तर।

Answer 4

पायथन, 63 वर्ण

F=lambda n:`sorted(range(1<<n),key=lambda x:bin(x).count('1'))`

>>> F(3)
'[0, 1, 2, 4, 3, 5, 6, 7]'

Comments

@ एलेक्स: निहित प्रतिबंधों की सूची में वह एक स्ट्रिंग परिणाम चाहते थे।

— कीथ रान्डेल

क्षमा करें, वह याद किया।

— एलेक्स ए।

Answer 5

C 179 * 0.5 = 89.5

main(){int n,i=0,m,o;scanf("%d",&n);m=~((~0)<<n);for(;n--;++i){for(o=0;o<m;++o){int bc=0,cb=28;for(;cb--;)bc+=o&(1<<cb)?1:0;if(bc==i)printf("%d ",o);}}printf("%d\n",m);return 0;}

EDIT: 157 * 0.5 = 78.5

main(){int n,i=0,m,o;scanf("%d",&n);m=~((~0)<<n);for(++n;n--;++i){for(o=0;o<=m;++o){int bc=0,cb=28;for(;cb--;)bc+=o&(1<<cb)?1:0;if(bc==i)printf("%d ",o);}}}

EDIT: 132 * 0.5 = 66

main(){int n,i=0,m,o;scanf("%d",&n);m=~((~0)<<n);for(++n;n--;++i){for(o=0;o<=m;++o){if(__builtin_popcount(o)==i)printf("%d ",o);}}}

या थोड़ा अच्छा स्वरूपित:

main()
{
    int n, i = 0, m, o;
    scanf("%d", &n);
    m = ~((~0) << n);
    for(++n; n--; ++i)
    {
        for(o = 0; o <= m; ++o)
        {
            if (__builtin_popcount(o) == i)
                printf("%d ", o);
        }
    }
}

यह क्या करता है?

m = ~((~0) << n);

दिखाने के लिए अंतिम संख्या की गणना करता है (pow (2, n) - 1)

    for(++n; n--; ++i)
    {
        for(o = 0; o <= m; ++o)
        {

बाहरी लूप बिट गणना पर निर्भर करता है (इसलिए 0 से n-1) जबकि आंतरिक लूप केवल 0 से m तक गिना जाता है

            if (__builtin_popcount(o) == i)
                printf("%d ", o);

X86 पर POPCNT निर्देश है जिसका उपयोग सेट बिट्स को गिनने के लिए किया जा सकता है। GCC और संगत संकलक __builtin_popcount फ़ंक्शन का समर्थन कर सकते हैं जो मूल रूप से उस निर्देश का संकलन करता है।

Answer 6

सीजेएम, 13 बाइट्स

2ri#,{2b1b}$p

बहुत सीधे आगे कार्यान्वयन।

यह कैसे काम करता है :

2ri#,             "Get an array of 0 to 2^n - 1 integers, where n is the input";
     {    }$      "Sort by";
      2b1b        "Convert the number to binary, sum the digits";
            p     "Print the array";

इसे यहाँ ऑनलाइन आज़माएँ

Answer 7

गणितज्ञ, ५० ४६

SortBy[Range[0,2^#-1],Tr@IntegerDigits[#,2]&]&

।

SortBy[Range[0,2^#-1],Tr@IntegerDigits[#,2]&]&

{0, 1, 2, 4, 8, 16, 3, 5, 6, 9, 10, 12, 17, 18, 20, 
24, 7, 11, 13, 14, 19, 21, 22, 25, 26, 28, 15, 
23, 27, 29, 30, 31}

Comments

@ मार्टिनबटनर, फिक्स्ड! धन्यवाद!!!

— सेवेनकोव एलेक्सी

Answer 8

जावास्क्रिप्ट (ईएस 6) 41 (82 * 0.5)

सबसे सरल तरीका है, गोल्फ

F=b=>{
  for(l=0;l<=b;l++)
    for(i=1<<b;i;t||console.log(i))
      for(t=l,u=--i;u;--t)
        u&=u-1;
}

Ungolfed

F=b=>
{
  for (l = 0; l <= b; l++)
  {
    for (i = 1 << b; i > 0; )
    {
      --i;
      for (t = 0, u = i; u; ++t) // Counting bits set, Brian Kernighan's way
        u &= u - 1;
      if (t == l) console.log(i);
    }
  }
}

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

F(4)

0
8
4
2
1
12
10
9
6
5
3
14
13
11
7
15

Answer 9

बैश + कोरुटिल्स, 66

आपको आरंभ करने के लिए एक:

jot -w2o%dpc $[2**$1] 0|dc|tr -d 0|nl -ba -v0 -w9|sort -k2|cut -f1

Comments

यहां वास्तव में कुछ भी रोमांचक नहीं है। आपकी टिप्पणी को देखते हुए यदि आप प्रश्न बदलना चाहते हैं तो मैं इस उत्तर को खुशी से हटा दूंगा / संशोधित कर दूंगा।

— डिजिटल ट्रामा

निश्चित नहीं है कि मुझे आपके कार्यक्रम को उजागर करना चाहिए, 0 से 28 तक के सभी मूल्यों के लिए काम करना चाहिए। मुझे नहीं पता कि यहाँ कितने उत्तर उस आवश्यकता को पार करते हैं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

मैंने क्लॉज को हटा दिया है, क्योंकि लोग इसे वैसे भी नोटिस नहीं करते हैं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n @h ina̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ अब, सिद्धांत रूप में, कम से कम इसे 28 तक काम करना चाहिए। मैंने अब तक 22 परीक्षण किए हैं, लेकिन निश्चित रूप से इसमें sortलंबा समय लगता है। N = 28 के साथ, sort2 ^ 28 लाइनों / ~ 13GB डेटा को सॉर्ट करने की आवश्यकता होगी।

— डिजिटल ट्रामा

Answer 10

हास्केल, (87 * 0.5) = 43,5

f n=[0..n]>>=(\x->x#(n-x))
a#0=[2^a-1]
0#_=[0]
a#b=[1+2*x|x<-(a-1)#b]++[2*x|x<-a#(b-1)]

उपयोग उदाहरण: f 4जो आउटपुट[0,1,2,4,8,3,5,9,6,10,12,7,11,13,14,15]

यह कैसे काम करता है: [0..2 ^ n-1] पर न तो छंटाई और न ही बार-बार पुनरावृत्ति।

#सहायक कार्यों दो पैरामीटर लेता है aऔर bऔर से बना हर संख्या की एक सूची का निर्माण a1s और b0s। मुख्य फ़ंक्शन प्रत्येक संयोजन के लिए fकॉल करता #है aऔर bजहां a+bसमान होता है n, nक्रम में संख्याओं के लिए 1s और 0s के साथ शुरू होता है । हास्केल के आलस्य के लिए धन्यवाद उन सभी सूचियों का निर्माण पूरी तरह से स्मृति में नहीं होना चाहिए।

Comments

नहीं करता है ++में a#bमतलब है कि बाएं हाथ की ओर (जो बड़े हो सकता है) पूरी तरह से उत्पादन किया जा करने की जरूरत है और फिर से पहले परिणाम में पहले आइटम, उत्पादन किया जाता है इस प्रकार बोनस के लिए आवश्यकताओं का उल्लंघन करने की नकल की?

— जूल्स

आह, नहीं, इसके बारे में सोच अभी भी आलसी पैदा कर सकते हैं जबकि वे उत्पादित कर रहे हैं, यह सिर्फ प्रत्येक आइटम की एक प्रति बनाने की जरूरत है, जो प्रसंस्करण के दौरान दोनों कचरा इकट्ठा किया जा सकता है इसका मतलब है कि अंतरिक्ष उपयोग स्थिर है। मुझपर ध्यान मत दो।

— जूल्स

Answer 11

रूबी 47 चरस

अजगर की तरह @KeithRandall से एक:

f=->n{(0..1<<n).sort_by{|x|x.to_s(2).count ?1}}

Answer 12

गणितज्ञ, २६

Tr/@(2^Subsets@Range@#/2)&

उदाहरण:

Tr/@(2^Subsets@Range@#/2)&[4]

{, 1, 2, 4, 8, 3, 5, 9, 6, 10, 12, 7, 11, 13, 14, 15}

Answer 13

पर्ल, 64/2 = 32

#!perl -ln
for$i(0..$_){$i-(sprintf"%b",$_)=~y/1//||print for 0..2**$_-1}

बस [0..2^n-1] n + 1समय सीमा पर पुनरावृति । प्रत्येक पुनरावृत्ति में केवल वे संख्याएँ होती हैं जिनकी संख्या 1 बिट्स के बराबर होती है जो कि पुनरावृत्ति चर ( $i) के बराबर होती है । मतों की गिनती के द्वारा गिनती 1की जाती है (y/1// ) संख्या में साथ बाइनरी स्ट्रिंग में बदल जाती sprintf।

परीक्षा मुझे ।

पर्ल, 63

छँटाई दृष्टिकोण:

#!perl -l
print for sort{eval+(sprintf"%b-%b",$a,$b)=~y/0//dr}0..2**<>-1

Comments

@ ऑप्टिमाइज़र, यह O (1) मेमोरी का उपयोग करता है। हमारे पास और क्या परिभाषा है? उफ़, यह सच नहीं है क्योंकि मैं इसे प्रिंट करता हूं :)

— नटकी

@ ओप्टिमाइज़र, निश्चित।

— नटकी

ठीक है, मुझे इस बारे में पता है जब मैंने शर्त लगाई थी, लेकिन मैं इसे वैसे भी अनुमति देता हूं, क्योंकि मैं देखना चाहता हूं कि लोग क्या जवाब दे सकते हैं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

मैंने सिर्फ "कैसे" पूछा क्योंकि मैं पर्ल नहीं पढ़ सकता हूं :) अधिक स्पष्टीकरण जोड़ने के लिए देखभाल?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र, कुछ और स्पष्टीकरण जोड़ा।

— नटकी

Answer 14

जावा 8, 205

public class S{public static void main(String[] n){java.util.stream.IntStream.range(0,1<<Integer.parseInt(n[0])).boxed().sorted((a,b)->Integer.bitCount(a)-Integer.bitCount(b)).forEach(System.out::print);}}

Answer 15

C ++ 11, 117 वर्ण:

using namespace std;int main(){ set<pair<int,int> > s;int b;cin>>b;int i=0;while(++i<pow(2,b))s.insert({bitset<32>(i).count(),i});for (auto it:s) cout <<it.second<<endl;}

Ungolfed:

using namespace std;
int main()
{
    set<pair<int,int> > s;
    int b;
    cin>>b;
    int i=0;
    while (++i<pow(2,b))  {
        s.insert({bitset<32>(i).count(),i});
    }
    for (auto it:s) {
        cout <<it.second<<endl;
    }
}

स्पष्टीकरण:

इंट, इंट जोड़े का एक सेट बनाएं। पहला इंट बिट काउंट है, दूसरा नंबर है। जोड़े अपने पहले पैरामीटर के अनुसार खुद की तुलना करते हैं, इसलिए सेट को बिट गणना द्वारा क्रमबद्ध किया जाता है।