Générer de nombres aléatoires sans doublon dans une certaine gamme

Je suis actuellement à la création d'une application et il va générer des nombres aléatoires. Donc, chaque fois qu'il va générer trois numéros num1, num2 et num3. Ces chiffres ne doivent pas être dupliqués. Par exemple, si num1 = 1 que num2 et num3 ne peut être égal à 1. J'ai essayé ce code où il affiche trois différents nombre allant de 0 à 2. Et son travail. Cependant je voudrais générer de nombres aléatoires allant de 1-3, 2-4, 3-5 et ainsi de suite. Alors, comment puis-je réaliser cela en utilisant le code ci-dessous. Merci de m'aider car je suis nouveau sur ce. Merci.

for(int i=0; i<images.length; i++)
{
        num[i] = (int)(Math.random()*3);

        if (i == 0)
        {
        if(num[i]== 0)
            images[i].setImageResource(R.drawable.zero);
        else if(num[i]==1)
            images[i].setImageResource(R.drawable.one);
        else
            images[i].setImageResource(R.drawable.two);
        }

        else
        {
            while (num[i] ==  num[i-1] || num[i] == num[0] )
                num[i] = (int)(Math.random()*3);


        if(num[i]==0)
            images[i].setImageResource(R.drawable.zero);
        else if(num[i]==1)
            images[i].setImageResource(R.drawable.one);
        else
            images[i].setImageResource(R.drawable.two);

        }
    }

Votre question n'est pas très claire, vous devez l'exprimer mieux.
Je suis presque certain que je n'ai vu un duplicata de celui-ci. Cette question est également très proche. Lorsque vous traitez avec cela, j'avais en fait sous-classe Random, permettant l'injection et/ou les modifications de la configuration.
Comme @Clockwork-Muse mentionné précédemment, vous pouvez aléatoire d'une liste de valeurs à partir de la plage requise.

OriginalL'auteur amln_ndh | 2014-01-19

10

Créer une liste si tous les numéros de la plage, puis mélangez la liste:
```
List<Integer> numbers = new ArrayList<>();
//eg for range 3-5
for (int i = 3; i <= 5; i++)
    numbers.add(i);
Collections.shuffle(numbers);
```
Maintenant de les utiliser dans leur nouvelle (aléatoire) de commande.

Sauf si votre portée est très large (millions de dollars) ce sera beau travail.

Java8 version:
```
List<Integer> numbers = IntStream.rangeClosed(3, 5).boxed().collect(Collectors.toList());
Collections.shuffle(numbers);
```
Pour générer les 3 à 5, vous devez utiliser la condition i<=5
Doh! Thx.
Dans Java 8, vous pouvez utiliser IntStream.range(3, 6).collect(Collectors.toList())
pas tout à fait. Vous ne pouvez pas collecter un IntStream, et rangeClosed est plus approprié pour le contexte. Voir ma non réponse.

OriginalL'auteur Bohemian
1

Bien, vous pouvez stocker vos numéros sur une ArrayList<>. Chaque fois que vous générez un nombre aléatoire, voir si le ArrayList<> contient le nombre. Si elle le fait, générer un autre numéro et répétez le processus.

Mieux encore, utilisez un Set <>.

OriginalL'auteur Little Child
0

Obtenir des nombres allant de 1 à 3, 2-4, 3-5, etc, changer ce
```
num[i] = (int)(Math.random()*3);
```
à ce
```
num[i] = rand.nextInt(2) + 1 + i;
```
Vous aurez besoin d'importer Random et ajouter Random rand = new Random(); avant de l'utiliser.

OriginalL'auteur LMNOP

La formule pour générer des nombre aléatoire dans l'intervalle est :

    Random rn = new Random();
    int range = maximum - minimum + 1;
    int randomNum =  rn.nextInt(range) + minimum;

donc dans une ligne, vous pouvez générer comme ce

    int num1 = new Random().nextInt(3-1+1) + 1;
    int num2 = new Random().nextInt(4-2+1) + 1;
    int num3 = new Random().nextInt(5-2+1) + 1;

    num[i] = new Random.nextInt(range[i]) + 1 + i;

et alors vous pouvez faire votre logique trucs pour définir la ressource.
Amusez-Vous Bien 🙂

OriginalL'auteur Vikas Rathod

0

Le mieux possible et le plus efficace pour générer et stocker des numéros uniques serait de créer un HashSet qui contient vos données. Générer le numéro et puis essayez de l'ajouter à la HashSet. Si le complément de la méthode renvoie la valeur false, alors cela signifie que le numéro existe déjà dans le jeu et donc de re-générer un nombre.
L'avantage de cette méthode par rapport à l'ArrayList est que cela a une complexité temporelle en O(1) en utilisant la méthode contains () (à partir de la liste de tableaux) aurait pour conséquence une complexité temporelle en O(n) - efficacité diminue à mesure que la taille augmente.

Ce n'est certainement pas le moyen le plus efficace en raison de l'échec de la tente.
Le cas idéal serait de générer des nombres qui sont connus pour être unique, mais ce ne serait pas possible avec les Mathématiques.random(). Je pense que l'OP voulait s'en tenir aussi près que possible de son code d'origine. Ma priorité était le moyen le plus rapide pour trouver le nombre est unique étant donné que vous êtes en utilisant les Mathématiques.random().
Il n'y a pas de point à utiliser les Mathématiques.random() pour obtenir des entiers uniques. Même aléatoire est recommandé d'être obtenu de façon Aléatoire.nextInt().

OriginalL'auteur ucsunil
0

int base = (int)Math.random();
System.out.print(base);

int change = ((int)Math.random()) % 3;

if(change == 0) {
change++;
System.out.print(base + 1);
System.out.println(base + 2);
}

else {
System.out.print(base + 2);
System.out.println(base + 1);
}

OriginalL'auteur alesc3
0

Vous pouvez également utiliser la génération de nombre Aléatoire pour remplir un HashSet pour une plage fixe.

OriginalL'auteur akkig

Je sais il est tard, mais il pourrait être utile pour référence future.
Vous pouvez créer votre propre classe au sort:

//Generates random integers without repetition between two given numbers both inclusive
public class Random {
    private int start;
    private int end;
    private Stack<Integer> numbers = new Stack<>();
    public Random(int start, int end){
        this.start = start;
        this.end = end;
    }
    private void loadNumbers(){
         for (int i=start;i<=end;i++){
                numbers.push(i);
            }
         Collections.shuffle(numbers);
    }
    public int nextInt(){
        if (numbers.empty()) loadNumbers();
        return numbers.pop();
    }
}

Et de l'utiliser comme:

Random rand = new Random(1,20);
for(int i=0; i<100;i++){
    System.out.print(rand.nextInt()+ " ");
}

OriginalL'auteur Addis

De réduire le montant total de chaque course, et de manière appropriée incrémenter le résultat.

static int[] randomRange(Random random, int cap, int count) {
    assert count < cap && count > 0 && cap > 0;
    int[] output = new int[count];
    //initial placeholder. use 0x7FFFFFFF for convenience is also OK.
    Arrays.fill(output, -1);
    for(int i = 0; i < count; i++) {
        //you only have (cap - i) options left
        int r = random.nextInt(cap - i);
        //iterate through a sorted array
        for(int got : output) {
            //ignore placeholders
            if(got != -1 && got <= r) {
                //the generated random int counts number of not-yet-picked ints
                r++;
            }
        }
        //add to array in a sorted manner
        addToArray(output, r);
    }
    return output;
}

static void addToArray(int[] array, int value) {
    for(int i = 1; i <= array.length; i++) {
        if(i == array.length || array[i] >= value) {
            //shift smaller values one place left
            //this includes -1. If you use 0x7FFFFFFF,
            //you may have to sort the array the other way round.
            System.arraycopy(array, 1, array, 0, i - 1);
            array[i - 1] = value;
            return;
        }
    }
}

Cet algorithme a un inconvénient à ce que sa sortie est triée. Il est, bien sûr, également possible de garder la trace de deux tableaux, l'un triées (par incrément) et un non triés (pour le retour).

L'extrait de code ci-dessus a été testé par le biais de cap = 20, count = 10 et cap = 20, count = 20 deux fois chacun.

OriginalL'auteur SOFe

0
```
Integer[] a = new Integer[3];
Random r = new Random();
for (int i = 0; i < a.length; i++) { 
        a[i] = r.nextInt(3-1) + 1;  
}
Collections.shuffle(Arrays.asList(a), r);
```
Êtes-vous sûr que vous voulez pour instancier une nouvelle instance de Random à chaque fois?
chaque fois pas nécessaire..
C'est pourquoi, vous devez déplacer le Random ligne en dehors de la boucle.

OriginalL'auteur Suresh

Vous devez vous connecter pour publier un commentaire.