คำปฏิเสธ

คำถามนี้ไม่ซ้ำกับคำถามนี้ ฉันไม่ได้นับตัวเลขเฉพาะเนื่องจากเรามีการตั้งค่าเหล่านั้นไว้ในพารามิเตอร์เริ่มต้นแล้ว คำถามนี้มุ่งเน้นไปที่ตัวเลขทศนิยมที่สามารถสร้างได้จากสตริงไบนารีตามตัวเลขที่ให้ไว้

ท้าทาย

กำหนดจำนวนเต็มสองจำนวนXและYแสดงจำนวนศูนย์ ( 0) และคน ( 1) ตามลำดับคำนวณจำนวนเทียบเท่าทศนิยมที่เป็นไปได้ทั้งหมดที่สามารถกำหนดได้จากการสร้างสตริงไบนารีโดยใช้เฉพาะเลขศูนย์และคนที่ให้และแสดงเป็นเอาท์พุท

ตัวอย่างที่ 1:

การป้อนข้อมูล: 0 1

เอาท์พุท: 1

คำอธิบาย: มีเพียง1บัญชีเดียวเท่านั้นที่สามารถทำการแปลงได้ทางเดียวเท่านั้น

ตัวอย่างที่ 2:

การป้อนข้อมูล: 1 1

เอาท์พุท: 1,2

คำอธิบาย: 01แปลงเป็น 1, 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), 18 10100(20), 11000(24)

ข้อ จำกัด และกฎ

• ฉันเท่านั้นที่จะคาดหวังว่ารหัสของคุณในการทำงานที่0 < X + Y <= 16ดังนั้นจำนวนสูงสุดในการส่งออกเพียงอย่างเดียวอาจเกิดขึ้นตั้งแต่วันที่ 16 1s พารามิเตอร์เช่นและ016
• อันเป็นผลมาจากข้อ จำกัด ข้างต้นช่วงของตัวเลขที่เราคาดหวังในการส่งออกจากและ065535
• ฉันจะรับฟังก์ชั่นหรือรหัสตราบใดที่มีการส่งออกผลลัพธ์ไม่ว่าจะเป็นรายการที่คั่นด้วยเครื่องหมายจุลภาค, อาร์เรย์, รายการที่ส่งออกไปยัง STDOUT เป็นต้นเกณฑ์เดียวที่ฉันต้องเน้นเกี่ยวกับผลลัพธ์คือต้องเรียงลำดับ
• นี่คือโค้ดกอล์ฟไบต์ต่ำสุดจะได้รับเกียรติสูงสุด
• เราจะไม่ยอมให้ช่องโหว่โง่ ๆ

เยลลี่ 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.

Python ขนาด 60 ไบต์

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

ทดสอบบนIdeone

มันทำงานอย่างไร

ตัวเลขบวกทั้งหมดที่สามารถแสดงในไบนารีด้วยx zeroes และyนั้นมีขนาดเล็กกว่า2 ^{x + y}อย่างชัดเจนเนื่องจากการแสดงไบนารีแบบบัญญัติของผู้หลังมีx + y + 1หลัก

แลมบ์ดาเพียง iterates กว่าจำนวนเต็มใน[0, 2 ^{x + Y} )และช่วยให้ทุกจำนวนเต็มnอยู่ในช่วงที่มีYคน ตั้งแต่n <2 ^{x + y ที่}จะสามารถแทนด้วยx (หรือน้อย) เลขศูนย์

Mathematica, 59 57 ไบต์

ผลลัพธ์ตามปกติด้วย Mathematica: ฟังก์ชันระดับสูง = ดีชื่อฟังก์ชันยาว = ไม่ดี

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

Join[0&~Array~#,1&~Array~#2]สร้างรายการที่มีจำนวน0s และ1s ที่ถูกต้อง Permutationsสร้างการเรียงสับเปลี่ยนทั้งหมดของรายการนั้นโดยไม่มีการทำซ้ำ (ตามที่ฉันเรียนรู้) และเรียงตามลำดับ #+##&~Fold~#(รุ่น golfuscated ของ#~FromDigits~2) แปลงรายการของตัวเลขฐาน 2 เป็นจำนวนเต็มพวกเขาเป็นตัวแทน

รุ่นก่อนหน้าก่อนที่ความคิดเห็นของ Martin Ender:

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

CJam ( 15 14 ไบต์)

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

นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชัน) ซึ่งรับอินพุตเป็นอาร์เรย์[number-of-ones number-of-zeros]และส่งคืนเอาต์พุตเป็นอาร์เรย์

การสาธิตออนไลน์

ทางที่ไกลออกไปจากเครื่องหมาย แต่น่าสนใจกว่า : นี่คือไม่มีการเปลี่ยนแปลงภายในหรือการแปลงฐาน:

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

มันจะทำงานได้ดีเหมือน GolfScript คลี่

Japt , 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

ฉันพยายามต่อไปทั้งสองรุ่น แต่ฉันไม่สามารถหาข้อบกพร่องได้ ...

Ruby, 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

Pyth - 11 ไบต์

{iR2.psmVU2

Test Suite

{                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

Python 2 - 105 99 ไบต์

+8 ไบต์เนื่องจากเอาต์พุตของเราต้องเรียงลำดับ

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

Mathematica, 47 ไบต์

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

ฟังก์ชันที่ไม่มีชื่อซึ่งรับสองอาร์กิวเมนต์: จำนวนของ1s, จำนวนของ0s

หลักพอร์ตของเดนนิสเป็นวิธีการแก้ปัญหาหลาม เราสร้างช่วงจาก0ถึงแล้วเก็บเฉพาะตัวเลขที่มีจำนวนบิตเท่ากับอินพุตแรก บิตที่น่าสนใจที่สุดน่าจะเป็นซึ่งใช้เวทย์มนตร์ลำดับต่อเนื่องเพื่อหลีกเลี่ยงวงเล็บในการเพิ่มอาร์กิวเมนต์ทั้งสอง2x+y-112^+##

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

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

ที่จริงแล้ว 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.

Groovy 74 Bytes, 93 Bytes หรือ 123 Bytes

ฉันไม่รู้ว่าคุณคิดว่าจะตอบคำถามนี้แบบไหน แต่ ...

โซลูชัน 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 Byte Solution

{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

JavaScript (Firefox 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 อย่างเป็นทางการ

JavaScript (ES6), 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))

ควรทำงานกับเบราว์เซอร์ที่สอดคล้องกับ ES6 ทั้งหมดในขณะนี้ บันทึกแล้ว 7 ไบต์บนอันนี้ต้องขอบคุณ @Neil

Groovy 80 Bytes

ตามคำตอบโดย @carusocomputing

โซลูชัน 123 Byte ของเขาสามารถบีบอัดเป็น 80 Bytes:

80 Byte Solution

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

สำหรับการป้อนข้อมูล 1,2 คุณจะได้รับ:

[5, 3, 6]

C (gcc) , 72 68 ไบต์

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

ลองออนไลน์!

น่าเสียดายที่ไม่มี popcount () ในไลบรารีมาตรฐาน แต่มีให้เป็น "ฟังก์ชัน builtin" โดย GCC เอาต์พุตถูกเรียงลำดับ แต่เรียงกลับกัน

ขอบคุณ @ceilingcat สำหรับการกำจัด 4 ไบต์!

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

Perl 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)