Avertissement

Cette question n'est pas un double de cette question . Je ne compte pas les chiffres spécifiques, car nous avons déjà ceux définis dans les paramètres initiaux. Cette question se concentre sur les nombres décimaux qui peuvent être construits à partir des chaînes binaires en fonction des chiffres fournis.

Défi

Étant donné deux nombres entiers Xet Y, représentant respectivement le nombre de zéros ( 0) et de uns ( 1), calculez tous les équivalents décimaux possibles qui peuvent être déterminés à partir de la création de chaînes binaires en utilisant uniquement les zéros et les uns fournis, et affichez-les en sortie.

Exemple 1:

Contribution: 0 1

Production: 1

Explication: Un seul 1compte, qui ne peut être converti que dans un sens.

Exemple 2:

Contribution: 1 1

Production: 1,2

Explication: 01convertit en 1, 10convertit en 2.

Exemple 3:

Contribution: 3 2

Production: 3,5,6,9,10,12,17,18,20,24

Explication: trois 0s et deux 1s font 00011(3), 00101(5), 00110(6), 01001(9), 01010(10), 01100(12), 10001(17), 10010(18), 10100(20), 11000(24)

Limitations et règles

• Je m'attendrai seulement à ce que votre code fonctionne là où 0 < X + Y <= 16le nombre maximum dans la sortie ne peut se produire qu'à partir de 16 1s, c'est-à-dire les paramètres 0et 16.
• En raison de la limitation ci-dessus, la plage de nombres attendue dans la sortie provient de 0et 65535.
• J'accepterai des fonctions ou du code, tant que la sortie résultante est fournie, que ce soit une liste séparée par des virgules, un tableau, une liste sortie vers STDOUT, etc. Le seul critère que je dois souligner à propos de la sortie est qu'elle doit être triée.
• Ceci est du golf de code, les octets minimum recevront le maximum de gloire.
• Nous ne tolérerons pas de failles idiotes

Gelée , 8 octets

0,1xŒ!ḄQ

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Testez-le sur Ideone .

Comment ça fonctionne

Tous les nombres positifs qui peuvent être représentés en binaire avec x zéros et y uns sont clairement inférieurs à 2 ^{x + y} , car la représentation binaire canonique de ce dernier a x + y + 1 chiffres.

Le lambda itère simplement sur les entiers dans [0, 2 ^{x + y} ) et conserve tous les entiers n dans cette plage qui ont y ceux. Puisque n <2 ^{x + y} est peut être représenté avec x (ou moins) zéros.

Mathematica, 59 57 octets

Un résultat habituel avec Mathematica: fonctions de haut niveau = bonnes, noms de fonctions longues = mauvaises.

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

Join[0&~Array~#,1&~Array~#2]crée une liste avec le nombre correct de 0s et 1s. Permutationsgénère toutes les permutations de cette liste, sans répétitions (comme je l'ai appris) et dans l'ordre trié. #+##&~Fold~#(une version golfée de #~FromDigits~2) convertit une liste de chiffres de base 2 en l'entier qu'ils représentent.

Version précédente, avant le commentaire de Martin Ender:

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

CJam ( 15 14 octets)

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

Il s'agit d'un bloc anonyme (fonction) qui prend l'entrée en tant que tableau [number-of-ones number-of-zeros]et renvoie la sortie en tant que tableau.

Démo en ligne

Loin de là , mais plus intéressant : c'est sans permutation intégrée ni conversion de base:

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

Cela fonctionnerait bien pendant le déroulement d'un GolfScript.

Japt , 16 octets

'0pU +'1pV)á mn2

Testez-le en ligne!

Comment ça fonctionne

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

Version alternative, 17 octets

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

J'ai essayé de jouer au golf sur les deux versions, mais je ne trouve tout simplement aucun jeu ...

Rubis, 63 octets

Une implémentation simple. Suggestions de golf bienvenues.

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

{iR2.psmVU2

Suite de tests .

{                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 octets

+8 octets car notre sortie doit être triée

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

Mathematica, 47 octets

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

Une fonction sans nom prenant deux arguments: nombre de 1s, nombre de 0s.

Essentiellement un portage de la solution Python de Dennis . Nous créons une plage de 0à puis ne conservons que les nombres dont la quantité de bits correspond à la première entrée. Le bit le plus intéressant est probablement celui qui utilise une certaine magie de séquence pour éviter les parenthèses autour de l'ajout des deux arguments.2x+y-112^+##

MATLAB 57 + 6

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

courir en utilisant

ans(2,3)

non golfé

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 octets

y+:<Y@XBu

Essayez-le en ligne!

Explication

L'approche est similaire à celle de la réponse de 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

En fait, 21 octets

Un portage de ma réponse Ruby . Suggestions de golf bienvenues. Essayez-le en ligne!

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

Comment ça fonctionne

          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 octets, 93 octets ou 123 octets

Je ne sais pas lequel vous considérez le mieux répond à la question mais ...

Solution de 74 octets

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

Pour une entrée de 1,2, vous obtenez:

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

Solution de 93 octets

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

Pour une entrée de 1,2, vous obtenez:

[101, 011, 110]

Solution de 123 octets

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

Pour une entrée de 1,2, vous obtenez:

[5, 3, 6]

Essayez-le ici:

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

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

Enregistré 3 octets grâce à @Neil.

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

La compréhension des tableaux est impressionnante. Dommage qu'ils n'aient pas encore fait partie des spécifications officielles d'ECMAScript.

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

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

Devrait fonctionner dans tous les navigateurs compatibles ES6 maintenant. 7 octets enregistrés sur celui-ci, également grâce à @Neil.

Groovy 80 octets

basé sur la réponse de @carusocomputing

sa solution de 123 octets peut être compressée en 80 octets:

Solution de 80 octets

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

Pour une entrée de 1,2, vous obtenez:

[5, 3, 6]

C (gcc) , 72 68 octets

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

Essayez-le en ligne!

Malheureusement, il n'y a pas de popcount () dans la bibliothèque standard, mais il est fourni comme "fonction intégrée" par GCC. La sortie est triée, mais dans l'ordre inverse.

Merci à @ceilingcat d'avoir rasé 4 octets!

PHP, 80 ou 63 octets

selon si je dois utiliser $argvou peut utiliser $xet à la $yplace.

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

imprime tous les nombres correspondants dans l'ordre décroissant délimité par des traits de soulignement.
le nom de fichier ne doit pas commencer par un chiffre.

pas de builtins, 88 ou 71 octets

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

ajoutez un octet chacun pour un seul trait de soulignement après chaque numéro.

@WallyWest: Vous aviez raison. Économise 3 octets pour moifor($i=-1;++$i<...;)

Perl 6 ,  64 62  49 octets

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

Explication:

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