免责声明

这个问题不是这个问题的重复。我没有在计算特定数字，因为我们已经在初始参数中设置了这些数字。这个问题集中在可以根据提供的数字从二进制字符串构造的十进制数。

挑战

给定两个整数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），10100（20），11000（24）

限制和规则

• 我只希望您的代码能在0 < X + Y <= 16这样的地方工作，所以输出中的最大数量只能从16 1秒开始，即参数0和16。
• 由于上述限制，我们期望输出中的数字范围是0和65535。
• 我将接受功能或代码，所以只要提供所得到的输出，这是否是一个逗号分隔的列表，阵列，输出到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个零和y个二进制表示的所有正数明显小于2 ^{x + y}，因为后者的规范二进制表示具有x + y +1个数字。

Lambda只是迭代[0，2 ^{x + y}）中的整数，并将所有具有y的整数n保持在该范围内。由于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~#（的高尔夫球版本#~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}

开球

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

测试套件。

{                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字节cos我们的输出需要排序

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。

本质上是Dennis的Python解决方案的一部分。我们创建从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)

不打高尔夫球

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

在线尝试！

说明

该方法类似于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

其实是21个位元组

我的Ruby答案的端口。欢迎打高尔夫球。在线尝试！

│+)'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字节，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

JavaScript（Firefox 48），85 76 74 71 70字节

@Neil节省了3个字节。

(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字节

基于@carusocomputing的答案

他的123字节解决方案可以压缩为80字节：

80字节解决方案

{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（），但是它是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)