[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.

#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

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

#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.

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.

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.