Khước từ

Câu hỏi này không phải là một bản sao của câu hỏi này . Tôi không tính các chữ số cụ thể, vì chúng ta đã có những chữ số được đặt trong các tham số ban đầu. Câu hỏi này đang tập trung vào các số thập phân có thể được xây dựng từ các chuỗi nhị phân dựa trên các chữ số được cung cấp.

Thử thách

Cho hai số nguyên Xvà Y, tương ứng với số lượng số 0 ( 0) và số nguyên ( 1), tính tất cả các số tương đương thập phân có thể có thể được xác định từ việc tạo các chuỗi nhị phân chỉ sử dụng các số 0 và số được cung cấp và hiển thị chúng dưới dạng đầu ra.

Ví dụ 1:

Đầu vào: 0 1

Đầu ra: 1

Giải thích: Chỉ có một 1tài khoản, chỉ có thể được chuyển đổi một chiều.

Ví dụ 2:

Đầu vào: 1 1

Đầu ra: 1,2

Giải thích: 01chuyển đổi thành 1, 10chuyển đổi thành 2.

Ví dụ 3:

Đầu vào: 3 2

Đầu ra: 3,5,6,9,10,12,17,18,20,24

Giải thích: Ba 0 s và hai 1s tạo 00011(3), 00101(5), 00110(6), 01001(9), 01010(10), 01100(12), 10001(17), 10010(18), 10100(20), 11000(24)

Hạn chế và quy tắc

• Tôi sẽ chỉ mong mã của bạn hoạt động khi 0 < X + Y <= 16số lượng tối đa trong đầu ra chỉ có thể xảy ra từ 16 1giây, tức là các tham số 0và 16.
• Do giới hạn trên, phạm vi số mà chúng tôi mong đợi ở đầu ra là từ 0và 65535.
• Tôi sẽ chấp nhận các hàm hoặc mã, miễn là đầu ra kết quả được cung cấp, cho dù đây là danh sách được phân tách bằng dấu phẩy, một mảng, danh sách được xuất ra STDOUT, v.v. Các tiêu chí duy nhất tôi phải nhấn mạnh về đầu ra là nó phải được sắp xếp.
• Đây là mã golf, byte tối thiểu sẽ nhận được vinh quang tối đa.
• Chúng tôi sẽ không chịu đựng những sơ hở ngớ ngẩn

Thạch , 8 byte

0,1xŒ!ḄQ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Tất cả các số dương có thể được biểu diễn dưới dạng nhị phân với x số 0 và y rõ ràng nhỏ hơn 2 ^{x + y} , vì biểu diễn nhị phân chính tắc của số sau có x + y + 1 chữ số.

Lambda chỉ đơn giản lặp lại các số nguyên trong [0, 2 ^{x + y} ) và giữ tất cả các số nguyên n trong phạm vi đó có y . Kể từ khi n <2 ^{x + y} là có thể được biểu diễn với x (hoặc ít hơn) zero.

Toán học, 59 57 byte

Một kết quả thông thường với Mathicala: các hàm cấp cao = tốt, tên hàm dài = xấu.

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

Join[0&~Array~#,1&~Array~#2]tạo một danh sách với số 0s và 1s chính xác . Permutationstạo ra tất cả các hoán vị của danh sách đó, không lặp lại (như tôi đã học) và theo thứ tự sắp xếp. #+##&~Fold~#(một phiên bản golfuscated #~FromDigits~2) chuyển đổi một danh sách các chữ số cơ sở 2 thành số nguyên mà chúng đại diện.

Phiên bản trước, trước bình luận của Martin Ender:

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

CJam ( 15 14 byte)

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

Đây là một khối ẩn danh (hàm) lấy đầu vào là một mảng [number-of-ones number-of-zeros]và trả về đầu ra dưới dạng một mảng.

Bản demo trực tuyến

Một chặng đường dài, nhưng thú vị hơn : điều này không có nội dung hoán vị hoặc chuyển đổi cơ sở:

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

Nó sẽ hoạt động độc đáo khi một GolfScript mở ra.

Japt , 16 byte

'0pU +'1pV)á mn2

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

                  // 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

Phiên bản thay thế, 17 byte

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

Tôi đã cố gắng chơi gôn cả hai phiên bản, nhưng tôi không thể tìm thấy bất kỳ sự chậm chạp nào ...

Ruby, 63 byte

Một cách thực hiện đơn giản. Gợi ý chơi golf chào mừng.

->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 byte

{iR2.psmVU2

Phòng thử nghiệm .

{                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

Con trăn 2 - 105 99 byte

+8 byte cos đầu ra của chúng tôi cần được sắp xếp

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

Toán học, 47 byte

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

Một hàm không tên lấy hai đối số: số 1s, số 0s.

Về cơ bản là một cổng của giải pháp Python của Dennis . Chúng tôi tạo một phạm vi từ 0đến và sau đó chỉ giữ lại những số có số lượng bitcoin bằng với đầu vào đầu tiên. Điều thú vị nhất có lẽ là việc sử dụng một số phép thuật chuỗi để tránh các dấu ngoặc đơn xung quanh việc thêm hai đối số.2x+y-112^+##

MATLAB 57 + 6

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

chạy bằng

ans(2,3)

vô dụng

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 byte

y+:<Y@XBu

Hãy thử trực tuyến!

Giải trình

Cách tiếp cận tương tự như trong câu trả lời của Dennis 'Jelly .

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

Trên thực tế, 21 byte

Một cổng câu trả lời Ruby của tôi . Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

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

Làm thế nào nó hoạt động

          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 Byte, 93 Byte hoặc 123 Byte

Tôi không biết người nào bạn xem xét trả lời đầy đủ hơn câu hỏi nhưng ...

Giải pháp 74 byte

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

Đối với đầu vào 1,2 bạn nhận được:

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

Giải pháp 93 byte

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

Đối với đầu vào 1,2 bạn nhận được:

[101, 011, 110]

Giải pháp 123 byte

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

Đối với đầu vào 1,2 bạn nhận được:

[5, 3, 6]

Dùng thử tại đây:

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

JavaScript (Firefox 48), 85 76 74 71 70 byte

Đã lưu 3 byte nhờ @Neil.

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

Hiểu mảng là tuyệt vời. Quá tệ, họ chưa đưa nó vào thông số ECMAScript chính thức.

JavaScript (ES6), 109 87 79 78 71 70 byte

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

Nên hoạt động trong tất cả các trình duyệt tuân thủ ES6. Đã lưu 7 byte trên cái này, cũng nhờ @Neil.

Groovy 80 byte

dựa trên câu trả lời của @carusocomputing

giải pháp 123 Byte của anh ta có thể được nén thành 80 Byte:

Giải pháp 80 byte

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

Đối với đầu vào 1,2 bạn nhận được:

[5, 3, 6]

C (gcc) , 72 68 byte

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

Hãy thử trực tuyến!

Thật không may, không có popcount () trong thư viện chuẩn, nhưng nó được cung cấp dưới dạng "hàm dựng sẵn" của GCC. Đầu ra được sắp xếp, nhưng theo thứ tự ngược lại.

Cảm ơn @ceilingcat đã cạo sạch 4 byte!

PHP, 80 hoặc 63 byte

tùy thuộc vào thời tiết tôi phải sử dụng $argvhoặc có thể sử dụng $xvà $ythay vào đó.

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

in tất cả các số phù hợp theo thứ tự giảm dần được phân định bởi dấu gạch dưới.
tên tệp không được bắt đầu bằng một chữ số.

không có nội dung, 88 hoặc 71 byte

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

thêm một byte cho mỗi chỉ một dấu gạch dưới sau mỗi số.

@WallyWest: Bạn đã đúng. Lưu 3 byte cho tôi từfor($i=-1;++$i<...;)

Perl 6 ,  64 62  49 byte

{(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}}

Giải trình:

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