C++ - Newbie braucht, hilft zum drucken von Kombinationen von zahlen

Hier ist dein code bearbeitet werden 😀 😀 mit einem rekursive Lösung:

#include <iostream>

int iRange=0;   
int iN=0;           //Number of items taken from iRange, for which u want to print out the combinations
int iTotalCombs=0;
int* pTheRange;
int* pTempRange;

int find_factorial(int n)
{
    if ( n<1)
        return 1;
    else
    return find_factorial(n-1)*n;
}

//--->Here is another solution:
void print_out_combinations(int *P, int K, int n_i) 
{
    if (K == 0)
    {
        for (int j =iN;j>0;j--)
        std::cout<<P[j]<<" ";
        std::cout<<std::endl;
    }
    else
        for (int i = n_i; i < iRange; i++) 
        {
            P[K] = pTheRange[i];
            print_out_combinations(P, K-1, i+1);
        }
}
//Here ends the solution...

int main() 
{
    std::cout<<"Give the set of items -iRange- = ";
    std::cin>>iRange;
    std::cout<<"Give the items # -iN- of iRange for which the combinations will be created = ";
    std::cin>>iN;

    pTheRange = new int[iRange];
    for (int i = 0;i<iRange;i++)
    {
        pTheRange[i]=i+1;
    }
    pTempRange = new int[iN];

    iTotalCombs = (find_factorial(iRange)/(find_factorial(iRange-iN)*find_factorial(iN)));

    std::cout<<"The number of possible combinations is: "<<iTotalCombs<<std::endl;
    std::cout<<"i.e.the combinations of "<<iN<<" elements drawn from a set of size "<<iRange<<" are: "<<std::endl;
    print_out_combinations(pTempRange, iN, 0);
    return 0;
}

Sieht aus wie ein gutes problem für Rekursion.

Definieren Sie eine Funktion f(prefix, iMin, iMax, n), druckt alle Kombinationen von n Ziffern im Bereich [iMin, iMax] und gibt die gesamte Anzahl von Kombinationen. Für n = 1, es ausdrucken sollte jede Ziffer von iMin zu iMax und zurück iMax - iMin + 1.

Für Ihre iRange = 5 und n = 3 Fall, rufen Sie f("", 1, 5, 3). Die Ausgabe sollte 123 - 124 - 125 - 134 - 135 - 145 - 234 - 235 - 245 - 345.

Beachten Sie, dass die erste Gruppe der Ausgänge sind einfach 1 vorangestellt, die auf die Ausgänge von f("", 2, 5, 2), d.h. f("1", 2, 5, 2), gefolgt von f("2", 3, 5, 2) und f("3", 4, 5, 2). Sehen, wie Sie tun würden, die mit einer Schleife. Zwischen diesem, die Fall für n = 1 oben und fallen für schlechte Eingänge (am besten, wenn Sie nichts drucken und geben 0 zurück, sollte es vereinfachen, Ihre loop), sollten Sie in der Lage zu schreiben f().

Bin ich kurz anhalten, weil das sieht aus wie eine Hausaufgabe. Ist das genug, um Sie zu erhalten begann?

EDIT: Nur für kichert, schrieb ich ein Python-version. Python hat eine einfachere Zeit werfen um Sätze und Listen von Dingen und bleiben lesbar.

#!/usr/bin/env python

def Combos(items, n):
    if n <= 0 or len(items) == 0:
        return []
    if n == 1:
        return [[x] for x in items]
    result = []
    for k in range(len(items) - n + 1):
        for s in Combos(items[k+1:], n - 1):
            result.append([items[k]] + s)
    return result

comb = Combos([str(x) for x in range(1, 6)], 3)
print len(comb), " - ".join(["".join(c) for c in comb])

Beachten Sie, dass Combos() kümmert sich nicht um die Typen der Elemente in der items Liste.

Dies ist mein C++ - Funktion mit unterschiedlichen Schnittstellen (basierend auf der sts::set), aber die gleiche Aufgabe durchführen:

typedef std::set<int> NumbersSet;
typedef std::set<NumbersSet> CombinationsSet;

CombinationsSet MakeCombinations(const NumbersSet& numbers, int count)
{
  CombinationsSet result;

  if (!count) throw std::exception();

  if (count == numbers.size())
  {
    result.insert(NumbersSet(numbers.begin(), numbers.end()));
    return result;
  }

  //combinations with 1 element
  if (!(count - 1) || (numbers.size() <= 1))
  {
    for (auto number = numbers.begin(); number != numbers.end(); ++number)
    {
      NumbersSet single_combination;
      single_combination.insert(*number);
      result.insert(single_combination);
    }
    return result;
  }

  //Combinations with (count - 1) without current number
  int first_num = *numbers.begin();
  NumbersSet truncated_numbers = numbers;
  truncated_numbers.erase(first_num);
  CombinationsSet subcombinations = MakeCombinations(truncated_numbers, count - 1);

  for (auto subcombination = subcombinations.begin(); subcombination != subcombinations.end(); ++subcombination)
  {
    NumbersSet cmb = *subcombination;
    //Add current number
    cmb.insert(first_num);
    result.insert(cmb);
  }

  //Combinations with (count) without current number
  subcombinations = MakeCombinations(truncated_numbers, count);
  result.insert(subcombinations.begin(), subcombinations.end());

  return result;
}