JS berechnet die Gewinnwahrscheinlichkeit basierend auf dem Preisgewicht

JS berechnet die Gewinnwahrscheinlichkeit basierend auf dem Preisgewicht

1. Beispielszenario

1.1. Legen Sie den Preisnamen für die Verlosung fest

Namen der Auszeichnungen: [„Erster Preis“, „Zweiter Preis“, „Dritter Preis“, „Kein Preis“]. Gehen wir davon aus, dass es bei der Gewinnspielveranstaltung diese vier Preise gibt. Der Entwickler kann diese natürlich auf weitere erweitern.

var prizes = ["Erster Preis", "Zweiter Preis", "Dritter Preis", "Kein Preis"]; // Array mit Preisnamen

1.2. Legen Sie das Gewicht jeder Auszeichnung fest

Gewichtungen der Auszeichnungen: [1, 5, 20, 74]. Preisgewichte werden hauptsächlich verwendet, um die Wahrscheinlichkeit darzustellen, jeden Preis zu gewinnen. Hier ist die Summe der Preisgewichte 100 (=1+5+20+74), wobei 1 bedeutet, dass die Wahrscheinlichkeit, den ersten Preis zu gewinnen, 1 % beträgt; 5 bedeutet, dass die Wahrscheinlichkeit, den ersten Preis zu gewinnen, 5 % beträgt; 20 bedeutet, dass die Wahrscheinlichkeit, den dritten Preis zu gewinnen, 20 % beträgt; und die restlichen 74 bedeuten, dass die Wahrscheinlichkeit, nicht zu gewinnen, 74 % beträgt.

var prizeWeight = [1, 5, 20, 74]; // Preisgewichtungs-Array, das den Prozentsatz der Gewinnchance für jeden Preis insgesamt darstellt. Beispielsweise beträgt die Gewinnquote für den ersten Preis 1 % und die Gewinnquote für den zweiten Preis 5 %.

Wenn für die Lotterie mehrere Preise festgelegt sind, kann der Entwickler auch die Summe des Gewichtsarrays entsprechend erweitern, z. B. wenn die Summe der Gewichte 500, 1000 usw. beträgt, und die Array-Elemente entsprechend festlegen, um darzustellen, wie oft und in welcher Höhe bei jeweils 500 Ziehungen Preise gewonnen werden können.

Darüber hinaus können Entwickler den Auszeichnungsnamen und das Auszeichnungsgewichtungs-Array auch zusammen in einem Objekt deklarieren:

//Legen Sie den Namen der Auszeichnung, das Gewicht usw. fest. Array var prizes = [
    {"name": "Erster Preis", "weight": 1}, 
    {"name": "Zweiter Preis", "weight": 5}, 
    {"name": "Dritter Preis", "weight": 20}, 
    {"name": "Nicht gewinnend", "weight": 74}
];

1.3. Regeln für die Verlosung

  • 0 < die Zufallszahl dieser Lotterie <= 1, was bedeutet, dass der erste Preis gewonnen wurde;
  • 1 < die Zufallszahl dieser Lotterie <= 5, was bedeutet, dass Sie den zweiten Preis gewinnen;
  • 5 < die Zufallszahl dieser Lotterie <= 20, was bedeutet, dass Sie den dritten Preis gewinnen;
  • Die Zufallszahl für diese Ziehung ist > 20, was bedeutet, dass es keinen Gewinner gibt.

2. Umsetzungsprinzip

Da es sich bei diesem Artikel um eine einfache Implementierung handelt, ist auch das Prinzip dieses Lotterieprogramms relativ einfach gestaltet:

  • Basierend auf der Summe des Gewichtungsarrays (weightSum) wird bei jeder Ziehung eine Gewichtungszufallszahl (weightRandom) generiert. Diese Gewichtungszufallszahl (weightRandom) liegt zwischen 0 und weightSum (Gewichtssummenwert). Der in diesem Beispiel festgelegte Gewichtungsarray-Summenwert beträgt 100, was bedeutet, dass die generierte Gewichtungszufallszahl zwischen 0 und 100 liegt.
  • Anschließend vergleichen wir diese gewichtete Zufallszahl (weightRandom) mit allen Elementwerten im Gewichtsarray, um zu berechnen, zwischen welchen zwei Preisen diese gewichtete Zufallszahl (weightRandom) liegt, welche Gewinnregel sie erfüllt und welchem ​​Preisnamen sie entspricht.

Beispielsweise beträgt die in einer bestimmten Lotterie generierte gewichtete Zufallszahl (weightRandom) 15,15. Gemäß den Aktivitätsregeln in 1.3 bedeutet dies, dass die diesmal generierte gewichtete Zufallszahl (weightRandom) den dritten Preis gewinnen kann, da 5 <15,15 <= 20 ist.

Lassen Sie uns sie separat implementieren:

2.1. Gewichte und Werte berechnen

//Kumulative Summenfunktion des Arrays: Array.reduce(function(prev ,curentValue), initialValue)
var weightSum = prizeWeight.reduce(function(prev, currVal){ //Summe der Gewichte berechnen: 1+5+20+74=100
    return prev + currVal; //prev ist der Wert nach der vorherigen Akkumulation, currVal ist der Wert, der dieses Mal hinzugefügt werden soll}, 0);

2.2. Schreiben Sie eine Lotteriefunktion

Generieren Sie einen zufälligen Gewichtswert zwischen 0 und weightSum basierend auf dem Gewicht und dem Wert weightSum

//Lotteriefunktion var lottery = function(weightSum) {
    var res = "Kein Gewinn"; //Die Standardeinstellung für das Lotterieergebnis ist "Kein Gewinn"
    console.log("Auszeichnungsgewicht und -wert dieses Programms:", weightSum);
    
    //Generiere eine zufällige Gewichtszahl zwischen 0-weightSumvar random = Math.random()*weightSum; //Generiere eine zufällige Gewichtszahl (zwischen 0 und weightSum)
    console.log("Das zufällige Gewicht dieser Ziehung:", random);
    
    //Gewichtsarray neu organisieren und sortieren var concatWeightArr = prizeWeight.concat(random); //Zufallszahlen zum Gewichtsarray hinzufügen var sortedWeightArr = concatWeightArr.sort(function(a, b){return ab;}); //Das neue Gewichtsarray mit den Zufallszahlen von klein nach groß sortieren (aufsteigende Reihenfolge) console.log("Das neue Gewichtsarray mit den Zufallszahlen ist aufsteigend sortiert:", sortedWeightArr);
    
    //Array-Index der gewichteten Zufallszahl var randomIndex = sortedWeightArr.indexOf(random); //Die Position der indizierten Zufallszahl im neuen Gewichtsarray randomIndex = Math.min(randomIndex, prizes.length -1); //Der Index der gewichteten Zufallszahl darf die Länge des Preisarrays -1 nicht überschreiten, berechne die Indexposition der Zufallszahl im Preisarray neu console.log("Array-Index, der dieser gewichteten Zufallszahl entspricht:", randomIndex);
    
    //Den entsprechenden Preis abrufen res = Preise[Zufallsindex]; //Das Ergebnis dieser Lotterie aus dem Preis-Array abrufen console.log("Das Ergebnis dieser Lotterie:", res);
    
    return {"weightSum": weightSum , "weightRandom": random, prizeIndex: randomIndex, "data": res}; //Gibt das Ergebnis dieser Lotterie zurück};

Es ist zu beachten, dass:

(1) Generieren Sie in der Lotteriefunktion zuerst eine zufällige Gewichtszahl (zufällig), führen Sie dann diese zufällige Gewichtszahl (zufällig) mit dem ursprünglichen Gewichtsarray zusammen (mit der Funktion Array.concat (), der Rückgabewert ist ein neues Array, das ursprüngliche Gewichtsarray bleibt unverändert), generieren Sie ein neues Gewichtsarray und sortieren Sie das neue Gewichtsarray von klein nach groß (aufsteigende Reihenfolge) (mit der Funktion Array.sort ()). Auf diese Weise liegt die zufällige Gewichtszahl (zufällig) der Größe nach zwischen zwei Preisgewichtswerten. Schließlich können Sie durch Indizieren der zufälligen Gewichtungszahl (random) im neuen Gewichtungs-Array das entsprechende Element im Array mit den Auszeichnungsnamen abrufen.

(2) Beispielsweise beträgt die von einer Lotteriefunktion generierte Zufallsgewichtszahl 15,15. Wenn sie mit dem ursprünglichen Gewichtsarray [1, 5, 20, 74] zusammengeführt und sortiert wird, entsteht ein neues Gewichtsarray [1, 5, 15,15, 20, 74]. Die Zufallsgewichtszahl (15,15) liegt zwischen 5 und 20. Der Index der Zufallsgewichtszahl (15,15) im neuen Gewichtsarray ist 2. Das entsprechende Element des Preisnamen-Arrays mit dem Index 2 wird herausgenommen: Preise[2] = „dritter Preis“. Daraus lässt sich schließen, dass bei dieser Lotterie der dritte Preis gewonnen werden kann.

(3) Um in der Lotteriefunktion zu bestimmen, welchem ​​Preis die Größe der gewichteten Zufallszahl (random) entspricht, d. h. um die Größe der gewichteten Zufallszahl mit dem Wert jedes Elements im Gewichtsarray zu vergleichen, verwendete der Editor nicht die herkömmliche for-Schleife, um die Größe der gewichteten Zufallszahl (random) und jedes Element im Array PrizeWeight zu durchlaufen und zu vergleichen. Stattdessen führte der Editor ein neues Gewichtsarray zusammen, generierte es und sortierte es. Anschließend verwendete er die Funktion Array.indexOf(), um den Index der gewichteten Zufallszahl (random) zu indizieren und den diesem Index entsprechenden Preisnamen abzurufen.

3. Projektcode vervollständigen

Der Kerncode dieses Beispielprojekts js lautet wie folgt:

//layui modulare Referenz layui.use(['jquery', 'util'], function(){
    var $ = layui.$, util = layui.util;
    
    //Arrays für Preisnamen, Gewicht, Anzahl der Gewinne usw. festlegen. var prizes = ["Erster Preis", "Zweiter Preis", "Dritter Preis", "Kein Gewinner"]; //Array mit Preisnamen var prizeWeight = [1, 5, 20, 74]; //Array mit Preisgewicht, das den Prozentsatz der Gewinnchance für jeden Preis insgesamt darstellt. Beispielsweise beträgt die Gewinnquote für den ersten Preis 1 % und die Gewinnquote für den zweiten Preis 5 %.            
    
    // Entwickler können auch Preisnamen, Gewichte und andere Arrays in einem Objekt deklarieren // var prizes = [
    // {"name": "Erster Preis", "weight": 1}, 
    // {"name": "Zweiter Preis", "weight": 5}, 
    // {"name": "Dritter Preis", "weight": 20}, 
    // {"name": "Nicht gewinnend", "weight": 74}
    //];                
    
    //Kumulative Summenfunktion des Arrays: Array.reduce(function(prev ,curentValue), initialValue)
    var weightSum = prizeWeight.reduce(function(prev, currVal){ //Summe der Gewichte berechnen: 1+5+20+74=100
        return prev + currVal; //prev ist der Wert nach der vorherigen Akkumulation, currVal ist der Wert, der dieses Mal hinzugefügt werden soll}, 0);
    document.getElementById("weightSum").innerhtml = weightSum; //Gewicht und Wert festlegen //Lotteriefunktion var lottery = function(weightSum) {
        var res = "Kein Gewinn"; //Die Standardeinstellung für das Lotterieergebnis ist "Kein Gewinn"
        console.log("Auszeichnungsgewicht und -wert dieses Programms:", weightSum);
        
        //Generiere eine zufällige Gewichtszahl zwischen 0-weightSumvar random = Math.random()*weightSum; //Generiere eine zufällige Gewichtszahl (zwischen 0 und weightSum)
        console.log("Das zufällige Gewicht dieser Ziehung:", random);
        
        //Gewichtsarray neu organisieren und sortieren var concatWeightArr = prizeWeight.concat(random); //Zufallszahlen zum Gewichtsarray hinzufügen var sortedWeightArr = concatWeightArr.sort(function(a, b){return ab;}); //Das neue Gewichtsarray mit den Zufallszahlen von klein nach groß sortieren (aufsteigende Reihenfolge) console.log("Das neue Gewichtsarray mit den Zufallszahlen ist aufsteigend sortiert:", sortedWeightArr);
        
        //Array-Index der gewichteten Zufallszahl var randomIndex = sortedWeightArr.indexOf(random); //Die Position der indizierten Zufallszahl im neuen Gewichtsarray randomIndex = Math.min(randomIndex, prizes.length -1); //Der Index der gewichteten Zufallszahl darf die Länge des Preisarrays -1 nicht überschreiten, berechne die Indexposition der Zufallszahl im Preisarray neu console.log("Array-Index, der dieser gewichteten Zufallszahl entspricht:", randomIndex);
        
        //Den entsprechenden Preis abrufen res = Preise[Zufallsindex]; //Das Ergebnis dieser Lotterie aus dem Preis-Array abrufen console.log("Das Ergebnis dieser Lotterie:", res);
        
        return {"weightSum": weightSum , "weightRandom": random, prizeIndex: randomIndex, "data": res}; //Gibt das Ergebnis dieser Lotterie zurück};

    //Schaltflächenereignis registrieren $('.layui-btn[data-type="save"]').on('click', function () {
        var res = Lotterie(Gewichtssumme);
        document.getElementById("dateNow").innerhtml = util.toDateString(new Date()); //Gib die Uhrzeit dieser Lotterie aus document.getElementById("weightRandom").innerHTML = res.weightRandom; //Gib die gewichtete Zufallszahl dieser Lotterie aus document.getElementById("printData").innerHTML = res.data; //Gib das Ergebnis dieser Lotterie aus //Sezt die Schriftfarbe des Textes mit den Gewinnregeln zurück $('.rule-body>p').css("color", "inherit");
        $('.rule-body>p:eq(' + res.prizeIndex + ')').css("Farbe", "rot");
    });
});

Oben finden Sie Einzelheiten dazu, wie JS die Gewinnwahrscheinlichkeit basierend auf dem Preisgewicht berechnet. Weitere Informationen zur Berechnung der Gewinnwahrscheinlichkeit durch JS finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • jquery.rotate.js implementiert den Lotteriecode des Drehtellers mit optionaler Lotterienummer und Gewinninhalt
  • Codebeispiel für die Wahrscheinlichkeitsgenerierung von Zufallszahlensteuerung
  • js realisiert die Generierung von 1,2,3,5 Zahlen entsprechend der Wahrscheinlichkeit
  • js-Array zum Erreichen einer Gewichtswahrscheinlichkeitsverteilung
  • js Wahrscheinlichkeitsberechnung (einfache Version)
  • Detaillierte Erklärung der zufälligen Wahrscheinlichkeitsgenerierung von Ereignissen in JavaScript
  • JavaScript zum Erreichen einer zufälligen Lotteriefunktion
  • js zur Realisierung der Lotteriefunktion
  • Native JS realisiert die Neun-Quadrat-Lotterie
  • js, um eine einfache Lotteriefunktion zu erreichen

<<:  Zabbix' PSK-Verschlüsselung kombiniert mit zabbix_get-Wert

>>:  So installieren Sie MySQL 5.7 aus dem Quellcode in einer CentOS 7-Umgebung

Artikel empfehlen

So öffnen Sie Port 8080 auf dem Alibaba Cloud ECS-Server

Aus Sicherheitsgründen verfügt Alibaba Cloud Serv...

JavaScript zum Erzielen eines einfachen Drag-Effekts

In diesem Artikel wird der spezifische JavaScript...

Ausführliche Erklärung zum Currying von JS-Funktionen

Inhaltsverzeichnis 1. Ergänzende Wissenspunkte: i...

So verwenden Sie Docker, um Containerressourcen zu begrenzen

Problem beim Gucken Angenommen, der IIS-Dienst st...

Docker-Lernen: Die spezifische Verwendung von Container-Containern

Container sind ein weiteres Kernkonzept von Docke...

Zusammenfassung der Ausführungsprobleme zwischen MySQL Max und Where

Ausführungsproblem zwischen MySQL Max und Where S...

So lassen Sie DOSBox nach dem Start automatisch Befehle ausführen

Mit DOSBox können Sie DOS unter Windows simuliere...

Beispiele für die MySQL-Verschlüsselung und -Entschlüsselung

Beispiele für die MySQL-Verschlüsselung und -Ents...