기권

이 질문의 중복없는 이 질문에 . 초기 매개 변수에 이미 설정된 숫자가 있으므로 특정 숫자를 세지 않습니다. 이 질문은 제공된 숫자를 기준으로 이진 문자열로 구성 할 수있는 10 진수에 중점을 둡니다.

도전

주어 두 정수 X와 Y, 제로의 개수를 나타내는 ( 0)과 1 ( 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

설명 : 3 0과 2 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.

파이썬, 60 바이트

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

Ideone에서 테스트하십시오 .

작동 원리

x 0과 y 1 로 2 진수로 표현할 수있는 모든 양수 는 2 ^{x + y} 보다 분명히 작습니다 . 후자의 표준 이진 표현에는 x + y + 1 자리 가 있기 때문 입니다.

람다는 단순히 [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

두 가지 버전 모두 더 골프를 시도했지만 슬랙을 찾을 수 없습니다 ...

루비, 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

파이썬 2-105 99 바이트

+8 바이트이므로 출력을 정렬해야합니다.

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

수학, 47 바이트

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

명명되지 않은 함수는 1s의 수, s의 두 인수 를 사용 0합니다.

본질적으로 Dennis의 Python 솔루션 포트입니다 . 우리의 범위 생성 0에를 그 양의 그 숫자 계속 다음과 -bits 첫 번째 입력과 동일합니다. 가장 흥미로운 비트는 아마도 두 개의 인수를 추가하는 괄호를 피하기 위해 일부 시퀀스 매직 을 사용 하는 것입니다.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 바이트

내 루비 답변 의 포트 . 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

│+)'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.

그루비 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

자바 스크립트 (Firefox 48), 85 76 74 71 70 bytes

@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 사양으로 만들지 못했습니다.

자바 스크립트 (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 호환 브라우저에서 작동합니다. @Neil 덕분에 이것에 7 바이트를 절약했습니다.

그루비 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에 의해 "내장 함수"로 제공됩니다. 출력은 정렬되지만 역순으로 정렬됩니다.

4 바이트를 줄인 @ceilingcat에게 감사드립니다!

PHP, 80 또는 63 바이트

내가 사용합니다 어떠했는지에 따라 $argv또는 사용 $x하고 $y대신.

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

밑줄로 구분 된 모든 일치하는 숫자를 내림차순으로 인쇄합니다.
filename은 숫자로 시작해서는 안됩니다.

내장되지 않은 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<...;)

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