Variablen Mehrere Zahlen mit unterschiedlicher Wahrscheinlichkeit mit Random auswählen

[.Buh]

Hallo,
Ich würde gerne mittels Math.random() unter mehreren Zahlen eine bestimmte auswählen ,!aber!
diese unterschiedlichen Zahlen sollen auch unterschiedliche Wahrscheinlichkeiten haben
(z.B.)
10 hätte die Wahrscheinlichkeit 1/10 und 1000 hätte die Wahrscheinlichkeit 1/100
Nun kann ich sie deswegen ja nicht einfach mit Random zufällig auswählen , wie mache ich das am besten?

Mfg. Buh

 

[Marco13]

Je nachdem um wie viele Intervalle es geht, reicht da schon sowas wie

Random random = new Random(0); // Reproduzierbarer als Math.random....
...

double d = random.nextDouble();
if (d < 0.1) zehnProzentFall();
else if (d < 0.5) vierzigProzentFall();
else restlicheFünzigProzentFall();

Selbst bei "relativ vielen" Zahlen könnte man sich da noch was trickreicheres überlegen, mit einer TreeMap und ceilingEntry und so (war auch schonmal hier im Forum, aber ich bin gerade AUCH zu faul zum Suchen )

EDIT: Wenn das ganze irgendwie "regelmäßig" ist, könnte man ggf. auch direkt das Ergebnis berechnen, aber ich nehme an, die genannten Zahlen sollten nur Beispiele sein. .

 

[.Buh]

Es wird öfters berechnet aus mehreren werten die nicht nur die oben genannten zahlen haben , ich habe das so gelöst (allerdings weiß ich nicht ob das korrekt ist)

1 gehe ich alle werte durch die enthalten sind und suche den mit der niedrigsten wahrscheinlichkeit raus
(int nied.)

2 ich rechne Math.Random() * die wahrscheinlichkeit der Zahl / nied.

wäre das so richtig?

 

[Marco13]

Bei allem, was mit Wahrscheinlichkeiten (und fragwürdigen, natürlichsprachlichen Beschreibungen von Algorithmen) zu tun hat kann ein Bauchgefühl leicht täuschen, aber da du nicht gesagt hast, was das Ergebnis deiner Rechnung denn sein soll, ist es schwer, zu sagen, ob es richtig oder falsch ist.

 

[Helper]

ich erwähnte es bereits an anderer stelle aber sage es hier gerne noch mal

1) Math.random() ruft intern Random.next() auf , ergo kann man gleich Random verwenden und spart sich so ein oder zwei calls auf dem stack

2) Random ist so implementiert das alle zahlen gleich oft verteilt auftreten
zieht man also 10'000 mal eine zahl zwischen 1 und 10 (inkl) dann kommen alle zahlen mit einer abweichung von weniger als 0,1% gleich oft vor ...

3) Random(0) ist vielleicht "logisch" sinnvoll, da aber intern mit der system-zeit gerechnet wird entstehen auch hierbei immer andere folgen (es sei denn man setzt bei jedem call die zeit immer wieder auf exakt die selbe nano-sekunde ... was schlicht nicht geht)Von dir ausgewählter Benutzername ist gesperrt

 

[.Buh]

Bei allem, was mit Wahrscheinlichkeiten (und fragwürdigen, natürlichsprachlichen Beschreibungen von Algorithmen) zu tun hat kann ein Bauchgefühl leicht täuschen, aber da du nicht gesagt hast, was das Ergebnis deiner Rechnung denn sein soll, ist es schwer, zu sagen, ob es richtig oder falsch ist.

Wie ich oben gesagt habe ich habe mehrere Zahlen die eine bestimmt chance haben (beliebig änderbar aber)

z.B.
Nummer:15
chance:1/10

Nummer:19
chance:1/100

Nummer 14
chance:1/12

nun möchte ich daraus eine der 3 Zahlen bekommen , wobei 14 und 15 die höchsten chancen haben und 19 die wenigsten aber es sollen dabei die chancen nicht verändert werden also das ich z.B. etwa alle 12 mal ne 14 kriege aber nur ca. alle 100 mal eine 19

 

[Marco13]

Dir ist klar, dass die Summe der Wahrscheinlichkeiten 1 ergeben muss? ???:L

@Helper: Random(0) liefert immer die gleiche Folge, Random() immer unterschiedliche. Random(0) ist zum Testen.

 

[s4ke]

Die 0 in new Random(0) ist der Seed. Wenn keiner übergeben wird, wird einer aus der Systemzeit errechnet.

 

[Andreas29]

Hi,

hier eine mögliche Lösung, um über Math.random Zahlen mit unterschiedlicher Wahrscheinlichkeit zu ermitteln:

import java.util.LinkedHashMap;
import java.util.Map;
 
public class RandomBeispiel {
 
    private static final Map<Double, Integer> GRENZEN = new LinkedHashMap<Double, Integer>();
 
    static {
        GRENZEN.put(0.4, 11);
        GRENZEN.put(0.9, 12);
        GRENZEN.put(1.0, 13);
    }
 
    private Integer naechsteZufallzahl() {
        double random = Math.random();
        System.out.println("Zufallszahl: " + random);
        for (Map.Entry<Double, Integer> entry : GRENZEN.entrySet()) {
            if (random <= entry.getKey().doubleValue()) {
                return entry.getValue();
            }
        }
 
        throw new UnsupportedOperationException("Fuer die Zufallszahl wurde kein passender Wert in der Map gefunden");
    }
 
    public static void main(String[] args) {
        int anzahl11 = 0;
        int anzahl12 = 0;
        int anzahl13 = 0;
        RandomBeispiel b = new RandomBeispiel();
 
        for (int i = 0; i < 100000; i++) {
            Integer z = b.naechsteZufallzahl();
            if (z.intValue() == 11) {
                anzahl11++;
            } else if (z.intValue() == 12) {
                anzahl12++;
            } else {
                anzahl13++;
            }
        }
 
        System.out.println("11: " + anzahl11);
        System.out.println("12: " + anzahl12);
        System.out.println("13: " + anzahl13);
        System.out.println("Gesamtzahl: " + (anzahl11 + anzahl12 + anzahl13));
    }
}

Die Map GRENZEN regelt die Wahrscheinlichkeiten, mit der die einzelnen Zahlen ermittelt werden. Hier wird also die Zahl 11 mit 40%, die Zahl 12 mit 50% und die Zahl 13 mit 10% Wahrscheinlichkeit ermittelt. Diese kann man natürlich auch via Konfiguration von außen übergeben. Die ganze Idee beruht auf der Tatsache, dass alle Wahrscheinlichkeiten in der Summe 1 ergeben müssen, da ja irgendeine Zahl immer gewürfelt wird. Diese 1 (oder 100%) habe ich dann eben auf die einzelnen Werte verteilt. Danach wird eine Zahl zwischen 0 und 1 über Math.random ermittelt und über die Map geprüft, in welchen Bereich die Zahl fällt (hier alles unter 0.4 gibt 11, zwischen 0.4 und 0.9 gibt 12 und über 0.9 gibt 13). Fertig.

Als Map habe ich bewusst eine LinkedHashMap verwendet, um die Reihenfolge der Zahlen in der Map zu erhalten. Somit brauche ich später nur noch den Eintrag in der Map suchen, der als erster größer ist als die Zahl, die von Math.random() ermittelt wurde.

Ich hoffe, geholfen zu haben.

Grüße und schönen Sonntag abend noch,
Andreas

 

[kaetzacoatl]

Random r = new Random();
double p0 = 0.1
boolean e0 = 0 == r.nextInt((int) 1/p0);

Damit kann man die Wahrscheinlichkeit setzen.

[EDIT]
Ich glaub das ist nicht das was du suchst.:autsch:
Aber was ist, wenn man jeder Zahl einen Bereich
gibt, in dem die Zufallszahlm sein muss, damit das
Ereignis eintritt.

static class Zahl {
		
		final double P;
		final double E;
		double[] range;
		
		public Zahl(double p, double e) {
			P = p;
			E = e;
		}

	}

	public static void main(String[] args){
		ArrayList<Zahl> list = new ArrayList<Zahl>();
		list.add(new Zahl(0.1,1));
		list.add(new Zahl(0.2,2));
		list.add(new Zahl(0.3,3));
		list.add(new Zahl(0.4,4));
		double d = 0;
		for (Zahl zahl : list) {
			zahl.range = new double[2];
			zahl.range[0] = d;
			d += zahl.P;
			zahl.range[1] = d;
		}
		d = Math.random();
		for (Zahl zahl : list) {
			if(zahl.range[0] < d && d < zahl.range[1]){
				System.out.println(zahl.E);
				return;
			}
		}
	}

[/EDIT]

 

[Marco13]

Als Map habe ich bewusst eine LinkedHashMap verwendet, um die Reihenfolge der Zahlen in der Map zu erhalten. Somit brauche ich später nur noch den Eintrag in der Map suchen, der als erster größer ist als die Zahl, die von Math.random() ermittelt wurde.

In diesem Fall könnte man sich die Map auch als NavigableMap (Java Platform SE 6) merken (bzw. TreeMap, wie in der ersten Antwort). Damit kann man direkt mit floorEntry/ceilingEntry zum richtigen Eintrag springen. (Macht aber sicher erst einen Unterschied, wenn es wirklich "viele" Intervalle gibt - ist eher so ein theoretisch-prinzipieller Gedanke...)

 

[.Buh]

Hallo , ich habe nun wieder ein neues problem , ich probiere mit einem WeightedGenerator zufällige ein item raus zu nehmen , mit Integern geht das auch ganz gut , nun möchte ich aber mit double's arbeiten wo es dann aber items mit der chance von z.B. 0.5% garnicht mehr drann kommen wegen

generated -= getWeight(result);

Und somit einfach das erste item nimmt was er prüft.... weswegen das item mit der chance 0.5% nie mehr ausgegeben wird ....

Hier der abschnitt der .class der für das zu fällige item zuständig ist:

    public T generate(Random generator)
    {
        T result = null;
        Iterator<T> iterator = table.keySet().iterator();
        Double generated = generator.nextDouble()*totalWeight;
        while(generated>=0 && iterator.hasNext())
        {
            result = iterator.next();
            generated -= getWeight(result);
        }
        return result;
    }

Hier die komplette .class

package de.eistee2.mobdrop;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
 
public class WeightedGenerator<T> 
{
    private Map<T,Double> table = new HashMap<T,Double>();
    private Double totalWeight = (double) 0;
    
    public void setWeight(T key,Double weight)
    {
        if(weight<0) weight=(double) 0;
        
        
        totalWeight-=getWeight(key);
        table.put(key,weight);
        totalWeight+=getWeight(key);
    }
    
    public Double getWeight(T key)
    {
        if(table.containsKey(key))
        {
            return table.get(key);
        }
        else
        {
            return (double) 0;
        }
    }
    
    public T generate(Random generator)
    {
        T result = null;
        Iterator<T> iterator = table.keySet().iterator();
        Double generated = generator.nextDouble()*totalWeight;
        while(generated>=0 && iterator.hasNext())
        {
            result = iterator.next();
            generated -= getWeight(result);
        }
        return result;
    }
    
   public int size()
   {
	   return table.size();
   }
   
   public void clear()
   {
	   totalWeight = (double) 0;
	   table.clear();
   }
}

Wäre für hilfe sehr sehr sehr dankbar !
Mfg. Buh

 

[.Buh]

Hallo ? :/

 

[Marco13]

Poste nochmal ein KSKB und versuche genauer zu beschreiben, was du meinst (ich hab's jedenfalls nicht kapiert... :bahnhof: )

 

[.Buh]

Poste nochmal ein KSKB und versuche genauer zu beschreiben, was du meinst (ich hab's jedenfalls nicht kapiert... :bahnhof: )

Um es zufällig zu machen

Habe ich die class WeightedGenerator (oben gepostet)
und benutzen tue ich sie so;

WeightedGenerator<String> generator = new WeightedGenerator<String>();

In einer schleife alle möglichkeiten hinzu fügen:

generator.setWeight("Hier der String , Double(wahrscheinlichkeit));

Per zufall was aus der liste nehmen:

String zufälligesItem = generator.generate(new Random());

Mein problem ist das es bei doubels die unter 1 kommen (0.90 etc.) nicht mehr richtig zufällig ist und diese nie dran kommen , hoffe das war besser erklärt

Mfg buh

 

[Marco13]

Das tut man wenn vieles gesagt wird und manches nicht das was man meint ist und das andere wichtig ist und man wegen dem Wetter nicht sieht was wichtig ist sehen: Manchmal ist es anscheinend schwer, sich klar auszudrücken.

Vermutlich willst du darauf hinaus, dass diese Schleife falsch ist:

        while(generated>=0 && iterator.hasNext())
        {
            result = iterator.next();
            generated -= getWeight(result);
        }

Die wird ja IMMER einmal durchlaufen. Ich würde tippen, dass sie ETWA so aussehen müßte

        while(true)
        {
            generated -= getWeight(result);
            if (generated <= 0) break;
            if (!iterator.hasNext()) break; // oder so
            result = iterator.next();
        }

aber habe nicht so detailliert den ganzen Code nachvollzogen, um zu sehen, ob das ansonsten so Sinn macht.

 

[.Buh]

Nein Mein problem ist nicht das sie einmal durch läuft sobald generated unter 0 ist oder es kein next mehr gibt bricht sie ja sofort ab
Mein problem ist das items mit weniger als 1% chance nie drann kommen t.B.
Ich habe die möglichkeiten(aus einer text datei)

Nummer:15
chance:40%

Nummer:19
chance:40%

Nummer:14
chance:19.5%

Nummer:77
chance:0.5%


Die speicher ich dann alle in die HashMap aus der WeightedGenerator.class

WeightedGenerator<String> generator = new WeightedGenerator<String>();
         for(......)
          {
             generator.setWeight(NUMMER , WAHRSCHEINLICHKEIT);
           }

Und danach nehme ich mit

String zufälligesItem = generator.generate(new Random());

zufällig eine der vier Nummern das problem aber ist alle Nummern die unter 1% chance haben, hier Nummer 77, kommen NIE dran.

 

[Marco13]

Als Map habe ich bewusst eine LinkedHashMap verwendet, um die Reihenfolge der Zahlen in der Map zu erhalten.

(h.v.m)


*seufz*

package javaforum;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;

public class WeightedRandomTest
{
    public static void main(String[] args)
    {
        WeightedGenerator<Integer> w = new WeightedGenerator<Integer>();
        w.setWeight(15, 40.0);
        w.setWeight(19, 40.0);
        w.setWeight(14, 19.5);
        w.setWeight(77,  0.5);

        Random random = new Random(0);
        Map<Integer, Integer> counts = new HashMap<Integer, Integer>();
        int n = 100000;
        for (int i=0; i<n; i++)
        {
            //double d = (double)i/(n-1);
            //Integer result = w.generate(d);
            //System.out.println("For "+d+" got "+result);
            
            Integer result = w.generate(random);
            Integer count = counts.get(result);
            if (count == null)
            {
                counts.put(result, 1);
            }
            else
            {
                counts.put(result, count+1);
            }
        }
        for (Integer k : counts.keySet())
        {
            Integer count = counts.get(k);
            System.out.println("Element "+k+" probability "+(double)count/n);
        }
    }
}


class WeightedGenerator<T> 
{
    private Map<T,Double> table = new LinkedHashMap<T,Double>();
    private Double totalWeight = (double) 0;
    
    public void setWeight(T key,Double weight)
    {
        if(weight<0) weight=(double) 0;
        
        
        totalWeight-=getWeight(key);
        table.put(key,weight);
        totalWeight+=getWeight(key);
    }
    
    public Double getWeight(T key)
    {
        if(table.containsKey(key))
        {
            return table.get(key);
        }
        else
        {
            return (double) 0;
        }
    }
    
    public T generate(Random generator)
    {
        T result = null;
        Iterator<T> iterator = table.keySet().iterator();
        Double generated = generator.nextDouble()*totalWeight;
        while(generated>=0 && iterator.hasNext())
        {
            result = iterator.next();
            generated -= getWeight(result);
        }
        return result;
    }
    
    public T generate(double randomValue)
    {
        T result = null;
        Iterator<T> iterator = table.keySet().iterator();
        Double generated = randomValue*totalWeight;
        while(generated>=0 && iterator.hasNext())
        {
            result = iterator.next();
            generated -= getWeight(result);
        }
        return result;
    }
    
   public int size()
   {
       return table.size();
   }
   
   public void clear()
   {
       totalWeight = (double) 0;
       table.clear();
   }
}