welcher container für mein problem

BlackDragon

Hallo, ich möchte aus 49 zahlen alle möglichen sechserkombinationen rausfinden. Das Problem löse ich auf diese weise:

//deklaration von 6 zahlen mit den gearbeitet wird
syszahlen.clear(); // vector löschen
int a=0,b=1,c=2,d=3,e=4,f=5;

// [49]array - anzahl der gewaehlten zahlen
int *x = new int[Zahlenanzahl];

// gewaehlte zahlen nacheinander in die richtige reihenfolge bringen
int y=Zahlenanzahl-1;

// initialisiert welche zahle makiert wurde und ordne diese in neuen array nach einander ein
   for(int i=48;i>=0;i-- )
   {
      if(zahl[i]!=0)
      {
         x[y]=zahl[i];
         y--;
      }
   }

   // wenn nur 6 zahlen angekreuzt dann gib sie alle einfach aus
   if(Zahlenanzahl==6)
   {

      syszahlen.push_back();
      syszahlen[0].z1=x[0];
      syszahlen[0].z2=x[1];
      syszahlen[0].z3=x[2];
      syszahlen[0].z4=x[3];
      syszahlen[0].z5=x[4];
      syszahlen[0].z6=x[5];

   }
   else //----- mehr als 6 zahlen-----------------
   {

      syszahlen.push_back();
      syszahlen[0].z1=x[a];
      syszahlen[0].z2=x[b];
      syszahlen[0].z3=x[c];
      syszahlen[0].z4=x[d];
      syszahlen[0].z5=x[e];
      syszahlen[0].z6=x[f];

      for(int i=1;i<Reihenanzahl;i++)
      {

         Application->ProcessMessages();
         if(abbruch)
            break;
         if(x[f]<x[Zahlenanzahl-1])
         {

            f=f+1;

         }
         else
         {
            if(x[e]<x[Zahlenanzahl-2])
            {

               e=e+1;
               f=e+1;

            }
            else
            {
               if(x[d]<x[Zahlenanzahl-3])
               {

                  d=d+1;
                  e=d+1;
                  f=e+1;

               }
               else
               {
                  if(x[c]<x[Zahlenanzahl-4])
                  {

                     c=c+1;
                     d=c+1;
                     e=d+1;
                     f=e+1;

                  }
                  else
                  {
                     if(x[b]<x[Zahlenanzahl-5])
                     {

                        b=b+1;
                        c=b+1;
                        d=c+1;
                        e=d+1;
                        f=e+1;

                     }
                     else
                     {

                        a=a+1;
                        b=a+1;
                        c=b+1;
                        d=c+1;
                        e=d+1;
                        f=e+1;

                     }
                   }
                }
             }
          }

            syszahlen.push_back();
            syszahlen[i].z1=x[a];
            syszahlen[i].z2=x[b];
            syszahlen[i].z3=x[c];
            syszahlen[i].z4=x[d];
            syszahlen[i].z5=x[e];
            syszahlen[i].z6=x[f];

      }

   }

Mein Problem ist halt, dass es bei 49 zahlen knapp 14 milionen 6er-kombinationen gibt. Wenn ich diese in den vector einlese dann dauert das ca. 1h. Ich habe einen Pentium4 2,56ghz. Auf einen Athlon 1Ghz dauert das natürlich noch länger. Ist das normal dass sowas so lange braucht oder haben ich dafür die falsche wahl gemacht. Gibt es eine schnellere lösung. Stimmt vieleicht in dem code was nicht?

triendl.kj

berechne die anzahl der möglichkeiten im vorhinein und initialisiere den vektor damit:

int Reihenanzahl = 5;
vector<xxx> syszahlen(Reihenanzahl);

oder wenn das nicht möglich ist, dann reserviere im nachhinein soundsoviele elemente:

syszahlen.reserve(Reihenanzahl);

ansonsten wird bei jeder vergößerung des vektors neuer speicher reserviert und die alten elemente dorthin kopiert - das braucht zeit

BlackDragon

Hallo, danke. Werde ich gleich probieren. Vielen dank nochmal.

Herr der Dinge

Ich glaube mich an eine Formel für sowas von jemand anders in diesem Forum zu errinern:
Alle Möglichkeiten=Anzahl d. Möglichen Ziffern^Anzahl der Stellen

Also in deinem Fall 49^6==13.841.287.201;

MisterZ

Die Formel lautet nicht 49^6 sondern 49 c 6. Also nur 13983816 Möglichkeiten. Deine Formel setzt die Möglichkeiten 1,2,3,4,5,6 und 6,5,4,3,2,1 nicht gleich!