Zufallszahl nach Größe ordnen ?

kaizuki

Hallo ,
ich habe gerade ein Programm geschrieben ,welches eine Reihe von 6 Zufallstzahl zwichen 0 bis 49 ausgeben kann .

[i] = Anzahl der Zufallszahlen
[j] = Anzahl der Reihen

#include <iostream.h>
int main()
{
int i,j,anz,k;
int tipp[6][100];
/*-----------------------------------------------*/
do{
   cout<<"Geben Sie die Anzahl der Tipps ein:";
   cin>>anz;
   }
   while(anz<1||anz>100);
/*----------------------------------------------*/

for ( j=0;j<anz;j++)
  { for (i=0;i<6; i++)
     { tipp[i][j]=random(49)+1;
       cout<<tipp[i][j]<<"\t";
     }
    cout<<"\n"; 
  } 
  getchar();
  return 0;
}

so weit so gut, jetzt möchte ich diese 6 Zufallszahl nur noch nach Größe ordnen , hab aber keinen Plan ,wie ich das realiseiren kann
kann jemand mir weiter helfen :p
mfG.

freaky

http://www.cplusplus.com/reference/algorithm/sort/
http://ittk.falb.at/pt/unterlagen/vcppk/bubble_sort.html

unskilled

Sieht so aus, wie Lottozahlen - aber ich sehe nicht, dass du irgendwo prüfst, ob die Zahl schon mal vor kam...
Deshalb wird bei Lotto-Zahlen auch immer ein random_shuffle empfohlen:

#include <algorithm>
#include <cstdlib>
#include <time>
#include <vector>

int main()
{
	std::vector<int> zahlen;
	zahlen.reserve(49);
	for(int i(1); i != 49; ++i)
		zahlen.push_back(i);

	std::srand(unsigned(std::time()));
	std::random_shuffle(zahlen.begin(), zahlen.end());

	std::sort(zahlen.begin(), zahlen.begin()+6);

	for(int i(0); i != 7; ++i)
		std::cout << zahlen[i] << ", ";
}

hier mal eine anfängerfreundliche Version

ich hoffe, es hilft dir weiter...

bb

sirchillalot

Oder mit Kanonen auf Spatzen schießen ^^

Man könnte ja auch die Zufallswerte solange in ein std:set schieben bis 6 Elemente vorhanden sind ^^. Sortieren geht dann auch über STL

SeppJ

An dieser Stelle natürlich obligatorisch ein Programm, dass tatsächlich nur 6 Zufallszahlen zieht. Nicht 49(?) wie std::random_shuffle und auch nicht potentiell unendlich viele wie die Methode mit dem std::set.

#include<vector>
#include<iostream>
#include<cstdlib>
#include<cstddef>
#include<ctime>

using namespace std;

const int minimum = 1;
const int maximum = 49;
const size_t anzahl = 6;

int main()
{
  // Abbildung zwischen Zufallswerten und gezogenen Zahlen
  vector<int> zahlen;

  // Füllen:
  for (int i=minimum; i<=maximum; ++i) zahlen.push_back(i);

  // Zufallszahlen ziehen:
  srand ( time(0) );
  for (size_t i=0; i<anzahl; ++i)
    {
      // Zufallszahl im Intervall [0, zahlen.size()]
      int random = rand() % (zahlen.size());
      cout << i+1 << ". Zahl: " << zahlen[random] <<endl;
      // Gezogenes Element aus der Liste löschen:
      zahlen[random] = zahlen.back();
      zahlen.pop_back();
    }
}

Sortieren geht dann mit einem beliebigen Sortieralgorithmus, beispielsweise std::sort.

kaizuki

hi, erstmal danke für eure Hilfbereitschaft .
ich hätte nicht gedacht,dass ich so schnell und vor allem so viele Hilfe bekommt ,
eure Lösungsvorschläge sind sehr ausführlich erklärt ,sie enthalten jedoch zu viele Befehle,die ich noch nicht kannte
kann ich nur mit Schleife die Zufallszahlen sortieren ?

SeppJ

kaizuki schrieb:

kann ich nur mit Schleife die Zufallszahlen sortieren ?

Dazu guck dir mal das verlinkte BubbleSort an. Was die Effizienz angeht, ist Bubblesort zwar extrem schlecht, dafür ist es recht leicht verständlich. Was ich sogar noch etwas leicher verständlich finde, ist Selection Sort:
http://en.wikipedia.org/wiki/Selection_sort
Das ist schon effizienter und entspricht ungefähr dem, wie ein normaler Mensch (kein Informatiker) sortiert. Bei Bubblesort habe ich immer das Gefühl, dass man sich mit Absicht einen schlechten Algorithmus ausgedacht hat.

Beide sind sehr einfach nur mit Schleifen umsetzbar.

Nexus

SeppJ schrieb:

Bei Bubblesort habe ich immer das Gefühl, dass man sich mit Absicht einen schlechten Algorithmus ausgedacht hat.

Das hat definitiv was. Kein normaler Mensch sortiert seine Dinge, in dem sie jeweils mit dem Nachbarding austauscht.