long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    int *temp=new int;
    if (*temp!=Zufall)
    {
        *temp=Zufall;
        return Zufall;
    }
    if (*temp==Zufall)
    {
       return rnd(a,b);
    }
}

Ich hab mir gedacht ich speichere die vorherige Zufallszahl auf dem HEap, weil auf diesem ja nichts gelöscht wird, auch nicht nach Beendigung der Funktion. Und wann den die Variable Zufall mit der Zahl auf dem Heap übereinstimmt dann wird die selbe Funktion wieder aufgerufen und returned, solange bis die Variable Zufall nicht mehr mit der Zahl auf dem Heap übereinstimmt.
Aber irgendwie gibt es immer noch zwei gleiche Zahlen hintereinander.
Kann sich jemand vorstellen was ich bezwecken möchte? Und geht das auch? Ich glaub das meine Funktion nicht geht hat irgendwas mit der Zeile:

int *temp=new int;

zu tun. Da immer wieder neuer Speicher mit dem selben Namen reserviert wird, das is glaub ziemlich böse da ja dann Speicherlecks entstehen, aber wie kann ich das dann machen, das *temp nur ein einziges mal auf dem Heap reserviert wird, und nicht wieder überschrieben wird, sodass man immer auf die gleiche Stell auf dem Heap zugreift???
Dankeschön schon mal im Voraus.

http://www.cplusplus.com/reference/clibrary/cstdlib/srand.html

sie arbeiten zusammen.

ps: zur zweiten frage, warum denn auf dem heap? und warum nicht der funktion .. wenn schon auf dem heap, den zeiger auf die stelle übergeben, und vorher allozieren, und später freigeben..

long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int temp=a-1;//Startwert ist garantiert außerhalb des Ziel-Intervalls
    if (temp!=Zufall)
    {
        temp=Zufall;
        return Zufall;
    }
    else
    {
       return rnd(a,b);
    }
}

(PS: Wenn du dir mehrere frühere Zufallswerte merken willst, benötigst du ein Array oder einen STL-Container)

Ich wollte meine Zufalls Funktion verbessern,...

... was prinzipiell eine gute Idee ist.
Aaaaber: Bedenke, dass Du "Zufall nur durch Zufall erzeugst"
Wenn Du also verbessern möchtest, brauchst Du eine weitere "Zufallsquelle". Das Ganze ist nicht trivial und hat weniger mit Programmiertechnik als mit dem Konzept zu tun.

Ich habe allerdings den Eindruck, dass das, was Du willst, eigentlich schon srand() (und ein sinnvoller Umgang damit) erledigt ... und wenn Du bei jedem Programmstart einen anderen Startwert haben willst, kannst Du das srand() über einen entsprechenden "seed-Parameter" mitteilen (r.B. letztes erzeugtes rand() oder aktueller Timestamp oder Rauschen am PCI-Bus oder ....).

Gruß,

Simon2.

Ich wollte meine Zufalls Funktion verbessern, sodass nie zweimal der gleiche Zufall ist bzw. die gleiche Zahl:

Super! Wenn du CStolls Lösung eingebaut hast solltest du deine Funktion am besten noch "zufälliger" machen:

Sorg dafür dass niemals zwei
- ungerade Zahlen
- gerade Zahlen
- Primzahlen
- Zahlen der Form x^n
- ...
aufeinander folgen

srand(time(0));
rand()

...ist natürlich immer fester Bestandteil meines Programms und wird gleich ganz am anfang von der main eingefügt, hab aber jetzt halt bloß meine Funktion gepostet.

Super! Wenn du CStolls Lösung eingebaut hast solltest du deine Funktion am besten noch "zufälliger" machen:

Sorg dafür dass niemals zwei
- ungerade Zahlen
- gerade Zahlen
- Primzahlen
- Zahlen der Form x^n
- ...
aufeinander folgen

Das war doch ironisch gemeint, oder?

Die ganze Idee ist doch total unsinnig, denn du verschlechterst durch solche Bedingungen doch nur deine Zufallsfunktion. Warum sollte denn nicht zweimal hintereinander dieselbe Zahl fallen? Die Wahrscheinlichkeit für jede Zahl sollte doch immer gleich sein. Du hingegen veränderst die Wahrscheinlichkeiten, indem du einige Zahlen basierend auf vorherigen Ergebnissen unmöglich machst.

Beim Würfeln kommt es ja auch vor, dass man mehrmals hintereinander dieselbe Zahl würfelt.

finix schrieb:

...
aufeinander folgen

Das war doch ironisch gemeint, oder?

Wie kommst jetzt darauf?

Echten Zufall kannst du nur erhalten, wenn du auf etwas zurückgreifst, was du von außen nicht beeinflussen kannst, z.B. statisches Rauschen oder ein Würfelbecher (obwohl - wer richtig wirft, kann da dem "Zufall" auch auf die Sprünge helfen ;)).

Bei meinem Zufall darf das aber nicht passieren, schon klar das bei einem Zufall auch mal 2 Zahlen hintereinander kommen aber

Hätte man sich fast denken können. Du setzt an der komplett falschen Stelle an. Die Lösung ist nicht int random( int min, int max ) (ja, Bezeichner dürfen lang & sinnvoll sein) kaputt zu machen, sondern dein Bot muss sich selber merken welche Antwort er zuletzt gegeben hat (ggf mehr als nur die letzte -> std::deque , std::list ).

...1.die Zufallsfunktion in C++ find ich soieso irgendwie merkwürdig, das ist kein richtiger Zufall sondern es wird nur errechnet und ist somit kein Zufall mehr weil mans immer ausrechnen kann. 2.was ist eigentlich Zufall ist das was C++ da jetzt macht Zufall oder ist es Zufall wenn man diesen nicht errechnet sondern "zufällig" vom Treiber rauschen bekommt (hab da mal sowas gelesen das man das mit so ner Speziellen Hardware machen kann), oder ist es nur Zufall wenn man würfelt oder gibts überhaupt gar keinen Zufall. Ich find das is jetzt schon fast bisschen philosophisch.
3. Bei mir dürfen keine gleichen Zahlen hintereinander kommen, da http://www.c-plusplus.net/forum/viewtopic-var-t-is-169080-and-start-is-0.html da ist mein Programm bisschern weiter gepostet (jetzt funktioniert alles und es ist bisschen umgebaut) zumindestens will ich nicht das der "Bot" zweimal den gleichen Satz sagt. Wäre ja immer blöd wenn der dreimal hintereinander sagt "Schön dich zu sehen." "Schön dich ....."........".

*** semantic underflow error ***
Sorry, aber das kann kein Mensch lesen.

Übrigens: Zufall ist mitnichten "philospohisch" (im Sinne von "kann jeder machen, wie er will"), sondern durchaus streng mathematisch zu fassen.
Du musst Dich halt entscheiden, welches Zufallskriterium Du brauchst (und in welchem Maß): Unvorhersagbarkeit ? gleichförmige Verteilung ? Unabhängigkeit von bestimmten Parametern (z.B. Zeit) ? ....

Ersteres also schonmal nicht, denn Deine Forderung "x(i) != x(i-1)" bricht damit - übrigens sitzt Du damit einem Trugschluß über den Zufall auf. Darf denn der übernächste Wert wieder gleich sein ? Oder auch das nicht ? Und der überübernächste ? ....
Mit jeder weiteren Abhängigkeit schränkst Du den Zufall weiter ein - obwohl Du ihn doch eigentlich erweitern willst, oder ?

Ach ja: "Echten Zufall" (im Sinne von underterministischem Verhalten) wirst Du mit deterministischen Algorithmen sowieso nicht hinbekommen - egal, wie Du sie noch "verrickelst".
Dann lies lieber gleich den (ungenutzten) Eingang der TV-Karte aus.

Gruß,

Simon2.

Wenn du andere Random-Algos brauchst: in der Boost-Library sind welche vorhanden. Habe von der Materie selber aber keine Ahnung. Sieht aber interessant aus:
http://www.boost.org/libs/random/index.html

Diese random-Lib ist auch im TR1 drin, dürfte hier im Forum aber noch niemand haben.

long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int *temp=new int[10];
    static int *counter=new int(0);
    static int *hv=new int(0);

    if (*counter>10)
    {
        *counter=0;
    }
    if (*hv>10)
    {
        *hv=10;
    }

    for(int i=0;i<*hv+1;i++)
    {
        if(Zufall==temp[i])
        {
            return rnd(a,b);
        }
    }
    temp[*counter]=Zufall;
    *counter++;
    *hv++;
    return Zufall;
}

Dankeschön schon mal im Voraus.

Zum Seeden verwendest du dann z.B. /dev/rand (*nix) bzw. CryptGenRandom (win32), dann hast du sehr sehr gute Zufallszahlen.

Und zu guten Zufallszahlen gehört auch dass manchmal 2x (oder auch öfters) hintereinander die gleiche Zahl kommt.

p.S.: zum Thema Bot: schreib doch einfach alle Antworten beim Initialisieren des Bots in einen Vektor, und mische den dann mit Hilfe des Zufallszahlengenerators durch. Dann gehst du einfach der Reihe nach den Vektor durch, und wenn du am Ende angekommen bist mischt du den Vektor nochmal durch und fängst von vorne an.

Und natürlich tuts für so eine einfache und unkritische Aufgabe auch rand()

long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int temp[10];
    static int counter=0;
    static int hv=0;
    ...
}

Eventuell könntest du die Rekursion noch durch eine Schleife ersetzen:

while(find(temp,temp+hv,Zufall)!=temp+hv)
  Zufall = rand()%(b-a+1) + a;

...ist ein echt guter Generator...

Dass Problem ist aber wohl, dass er gar keine echten Zufallszahlen will. Letztlich will Stromberg auf eine Strategie hinaus - und da ist echter Zufall nur bedingt hilfreich.
@Stromberg: Ich würde Dir raten, "Zufallszahl" und "Strategie" komplett zu trennen - so wie Du schon damit anfängst, indem Du die Regel "Zug darf nicht innerhalb der letzten 10 Züge vorkommen" aufstellst. Werde Dir doch erstmal klar darüber, welche sonstigen Strategieregeln Du verfolgen möchtest ... das ist viel wesentlicher als die Qualität der Zufallszahl.

Gruß,

Simon2.

...

...
    static int *counter=new int(0);
    static int *hv=new int(0);
...

...

Kann es sein, dass Du von Java kommst ?

Gruß,

Simon2.

Die Idee mit den vectoren durchmixen is echt clever mal schaun ob ich das umsetze, aber was sagst du zu der Funktion?
Dankeschön schon mal im Voraus.

Ich würde auf jede Fall das

static int *temp=new int[10];
    static int *counter=new int(0);
    static int *hv=new int(0);

in das

static int temp[10] = {};
    static int counter = 0;
    static int hv = 0;

ändern.

static int *temp=new int[10];
static int *counter=new int(0);
static int *hv=new int(0);

Weil: Wenn ich die Variablen nicht auf dem Heap reserviere dann werden die doch nach Beendigung der Funktion wieder gelöscht. Aber ich will doch das die auch beim neuen Funktionsaufruf scon mitgezählt haben. Weil was auf dem Heap deklariert wird, da is es doch so das es erst wieder gelöscht wird wenn man die halt mit delete löscht. Und static benutze ich da ja nur, das sie nur einmal deklariert werden und nicht andauernd überschrieben werden und es dann Speicherlecks gibt!
Oder macht static etwa etwas anderes hab ich hier irgendwas falsch verstanden.
Bitte klärt mich auf :)! Dankeschön schon mal im Voraus.

PS: Is mir noch aufgefallen hier is n kleiner Fehler drin. Gut das ich den selber gefunden habe is n peinlicher Fehler.

long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int *temp=new int[10]; //<-- wenn das Array 10 Felder hat dann is es ja von 0-9
    static int *counter=new int(0);
    static int *hv=new int(0);

    if (*counter>10) //Dann muss es hier aber heißen if(*counter>9)
    {
        *counter=0;
    }
    if (*hv>10)  //Und hier muss es heißen is *hv>9
    {
        *hv=10;
    }

    for(int i=0;i<*hv+1;i++)
    {
        if(Zufall==temp[i])
        {
            return rnd(a,b);
        }
    }
    temp[*counter]=Zufall;
    *counter++;
    *hv++;
    return Zufall;
}

PS: Und den Flüchtigkeitsfehler hast du vermutlich an der falschen Stelle ausgemerzt - lass lieber das "i<*hv+1" in der for-Schleife weg.