Probabilité en Java

Question

J'étais curieux de savoir, comment puis-je implémenter la probabilité en Java? Par exemple, si les chances qu'une variable s'affiche sont de 1/25, comment pourrais-je l'implémenter? Ou toute autre probabilité? S'il vous plaît, orientez-moi dans la bonne direction.

Answer 1

Vous utiliseriez Random pour générer un nombre aléatoire, puis le testeriez contre une valeur littérale pour correspondre à la probabilité que vous essayez d'atteindre.

Donc étant donné:

boolean val = new Random().nextInt(25)==0;

val aura une probabilité de 1/25 d'être vrai (puisque nextInt() a une probabilité uniforme de retourner n'importe quel nombre commençant à 0 et jusqu'à, mais sans inclure, 25.)

Vous devriez bien sûr également importer java.util.Random;.

Comme indiqué ci-dessous, si vous obtenez plus d'un nombre aléatoire, il serait plus efficace de réutiliser l'objet Random plutôt que de le recréer tout le temps:

Random rand = new Random();
boolean val = rand.nextInt(25)==0;

..

boolean val2 = rand.nextInt(25)==0;

Answer 2

Généralement, vous utilisez un générateur de nombres aléatoires. La plupart d'entre eux renvoient un nombre dans l'intervalle [0,1[, vous vérifieriez donc ensuite si ce nombre est < 0,04 ou non.

if( new Random().nextDouble() < 0.04 ) {  //vous voudrez peut-être mettre en cache l'instance Random
   //nous avons le cas 1/25 (4%)
}

Ou

if( Math.random() < 0.04 ) {
  //nous avons le cas 1/25 (4%)
}

Il convient de noter qu'il existe plusieurs générateurs de nombres aléatoires ayant des propriétés différentes, mais pour des applications simples, la classe Random devrait être suffisante.

Édition: J'ai changé la condition de <= à < car la limite supérieure du nombre aléatoire est exclusive, c'est-à-dire que la plus grande valeur retournée sera toujours < 1,0. Par conséquent, x <= 0,04 serait en fait légèrement plus que 4% de chances, tandis que x < 0,04 serait précis (ou aussi précis que les calculs en virgule flottante peuvent l'être).

Answer 3

Depuis la version 1.7, il est préférable d'utiliser (dans un environnement concurrent au moins) :

ThreadLocalRandom.current().nextInt(25) == 0

Javadoc

Un générateur de nombres aléatoires isolé dans le thread actuel. Comme le générateur aléatoire global utilisé par la classe Math, un ThreadLocalRandom est initialisé avec une graine générée en interne qui ne peut pas être modifiée autrement. Lorsque cela est applicable, l'utilisation de ThreadLocalRandom plutôt que d'objets Random partagés dans des programmes concurrents rencontrera généralement beaucoup moins de surcharge et de contention. L'utilisation de ThreadLocalRandom est particulièrement appropriée lorsque plusieurs tâches (par exemple, chacune étant une ForkJoinTask) utilisent des nombres aléatoires en parallèle dans des pools de threads. Les utilisations de cette classe devraient typiquement être de la forme : ThreadLocalRandom.current().nextX(...) (où X est Int, Long, etc). Lorsque toutes les utilisations sont de cette forme, il n'est jamais possible de partager accidentellement un ThreadLocalRandom entre plusieurs threads.

Cette classe fournit également des méthodes de génération aléatoire bornées couramment utilisées.

Answer 4

Java possède une classe appelée java.util.Random qui peut générer des nombres aléatoires. Si vous souhaitez qu'un événement se produise avec une probabilité de 1/25, il vous suffit de générer un nombre aléatoire entre 1 et 25 (ou entre 0 et 24 inclus) et de vérifier si ce nombre est égal à 1.

if(new java.util.Random().nextInt(25)==0){
    //Faire quelque chose.
}

Answer 5

Peut-être pouvez-vous implémenter cela en générant des nombres aléatoires.

  Random rn = new Random();
    double d = rn.nextDouble();     // valeur aléatoire dans la plage 0.0 - 1.0
    if(d<=0.04){
    faitQuelqueChose();
    }