Randomize()

Was mache ich hier denn falsch?!
Es kommt immer wieder nur eine Zahl raus...

#include <iostream>
#include <ctime>

int randomize()
{
	srand(time(0));
	int zahl = rand()%255;
	return zahl;
}

int main(int argc, char** argv)
{
	for(int i=0;i!=49;i++)
	{
		randomize();
		std::cout << randomize() << std::endl;
	}

}

Es kommt zum Beispiel: 1 1 1 1 1 1 1 1 1 1 1 1 raus. anstatt: 1 8 7 2 4 6 9...

Bitte um Hilfe.

weil du srand() GENAU EINMAL aufrufen sollst!

#include <iostream>
#include <ctime>

int randomize()
{
    int zahl = rand()%255;
    return zahl;
}

int main(int argc, char** argv)
{
    srand(time(0));

    for(int i=0;i!=49;i++)
    {
        randomize();
        std::cout << randomize() << std::endl;
    }

}

volkard

eher so

#include <iostream> 
#include <ctime> 

void randomize() 
{ 
    srand(time(0)); 
} 

int main(int argc, char** argv) 
{ 
    randomize(); 
    for(int i=0;i!=49;i++) 
    { 
        std::cout << rand()%256 << std::endl; 
    } 

}

DeepCopy

Ändere

srand()

in

randomize()

auf Variante:

int randomize()
{
    static bool bFirstCall = false;

    if (!bFirstCall)
    {
        srand(time(0));
        bFirstCall = true;
    }

    int zahl = rand();
    return zahl;
}

Danke!

Thank you very much

Ich kriegs nicht hin,...

Entweder mache ich beim übergeben des Arrays was falsch.
oder
Meine Bedingungen sind falsch.

Die Ausgabe in der Funktion ist:

FUNKTION: -89....... sollte ja eigentlich gar nicht sein, da in Main alles reingeschoben wird.

Meine Funktion ist anscheinend total falsch?
Die Funktion sollte eigentlich überprüfen ob ein Wert im Array vorhanden ist, wenn ja dann so oft weitermachen bis "checkme" true ergibt...

WÄRE EUCH SOOOO SEHR DANKBAR! Sitze schon knapp 2h dran, weil ich es umbedingt selber schaffen wollte. Aber ich habe nicht mehr die Kraft dazu.

#include <iostream>
#include <ctime>

void randomize()
{
	srand(time(0));
}

bool checkme(int carray[])
{

	for(int a=0; a<=48;a++)
	{
		for(int i=0;i<=48;i++)
		{
			if(carray[i] == carray[a])
			{
				std::cout << carray[i] << std::endl;
				return false;
			}
		}
	}
	return true;
}

int main()
{
	srand((time(0)));
	int x[48];
	for(int i=0;i<=48;i++)
	{
		while(checkme(x)!=false)
		{
			x[i] = rand()%255;
			std::cout << x[i] << std::endl;
		}
	}
}

Die Programmlogik habe ich mir jetzt nicht weiter angeschaut. Aber du greifst über die Grenzen deines Arrays zu.

int array[48]; //48 elemente. von 0 bis 47

for(int a=0; a<48;a++)
oder
for(int a=0; a!=48;a++)
oder
for(int a=0; a<=47;a++)

bei <= 48 greifst du auf element 48 zu, das es aber garnicht gibt

jooo, das war ein dummer fehler... Danke.

Jedoch bin ich noch immer so weit wie vorher

volkard

Falls das Programm 49 unterschiedliche Zahlen würfeln soll, muß man noch an zwei oder drei Ecken schrauben.

#include <iostream>
#include <ctime>
#include <cstdlib>

void randomize()
{
    srand(time(0));
}

bool checkme(int carray[],int anzahl)
{
    for(int a=0; a<anzahl;a++)
    {
        for(int i=0;i<anzahl;i++)
        {
            if(i!=a && carray[i]==carray[a])
            {
//                std::cout << carray[i] << std::endl;
                return false;
            }
        }
    }
    return true;
}

int main()
{
    srand((time(0)));
    int x[49];
    for(int i=0;i<=48;i++)
    {
        do{
            x[i] = rand()%255;
//            std::cout << x[i] << std::endl;
						for(int j=0;j<=i;j++)
						{
								std::cout << x[j] << ' ';
						}
						std::cout << '\n';
        }while(checkme(x,i+1)==false);
    }
}

|
          ||
          ||
      --\ \||
       --\ \||
        --\ \||
         --\ \|
          --\ \
             \ \
              \ \
               \ \
              MMMMMMMMM                         MMMMMMMMM
          MMMMMMMMMMMMMMMMMM               MMMMMMMMMMMMMMMMMM
       MMMMMMMXXXXXXXXXXMMMMMMM         MMMMMMMXXXXXXXXXXMMMMMMM
    MMMMMMXXXXXXXXXXXXXXXXXMMMMMM     MMMMMMXXXXXX:::::XXXXXXMMMMMM
   MMMMMXXXXXXXX::::::::XXXXXXMMMM   MMMMXXXXXX:::::::::::XXXXXMMMMM
  MMMMXXXXXXX:::::::::::::::XXXXMMM MMMXXXX::::::::::::::::::XXXXMMMM
 MMMMXXXXXX::::::::::::::::::::XXXMMMXXX:::::::::::.....:::::::XXXMMMM
 MMMXXXXX::::::::::::::::::::::::XXXXX:::::::::...........::::::XXXMMM
MMMXXXXX:::::::::::.......:::::::::X::::::::......    ......::::XXXXMMM
MMMXXXX:::::::::..............:::::::::::.......         ....::::XXXMMM
MMMXXXX::::::::..................:::::.......             ...::::XXXMMM
MMMXXXX:::::::.....................:............         ....::::XXXMMM
MMMXXXX:::::::....................................       ....::::XXXMMM
MMMXXXX:::::::......................................    .....::::XXXMMM
MMMXXXXX::::::....................................... ......::::XXXXMMM
MMMMXXXX:::::::.............................................::::XXXMMMM
 MMMXXXX::::::::............................................::::XXXMMM
 MMMMXXXX::::::::..........................................::::XXXMMMM
  MMMXXXX::::::::::.......................................:::::XXXMMM
  MMMMXXXX:::::::::::...................................::::::XXXMMMM
   MMMXXXXX::::::::::::..............................::::::::XXXXMMM
   MMMMXXXXX:::::::::::::.........................::::::::::XXXXMMMM
    MMMMXXXXX:::::::::::::::...................::::::::::::XXXXMMMM
     MMMMXXXXX:::::::::::::::::.............::::::::::::::XXXXMMMM
      MMMMXXXXXX::::::::::::::::::.......::::::::::::::XXXXXXMMMM
       MMMMXXXXXXXX::::::::::::::::...::::::::::::::XXXXXXXXMMMM
         MMMMXXXXXXXXX::::::::::::::::::::::\::::XXXXXXXXXMMMM
           MMMMMXXXXXXXXXX:::::::::::::::::\ \XXXXXXXXXMMMMM
              MMMMMMXXXXXXXXXXX:::::::::XXXX\ \XXXXMMMMMM
                  MMMMMMXXXXXXXXXXX:XXXXXXXXX\ \MMMMM
                      MMMMMMXXXXXXXXXXXXXXXMMM\ \
                          MMMMMMXXXXXXXMMMMMM  \ \
                              MMMMMXMMMMM       \ \
                                 MMMMM           \ \   \
                                  MMM          \  \ \ \\
                                   M            \\\\\\\\
                                                  \\\\\\
                                                    \\\\
                                                      \\

Danke

volkard

leicht verbesserte version.

#include <iostream>
#include <ctime>
#include <cstdlib>

bool checkme(int carray[],int anzahl)
{
    for(int a=0; a<anzahl;a++)
    {
        for(int i=0;i<a;i++)
        {
            if(carray[i]==carray[a])
            {
                return false;
            }
        }
    }
    return true;
}

int main()
{
    srand((time(0)));
    int x[49];
    for(int i=0;i<49;i++)
    {
        do{
            x[i] = rand()%256;
        }while(checkme(x,i+1)==false);
    }

    for(int i=0;i<49;i++)
    {
        std::cout << x[i] << ' ';
    }
    std::cout << '\n';
}

Ach volkard, die Version ist mir lieber Danke dir!

____               ____
	             /,,,,\_____________/,,,,\
	            |,(  )/,,,,,,,,,,,,,\(  ),|
	             \__,,,,___,,,,,___,,,,__/
	               /,,,/(')\,,,/(')\,,,\
	              |,,,,___ _____ ___,,,,|
	              |,,,/   \\o_o//   \,,,|
	              |,,|       |       |,,|
	              |,,|   \__/|\__/   |,,|
	               \,,\     \_/     /,,/
	                \__\___________/__/
	  ________________/,,,,,,,,,,,,,\________________
	 / \,,,,,,,,,,,,,,,,___________,,,,,,,,,,,,,,,,/ \
	(   ),,,,,,,,,,,,,,/           \,,,,,,,,,,,,,,(   )
	 \_/____________,,/             \,,____________\_/
	               /,/               \,\
	              |,| *H   U   G   S* |,|
	              |,|                 |,|
	              |,|                 |,|
	              |,|                 |,|
	               \,\       O       /,/
	               /,,\_____________/,,\
	              /,,,,,,,,,,,,,,,,,,,,,\
	             /,,,,,,,,_______,,,,,,,,\
	            /,,,,,,,,/       \,,,,,,,,\
	           /,,,,,,, /         \,,,,,,,,\
	          /_____,,,/           \,,,_____\
	         //     \,/             \,/     \\
	         \\_____//               \\_____//

DeepCopy

Lässt sich optimieren, auf reduzierte Komplexität von O(n²) zu O(n).

Alter Code:

for(int a=0; a<anzahl;a++)
    {
        for(int i=0;i<a;i++)
        {
            if(carray[i]==carray[a])
            {
                return false;
            }
        }
    }

Neuer Code:

#include <iostream>
#include <ctime>
#include <cstdlib> // rand, srand

void randomize()
{
    srand(time(0));
}

/** vergleiche die zahlen deiner liste nur bis zur neuen zahl    **/
/** ein doppelter vergleich mit den alten zahlen ist nicht nötig **/
/** es ist bekannt das diese einmalig sind!                      **/  

bool checkme(int carray[], int checkpos)
{
    for(int a=0; a < checkpos; a++)
    {
        if(carray[checkpos] == carray[a])
        {
            return false;
        }
    }
    return true;
}

int main()
{
    int x[49];
    randomize();

    for(int i=0;i<=48;i++)
    {
        do
        {
            x[i] = rand()%255;
        }
        while(checkme(x, i)==false);
    }

    for(int i=0;i<=48;i++)
      std::cout << x[i] << std::endl;
}

Ich hoffe das sehe ich richtig.

camper

Wir können auch gleich O(1) daraus machen

#include <iostream>
#include <ctime>
#include <cstdlib> // rand, srand

void randomize()
{
    srand(time(0));
}

int main()
{
    int x[49];
    bool check[255]={};
    randomize();

    for(int i=0;i<=48;i++)
    {
        do
        {
            x[i] = rand()%255;
        }
        while(check[x[i]]);
        check[x[i]]=true;
    }

    for(int i=0;i<=48;i++)
      std::cout << x[i] << std::endl;
}

Nexus

Falls es mit der STL gelöst werden soll:

#include <iostream>
#include <vector>
#include <algorithm>

int main() 
{ 
    srand(static_cast<unsigned int>(time(0))); 
	const size_t max_size = 256;
	const size_t size = 49;

	std::vector<int> numbers(max_size);
	for (int i = 0; i < max_size; ++i)
		numbers[i] = i;

	std::random_shuffle(numbers.begin(), numbers.end()); 

	for (int i = 0; i < size; ++i)
		std::cout << numbers[i] << std::endl;
}

DeepCopy

camper schrieb:

Wir können auch gleich O(1) daraus machen

Nein können wir nicht!

for(int i=0;i<=48;i++)
    {
        do
        {
            x[i] = rand()%255;
        }
        while(check[x[i]]);
        check[x[i]]=true;
    }

das hineinziehen des Funktionsaufrufs ändert die Komplexität nicht, wenn du darüber nachdenkst kommst du vielleicht von selber darauf.

Eine Auswahl und Vergleich von Zufallsbestimmen Zahlen kann niemals O(1) sein, w.z.B konstante Aufrufe von 102, oder 100, 48 Schleifen. Es ist nicht bekannt wie viele Aufrufe stattfinden, der Aufruf ist zwar linear aber das n in O(n) müsste für diese n-Funktion erst noch ermittelt werden. Das n in O(n) hätte also einen min-Wert mittel-Wert und einen max-Wert und kann damit nicht const sein, was die Voraussetzung für O(1) ist.

Bem: for() ist Konstant O(1), while() O(n) --> O(n+1) = O(n)

camper

Ich bezog mich nur auf die Komplexität des Vergleichs. Schließlich terminiert ein solcher Algorithmus im schlimmsten Fall gar nicht.

DeepCopy

Doch tut er, weil die Funktion rand() garantiert das ALLE zahlen gleichverteilt vorkommen und folglich der max-Wert der Funktion dem O(lim n->∞ - const) entspricht, wobei gilt n != ∞ und const fest.

volkard

Also den Vergleich kriegten wir von O(n^2) über O(n) runter auf O(1).
Interesaant ist die Komplexität des ursprünglichen Algos, wenn man damit n zufällige Zahlen von 1 bis n finden will. Für n=10000 waren es glaub ich 20 Minuten und n=100000 hab ich mich nicht getraut. Ich glaube auch nicht, daß es O(n^3) ist, sondern was viel Schrecklicheres.

DeepCopy

vokhard schrieb:

Also den Vergleich kriegten wir von O(n^2) über O(n) runter auf O(1).

Also ich weiß ja nicht wo du Informatik/Mathematik studiert hast aber es ist wirklich nicht O(1), mein letzter Kommentar dazu.

In diesem Sinne
Gruß Deep Copy

life

Doch es der Vergleich ist bei camper O(1).

@volkard: Dann probier doch mal Nexus Algorithmus aus. Der hat ja O(n) für die Gesamtlaufzeit ;).
Für den ursprünglichen Algorithmus müsste man die erwartete Laufzeit ausrechnen... Würd man spontan auf O(n^3 log(n)) tippen..