Penolakan

Pertanyaan ini bukan duplikat dari pertanyaan ini . Saya tidak menghitung angka tertentu, karena kami sudah menetapkannya di parameter awal. Pertanyaan ini berfokus pada angka desimal yang dapat dibangun dari string biner berdasarkan digit yang disediakan.

Tantangan

Diberikan dua bilangan bulat Xdan Y, masing-masing mewakili jumlah nol ( 0) dan satu ( 1), menghitung semua ekivalen desimal yang mungkin yang dapat ditentukan dari membuat string biner hanya menggunakan nol dan yang disediakan, dan menampilkannya sebagai output.

Contoh 1:

Memasukkan: 0 1

Keluaran: 1

Penjelasan: Hanya satu yang 1diperhitungkan, yang hanya dapat dikonversi satu arah.

Contoh 2:

Memasukkan: 1 1

Keluaran: 1,2

Penjelasan: 01convert ke 1, 10convert ke 2.

Contoh 3:

Memasukkan: 3 2

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

Penjelasan: Three 0s dan two 1s make 00011(3), 00101(5), 00110(6), 01001(9), 01010(10), 01100(12), 10001(17), 10010(18), 10100(20), 11000(24)

Keterbatasan dan Aturan

• Saya hanya akan mengharapkan kode Anda bekerja di mana 0 < X + Y <= 16sehingga jumlah maksimum dalam output hanya dapat terjadi dari 16 1detik, yaitu parameter 0dan 16.
• Sebagai hasil dari batasan di atas, kisaran angka yang kami harapkan dalam output berasal dari 0dan 65535.
• Saya akan menerima fungsi atau kode, selama output yang dihasilkan disediakan, apakah ini daftar yang dipisahkan koma, array, daftar yang di-output ke STDOUT, dll. Satu-satunya kriteria yang harus saya tekankan tentang output adalah bahwa ia harus diurutkan.
• Ini adalah kode golf, byte minimum akan menerima kemuliaan maksimum.
• Kami tidak akan mentolerir celah konyol

Jelly , 8 byte

0,1xŒ!ḄQ

Cobalah online!

Bagaimana itu bekerja

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]

Uji di Ideone .

Bagaimana itu bekerja

Semua angka positif yang dapat direpresentasikan dalam biner dengan x nol dan y adalah lebih kecil dari 2 ^{x + y} , karena representasi biner kanonik yang terakhir memiliki x + y + 1 digit.

Lambda hanya iterates atas bilangan bulat dalam [0, 2 ^{x + y} ) dan membuat semua bilangan bulat n dalam kisaran yang yang memiliki y yang. Sejak n <2 ^{x + y} adalah dapat diwakili dengan x (atau kurang) nol.

Mathematica, 59 57 byte

Hasil yang biasa dengan Mathematica: fungsi tingkat tinggi = baik, nama fungsi panjang = buruk.

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

Join[0&~Array~#,1&~Array~#2]membuat daftar dengan jumlah 0s dan 1s yang benar. Permutationsmenghasilkan semua permutasi daftar itu, tanpa pengulangan (seperti yang saya pelajari) dan dalam urutan. #+##&~Fold~#(versi golfuscated #~FromDigits~2) mengubah daftar digit basis-2 menjadi bilangan bulat yang mereka wakili.

Versi sebelumnya, sebelum komentar Martin Ender:

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

CJam ( 15 14 bytes)

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

Ini adalah blok anonim (fungsi) yang mengambil input sebagai array [number-of-ones number-of-zeros]dan mengembalikan output sebagai array.

Demo online

Jauh dari sasaran, tetapi lebih menarik : ini tanpa builtin permutasi atau konversi basis:

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

Ini akan berfungsi dengan baik saat GolfScript dibuka.

Japt , 16 byte

'0pU +'1pV)á mn2

Uji secara online!

Bagaimana itu bekerja

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

Versi alternatif, 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

Saya sudah mencoba untuk bermain golf kedua versi, tapi saya tidak dapat menemukan ...

Ruby, 63 byte

Implementasi yang sederhana. Saran bermain golf diterima.

->a,b{(?0*a+?1*b).chars.permutation.map{|b|(b*'').to_i 2}.uniq}

Tidak melakukanolf

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 karena output kami perlu disortir

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]==#]&

Fungsi yang tidak disebutkan namanya mengambil dua argumen: jumlah 1s, jumlah 0s.

Pada dasarnya port solusi Dennis Python . Kami membuat rentang dari 0ke dan kemudian hanya menyimpan angka-angka yang jumlah- bitnya sama dengan input pertama. Bit yang paling menarik mungkin adalah yang menggunakan beberapa sihir urutan untuk menghindari tanda kurung di sekitar penambahan dua argumen.2x+y-112^+##

MATLAB 57 + 6

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

jalankan menggunakan

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

Cobalah online!

Penjelasan

Pendekatannya mirip dengan yang ada dalam jawaban 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

Sebenarnya, 21 byte

Port jawaban Ruby saya . Saran bermain golf diterima. Cobalah online!

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

Bagaimana itu bekerja

          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 Bytes, 93 Bytes atau 123 Bytes

Saya tidak tahu yang mana yang Anda anggap lebih lengkap menjawab pertanyaan tetapi ...

74 Byte Solution

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

Untuk input 1,2 Anda mendapatkan:

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

93 Byte Solution

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

Untuk input 1,2 Anda mendapatkan:

[101, 011, 110]

123 Byte Solution

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

Untuk input 1,2 Anda mendapatkan:

[5, 3, 6]

Cobalah di sini:

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

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

Disimpan 3 byte berkat @Neil.

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

Pemahaman array sangat bagus. Sayang sekali mereka belum membuatnya menjadi spec ECMAScript resmi.

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

Harus berfungsi di semua browser yang mendukung ES6 sekarang. Disimpan 7 byte yang satu ini, juga berkat @Neil.

Groovy 80 Bytes

berdasarkan jawaban oleh @carusocomputing

solusi 123 Byte-nya dapat dikompresi menjadi 80 Bytes:

80 Byte Solution

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

Untuk input 1,2 Anda mendapatkan:

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

Cobalah online!

Sayangnya tidak ada popcount () di perpustakaan standar, tetapi disediakan sebagai "fungsi bawaan" oleh GCC. Outputnya diurutkan, tetapi dalam urutan terbalik.

Terima kasih kepada @ceilingcat untuk mencukur 4 byte!

PHP, 80 atau 63 byte

tergantung pada apakah saya harus menggunakan $argvatau dapat menggunakan $xdan $ysebagai gantinya.

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

mencetak semua angka yang cocok dalam urutan menurun yang dibatasi oleh garis bawah.
nama file tidak boleh dimulai dengan angka.

tidak ada builtin, 88 atau 71 byte

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

tambahkan masing-masing satu byte untuk hanya satu garis bawah setelah setiap angka.

@WallyWest: Anda benar. Menghemat 3 byte untuk saya darifor($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}}

Penjelasan:

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