Moin,
momentan benutze ich für Zufallszahlen in Javascript folgende Funktion:
function zufallszahl(min,max)
{
return(min+parseInt(Math.random()*(max-min+1)));
}Oft kommen da jedoch gleiche Werte raus bzw die Wahrscheinlichkeit, dass bestimmte Werte kommen ist recht hoch. So wirklich zufällig ist das also nicht. Kann man das irgendwie verbessern?
Auch ernstgemeinte Antworten?
Uhm, bei mir kommen recht unterschiedliche Zahlen raus?
> function test(n, min, max) {
... var a=[];
... for (var i = 0; i < n; i++) {
..... a.push(zufallszahl(min, max));
..... }
... return a;
... }
undefined
> test(100, 1000, 2000);
[ 1556,
1259,
1769,
1052,
1811,
1106,
1771,
...
1533,
1891 ]> function test2(n, min, max) {
... var counter = 0, avg = 0;
... test(n, min, max).map(function(i) {
..... avg += i;
..... counter++;
..... });
... avg /= counter;
... return avg;
... }
undefined
> test2(1000, 10000, 20000);
15097.014
> test2(1000, 10000, 20000);
15115.344
> test2(1000, 10000, 20000);
14879.681
> test2(1000, 10000, 20000);
15006.768
> test2(1000, 10000, 20000);
14975.547
> test2(1000, 10000, 20000);
14992.434
> test2(1000, 10000, 20000);
15017.513
Das sieht doch auf dem ersten Blick solide verteilt aus?
Edit: parseInt ist eigentlich eine dumme Methode, um Zahlen zu runden. Es gibt extra Math.round dafür, denn parseInt macht aus 1.5 auch 1 und schon ist dein Zufall auf einer kleinen Zahlenmenge direkt über diesen Generator verfälscht.
Den wollte ich eigentlich auch bringen. Zum Thema: Wenn ein Pseudozufallsgenerator öfters die selben Zahlen bringt, muss es nicht heißen, das er nicht funktioniert. Zufällig kann es auch sein, dass der auch häufig die selbe Zahl bringt. Es gabs auch mal bei Apple Ipod shuffle, die leuten beschwerten sich, das der zufall manche songs bevorzugen würde. Die Apple Techniker konnten aber nichts am Allgorythmus finden und haben einfach ne Glättung rübergezogen, das die Zufall veränderte, in dem die Vergangenheit einbezogen wird.
Du kannst dir also Variablen für die letzten x Zahlen machen und in der aktuellen Ziehung überprüfen, ob in den letzten x Mal schonmal die Zufallszahl gezogen wurde. Wenn ja zieht er neu und falls neu, werden die variblen umgeschrieben.
Alternativ: Arbeite mit sehr großen Zahlbereichen mit Random, und Rechne den Modulo Rest von deinem Bereich. Ne Glättung tritt dabei nicht auf, aber vielleicht die Chance auf mehr Varianz im Pseudozufallszahlalgorytmus.
Ich hab eben nochmal herumgespielt und dieses +1 und parseInt verzerrt doch das Ergebnis, daher lieber:
function zufallszahl(min,max) {
return(min+Math.round(Math.random()*(max-min)));
}Ansonsten schließe ich mich Dirk an, wenn es um Pseudozufall-Anwendungsbereiche dieser Art geht.
xkcd quoten ist nie falsch. 
Bist du dir sicher, dass die Entropie zu gering ist? Ich hab’s mal mit 1 bis 100 getestet und ich finde es »ausreichend zufällig«. Geringe Zufallsbereiche sind für Menschen tückisch, weil sie oft den Eindruck vermitteln, sie wären nicht zufällig genug, aber auch mehrere aufeinanderfolgende Ergebnisse (im nicht ausufernden Maße) sind ein Zeichen für Entropie.
CHRiSNEW: Erreicht man durch Runden nicht den ungewünschten Nebeneffekt wie bei Schulnoten, dass man für das erste und letzte Element nur den halben Spielraum hat?
CHRiSNEW: Erreicht man durch Runden nicht den ungewünschten Nebeneffekt wie bei Schulnoten, dass man für das erste und letzte Element nur den halben Spielraum hat?
Hah, lustig. Ich wollte mich gerade im Augenblick noch verbessern. 
Da hast du natürlich Recht!
Daher doch (bzw die erste Version mit parseInt)
function zufallszahl(min,max) {
return(min+Math.floor(Math.random()*(max-min+1)));
}Also die Verteilung sieht jetzt weiterhin recht fair aus:
count(100000, 10, 30);
{ '10': 4714,
'11': 4795,
'12': 4807,
'13': 4858,
'14': 4819,
'15': 4746,
'16': 4711,
'17': 4814,
'18': 4794,
'19': 4699,
'20': 4771,
'21': 4761,
'22': 4898,
'23': 4646,
'24': 4676,
'25': 4654,
'26': 4740,
'27': 4924,
'28': 4757,
'29': 4692,
'30': 4724 }
Oder liege ich falsch?
Ich habs über nen Array gejagt, welches das Alphabet enthielt. Kam leider relativ häufig E raus. Nicht immer, aber doch erschreckend häufig.
Ich werde mal testen, wie sich das mit der Variante "return(min+Math.round(Math.random()*(max-min)));" verhält, Vielen Dank schon mal!
Ich habs über nen Array gejagt, welches das Alphabet enthielt. Kam leider relativ häufig E raus. Nicht immer, aber doch erschreckend häufig.
Da hatte bestimmt Etaoin Shrdlu die Finger mit im Spiel.
Fast alle Browser (mit Ausnahme von Apple-WebKit unter Windows, das einen kryptografisch sicheren Zufallsgenerator nutzt) nutzen einen linearen Kongruenzgenerator mit unterschiedlicher Periode auf Basis der ursprünglichen Java-Implementation bzw. rand() in der GNU- oder BSD-C-Standardbibliothek. Ein Problem ist dabei, dass der Startwert dabei neben anderen Faktoren (z. B. Fenster-Handle beim IE) häufig nur vom Startzeitpunkt des Browserprozesses abhängt.
Deswegen kann es sein, dass der Zufall häufig nicht zufällig genug aussieht. Ich habe auch in ein Projekt wie von Dirk beschrieben eine Warteschlange eingebaut, die die letzten 100 Ergebnisse nicht als zufälliges Ergebnis zulässt. Da handelte es sich aber auch schon um den gesamten Bestand von Flashloops auf z0r.de, die sich in ihrer Gesamtheit z. Zt. auf 7099 belaufen.
Ggf. wäre ein anderer, in Javascript implementierter PRNG wie z. B. ein Mersenne-Twister geeignet.
Ansonsten kann ich deinen Anwendungsfall auch nicht weiter nachvollziehen.
var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (var i = 0; i < 20; i++) {
console.log( // yay, funktionales Programmieren
Array.apply(null, Array(60)).map(function(_, i) {
return alphabet.charAt(Math.floor(Math.random() * alphabet.length))
}).join("")
)
}
BZJRBKXQGHGZJRKXRZGPNXRPAWAEPDLWFPJVJEERXGFGYGQXLLUNBXOGTXBQ
BDDCPPKLPGRGDSIFHABRMMNLGGTYXGKNLVMXDJHBMPPEABLQGZCXWYAMXIZY
UGOUUKNARTDXPWQOZOYCOBZXJCUYTUKAMIFIMACFVERUNGCXYVJWWMWEZAZC
VYHYQAKJZLPPAPVQDQBHTDHZNTLRKSTXONSHNAGBBIHKXGNOWVXPWFIMEWST
ITOIUOQOFQLMKZLOVWUAWFXIIGUCDODWLYYMGSKFLFIZFOHCZFXRRNGLUCZA
NEOBYNLMEQFLBGFIDFSHEPFNOZIPCUGXTHEFMMVGCRZYEIURLQNFKXQOFQDJ
VHDGPBAZUWJOFYLUOMZGOTSVJUBNGVAFHMQACPCNGYRMKILWDYUWTXJXKYJV
MFNCQJWGYMPADYPDHERJSWRAAZGHNADVXTTWINXLAUOVNNKIVVHNANYVJAFU
RJJJLXWLUACPGEKMCHFWNRFTCRQXDYNTRFROPNOTHEDXSJIKMOPUVIJVWCJL
YOJGSHMRNIJKGZVMWQFOULRGXBGNRORVHXANOEPMDJMXKLDQEUIGFEGBFPUG
SWNHBQTKDPBUWZRESNXZAJEPAQCDYXOHYEYRVZMITIFDGPNCFVPZQZIVZCVP
GPYYWTEXQQDIHRWSZQVOCEUZMYYDOKTQYITBJSTGTYVLCHCVFINJGUZDXEAO
WECGJIDXLGFZFRTGLWVGZHHYVITSUJLFMIILNRTEXWPLYPXUEPDBBZDUHQFQ
VJVVWABNLFWEOBRHPOJQKHGMZPPOJBOLRVVJRORWWGDOIEAQNSOFUIKLDDRY
TZWFQDUDOTUQCAKXZOOCZDCKTKLSORNMMMJAMLJVENPAGWTXRVLNLOLMEVZZ
KAAWEMUHMEQGKQMRJIWPIQUFOGKCGURQEOVBVSWVSSIUSSBDKPRWNJELUOAQ
OFWEXHPIPNIUSDLNCQFVVHCFOHADWDXXKQGQPDHTEJYAEMXKXCUJYIFZQDHQ
CYKYNFBHDPCVYWYOGBTTDHYOEFOJNIREEDKATMGUENJMYEPPQEEAWAJITMTE
EEODYLFEJSFIMHSALGGKFCJQABINPIGLAWUTXOQQGZLDKZMUOTCRZYYJKQCA
JRPPDUGDGZOTPISHQCRQCBYEAHHSVHTCBHOSQGYKABIDTHHSFIPXVGONWVPRIch empfehle: Dual_EC_DRBG
So habe ich das momentan:
function zufallszahl(min,max)
{
return(min+Math.round(Math.random()*(max-min)));
}
function getbuchstabe()
{
var alphabet=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","R","S","T","U","V","W","Z"];
var buchstabenzahl=alphabet.length;
var zufall=zufallszahl(0,buchstabenzahl);
return alphabet[zufall];
}(Q, R, X und Y bewusst weggelassen)
1. Wenn dir der lineare Kongruenzgenerator nicht zufällig genug aussieht, machst du was falsch (ausser du arbeitest an Krypto).
2. Zufall ist halt zufällig ¯\_(ツ)_/¯
Erster kurzer Hinweis, da ist ein Bug im Code. So wie deine Funktion geschrieben ist, sind sowohl min als auch max inklusive. Da hast du in manchen Fällen Rückgabewerte ausserhalb des Arrays (zufall == array.length).
Bugfix, einfach abrunden, siehe unten.
Math.round() ist sowieso gefährlich, siehe: https://de.wikipedia.org/wiki/Rundung#Mathematisches_Runden
»Das kaufmännische Runden erzeugt kleine systematische Fehler, da das Aufrunden um 0,5 vorkommt, das Abrunden um 0,5 jedoch nie; das kann Statistiken geringfügig verzerren.«
In deinem Falle ist hier aber noch ein anderes Problem: Weil A am Rand ist, können nur die Werte [0 bis 0.4999] zu A werden. Für alle anderen ist es aber mehr, nämlich z.B. [3.5 bis 4.4999] für den Buchstaben D. Das heisst konkret, dass A bei dir halb mal so oft vorkommt wie alle anderen Buchstaben! Für das letzte Element gilt das gleiche - das ist bei dir wegen obigem Bug aber nicht einem Buchstaben zuzuweisen.
Darum: Unbedingt Math.floor() (oder .ceil()) nehmen!
function zufallszahl(min,max)
{
return(min+Math.floor(Math.random()*(max-min)));
}Die Zufälligkeit sieht für mich aber ziemlich okay aus, das ist alles Uniformverteilt wie es sein soll: https://jsfiddle.net/p7r3owL3/
Tipp: Mach Math.round() an, dann siehst du auch den statistischen Fehler den ich erwähnt habe.
Wenn du die Anzahl versuche runterdrehst (z.B. auf 100) dann sieht es anders aus. Kann gut sein dass beim manuellen Testen (mit weniger als 100 Versuchen) ein Buchstabe überdurchschnittlich häufig vorkommt, so funktioniert halt Zufall. Erst bei sehr vielen Versuchen gleicht sich das wieder aus.
Meine Konklusion ist also, dass alles okay ist. Wenn du trotzdem einen besseren Zufallsgenerator willst (wobei wie heinze sagt, das Ding ist zufällig, sieht man halt nicht), alle modernen Browser (IE11+) besitzen einen kryptografisch sicheren Zufallsgenerator: https://developer.mozilla.org/en-US/docs/Web…getRandomValues
Der obligatorische Comic zu dem Thema
Nachtrag: Habe die Diskussion zwischen sandi und CHRISNEW oben übersehen, sorry!
Danke für den Hinweis! Habe es jetzt auf "return(min+Math.floor(Math.random()*(max-min)));" umgebaut
Aus aktuellem Anlass (Blogpost von Kumpel, Englisch): http://nickler.ninja/blog/2015/06/28/csgojackpots-weak-rng/
Kurzum: Math.random() ist zwar uniform (d.h. jede Zahl hat die gleiche Wahrscheinlichkeit), aber vorhersagbar. Wenn man zwei rohe (d.h der direkte Output zwischen 0 und 1), aufeinander folgende Zufallszahlen kennt, kann man die restlichen voraus sagen.
Oh schön.. Vielen Dank für den Link!
Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!