интеллектуальное создание комбинаций комбинаций

Ну, там (30_C5*25_C5*20_C5*15_C5*10< sub>C5*5_C5)/6! = 30!/(6!*5!⁶) = 123 378 675 083 039 376 различных частей из 30 в группы по 5, поэтому создание их всех займет некоторое время, независимо от того, какой метод вы используете.

В общем, однако, хороший способ выбора такого раздела состоит в том, чтобы упорядочить элементы и найти группировку для самого высокого негруппированного элемента, а затем сгруппировать остальные.

     find_partition = lambda do |elts|
        if elts.empty?
         [[]]
        else
         highest = elts.pop
         elts.combination(4).map do |others|
            find_partition[elts - others].map { |part| part << [highest,*others] }
         end.inject(:+)
        end
     end
     find_partition[(1..30).to_a]

Таким образом, вы создаете каждый раздел только один раз

Это старый вопрос, но в любом случае, для протокола, я бы сделал это в Ruby:

class Array
  def groups_of_size(n)
    Enumerator.new do |yielder|
      if self.empty?
        yielder.yield([])
      else
        self.drop(1).combination(n-1).map { |vs| [self.first] + vs }.each do |values|
          (self - values).groups_of_size(n).each do |group|
            yielder.yield([values] + group)
          end   
        end
      end
    end
  end
end

Я использую перечислитель, потому что вывод может расти очень быстро, строгий вывод (например, массив) был бы бесполезен. Пример использования:

>> pp [0, 1, 2, 3, 4, 5].groups_of_size(3).to_a
=> 
[[[0, 1, 2], [3, 4, 5]],
 [[0, 1, 3], [2, 4, 5]],
 [[0, 1, 4], [2, 3, 5]],
 [[0, 1, 5], [2, 3, 4]],
 [[0, 2, 3], [1, 4, 5]],
 [[0, 2, 4], [1, 3, 5]],
 [[0, 2, 5], [1, 3, 4]],
 [[0, 3, 4], [1, 2, 5]],
 [[0, 3, 5], [1, 2, 4]],
 [[0, 4, 5], [1, 2, 3]]]

Вы можете сделать некоторую пост-обработку перестановок. Некоторый псевдокод (реализуйте на выбранном вами языке...):

// We have a list of lists called 'permutations'
// combinations is an (empty) list of lists
for each permutation in permutations
{
   sortedPermutation = permutation.sort()
   if (! combinations.find(sortedPermutation) )
   {
       combinations.add(sortedPermutation);
   }
}

Вероятно, не самый эффективный; Я бы добавил сортировку и сравнение с кодом, который лично генерирует перестановки.

Одной из возможностей было бы найти все комбинации для формирования отдельной группы, а затем просмотреть и сгенерировать комбинации, которые не содержат членов этой отдельной группы. Что-то типа:

List<List<Student>> combinations=Combinations(students);
public void GenerateCombinations(int startingIndex, List<List<Student>> currentGroups, int groupsLeft)
{
    if(groupsLeft==0) ProcessCombination(currentGroups);

    for(int i=startingIndex; i<combinations.Count; i++)
    {
        if combinations[i] does not contain a student in current groups
            GenerateCombinations(i+1, currentGroups + combinations[i], groupsLeft -1);
    }
}

Это будет не самый эффективный метод, но он должен генерировать все комбинации групп. Я подозреваю, что лучшую производительность можно было бы получить, если бы вы генерировали временные списки комбинаций, где все группы, которые не могут возникнуть, были удалены, но это было бы немного сложнее.

Небольшое отступление: должно быть 142 506 комбинаций из 30 студентов, чтобы сформировать одну группу из 5 человек. Мои математические способности «сарказм» и «сарказм» подсказывают, что должно быть около 10^17 = 100 квадриллионов комбинаций групп студентов ( 30!/((5!^6)*6!); 30! порядок учеников, порядок 6 групп по 5 не имеет значения, и порядок этих 6 групп не имеет значения). Возможно, вы сидите там некоторое время, ожидая, пока это закончится.