Benutzt die Forumssuche, zu *zufall* ist ein Haufen passender Threads zu finden.

bis bald
akari

du must das wort zufall mit je einem Sternchen davor und dahinter in der Suchfunktion eingeben, und hier im C++ Subforum suchen lassen. Da kommen gunug Treffer.

bis bald
akari

Dann schau dir die Beispiele an, überleg dir was die Zufallszahlen erzeugen könnte (Tip : Zufall heißt im englischen Random) und setzt dann diese wie du willst ein.

bis bald
akari

*sob* ich such hier eignetlich nur eine ganz normale zufallsfunktion o_o da stehen x andere mit arrays blabla^^ ürgentwelchen rouletten tonnen von zahlen und was weiß ich ^^

Kannst du mal normal schreiben? So hat bestimmt niemand Lust dir zu helfen.

erstelltst du eine Zufalls Zahl, von der du das Modulum von 2 nimmst,
das sollte dir als erklärung reichen.

#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;

int main()
{
  srand(time(NULL));//einmal bei Programmstart
  for(int i=0;i<100;++i)
    cout<<i<<'\t'<<rand()<<endl;
  return 0;
}

sollte reichen, ich verabschiede mich dann mal^^

[/code]#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;

int main()
{
int a,b;
int z[5];

srand(time(NULL));//einmal bei Programmstart

for(int i=0;i<5;++i)
{
z[i]=rand()%49+1;

for(int j=1; j<5; j++)
{
if(z[i]==z[j])
{
i--;
break;
}

}

}
// z[i]=rand()%49+1;

cout<<'\t'<<z[i];//rand()%49+1;
return 0;
}
[code]

(PS: Wenn du code-Tags benutzt, dann bitte richtig herum - das [/code] kommt ans Ende ;))

#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;

int main()
{

	int z[5];

	srand(time(NULL));//einmal bei Programmstart

	for(int i=0;i<5;++i)

	{
			z[i]=rand()%49+1;

			for(int j=0; j<i; j++)

				{
					if(z[i]==z[j])
						{
							i--;
							break;

						}

				}

	if(z[i]!=z[j])
		{

			cout<<'\t'<<z[i];
		}
	}
return 0;
}

ps.life dein vorschlag is n bissi zu kompliziert, hab mich mit den klassen noch net beschäftigt, aba kommt noch

set<int> zahlen;
while(zahlen.size()<6)
  zahlen.insert(rand()%49+1);

(das set<> stellt sicher, daß jedes Element nur einmal eingefügt werden kann, d.h. am Ende der Schleife stehen in "zahlen" 6 garantiert unterschiedliche Zufallszahlen drin)

Ich hätte da noch eine andere Idee, wie du deine Lotto-Ziehung machen kannst:

set<int> zahlen;
while(zahlen.size()<6)
  zahlen.insert(rand()%49+1);

(das set<> stellt sicher, daß jedes Element nur einmal eingefügt werden kann, d.h. am Ende der Schleife stehen in "zahlen" 6 garantiert unterschiedliche Zufallszahlen drin)

ist doch (fast) genauso ineffektiv.. wie teuer ist denn insert? log n?

Ja, insert() ist O(log n) - der Test in deinem ursprünglichen Programm ist O(n)

in meinem Programm ist er O(1), weil garkein Test stattfindet.. Das finden der n paarweise verschiedenen Zufallzahlen kosten somit nur O(n). Bei dir kostet das Ganze dann O(n logn) und bei der Version vom Threadersteller O(n²) und beides nur sofern keine Zahl doppelt gewürfelt wurde..

random_shuffle ist für das Problem auch nicht unbedingt meine erste Wahl, da du damit einfach viel zu viel machst und dann nachher wieder ein Teil rausschmeißt (wobei random_shuffle dann besser wird wenn sich n m annähered (also genau umgekehrt))..

das mit den doppelten zufallszahlen verhindern geht auch effektiver..

Wie, noch effektiver als wenn keine doppelten mehr drin sind? Also sozusagen *gar* keine doppelten mehr drin? Oder meinst Du vielleicht effizienter? :p
Aber ne schöne Lösung!

Allerdings kann man die erwartete Anzahl an Schritten ausrechnen. Die Schätze ich mal auf knapp über 1, bei diesen Werten. Die Wahrscheinlichkeit, daß es terminiert liegt übrigens bei 1. Die für unendliches Weiterlaufen bei 0, es kann also eigentlich nicht unendlich lange laufen. Beliebig lange schon, aber halt nicht unendlich.

Allerdings kann man die erwartete Anzahl an Schritten ausrechnen. Die Schätze ich mal auf knapp über 1, bei diesen Werten. Die Wahrscheinlichkeit, daß es terminiert liegt übrigens bei 1. Die für unendliches Weiterlaufen bei 0, es kann also eigentlich nicht unendlich lange laufen. Beliebig lange schon, aber halt nicht unendlich.

Beliebig lange kann aber schon ganz lange sein ;). Und im "worst-case" braucht der Algorithmus nunmal unendliche lange, obwohl die wahrscheinlichkeit für den "worst-case" bei 0 liegt (hört sich zugegebenermaßen irgendwie paradox an)

Auch wenn der Fall nie auftritt, denke ich, kann man ihn als worst-case bezeichnen.. oder was ist dann deiner Meinung nach der worst-case bei dem Algorithmus? :p

Das ist natürlich ne berechtigte Frage.

Aber wie relevant ist ein "worst-case", der nie eintritt?