wie kann man die Zahlen +1 oder -1 zufällig bestimmen lassen (nicht die 0 dazwischen, quasi ein Münzwurf)

Ich kenne:

rand() % 5

für eine Zahl wischen 0 und 5.

oder

rand() % 10 + 1

für eine Zahl zwischen 1 und 10.

Aber ich komm nicht drauf und finde nix wie ich nur zwischen -1 und 1 wählen lasse.

Hoffe ihr habt ein Tipp,

lg

Ollowain

Ansonsten benutze den neuen random-Header. Der ist in vielen Dingen besser.

Oder mit einer "Tabelle"... 0 -> -1, 1 -> 1

@marthog

Wie schaut denn der neue random header aus? Bin recht noch ein ziemlicher Neuling was das angeht, google spuckt alles mögliche aus..

Was bed. denn das "*" bei:

rand()%2*2-1

lg

Edit: hier eingefügt

rand() %2*2-1

doch nichts Anderes als eine Zahl von 4 bis -1 oder von 0 bis 3.
Oder falls Punkt vor Strich hier nicht gilt von 2 bis 1.

Doch raus kommt tatsächlich nur random 1 oder-1.

Ja aber dann steht bei:

rand() %2*2-1

Nettes Leerzeichen!
Ich mach auch mal eins rein:

rand()%2* 2-1

Also die Operatoren *, / und % sind gleichrangig und gehen von links nach rechts.

Die ist klar, was rand()%5 also macht, sagste.
Was macht dann (rand()%5)*2? (Die Klammern kann man auch weglassen hier.)

(rand()&2)-1

Schöne Lösung, zumal sie auch noch ohne Division (modulo) auskommt (auch wenn wohl jeder halbwegs intelligente Compiler bei einem "%2" wohl keine DIV-Instruktion erzeugt).

rand4speed schrieb:

Wie schaut denn der neue random header aus? Bin recht noch ein ziemlicher Neuling was das angeht, google spuckt alles mögliche aus..

http://en.cppreference.com/w/cpp/header/random

Für die hier genannten Lösungen sähe das dann mit dem neuen random-header etwa so aus:

#include <random>
...
std::minstd_rand generator(std::random_device());
std::uniform_int_distribution<int> verteilung(0, 1);
...
int zufallszahl = verteilung(generator) * 2 - 1;

Die Verteilung (hier Gleichverteilung - "uniform distribution") ermöglicht es ziemlich einfach einen Wertebereich anzugeben, in dem die Zufallszahlen liegen sollen. Ich würde diese Variante bevorzugen, da die Modulo-Lösung den Nachteil hat, dass die Zufallszahlen nicht für alle Wertebereiche genau gleichverteilt sind (In diesem speziellen Fall allerdings schon).

Finnegan

rand()%2? 1 : -1

Wir sind hier schließlich nicht beim obfuscated code contest.

"\xFF\x01"[rand()%2]

Hier noch eine Möglichkeit:

"\xFF\x01"[rand()%2]

Und dann mit -fsigned-char kompilieren?

std::array<int,2>{-1,1}[rand()%2]

ist standardkonformer (da es weder von der Signedness, noch der 8-Bittigkeit und Overfloweigenschaft von char abhängt).

for (;;)
{
	int r = -23 + std::rand();
	if (std::labs(r) == 1)
	{
		return r;
	}
}

Wenn die Zufallszahl sich nicht so oft ändern muss, geht auch das:

std::ptrdiff_t randomness = reinterpret_cast<std::intptr_t>(&std::rand);
return (randomness < 0) ? -1 : 1;

Oder der Klassiker für maximale Effizienz:

int uninitialized;
return (uninitialized < 0) ? -1 : 1;

Oder der Klassiker für maximale Effizienz:

UB. Außerdem nicht zufällig wenn die Stackframes sich überschneiden.

Ich befürchte eine Deface-Attacke auf TyRoXx Account, daher fühle ich mich verpflichtet moderationstechnische Maßnahmen zu ergreifen und Account bis auf weiteres zu sperren.

Und warum ptrdiff_t für randomness ?

Oh, ich habe das mal korrigiert:

std::intptr_t randomness = reinterpret_cast<std::ptrdiff_t>(&std::rand);
return (randomness < 0) ? -1 : 1;

Arcoth schrieb:

Oder der Klassiker für maximale Effizienz:

UB. Außerdem nicht zufällig wenn die Stackframes sich überschneiden.

Kein Problem, einfach mit -O0 übersetzen.