Перерахуйте всі комбінації із заміною (або комбінаціями з повторенням) розміром k із набору n елементів.

Поєднання із заміною - це не упорядкований багатонаціональний набір, що кожен елемент в ньому також знаходиться у наборі n елементів. Зауважте, що:

• Це не упорядковано. Тому попередньо надрукований набір з іншим порядком не слід надрукувати знову.
• Це мультисети. Той самий елемент може (але не обов'язково) з'являтися не один раз. Це єдина різниця між комбінацією із заміною та звичайною комбінацією.
• Набір повинен мати рівно k елементів.

Крім того, це також підмножина розміру k з мультисети, яка містить кожен з n елементів k разів.

Вхід повинен бути або n і k , де елементи є першими n позитивними чи негативними цілими числами, або n елементів і k , де можна вважати, що n елементів різняться один від одного.

Вихід повинен бути переліком усіх комбінацій із заміною розміром k із заданого набору. Ви можете надрукувати їх та елементи в кожному з них у будь-якому порядку.

Ви не можете використовувати вбудовані, що генерують комбінації із заміною. Але ви можете використовувати вбудовані для створення нормальних комбінацій, перестановок, кортежів тощо.

Це код-гольф, найкоротший виграш коду.

Приклад

Input: 4 2
Output: [0 0] [0 1] [0 2] [0 3] [1 1] [1 2] [1 3] [2 2] [2 3] [3 3]

Желе, 4 байти

Завдяки Sp3000 за збереження 2 байт.

ṗṢ€Q

Вхід є nі kяк аргументи командного рядка в цьому порядку. Використовує елементи 1до n.

Спробуйте в Інтернеті!

Пояснення

ṗ     # Get k-th Cartesion power of n.
 Ṣ€   # Sort each tuple.
   Q  # Remove duplicates.

CJam (8 байт)

{m*:$_&}

Демонстрація в Інтернеті

Розсічення

{    e# Declare block (anonymous function); parameters are n k
  m* e# Cartesian product, which implicitly lifts n to [0 1 ... n-1]
  :$ e# Sort each element of the Cartesian product, to give them canonical forms
  _& e# Deduplicate
}

Математика, 31 29 байт

Завдяки A Simmons за збереження 2 байт.

{}⋃Sort/@Range@#~Tuples~#2&

Неназваний функція , приймаюча nі в kвигляді цілих аргументів в цьому порядку і повертає список списків. Елементи будуть 1до n. Працює так само, як і відповідь Петра CJam.

MATL , 11 байт

(Є 9-байтне рішення, засноване на декартовій потужності, але Пітер Тейлор уже це зробив . Спробуємо щось інше).

Поєднання із заміною можна звести до комбінацій без заміни, як описано нижче. Ми хочемо , щоб n Cr k, наприклад , з n=3, k=2:

0 0
0 1
0 2
1 1
1 2
2 2

Ми можемо обчислити n+k-1 C k:

0 1
0 2
0 3
1 2
1 3
2 3

а потім віднімайте 0 1 ... k-1з кожного рядка:

+q:2GXn2G:-

Пояснення:

+q     % take two inputs n, k and compute n+k-1
:      % range [1,2...,n+k-1]
2G     % push second input, k
Xn     % combinations without replacement
2G:    % range [1,2,...,k]
-      % subtract with broadcast. Display

Код працює у випуску 13.1.0 мови / компілятора, що є раніше, ніж виклик.

Ви можете спробувати онлайн! Зауважте, що онлайн-компілятор оновлено до версії 14.0.0, тому Xnйого потрібно змінити на XN.

JavaScript (Firefox 30-57), 71 байт

f=(n,k)=>k?[for(m of Array(n).keys())for(a of f(m+1,k-1))[...a,m]]:[[]]

Я отримую на використання keys()один раз.

Рубі, 56 55 байт

Два рішення, напрочуд обидва однакової довжини:

->n,k{[*1..n].repeated_permutation(k).map(&:sort).uniq}
->n,k{(a=[*1..n]).product(*[a]*(k-1)).map(&:sort).uniq}

Гей, ти ж сказав , що ми могли б використовувати перестановки ... вбудовані команди

Це просто генерує всі повторювані перестановки (другий генерує повторні декартові продукти) та видаляє ті, які не впорядковані.

Дякую Мартіну за збереження байта з 0...n-> 1..n!

Pyth, 7 байт

{SM^UQE

Використовується той же алгоритм, що і у відповіді Петра.

    UQ   range(input())
      E  input()
   ^     repeated Cartesian product of ^^, ^ times
 SM      map(sort)
{        uniq

Пітон, 63 байти

f=lambda n,k:n*k and[l+[n]for l in f(n,k-1)]+f(n-1,k)or[[]][k:]

Рекурсивний метод. Для того, щоб мультімножество kелементів, 1до n, ми вибираємо або:

• Увімкніть ще один екземпляр n, і залишається зробити мультімножество k-1елементів з 1доn
• Не включайте інший екземпляр n, і залишається зробити безліч kелементів від 1доn-1

Ми припиняємо, коли kабо nдосягаємо 0, і якщо він kдосяг 0, ми надаємо базовий випадок порожнього списку. Якщо ні, у нас неправильна кількість елементів, і так дайте порожній список.

Пітон 3, 81 80

Рекурсивне рішення:

t=lambda n,k,b=0:[[]]if k<=0 else [[i]+l for i in range(b,n)for l in t(n,k-1,i)]

Функція t(n, k, b)повертає список всіх k-елементних підмножин діапазону від bдо n. Цей список порожній, якщо k <= 0. В іншому випадку ми розбиваємо проблему на основі найменшого елемента мультипідмножини, який ми позначаємо i.

Для кожного iв діапазоні від bдо n, ми генеруємо всі kпідмножини -мільти підмножини з найменшим елементом i, починаючи з, [i]а потім додаючи кожну (k-1)-множину-підмножину діапазону від iдо n, яку ми отримуємо шляхом рекурсивного виклику t(n, k-1, i).

Діалог APL , 22 байти

{∪{⍵[⍋⍵]}¨↓⍉⍺⊥⍣¯1⍳⍺*⍵}

Вимагає ⎕IO←0, що за умовчанням у багатьох системах APL. Приймає k як лівий аргумент, n як правий аргумент.

⍳⍺*⍵0 1 2 ... kⁿ
⍺⊥⍣¯1перетворити на базу k
⍉транспонувати
↓внести матрицю в список списків,
{⍵[⍋⍵]}¨сортувати кожен ...
∪унікальний

J, 18 байт

[:~.#~<@/:~@#:i.@^

Аналогічний підхід використовується в @ Адамов розчині .

Ще один підхід із використанням декартового продукту {на 24 байти. Бере kна ЛГС та nна РЗС.

~.@:(/:~&.>)@,@{@(#<@i.)

Використання

   f =: [:~.#~<@/:~@#:i.@^
   4 f 2
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│0 0│0 1│0 2│0 3│1 1│1 2│1 3│2 2│2 3│3 3│
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

Пояснення

[:~.#~<@/:~@#:i.@^ Input: n on LHS and k on RHS
                 ^ Compute n^k
              i.@  Create a range [0, 1, ... n^k-1]
    #~             Create k copies on n
            #:     On each value in the range above, convert each digit to base-n
                   and take the last k digits of it
        /:~@       For each array of digits, sort it in ascending order
      <@           Box each array of digits
[:~.               Take the distinct values in the array of boxes and return it

Clojure, 94 байти

(defn f[k n](if(= 1 k)(for[i(range n)][i])(sort(set(for[i(f(dec k)n)j(range n)](conj i j))))))

Зверніть увагу на змінений порядок параметрів: 1-е є, kа 2-е є n. Це зберегло 1 байт у (f(dec k)n).

Математика, 36 байт

{##}&~Array~Table@##~Flatten~(#2-1)&

Скажіть, будь ласка , є бонус на 1/6 за користування no [] s ... А може, за багато використання ##?