disconoscimento

Questa domanda non è un duplicato di questa domanda . Non sto contando cifre specifiche, poiché abbiamo già quelle impostate nei parametri iniziali. Questa domanda si concentra sui numeri decimali che possono essere costruiti dalle stringhe binarie in base alle cifre fornite.

Sfida

Dati due numeri interi Xe Y, che rappresentano rispettivamente il numero di zero ( 0) e uni ( 1), calcolano tutti i possibili equivalenti decimali che possono essere determinati dalla creazione di stringhe binarie utilizzando solo gli zero e quelli forniti e li visualizzano come output.

Esempio 1:

Ingresso: 0 1

Produzione: 1

Spiegazione: Solo uno 1di cui tenere conto, che può essere convertito solo in un modo.

Esempio 2:

Ingresso: 1 1

Produzione: 1,2

Spiegazione: 01converte in 1, 10converte in 2.

Esempio 3:

Ingresso: 3 2

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

Spiegazione: Tre 0secondi e due 1secondi 00011(3), 00101(5), 00110(6), 01001(9), 01010(10), 01100(12), 10001(17), 10010(18), 10100(20), 11000(24)

Limitazioni e regole

• Mi aspetto solo che il tuo codice funzioni dove 0 < X + Y <= 16quindi il numero massimo nell'output può avvenire solo da 16 1s, cioè parametri 0e 16.
• Come risultato della suddetta limitazione, l'intervallo di numeri che ci aspetteremmo dall'output proviene da 0e 65535.
• Accetterò funzioni o codice, purché venga fornito l'output risultante, sia che si tratti di un elenco separato da virgole, di un array, di un elenco inviato a STDOUT, ecc. L'unico criterio che devo sottolineare sull'output è che deve essere ordinato.
• Questo è il codice golf, i byte minimi riceveranno la massima gloria.
• Non tollereremo scappatoie sciocche

Gelatina , 8 byte

0,1xŒ!ḄQ

Provalo online!

Come funziona

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]

Provalo su Ideone .

Come funziona

Tutti i numeri positivi che possono essere rappresentati in binario con x zero e y sono chiaramente inferiori a 2 ^{x + y} , poiché la rappresentazione binaria canonica di quest'ultimo ha x + y + 1 cifre.

La lambda scorre semplicemente sugli interi in [0, 2 ^{x + y} ) e mantiene tutti gli interi n in quell'intervallo che hanno y . Poiché n <2 ^{x + y} è può essere rappresentato con x (o meno) zeri.

Mathematica, 59 57 byte

Un risultato normale con Mathematica: funzioni di alto livello = buone, nomi di funzioni lunghe = cattive.

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

Join[0&~Array~#,1&~Array~#2]crea un elenco con il numero corretto di 0s e 1s. Permutationsgenera tutte le permutazioni di quell'elenco, senza ripetizioni (come ho imparato) e in ordine. #+##&~Fold~#(una versione golfuscated di #~FromDigits~2) converte un elenco di cifre di base 2 nell'intero che rappresentano.

Versione precedente, prima del commento di Martin Ender:

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

CJam ( 15 14 byte)

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

Questo è un blocco (funzione) anonimo che accetta input come array [number-of-ones number-of-zeros]e restituisce output come array.

Demo online

Molto lontano dal punto, ma più interessante : questo è senza permutazioni incorporate o conversione di base:

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

Funzionerebbe bene come si svolgerà un GolfScript.

Japt , 16 byte

'0pU +'1pV)á mn2

Provalo online!

Come funziona

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

Versione alternativa, 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

Ho provato a golf ulteriormente entrambe le versioni, ma non riesco a trovare alcun gioco ...

Rubino, 63 byte

Una semplice implementazione. Suggerimenti di golf benvenuti.

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

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 byte

+8 byte perché il nostro output deve essere ordinato

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

Mathematica, 47 byte

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

Una funzione senza nome che accetta due argomenti: numero di 1s, numero di 0s.

Essenzialmente una porta della soluzione Python di Dennis . Creiamo un intervallo da 0a e quindi manteniamo solo quei numeri la cui quantità di -bit è uguale al primo input. Il bit più interessante è probabilmente quello che usa un po 'di magia di sequenza per evitare le parentesi attorno all'aggiunta dei due argomenti.2x+y-112^+##

MATLAB 57 + 6

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

corri usando

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 byte

y+:<Y@XBu

Provalo online!

Spiegazione

L'approccio è simile a quello nella risposta Jelly di Dennis .

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

In realtà, 21 byte

Una porta della mia risposta di Ruby . Suggerimenti di golf benvenuti. Provalo online!

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

Come funziona

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

Non so quale consideri più pienamente rispondente alla domanda ma ...

74 Soluzione byte

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

Per un input di 1,2 ottieni:

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

93 Soluzione byte

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

Per un input di 1,2 ottieni:

[101, 011, 110]

123 Soluzione byte

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

Per un input di 1,2 ottieni:

[5, 3, 6]

Provalo qui:

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

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

3 byte salvati grazie a @Neil.

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

Le comprensioni dell'array sono fantastiche. Peccato che non siano ancora entrati nelle specifiche ufficiali ECMAScript.

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

Ora dovrebbe funzionare in tutti i browser conformi a ES6. Salva 7 byte su questo, anche grazie a @Neil.

Groovy 80 byte

basato sulla risposta di @carusocomputing

la sua soluzione da 123 byte può essere compressa in 80 byte:

Soluzione a 80 byte

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

Per un input di 1,2 ottieni:

[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);}

Provalo online!

Sfortunatamente non c'è popcount () nella libreria standard, ma è fornita come "funzione integrata" da GCC. L'output è ordinato, ma in ordine inverso.

Grazie a @ceilingcat per la rasatura di 4 byte!

PHP, 80 o 63 byte

a seconda di dove devo usare $argvo posso usare $xe $yinvece.

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

stampa tutti i numeri corrispondenti in ordine decrescente delimitato da caratteri di sottolineatura.
il nome file non deve iniziare con una cifra.

nessun builtin, 88 o 71 byte

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

aggiungere un byte ciascuno per un solo carattere di sottolineatura dopo ogni numero.

@WallyWest: avevi ragione. Salva 3 byte per me dafor($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}}

Spiegazione:

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