Problèmes De Production De Mathématiques.Nombre aléatoire, Soit 0 ou 1

J'ai vu cette question publiée dans un grand nombre de fois sur ce site et croyez-moi, j'ai regardé à travers de si nombreux et de si nombreux des vidéos YouTube, et rien n'a fini de travailler pour moi. Comme le titre le dit je veux un nombre aléatoire, soit 0 ou 1, puis qui sera retourné à la main() dans mon code ci-dessous.

import java.util.Scanner;
public class Exercise8Lab7 {
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        int numFlips = 0;
        int heads = 0;
        int tails = 0;
        String answer;


        System.out.print("Please Enter The Number Of Coin Tosses You Want: ");
        numFlips = input.nextInt();

        for(int x = 1;x <= numFlips; x++){
            if(coinToss() == 1){
                answer = "Tails";
                tails++;
            }
            else{
                answer = "Heads";
                heads++;
            }
            System.out.print("\nCoin Toss " + x + ": " + answer);
        }
        System.out.println("\n\n====== Overall Results ======" +
        "\nPercentage Of Heads: " + (heads/numFlips)*100 + "\nPercentage Of Tails: " + (tails/numFlips)*100);
    }

    public static int coinToss(){
        double rAsFloat = 1 * (2 + Math.random( ) );
        int r = (int)rAsFloat;
        return r;
    }
}

De nombreuses solutions ont été proposé d'utiliser l'util.Option aléatoire qui je l'ai fait et fonctionne parfaitement, mais je veux savoir pourquoi je ne peux pas obtenir que cela fonctionne. Évidemment, je veux que ce nombre est un entier de moi-même si je les convertir en int après le nombre aléatoire a été généré. Mais peu importe ce que je ajouter ou multiplier les Mathématiques.random (), il va toujours être la tête, ou en tous être soit des Queues. Ne sont jamais mélangées.

Toute aide appréciée!

  • Ainsi, l'écriture 1 * aurait dû être un indice que vous ne l'avez pas droit, car en multipliant tout par 1 n'est pas accomplir grand-chose.
  • Random a un .nextInt() version prenant une limite supérieure. Sinon, eh bien, juste la génération aléatoire d'int et ne % 2 sur elle.
  • parce que Math.random() + 2 génère un nombre aléatoire compris entre 2,0 et 2,9. Rien dans cette gamme sera jamais égal à 1. Si vous êtes uniquement intéressé par 0 ou 1 utilisation Math.round(Math.random())
  • Merci à tous ceux qui ont répondu! J'ai juste multiplié les Mathématiques.random() par 2 et maintenant, c'est de me donner aléatoire des réponses pour les Têtes et les Queues. Le problème maintenant est le pourcentage pour les Chefs et le pourcentage de Queues dans la dernière instruction d'impression ne fonctionne pas du tout, ils sont toujours à la fois = 0...
InformationsquelleAutor alannm37 | 2015-02-09
  1. 14

    Vous pouvez utiliser des valeurs booléennes de 0 ou 1 en fonction de la valeur de Math.random() en tant que double entre 0.0 et 1.0 et faire le générateur aléatoire beaucoup plus simple. Et vous pouvez se débarrasser complètement de la coinToss() méthode.

    if(Math.random() < 0.5) {
    answer = "Tails";
    tails++;
}

    Supprimer le tirage au sort de la méthode et de remplacer la première conditionnelle avec le code ci-dessus.

    Math.random(); par elle-même va retourner une valeur entre 0.0 et moins de 1.0. Si la valeur est dans la moitié inférieure, [0.0, 0.5), puis il a la même probabilité d'être dans la moitié supérieure, [0.5, 1.0). Par conséquent, vous pouvez régler une valeur dans la moitié inférieure comme vrai et le haut comme faux.

    InformationsquelleAutor
  2. 7

    Essayer cela), Il va générer un nombre 0 ou 1 

     Math.round( Math.random() )  ;
    • Code-et "essayer cette" réponses sont découragés.
    • Cela va générer de la valeur double. Exemple: 1.0
    InformationsquelleAutor DzenDzimon
  3. 1

    sa ne fonctionne pas à cause de l'entier de maths que vous utilisez, l'appel à 2+ Mathématiques.Le hasard est à peu près toujours de vous donner une réponse entre 0.0 et 1.0.

    donc en supposant que vous recevez 0.25 comme votre résultat de votre calcul est comme suit

    double d = 1* (2 + 0.25); //(result = 2

    Alors que vous vérifiez pour voir si votre résultat == 1 ( ce qui ne le sera jamais. )

    Un meilleur résultat serait de déclarer java.util.Aléatoire comme une variable de classe et d'appel aléatoire.nextBoolean() et il vous suffit d'effectuer votre tête/queue de calcul sur que.

    Si vous continuez à utiliser les Mathématiques.random() et permet de dire 

    return Math.random() < 0.5

    Vos résultats serais très légèrement de travers à cause du fait que les Mathématiques.random() ne peut pas retourner 1.0, en raison du fait que la spécification de l'API java états:

    "Renvoie une valeur de type double avec un signe positif, supérieur ou égal à 0.0 et moins de 1,0."

    • Je ne pense pas que les résultats seraient faussés. Si ma compréhension est correcte, le nombre de valeurs possibles que Math.random() pouvait revenir qui sont < 0,5 exactement égal au nombre de valeurs possibles qui sont >= 0.5. J'aurais pour l'étude de l'algorithme pour être certaine à 100%, cependant.
    • C'est en fait un impressionnant question, plus qu'un commentaire. permet de voir si je peux adapter ce dans la quantité d'espace pour un commentaire (et mes excuses pour le manque de mise en forme. ) Les versions précédentes de java avait un énorme biais vers zéro ( la fonction a: ((((long)suivant(27) << 27) + prochain(27)) / (double)(1L << 54);) , donc dans les versions ultérieures de réduire le biais, par une légère modification de maths ((((long)(à côté(26)) << 27) + prochain(27)) / (double)(1L << 53);) ... Donc en réduisant la taille du premier nombre aléatoire de bits (mais le maintien de la taille de la maj) ils présentent une très légère biais -cont-
    • au 134217728, Dans le code d'origine il y avait un biais du bit de poids faible dans l'intérieur de la mantisse du nombre à virgule flottante de 0 (il a été 3 fois plus susceptibles que pas du tout), donc, avec ce "mineur" changement qu'ils ont réussi à retirer en échange d'avoir un léger biais vers le juste au-dessus du centre, ce qui est mieux que d'avoir un biais à une donnée fixe de bits. La prochaine méthode a aussi ses propres biais, ce qui aggrave encore ce.. Si vous cochez la javadoc dans le détail, il convient de noter que la sortie est "à peu près" l'uniforme, il existe 2 méthodes de prouver cela, la première tout simplement de force brute la -suite-
    • 2 appels à côté avec 2 boucles for et en retournant une liste de tous les résultats (qui sera très coûteuse en temps) mais vous permettra de dessiner un histogramme des résultats. Sinon, si paresseux (et limitée dans le temps. ) créer une boucle pour exécuter le "coin flip" de l'algorithme et de compter les résultats, vous devriez remarquer une inclinaison dans le rapport entre le vrai et le faux, qui grandit au fil du temps.
    • Très intéressant!!! Je regarde cela de plus, quand je trouve le temps (un vœu pieux...).
    InformationsquelleAutor Damian Nikodem
  4. 1

    Math.random() retourne un hasard flotter dans l'intervalle [0.0,1.0) - ce qui signifie que le résultat peut être n'importe quoi allant de 0 à mais pas y compris 1.0.

    Votre code

    double rAsFloat = 1 * (2 + Math.random( ) );

    va prendre ce nombre dans [0.0,1.0) gamme; l'ajout de 2 pour qu'il vous donne un nombre dans [2.0,3.0) gamme; en la multipliant par 1 n'a rien d'utile; puis, quand vous tronquer un nombre entier, le résultat est toujours 2.

    Pour obtenir des nombres entiers de ce genre de fonction de lecture aléatoire, vous avez besoin de comprendre comment beaucoup de différents nombres entiers vous pouviez retourner, puis multipliez votre nombre aléatoire par qui. Si vous voulez un "0 ou 1" réponse, de votre portée est de 2 différents entiers, multiplier Math.random() par 2:

    double rAsFloat = 2 * Math.random();

    Cela vous donne un nombre aléatoire dans l'intervalle [0.0,2.0), qui peut ensuite être 0 ou 1 lorsque vous tronquez pour un entier avec (int). Si, au lieu de cela, vous voulais quelque chose qui renvoie 1 ou 2, par exemple, vous devriez juste ajouter 1:

    double rAsFloat = 1 + 2 * Math.random();

    Je pense que vous avez déjà compris que le Random classe vous donne ce que vous voulez beaucoup plus facilement. J'ai décidé d'expliquer tout cela de toute façon, parce qu'un jour vous pourriez travailler sur un système d'héritage dans une vieille langue où vous avez vraiment besoin de travailler avec un [0.0,1.0) valeur aléatoire. (OK, c'est peut-être pas trop probable, mais qui sait.)

    InformationsquelleAutor ajb
  5. 1

    (int)(Math.random()*2) fonctionne aussi très bien dans ce cas

    • pourquoi cette réponse est d'avoir downvote. Qui est le meilleur (si ce n'est le meilleur, le plus largement répandu) réponse connue depuis des décennies.
    InformationsquelleAutor Kanak Lata
  6. 0

    Le problème peut être traduite en booléen génération comme suit :

    public static byte get0Or1 {

Random random = new Random();
boolean res=   random.nextBoolean();

if(res)return 1;
else return 0;

}
    • Pourquoi downvote ma réponse ?
    InformationsquelleAutor Java Main
  7. 0

    Bizarre que personne n'est à l'aide d'un modulo de la division pour le nombre aléatoire.
    C'est l'implémentation la plus simple, vous pouvez obtenir:

    Random rand = new Random();
int randomValue = rand.nextInt() % 2;
    InformationsquelleAutor Pier Betos
  8. 0

    Mathématiques.round(Math.random()) retourne 0.0 et 1.0. Étant donné que ces deux valeurs sont bien dans les limites de l'int gamme, ils peuvent être castée pour int.

    public static int coinToss(){
    return (int)Math.round(Math.random());
}
    InformationsquelleAutor balaji
  9. -1
     for(int i=0;i<100;i++){
System.out.println(((int)(i*Math.random())%2)); 
    }

    utilisation de mod il va vous aider!

    InformationsquelleAutor Super Best