J'ai 4 variables aléatoires ...

int img1 = (int) Math.round((Math.random() * images.length)-1);
int img2 = (int) Math.round((Math.random() * images.length)-1);
int img3 = (int) Math.round((Math.random() * images.length)-1);
int img4 = (int) Math.round((Math.random() * images.length)-1);

Je dois m'assurer qu'ils ne s'égalisent jamais, même s'ils sont aléatoires. Je crée une application où il y a 4 vues d'image qui montrent une forme aléatoire (enregistrée dans un dossier pouvant être dessiné) Vous trouverez ci-dessous une image de mon application pour que vous compreniez mieux ce que je veux dire ...

shapegame

Les 4 formes en bas ne peuvent jamais être les mêmes, mais j'ai besoin qu'elles s'affichent au hasard lorsque l'application est en cours d'exécution. C'est mon code pour le moment ...

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_second);

    shape1 = (ImageView) findViewById(R.id.shape1);
    shape2 = (ImageView) findViewById(R.id.shape2);
    shape3 = (ImageView) findViewById(R.id.shape3);
    shape4 = (ImageView) findViewById(R.id.shape4);
    guessShape = (ImageView) findViewById(R.id.guessShape);
    shapes[0] = shape1;
    shapes[1] = shape2;
    shapes[2] = shape3;
    shapes[3] = shape4;

    //store all the shapes in an array
    int[] images = new int[] {R.drawable.img_0, R.drawable.img_1, R.drawable.img_2, R.drawable.img_3, R.drawable.img_4,
    R.drawable.img_5, R.drawable.img_6, R.drawable.img_7, R.drawable.img_8, R.drawable.img_9, R.drawable.img_10,
            R.drawable.img_11, R.drawable.img_12, R.drawable.img_13, R.drawable.img_14, R.drawable.img_15, R.drawable.img_16,
            R.drawable.img_17};

    int[] outlines = new int[] {R.drawable.outline_0, R.drawable.outline_1, R.drawable.outline_2,
            R.drawable.outline_3, R.drawable.outline_4, R.drawable.outline_5, R.drawable.outline_6,
            R.drawable.outline_7, R.drawable.outline_8, R.drawable.outline_9, R.drawable.outline_10,
            R.drawable.outline_11, R.drawable.outline_12, R.drawable.outline_13, R.drawable.outline_14,
            R.drawable.outline_15, R.drawable.outline_16,R.drawable.outline_17};

    //generate random number between 0 and image.length

    int img1 = (int) Math.round((Math.random() * images.length)-1);
    int img2 = (int) Math.round((Math.random() * images.length)-1);
    int img3 = (int) Math.round((Math.random() * images.length)-1);
    int img4 = (int) Math.round((Math.random() * images.length)-1);
    System.out.println(img1);
    System.out.println(img2);
    System.out.println(img3);
    System.out.println(img4);


    int whichImg = (int) Math.round((Math.random() * 4));

    System.out.println(whichImg);

    if(whichImg == 1){
        whichImg = img1;
    } else if(whichImg == 2){
        whichImg = img2;
    } else if(whichImg == 3){
        whichImg = img3;
    } else {
        whichImg = img4;
    }

    int outlineID = outlines[whichImg];

    //conditions so that the 4 boxes don't have the same image
    if(img1 == img2 && img1 !=0 || img1 == img3 && img1 != 0 || img1 == img4 && img1 != 0){ //if img1 and another img is the same

        img1 = img1 - 1;
    }
    else if(img2 == img3 && img2 != 0 || img2 == img4 && img2 != 0){ //if img2 and another img is the same
        img2 = img2 - 1;
    }

    else if(img3 == img4 && img3 !=0){ //if img3 and another image is that same
        img3 = img3 - 1;
    }
    else if(img1==0 && img2==0 && img3 == 0 && img4 == 0){ //if all the images were 0
        img1 = img1 + 10;
        img2 = img2 + 5;
        img3 = img3 + 7;
        img4 = img4 + 14;
    }
    else if(img1==img2 && img2 == img3 && img1 !=0 && img1 != 17){ //if img1 and 2 others were the same
        img1 = img1 - 1;
        img3 = img3 + 1;
    }
    else if(img2==img3 && img3 == img4 && img2 != 0 && img2 != 17){ //if img2 and 2 others were the same
        img2 = img2 - 1;
        img4 = img4 + 1;
    }
    else if(img3 == img4 && img4 == img2 && img3 != 0 && img3 != 17){ //if img3 and 2 others were the same
        img3 = img3 - 1;
        img2 = img2 + 1;
    }
    else if(img1 == 17 && img2 == 17 && img3 == 17 && img4 == 17){
        img1 = img1 - 1;
        img2 = img2 - 2;
        img3 = img3 -3;
    }
    else {
        System.out.println("Finished comparing 4 variables");//this doesnt work..fix!
    }

    //set the image
    guessShape.setBackgroundResource(outlineID);
    shape1.setBackgroundResource(images[img1]);
    shape2.setBackgroundResource(images[img2]);
    shape3.setBackgroundResource(images[img3]);
    shape4.setBackgroundResource(images[img4]);

Il doit y avoir un moyen plus simple de s'assurer qu'ils ne s'égalisent jamais plutôt que tant de déclarations if. Aidez-moi, s'il vous plaît !

0
Az Islam 20 avril 2017 à 21:22

3 réponses

Meilleure réponse

Si le nombre total d'images est important, vérifiez à chaque fois que vous en choisissez une nouvelle si elle est déjà dans votre ensemble. Dans le cas peu probable où ce serait le cas, rejetez-le et recommencez.

Si le nombre total d'images n'est pas si grand, il n'est pas si improbable qu'une répétition se produise. Dans ce cas, choisissez le premier parmi les index 0 à (n-1). Puis permutez celui que vous choisissez en position 0. Ensuite, choisissez le second parmi les index 1 à (n-1). Puis permutez celui-là en position 1. Continuez jusqu'à ce que vous ayez terminé votre jeu, qui dans votre cas sera aux positions 0 à 3. (Cet algorithme s'appelle Fisher-Yates shuffle.)

1
David Wright 20 avril 2017 à 21:11

Si je comprends bien votre question selon laquelle vous avez besoin TOUT de quatre nombres aléatoires qui ne sont pas égaux, vous pouvez essayer ceci:

int max = 4; // the maximum number of the random numbers
Set<Integer> uniqueCollection = new HashSet<Integer>();
while(uniqueCollection.size()<max){
    uniqueCollection.add((int)(Math.random()*max*10)+1); // the 1 here for 0 values if any
}
for(Integer r : uniqueCollection){ // to test it
    System.out.println(r);
}
0
Yahya 20 avril 2017 à 19:28

Voici deux possibilités:

Premièrement: créez une liste avec tous les aléas, et parcourez-la simplement.

final List<Integer> collect = IntStream.range(0, args.length).boxed().collect(Collectors.toList());
Collections.shuffle(collect);

Sinon, obtenez simplement 4:

Set<Integer> randoms = new HashSet<>();
Random r = new Random();
while(randoms.size() < 4){ randoms.add(r.nextInt(args.length)); }
0
Turing85 21 avril 2017 à 16:27