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

#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;
    }

}

#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; 
    } 

}

srand()

in

randomize()

auf Variante:

int randomize()
{
    static bool bFirstCall = false;

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

    int zahl = rand();
    return zahl;
}

Thank you very much

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;
		}
	}
}

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

Jedoch bin ich noch immer so weit wie vorher

#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);
    }
}

Danke

#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';
}

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

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.

#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;
}

#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;
}

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)

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

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

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

Der VERGLEICH, Du Nase! Du Weihnachtsmann!
Der Aufruf von checkme(i) war vorher quadratisch und jetzt ist er ersetzt durch das konstante check[x[i]].
Der Vergleich steckt noch in einer äußeren Schleife, weswegen der gesamte Algo O(viel) hat und nicht O(1), das ist klar.

Der VERGLEICH, Du Nase! Du Weihnachtsmann!

Ich kann mir ein Grinsen nicht verkneifen, ich ein Weihnachtsmann

Nicht böse sein, aber woher sollte ich wissen das du mit VERGLEICH eine Stelle im Code und nicht den ganzen Algo meinst.

... woher sollte ich wissen das du mit VERGLEICH eine Stelle im Code und nicht den ganzen Algo meinst.

Weil du damit angefangen hast, dich auf den Code, der den Vergleich durchführt, zu beschränken.

DeepCopy schrieb:

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

Alter Code:

...