How to choose all possible combinations?

问题

Let's assume that we have the list of loans user has like below:

loan1
loan2
loan3
...
loan10

And we have the function which can accept from 2 to 10 loans: function(loans). For ex., the following is possible:

function(loan1, loan2)
function(loan1, loan3)
function(loan1, loan4)
function(loan1, loan2, loan3)
function(loan1, loan2, loan4)
function(loan1, loan2, loan3, loan4, loan5, loan6, loan7, loan8, loan9, loan10)

How to write the code to pass all possible combinations to that function?

回答1:

On RosettaCode you have implemented generating combinations in many languages, choose yourself.

回答2:

Here's how we could do it in ruby :

loans= ['loan1','loan2', ... , 'loan10']

def my_function(loans)
  array_of_loan_combinations = (0..arr.length).to_a.combination(2).map{|i,j| arr[i...j]}

  array_of_loan_combinations.each do |combination|
    //do something
  end
end

To call :

my_function(loans);

回答3:

I have written a class to handle common functions for working with the binomial coefficient, which is the type of problem that your problem falls under. It performs the following tasks:

Outputs all the K-indexes in a nice format for any N choose K to a file. The K-indexes can be substituted with more descriptive strings or letters. This method makes solving this type of problem quite trivial.

Converts the K-indexes to the proper index of an entry in the sorted binomial coefficient table. This technique is much faster than older published techniques that rely on iteration. It does this by using a mathematical property inherent in Pascal's Triangle. My paper talks about this. I believe I am the first to discover and publish this technique, but I could be wrong.

Converts the index in a sorted binomial coefficient table to the corresponding K-indexes. I believe it might be faster than the link you have found.

Uses Mark Dominus method to calculate the binomial coefficient, which is much less likely to overflow and works with larger numbers.

The class is written in .NET C# and provides a way to manage the objects related to the problem (if any) by using a generic list. The constructor of this class takes a bool value called InitTable that when true will create a generic list to hold the objects to be managed. If this value is false, then it will not create the table. The table does not need to be created in order to perform the 4 above methods. Accessor methods are provided to access the table.

There is an associated test class which shows how to use the class and its methods. It has been extensively tested with 2 cases and there are no known bugs.

To read about this class and download the code, see Tablizing The Binomial Coeffieicent.

It should not be hard to convert this class to the language of your choice.

To solve your problem, you might want to write a new loans function that takes as input an array of loan objects and works on those objects with the BinCoeff class. In C#, to obtain the array of loans for each unique combination, something like the following example code could be used:

void LoanCombinations(Loan[] Loans)
{
   // The Loans array contains all of the loan objects that need
   // to be handled.
   int LoansCount = Loans.Length;
   // Loop though all possible combinations of loan objects.
   // Start with 2 loan objects, then 3, 4, and so forth.
   for (int N = 2; N <= N; N++)
   {
      // Loop thru all the possible groups of combinations.
      for (int K = N - 1; K < N; K++)
      {
         // Create the bin coeff object required to get all
         // the combos for this N choose K combination.
         BinCoeff<int> BC = new BinCoeff<int>(N, K, false);
         int NumCombos = BinCoeff<int>.GetBinCoeff(N, K);
         int[] KIndexes = new int[K];
         // Loop thru all the combinations for this N choose K.
         for (int Combo = 0; Combo < NumCombos; Combo++)
         {
            // Get the k-indexes for this combination, which in this case
            // are the indexes to each loan in Loans.
            BC.GetKIndexes(Loop, KIndexes);
            // Create a new array of Loan objects that correspond to
            // this combination group.
            Loan[] ComboLoans = new Loan[K];
            for (int Loop = 0; Loop < K; Loop++)
               ComboLoans[Loop] = Loans[KIndexes[Loop]];
            // Call the ProcessLoans function with the loans to be processed.
            ProcessLoans(ComboLoans);
         }
      }
   }
}

I have not tested the above code, but in general it should solve your problem.

来源：https://stackoverflow.com/questions/12373896/how-to-choose-all-possible-combinations

标签

algorithm

combinations