12

अस्वीकरण

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

चुनौती

दो पूर्णांकों को देखते हुए Xऔर Y, क्रमशः शून्य ( 0) और लोगों ( 1) की संख्या का प्रतिनिधित्व करते हुए, सभी संभावित दशमलव समकक्षों की गणना करें जो केवल शून्य और प्रदान किए गए लोगों का उपयोग करके बाइनरी स्ट्रिंग्स बनाने से निर्धारित किया जा सकता है, और उन्हें आउटपुट के रूप में प्रदर्शित कर सकता है।

उदाहरण 1:

इनपुट: 0 1

आउटपुट: 1

स्पष्टीकरण: केवल एक के 1लिए खाता है, जिसे केवल एक ही तरीके से परिवर्तित किया जा सकता है।

उदाहरण 2:

इनपुट: 1 1

आउटपुट: 1,2

स्पष्टीकरण: 011 में 10कनवर्ट करता है, 2 में कनवर्ट करता है।

उदाहरण 3:

इनपुट: 3 2

आउटपुट: 3,5,6,9,10,12,17,18,20,24

स्पष्टीकरण: तीन 0एस और दो 1एस मेक 00011(3), 00101(5), 00110(6), 01001(9), 01010(10), 01100(12), 10001(17), 10010(18), 10100(20), 11000(24)

सीमाएँ और नियम

मैं केवल आपके कोड से काम करने की उम्मीद करूंगा, जहां 0 < X + Y <= 16आउटपुट में अधिकतम संख्या केवल 16 1एस यानी पैरामीटर 0और 16।
उपरोक्त सीमा के परिणामस्वरूप, हम आउटपुट में अपेक्षित संख्याओं की सीमा से 0और 65535।
मैं फ़ंक्शन या कोड को स्वीकार करूंगा, इसलिए जब तक कि परिणामी आउटपुट प्रदान नहीं किया जाता है, चाहे यह अल्पविराम से अलग की गई सूची हो, एक सरणी, STDOUT के लिए आउटपुट की गई सूची, आदि। आउटपुट के बारे में मेरे पास एकमात्र मापदंड यह होना चाहिए कि इसे क्रमबद्ध किया जाना चाहिए।
यह कोड गोल्फ है, न्यूनतम बाइट्स को अधिकतम महिमा मिलेगी।
हम मूर्खतापूर्ण खामियों को बर्दाश्त नहीं करेंगे

code-golf binary

— WallyWest
स्रोत

1

क्या आउटपुट को छाँटना पड़ता है?

— डेनिस

हाय @ डेनिस, हाँ, मैं यह उल्लेख करना भूल गया कि ... आउटपुट को क्रमबद्ध किया जाना चाहिए। मैंने नियमानुसार अपडेट किया है।

— वैलीवेस्ट

2

क्या हमें मामले को संभालने की जरूरत है 0 0?

— ETHproductions

@ETHproductions मैंने ऊपर उल्लेख किया है 0 <= X + Y <= 16, इसलिए हाँ, क्योंकि 0 0वैध इनपुट माना जाएगा जो उस नियम को पूरा करता है।

— वैलेस्टेस्ट

2

उस स्थिति में, अपेक्षित आउटपुट क्या है 0 0? संख्या 0 को शून्य, एक या अधिक शून्य द्वारा दर्शाया जा सकता है।

— डेनिस

5

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

0,1xŒ!ḄQ

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

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

0,1xŒ!ḄQ Main link. Argument: [x, y]

0,1x     Repeat 0 x times and 1 y times.
    Œ!   Compute all permutations of the result.
      Ḅ   Unbinary; convert each permutation from base 2 to integer.
       Q  Unique; deduplicate the results.

— डेनिस
स्रोत

यह काफी प्रभावशाली है ... क्या सामान्य प्रोग्रामिंग बाजार में जे के लिए बहुत कॉल है? मैंने देखा कि जेली इस पर आधारित है?

— 1

1

इसका कुछ विशिष्ट अनुप्रयोगों (ज्यादातर गणित / सांख्यिकी) में एक उपयोगकर्ता आधार है, लेकिन मुझे ईमानदारी से पता नहीं है। मैंने कोड गोल्फ के बाहर J का उपयोग नहीं किया है।

— डेनिस

@WallyWest इसे अक्सर नहीं कहा जाता है क्योंकि यह एक ऐसे वातावरण के लिए सबसे उपयुक्त है जो कार्यात्मक प्रोग्रामिंग से लाभान्वित होगा। आमतौर पर केवल बहुत विशिष्ट प्रोग्रामिंग के लिए।

— कॉनर ओ'ब्रायन

7

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

lambda x,y:[n for n in range(1<<x+y)if bin(n).count('1')==y]

Ideone पर इसका परीक्षण करें ।

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

सभी सकारात्मक संख्याएं जो बाइनरी में एक्स जीरो और वाई के साथ दर्शायी जा सकती हैं, स्पष्ट रूप से 2 ^{x + y} से छोटी हैं , क्योंकि उत्तरार्द्ध के विहित द्विआधारी प्रतिनिधित्व में x + y + 1 अंक हैं।

लैम्ब्डा बस में पूर्णांक से अधिक iterates [0, 2 ^{x + y} ) और सभी पूर्णांकों रहता n उस श्रेणी में है कि y वाले। चूँकि n <2 ^{x + y} को x (या कम) शून्य से दर्शाया जा सकता है ।

— डेनिस
स्रोत

5

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

मैथेमेटिका के साथ एक सामान्य परिणाम: उच्च-स्तरीय फ़ंक्शन = अच्छा, लंबे फ़ंक्शन नाम = खराब।

#+##&~Fold~#&/@Permutations@Join[0&~Array~#,1&~Array~#2]&

Join[0&~Array~#,1&~Array~#2]0s और 1s की सही संख्या के साथ एक सूची बनाता है । Permutationsबिना पुनरावृत्ति (जैसा कि मैंने सीखा) और क्रमबद्ध क्रम में, उस सूची के सभी क्रमचय उत्पन्न करता है। #+##&~Fold~#(एक गोल्फ संस्करण #~FromDigits~2) का प्रतिनिधित्व करते हुए पूर्णांक में आधार -2 अंकों की एक सूची को परिवर्तित करता है।

मार्टिन एंडर की टिप्पणी से पहले पिछला संस्करण:

#~FromDigits~2&/@Permutations@Join[0&~Array~#,1&~Array~#2]&

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

1

फिर भी, अच्छी तरह से देखा और प्रलेखित ... गणितज्ञ संख्या की

— कमी के

1

FromDigitsआमतौर पर छोटा किया जा सकता है:#+##&~Fold~#&/@Permutations...

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

@MartinEnder: मुझे मिल गया! और देखें कि कैसे अन्य ठिकानों पर भी सामान्यीकरण किया जाए। मुझे इस चतुर मुहावरे को सिखाने के लिए धन्यवाद।

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

1

इसके साथ आने का श्रेय एलेफाल्फा को जाता है । ;)

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

1

यह पता चला है कि डेनिस के दृष्टिकोण पर स्विच करना हालांकि कम है:Select[Range[2^+##]-1,x=#;DigitCount[#,2,1]==x&]&

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

5

CJam ( 15 14 बाइट्स)

{As.*s:~e!2fb}

यह एक अनाम ब्लॉक (फ़ंक्शन) है जो एक सरणी के रूप में इनपुट लेता है [number-of-ones number-of-zeros]और एक सरणी के रूप में आउटपुट देता है।

ऑनलाइन डेमो

निशान से एक लंबा रास्ता, लेकिन अधिक दिलचस्प : यह बिना परमिट के निर्माण या आधार रूपांतरण है:

{2\f#~1$*:X;[({___~)&_2$+@1$^4/@/|_X<}g;]}

यह एक गोल्फस्क्रिप्ट के रूप में अच्छी तरह से काम करेगा।

— पीटर टेलर
स्रोत

मैं बदलने के लिए कोशिश कर रहा था ee{)*}/कुछ का उपयोग कर के साथ .*है और इस 14-बाइट समाधान के साथ आया था: अब हालांकि थोड़ा अक्षम लग रहा है। {As.*s:~e!2fb}s:~

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

1

@MartinEnder, मैंने वास्तव में शुरुआत की थी .*और निर्णय लिया eeथा कि उदाहरण के लिए अच्छे थे 2,:a.*e_। मुझे एहसास नहीं था कि e!इसके तर्क के आदेश की परवाह किए बिना वही आउटपुट देगा।

— पीटर टेलर

हाँ, मैंने केवल दूसरे दिन ही इसकी खोज की थी।

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

4

जाप , 16 बाइट्स

'0pU +'1pV)á mn2

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

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

                  // Implicit: U = first integer, V = second integer
'0pU              // Repeat the string "0" U times.
     +'1pV)       // Concatenate with the string "1" repeated V times.
           á      // Take all unique permutations.
             mn2  // Interpret each item in the resulting array as a binary number.
                  // Implicit: output last expression

वैकल्पिक संस्करण, 17 बाइट्स

2pU+V o f_¤è'1 ¥V
                   // Implicit: U = first integer, V = second integer
2pU+V              // Take 2 to the power of U + V.
      o            // Create the range [0, 2^(U+V)).
        f_         // Filter to only items where
           è'1     //  the number of "1"s in
          ¤        //  its binary representation
               ¥V  //  is equal to V. 
                   // Implicit: output last expression

मैं दोनों संस्करणों को आगे बढ़ाने की कोशिश कर रहा हूं, लेकिन मुझे अभी कोई सुस्ती नहीं मिली ...

— ETHproductions
स्रोत

यह अद्भुत लग रहा है ... और यह बहुत अच्छा काम करता है! दुभाषिया सही पर ट्रांसप्लड कोड नहीं दिखा रहा है, हालांकि? मुझे यह देखना अच्छा लगेगा कि यह कैसे प्रस्तुत करता है?

— वैलीवेस्ट

@WallyWest यह लगभग ट्रांसपाइल्स ("0".p(U)+"1".p(V)).á().m("n",2); प्रत्येक .x()कार्य स्रोत फ़ाइल में परिभाषित किया गया है ।

— ETHproductions

3

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

एक साधारण कार्यान्वयन। गोल्फ सुझाव का स्वागत करते हैं।

->a,b{(?0*a+?1*b).chars.permutation.map{|b|(b*'').to_i 2}.uniq}

Ungolfing

def f(a,b)
  str = "0"*a+"1"*b                   # make the string of 0s and 1s
  all_perms = str.chars.permutation   # generate all permutations of the 0s and 1s
  result = []
  all_perms.do each |bin|             # map over all of the permutations
    bin = bin * ''                    # join bin together
    result << bin.to_i(2)             # convert to decimal and append
  end
  return result.uniq                  # uniquify the result and return
end

— Sherlock9
स्रोत

3

पायथ - 11 बाइट्स

{iR2.psmVU2

टेस्ट सूट ।

{                Uniquify
 iR2             Map i2, which converts from binary to decimal
  .p             All permutations
   s             Concatenate list
    mV           Vectorized map, which in this case is repeat
     U2          0, 1
     (Q)         Implicit input

— Maltysen
स्रोत

2

पायथन 2 - 105 99 बाइट्स

+8 बाइट्स हमारे आउटपुट को सॉर्ट करने की जरूरत है

lambda x,y:sorted(set(int("".join(z),2)for z in __import__('itertools').permutations("0"*x+"1"*y)))

— जेरेमी
स्रोत

प्रभावशाली संपादन!

— 1

1

धन्यवाद, मुझे नहीं पता था कि आप लंबोदा फ़ंक्शन में मॉड्यूल आयात कर सकते हैं।

— जेरेमी

मुझे हमेशा लगता था कि आपको कोड गोल्फ के प्रयोजनों के लिए एक अलग आयात विवरण की अनुमति है। (जाहिर है आपको अभी भी इसकी लंबाई को शामिल करने की आवश्यकता है।) यह आपको एक बाइट या दो बचा सकता है?

— नील

2

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

Cases[Range[2^+##]-1,x_/;DigitCount[x,2,1]==#]&

एक अनाम फ़ंक्शन दो तर्क ले रहा है: 1s की संख्या, 0s की संख्या ।

अनिवार्य रूप से डेनिस के पायथन समाधान का एक बंदरगाह । हम से एक श्रृंखला बनाने 0के लिए और उसके बाद ही उन संख्याओं की राशि के रख -bits पहला इनपुट बराबर होती है। सबसे दिलचस्प बिट शायद वह है जो दो तर्कों के अलावा चारों ओर कोष्ठक से बचने के लिए कुछ अनुक्रम जादू का उपयोग करता है।2^x+y-112^+##

— मार्टिन एंडर
स्रोत

2

MATLAB 57 + 6

@(a,b)unique(perms([ones(1,a) zeros(1,b)])*2.^(0:a+b-1)')

का उपयोग कर चलाएं

ans(2,3)

ungolfed

function decimalPerms( nZeros, nOnes )
  a = [ones(1,nOnes) zeros(1,nZeros)];  % make 1 by n array of ones and zeros
  a = perms(a);                         % get permutations of the above 
  powOfTwo = 2.^(0:nOnes+nZeros-1)';    % powers of two as vector
  a = a * powOfTwo;                     % matrix multiply to get the possible values
  a = unique(a)                         % select the unique values and print

— रिचर्ड
स्रोत

1

प्लस 6 बाइट्स के लिए क्या है?

— mbomb007

मैं यही बात पूछने वाला था

— वैलीवेस्ट

2

MATL , 9 बाइट्स

y+:<Y@XBu

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

व्याख्या

यह दृष्टिकोण डेनिस जेली के उत्तर के समान है ।

y     % Implicitly take two inputs (say 3, 2). Duplicate the first.
      %   STACK: 3, 2, 3
+     % Add
      %   STACK: 3, 5
:     % Range
      %   STACK: 3, [1 2 3 4 5]
<     % Less  than
      %   STACK: [0 0 0 1 1]
Y@    % All permutations
      %   STACK: [0 0 0 1 1; 0 0 0 1 1; ...; 0 0 1 0 1; ...; 1 1 0 0 0]
XB    % Binary to decimal
      %   STACK: [3 3 ... 5 ... 24]
u     % Unique
      %   STACK: [3 5 ... 24]
      % Implicitly display

— लुइस मेंडो
स्रोत

1

दरअसल, 21 बाइट्स

मेरे रूबी जवाब का एक बंदरगाह । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

│+)'1*@'0*+╨`εj2@¿`M╔

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

          Implicit input of a and b.
│+)       Duplicate a and b, add, and rotate to bottom of stack. Stack: [b a a+b]
'1*@      "1" times b and swap with a.
'0*+      "0" times a and add to get "0"*a+"1"*b.
╨`...`M   Take all the (a+b)-length permutations of "0"*a+"1"*b
          and map the following function over them.
  εj        Join the permutation into one string
  2@¿       Convert from binary to decimal
╔         Uniquify the resulting list and implicit return.

— Sherlock9
स्रोत

1

ग्रूवी 74 बाइट्स, 93 बाइट्स या 123 बाइट्स

मुझे नहीं पता कि आप किस पर विचार करते हैं और पूरी तरह से प्रश्न का उत्तर देते हैं लेकिन ...

74 बाइट समाधान

{a,b->((1..a).collect{0}+(1..b).collect{1}).permutations().unique()}(1,2)

1,2 के इनपुट के लिए:

[[1,0,1], [0,1,1], [1,1,0]]

93 बाइट समाधान

{a,b->((1..a).collect{0}+(1..b).collect{1}).permutations().collect{it.join()}.unique()}(1,2)

1,2 के इनपुट के लिए:

[101, 011, 110]

123 बाइट समाधान

{a,b->((1..a).collect{0}+(1..b).collect{1}).permutations().collect{it.join()}.unique().collect{Integer.parseInt(it,2)}}(1,2)

1,2 के इनपुट के लिए:

[5, 3, 6]

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

https://groovyconsole.appspot.com/edit/5143619413475328

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

मैं 123 बाइट समाधान की गिनती करूंगा क्योंकि यह संक्षिप्त में उल्लिखित आउटपुट प्रकार से मेल खाता है। बहुत बढ़िया।

— १

1

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 48), 85 76 74 71 70 बाइट्स

3 बाइट्स @Neil की बदौलत सहेजे गए।

(m,n,g=x=>x?g(x>>1)-x%2:n)=>[for(i of Array(1<<m+n).keys())if(!g(i))i]

एरियर की समझ जबरदस्त है। बहुत बुरा वे इसे अभी तक आधिकारिक ECMAScript कल्पना में नहीं बनाया है।

जावास्क्रिप्ट (ईएस 6), 109 87 79 78 71 70 बाइट्स

(m,n,g=x=>x?g(x>>1)-x%2:n)=>[...Array(1<<m+n).keys()].filter(x=>!g(x))

अब सभी ईएस 6-अनुरूप ब्राउज़रों में काम करना चाहिए। इस पर 7 बाइट्स बचाए, @Neil को भी धन्यवाद।

— ETHproductions
स्रोत

उह, @ETHProductions, किसी कारण से मैं इसे undefinedअब हर टेस्ट रन के साथ वापस कर रहा हूं जो मैं कर रहा हूं ...?

— वॉलीवेस्ट

@ निश्चित रूप से सुनिश्चित करें कि आप पहले इसे एक चर में निर्दिष्ट कर रहे हैं, जैसे f=(m,n)=>... , फिर इसे कॉल करें f(3,2)। यदि आप ऐसा कर रहे हैं, तो आप किस ब्राउज़र का उपयोग कर रहे हैं?

— ETHproductions

Chrome 52 ... मेरे पास इस मशीन पर फ़ायरफ़ॉक्स नहीं है, इसलिए मैं केवल ES6 गैर-फ़ायरफ़ॉक्स संस्करण का परीक्षण कर सकता हूं ...

— WallyWest

इसे ब्राउज़र के कंसोल को चलाने की कोशिश कर रहा है।

— वॉलीवेस्ट

ओह, हम्म। मुझे वह समस्या क्रोम में भी दिख रही है। इस-रहित evalसंस्करण को आज़माएं (बिल्कुल वैसा ही काम करता है, लेकिन 3 बाइट्स लंबे समय तक):(m,n)=>{a="";for(i=0;i<1<<m+n;i++)if(i.toString(2).split(1).length==n+1)a+=i+" ";return a}

— ETHproductions

1

ग्रूवी 80 बाइट्स

@carusocomputing द्वारा उत्तर के आधार पर

उनके 123 बाइट समाधान को 80 बाइट्स में संपीड़ित किया जा सकता है:

80 बाइट समाधान

{a,b->([0]*a+[1]*b).permutations()*.join().collect{Integer.parseInt(it,2)}}(1,2)

1,2 के इनपुट के लिए:

[5, 3, 6]

— norganos
स्रोत

1

सी (जीसीसी) , 72 68 बाइट्स

f(a,b){for(a=1<<a+b;a--;)__builtin_popcount(a)^b||printf("%d\n",a);}

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

दुर्भाग्य से मानक पुस्तकालय में कोई पॉपकाउंट () नहीं है, लेकिन इसे जीसीसी द्वारा "बिल्टइन फ़ंक्शन" के रूप में प्रदान किया गया है। आउटपुट सॉर्ट किया गया है, लेकिन रिवर्स ऑर्डर में।

4 बाइट शेविंग के लिए @ceilingcat को धन्यवाद!

— जी। स्लीपेन
स्रोत

फिर भी स्वीकार्य है। अच्छा काम!

— 10

0

PHP, 80 या 63 बाइट्स

पर मौसम मैं का उपयोग करना चाहिए निर्भर करता है $argvया उपयोग कर सकते हैं $xऔर $yबजाय।

for($i=1<<array_sum($argv);$i--;)echo$argv[2]-substr_count(decbin($i),1)?_:$i._;

अवरोही क्रम में सभी मिलान संख्या को अंडरस्कोर करके सीमांकित किया जाता है।
फ़ाइल नाम एक अंक से शुरू नहीं होना चाहिए।

कोई भी निर्माण नहीं, 88 या 71 बाइट्स

for($i=1<<array_sum($argv);$i--;print$c?_:$i._)for($n=$i,$c=$argv[2];$n;$n>>=1)$c-=$n&1;

हर नंबर के बाद केवल एक अंडरस्कोर के लिए एक-एक बाइट जोड़ें।

@WallyWest: आप सही थे। से मेरे लिए 3 बाइट्स बचाता हैfor($i=-1;++$i<...;)

— टाइटस
स्रोत

0

पर्ल 6 , 64 62 49 बाइट्स

{(0 x$^a~1 x$^b).comb.permutations.map({:2(.join)}).sort.squish}

{[~](0,1 Zx@_).comb.permutations.map({:2(.join)}).sort.squish}

{(^2**($^x+$^y)).grep:{.base(2).comb('1')==$y}}

स्पष्टीकरण:

# bare block lambda with two placeholder parameters ｢$^x｣ and ｢$^y｣
{
  # Range of possible values
  # from 0 up to and excluding 2 to the power of $x+$y
  ( ^ 2 ** ( $^x + $^y ) )

  # find only those which
  .grep:

  # bare block lambda with implicit parameter of ｢$_｣
  {

    # convert to base 2
    # ( implicit method call on ｢$_｣ )
    .base(2)

    # get a list of 1s
    .comb('1')

    # is the number of elements the same
    ==

    # as the second argument to the outer block
    $y
  }
}

say {(0..2**($^x+$^y)).grep:{.base(2).comb('1')==$y}}(3,2)
# (3 5 6 9 10 12 17 18 20 24)

— ब्रैड गिल्बर्ट b2gills
स्रोत

दशमलव के लिए सभी बाइनरी संयोजन

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

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

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

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

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

CJam ( 15 14 बाइट्स)

जाप , 16 बाइट्स

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

वैकल्पिक संस्करण, 17 बाइट्स

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

पायथ - 11 बाइट्स

पायथन 2 - 105 99 बाइट्स

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

MATLAB 57 + 6

MATL , 9 बाइट्स

व्याख्या

दरअसल, 21 बाइट्स

ग्रूवी 74 बाइट्स, 93 बाइट्स या 123 बाइट्स

74 बाइट समाधान

93 बाइट समाधान

123 बाइट समाधान

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 48), 85 76 74 71 70 बाइट्स

जावास्क्रिप्ट (ईएस 6), 109 87 79 78 71 70 बाइट्स

ग्रूवी 80 बाइट्स

80 बाइट समाधान

सी (जीसीसी) , 72 68 बाइट्स

PHP, 80 या 63 बाइट्स

पर्ल 6 , 64 62 49 बाइट्स

स्पष्टीकरण: