Estoy tratando de obtener números aleatorios entre 0 y 100. Pero quiero ser único, no se repite en una secuencia. Por ejemplo, si tengo 5 números, deben ser 82,12,53,64,32 y no 82,12,53,12,32
He utilizado este, pero genera mismos números en una secuencia.

Random rand = new Random();
selected = rand.nextInt(100);
InformationsquelleAutor | 2011-11-13

17 Comentarios

  1. 121
    • Agregar cada número en el rango de forma secuencial en un lista estructura.
    • Shuffle ella.
    • Tome la primera a la ‘n’.

    Aquí es una simple aplicación. Esto imprimirá 3 únicos números aleatorios en el rango de 1-10.

    import java.util.ArrayList;
    import java.util.Collections;
    
    public class UniqueRandomNumbers {
    
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<Integer>();
            for (int i=1; i<11; i++) {
                list.add(new Integer(i));
            }
            Collections.shuffle(list);
            for (int i=0; i<3; i++) {
                System.out.println(list.get(i));
            }
        }
    }

    La primera parte de la revisión con el enfoque original, como Mark Byers señaló en una respuesta ahora eliminado, es el uso de un solo Random instancia.

    Que es lo que está causando los números para ser idénticos. Un Random instancia es sembrado por el tiempo actual en milisegundos. Para un determinado valor de la semilla, el ‘azar’ instancia devolverá el mismo secuencia de pseudo-aleatorios números.

    • +1 por señalar aleatorio simple instancia de y responder a la pregunta. 🙂
    • Simplemente genial, gracias!!!
    • Usted no tiene la reorganización de toda la gama. Si desea n números únicos a los que, después, sólo tendrá que barajar la primera posición n el uso de un Fisher-Yates shuffle. Esto puede ayudar con una lista grande y una pequeña n.
  2. 43

    Con Java 8+ puede utilizar el int método de Random para obtener una IntStream de valores aleatorios, a continuación, > distintos y límite para reducir la corriente a un único número de valores aleatorios.

    ThreadLocalRandom.current().ints(0, 100).distinct().limit(5).forEach(System.out::println);

    Random también tiene métodos que crear LongStreams y DoubleStreams si necesitas esas lugar.

    Si quieres que todos (o una gran cantidad) de los números en un rango en un orden aleatorio que podría ser más eficiente para agregar todos los números de una lista, shuffle, y tomar la primera a la n porque el ejemplo de arriba es la que actualmente llevan a cabo la generación de números aleatorios en el intervalo solicitado y se les pasa a través de un conjunto (de manera similar a Rob Kielty la respuesta), que puede requerir la generación de muchos más que el monto aprobado para limitar debido a que la probabilidad de generar un nuevo número único disminuye con cada uno de ellos encontrado. He aquí un ejemplo de la otra manera:

    List<Integer> range = IntStream.range(0, 100).boxed()
            .collect(Collectors.toCollection(ArrayList::new));
    Collections.shuffle(range);
    range.subList(0, 99).forEach(System.out::println);
    • Necesitaba esto para algunas código estoy de benchmarking, y Arrays#setAll() es un poco más rápido que un arroyo. Así: ` Integer[] índices = new Integer[n]; Matrices.setAll(índices, i -> i); las Colecciones.shuffle(Matrices.asList(índices)); return Matrices.corriente(índices).mapToInt(Integer::intValue).toArray(); `
  3. 18
    1. Crear una matriz de 100 números, entonces aleatorizar su orden.
    2. Diseñar un generador de números pseudoaleatorios que tiene un rango de 100.
    3. Crear un arreglo booleano de 100 elementos, a continuación, establecer un elemento de verdad cuando hay que elegir el número. Cuando se elige el siguiente número de verificación en contra de la matriz y probar de nuevo si el elemento de la matriz se establece. (Usted puede hacer un fácil-a-claro matriz de tipo boolean con una matriz de long donde se cambio y la máscara para acceder a cada uno de los bits.)
    • +1 para el enfoque alternativo; pick() es un ejemplo.
    • En lugar de utilizar una matriz de tipo boolean, usted podría usar un HashSet, donde se almacenan los números que ya han generado y el uso de contains para probar si ya ha generado que el número. El HashSet probablemente será un poco más lento que un arreglo booleano, pero ocupan menos memoria.
    • Estoy bastante seguro de que la matriz de tipo boolean tendría menos espacio, si se implementa como una matriz de tiempo[2]. No hay manera en que diablos podría hacer un HashSet que las pequeñas.
    • El último enfoque es un poco feo, ya que no habría un número bien definido de pasos para generar la secuencia entera. Además, no es necesario reinventar la rueda – BitSet.
  4. 11

    Me siento como este método es que vale la pena mencionar.

       private static final Random RANDOM = new Random();    
       /**
         * Pick n numbers between 0 (inclusive) and k (inclusive)
         * While there are very deterministic ways to do this,
         * for large k and small n, this could be easier than creating
         * an large array and sorting, i.e. k = 10,000
         */
        public Set<Integer> pickRandom(int n, int k) {
            final Set<Integer> picked = new HashSet<>();
            while (picked.size() < n) {
                picked.add(RANDOM.nextInt(k + 1));
            }
            return picked;
        }
  5. 8

    Me re-factor de Anand respuesta para hacer uso no sólo de las propiedades únicas de un Conjunto, pero también el uso de la booleano false devuelve el set.add() cuando un complemento para el conjunto falla.

    import java.util.HashSet;
    import java.util.Random;
    import java.util.Set;
    
    public class randomUniqueNumberGenerator {
    
        public static final int SET_SIZE_REQUIRED = 10;
        public static final int NUMBER_RANGE = 100;
    
        public static void main(String[] args) {
            Random random = new Random();
    
            Set set = new HashSet<Integer>(SET_SIZE_REQUIRED);
    
            while(set.size()< SET_SIZE_REQUIRED) {
                while (set.add(random.nextInt(NUMBER_RANGE)) != true)
                    ;
            }
            assert set.size() == SET_SIZE_REQUIRED;
            System.out.println(set);
        }
    }
    • Muy buena idea. Una marca importante, aunque – si SET_SIZE_REQUIRED es lo suficientemente grande (digamos, más de NUMBER_RANGE / 2 luego tienes mucho mayor que el esperado en tiempo de ejecución.
  6. 6

    He hecho esto así.

        Random random = new Random();
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
    
        while (arrayList.size() < 6) { //how many numbers u need - it will 6
            int a = random.nextInt(49)+1; //this will give numbers between 1 and 50.
    
            if (!arrayList.contains(a)) {
                arrayList.add(a);
            }
        }
    • Gracias.el código funciona como un encanto
  7. 4

    Esto va a funcionar para generar única de números aleatorios…………….

    import java.util.HashSet;
    import java.util.Random;
    
    public class RandomExample {
    
        public static void main(String[] args) {
            Random rand = new Random();
            int e;
            int i;
            int g = 10;
            HashSet<Integer> randomNumbers = new HashSet<Integer>();
    
            for (i = 0; i < g; i++) {
                e = rand.nextInt(20);
                randomNumbers.add(e);
                if (randomNumbers.size() <= 10) {
                    if (randomNumbers.size() == 10) {
                        g = 10;
                    }
                    g++;
                    randomNumbers.add(e);
                }
            }
            System.out.println("Ten Unique random numbers from 1 to 20 are  : " + randomNumbers);
        }
    }
  8. 3

    Una forma inteligente de hacer esto es utilizar exponentes de un elemento primitivo en el módulo.

    Por ejemplo, 2 es una raíz primitiva mod 101, lo que significa que las potencias de 2 mod 101 darle un no-repetición de la secuencia en la que se ve a cada número del 1 al 100 inclusiva:

    2^0 mod 101 = 1
    2^1 mod 101 = 2
    2^2 mod 101 = 4
    ...
    2^50 mod 101 = 100
    2^51 mod 101 = 99
    2^52 mod 101 = 97
    ...
    2^100 mod 101 = 1

    En código Java, habría que escribir:

    void randInts() {
    int num=1;
    for (int ii=0; ii<101; ii++) {
        System.out.println(num);
        num= (num*2) % 101;
        }
    }

    Encontrar una raíz primitiva de un módulo específico puede ser complicado, pero Maple «primroot» la función va a hacer esto para usted.

  9. 2

    He llegado aquí desde otra pregunta, que se ha duplicado de esta pregunta (Generar los únicos números aleatorios en java)

    1. Almacén de 1 a 100 números en una Matriz.

    2. Generar el número aleatorio entre 1 a 100 como la posición y el retorno de la matriz de posición [- 1] para obtener el valor

    3. Una vez que el uso de un número en la serie, marca el valor -1 ( No es necesario para mantener a otra matriz para comprobar si este número es ya utilizado)

    4. Si el valor en la matriz -1, obtener el número aleatorio de nuevo a buscar nueva ubicación en la matriz.

  10. 0

    probar esto

    public class RandomValueGenerator {
        /**
         * 
         */
        private volatile List<Double> previousGenValues = new ArrayList<Double>();
    
        public void init() {
            previousGenValues.add(Double.valueOf(0));
        }
    
        public String getNextValue() {
            Random random = new Random();
            double nextValue=0;
            while(previousGenValues.contains(Double.valueOf(nextValue))) {
                nextValue = random.nextDouble();
            }
            previousGenValues.add(Double.valueOf(nextValue));
            return String.valueOf(nextValue);
        }
    }
  11. 0

    Esto no es significativamente diferente de las otras respuestas, pero yo quería que el array de enteros en la final:

        Integer[] indices = new Integer[n];
        Arrays.setAll(indices, i -> i);
        Collections.shuffle(Arrays.asList(indices));
        return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();
  12. 0

    A continuación es una forma que utiliza para generar el número único de siempre. Función Random genera el número y la almacena en el archivo de texto, a continuación, la próxima vez lo verifica en el archivo compara y generar nuevo número único de aquí que en este camino hay siempre un nuevo número único.

    public int GenerateRandomNo()
    {
        int _min = 0000;
        int _max = 9999;
        Random _rdm = new Random();
        return _rdm.Next(_min, _max);
    }
    public int rand_num()
    {
        randnum = GenerateRandomNo();
        string createText = randnum.ToString() + Environment.NewLine;
        string file_path = System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath) + @"\Invoices\numbers.txt";
        File.AppendAllText(file_path, createText);
        int number = File.ReadLines(file_path).Count(); //count number of lines in file
        System.IO.StreamReader file = new System.IO.StreamReader(file_path);
        do
        {
            randnum = GenerateRandomNo();
        }
        while ((file.ReadLine()) == randnum.ToString());
        file.Close();
        return randnum;
    
    }
  13. 0

    puede utilizar la matriz de tipo boolean para llenar el verdadero si el valor tomado otro conjunto de navegar a través de la matriz de tipo boolean para obtener el valor según dan a continuación

    package study;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /*
    Created By Sachin  Rane on Jul 18, 2018
    */
    public class UniqueRandomNumber {
        static Boolean[] boolArray;
        public static void main(String s[]){
            List<Integer> integers = new ArrayList<>();
    
    
            for (int i = 0; i < 10; i++) {
                integers.add(i);
            }
    
    
            //get unique random numbers
            boolArray = new Boolean[integers.size()+1];
            Arrays.fill(boolArray, false);
            for (int i = 0; i < 10; i++) {
                System.out.print(getUniqueRandomNumber(integers) + " ");
    
            }
    
        }
    
        private static int  getUniqueRandomNumber(List<Integer> integers) {
            int randNum =(int) (Math.random()*integers.size());
            if(boolArray[randNum]){
                while(boolArray[randNum]){
                    randNum++;
                    if(randNum>boolArray.length){
                        randNum=0;
                    }
                }
                boolArray[randNum]=true;
                return randNum;
            }else {
                boolArray[randNum]=true;
                return randNum;
            }
    
        }
    
    }
  14. 0

    Que tienen fácil solución para este problema,
    Con esto se puede generar fácilmente un número n única de números aleatorios,
    Sólo la lógica de cualquier persona puede utilizarlo en cualquier idioma.

    for(int i=0;i<4;i++)
            {
                rn[i]= GenerateRandomNumber();
                for (int j=0;j<i;j++)
                {
                    if (rn[i] == rn[j])
                    {
                        i--;
                    }
                }
            }
  15. 0

    Elegir n única de números aleatorios de 0 a m-1.

    int[] uniqueRand(int n, int m){
        Random rand = new Random();
        int[] r = new int[n];
        int[] result = new int[n];
        for(int i = 0; i < n; i++){
            r[i] = rand.nextInt(m-i);
            result[i] = r[i];
            for(int j = i-1; j >= 0; j--){
                if(result[i] >= r[j])
                    result[i]++;
            }
        }
        return result;
    }

    Imaginar una lista que contiene los números de 0 a m-1. Para elegir el primer número, podemos utilizar simplemente rand.nextInt(m). A continuación, retire el número de la lista. Ahora no queda m-1 los números, por lo que llamamos a rand.nextInt(m-1). El número obtenemos representa la posición en la lista. Si es menor que el primer número, es el segundo número, ya que la parte de la lista antes de que el primer número no ha cambiado por la eliminación del primer número. Si la posición es mayor o igual que el primer número, el segundo número es la posición+1. Hacer algunas derivación, se puede obtener de este algoritmo.

    Explicación

    Este algoritmo O(n^2) complejidad. Por lo que es bueno para generar pequeña cantidad de números únicos a partir de un gran conjunto. Mientras que el shuffle algoritmo basado en la necesidad, al menos de O(m) para realizar la reproducción aleatoria.

    También shuffle algoritmo basado en la necesidad de memoria para almacenar todos los resultados posibles para hacer el shuffle, este algoritmo no necesita.

  16. -2

    Comprobar este

    public class RandomNumbers {
    
        public static void main(String[] args) {
            //TODO Auto-generated method stub
            int n = 5;
            int A[] = uniqueRandomArray(n);
            for(int i = 0; i<n; i++){
                System.out.println(A[i]);
            }
        }
        public static int[] uniqueRandomArray(int n){
            int [] A = new int[n];
            for(int i = 0; i< A.length; ){
                if(i == A.length){
                    break;
                }
                int b = (int)(Math.random() *n) + 1;
                if(f(A,b) == false){
                    A[i++] = b;
                } 
            }
            return A;
        }
        public static boolean f(int[] A, int n){
            for(int i=0; i<A.length; i++){
                if(A[i] == n){
                    return true;
                }
            }
            return false;
        }
    }
    • Lanzar java normas, la legibilidad y la facilidad de uso por la ventana eh?
    • El código no es una respuesta.. Que escribir una respuesta y, a continuación, agregue el código para explicar lo que quería.

Dejar respuesta

Please enter your comment!
Please enter your name here