Как я могу производить случайные числа, которые не повторялись бы?

Это способ получать nГєmeros случайные без того, чтобы они повторились начиная с определенного array, в этом случае как примере 5 типов стоимости.

var myArray = ['1','2','3','4','5'];

    var i,j,k;
    for (i = myArray.length; i; i--) {
        j = Math.floor(Math.random() * i);
        k = myArray[i - 1];
        myArray[i - 1] = myArray[j];
        myArray[j] = k;
    }


document.write("números aleatorios : " + myArray);

Это форма, чтобы получать nГєmeros случайные без того, чтобы они повторились, что ты должен реализовывать, состоит в том, чтобы получать один nГєmero случайный в определенном ранге и проверять не повторилось храня в array, примере получая nГєmeros случайные в ранге от 1 до 5:

//Define la cantidad de numeros aleatorios.
var cantidadNumeros = 5;
var myArray = []
while(myArray.length < cantidadNumeros ){
  var numeroAleatorio = Math.ceil(Math.random()*cantidadNumeros);
  var existe = false;
  for(var i=0;i<myArray.length;i++){
	if(myArray [i] == numeroAleatorio){
        existe = true;
        break;
    }
  }
  if(!existe){
    myArray[myArray.length] = numeroAleatorio;
  }

}
document.write("números aleatorios : " + myArray);

То, что я думаю, чем array [1,2,3,4,5], снимать элемент 1, и помещать это в случайное положение второго array, тогда остается [1].

Потом 2, и помещать это случайным образом, и смоги оставаться [2,1] или [1,2]. Если он [2,1], потом 3, смоги оставаться [3,2,1], [2,3,1] или [2,1,3]. Если он [2,1,3], потом 4, тогда [4,2,1,3] [2,4,1,3] [2,1,4,3] [2,1,3,4]. Если он [2,4,1,3].

В конце концов, 5 смоги быть введенным в каком-то месте, оставаясь этими возможными arrays.

[5,2,4,1,3]
[2,5,4,1,3]
[2,4,5,1,3]
[2,4,1,5,3]
[2,4,1,3,5]

Предполагая, что он был введен в четвертом положении, вытекающий array [2,4,1,5,3]. Matemáticamente, возможные arrays для x - x! а именно, factorial x, а именно, для 5 это 120 возможностей, в то время как, если повторяются числа^{, он xx}, а именно, для 5 это 3125 возможностей.

Код:

function insertarEn(array,valor,posición)
{
	var inicio=array.slice(0,posición)
	var medio=valor
	var fin=array.slice(posición)
	var resultado=inicio.concat(medio).concat(fin)
	return resultado
}
function aleatoriosNoRepetidos(cantidad)
{
	var array=[]
	for(var i=0;i<cantidad;i++)
	{
		array=insertarEn(array,i,Math.random()*(cantidad+1) )
	}
	return array
}
console.log( aleatoriosNoRepetidos(5)+"" )

Ты можешь использовать closures, чтобы создавать твой собственный генератор случайных чисел, основанный на списке элементов.

В следующем коде я показываю тебе, как создавать функцию, параметр которой - список.

Этот список "тасуется" в цикле for, (закончив цикл for, элементы будут приведены в беспорядок случайным образом).

Однажды сделанный это, функция возвращает другую функцию, которая возьмется за то, чтобы давать тебе случайное число, отличное от этого списка в каждом вызове, кругового способа (когда он возвратит тебе все те, кто у него есть, не повторяя, он вновь начнет давать их тебе в том же предварительном порядке).

var randomFromListGenerator = function (list) {
    var position = 0;

    for (var i=0, l=list.length; i<l; i++) {
        var random = Math.floor((Math.random() * l));
        var aux = list[i];
        list[i] = list[random];
        list[random] = aux;
    }

    return function () {
        return list[position++ % list.length];
    }
}

Чтобы использовать эту функцию только ты должен делать следующее:

var nextRandomFromList = randomFromListGenerator ([1,2,3,4,5]);

И когда ты захочешь новое случайное число делать:

var newRandom = nextRandomFromList();

С этим ты можешь осуществлять это поведение со всеми списками хоти. Ты можешь изменять функцию для того, чтобы он бросил в тебя ошибку, когда уже он возвратил тебе всю стоимость списка, или для того, чтобы он повторно тасовал список, и получать новый порядок для того, чтобы он не был всегда "круговым".

Это простой способ наполнять договоренность с nГєmeros случайные, с переменными для parametrizar то, в чем ты нуждаешься.

var arr = []; // Arreglo para llenar
var cantidadNumeros = 5; // Cantidad de números en el arreglo
var hasta = 10; // Máximo valor de los números en el arreglo

function llenarAleatorios(a){
    var v = Math.floor(Math.random() * hasta);
    if(!a.some(function(e){return e == v})){
        /** 
         * Si no se encuentra el valor aleatorio en el arreglo
         * se pushea el valor.
         */ 
        a.push(v);
    }
}
/**
 * Bucle para llenar el arreglo con la cantidad que necesites
 */
while(arr.length < cantidadNumeros && cantidadNumeros < hasta){
    llenarAleatorios(arr);
}

После этого, tenes твоя договоренность, полная nГєmeros случайные не повторенные .

Я ответил сходный вопрос в другом трэде:
Извлекать 4 Strings random Array в языке сценариев JavaScript
Идея состоит в том, чтобы хранить уже появившиеся числа и выбирать числа остальных.
EDIT:
Пример функции, ты вводишь минимум и максимум, и выбери числа случайным образом до тех пор, пока не заканчиваются выборы, если включается reset, resetea список, если меняется ранг также.

	function numAleatorioSinRepetir(minimo,maximo) {
		var i;
		if (minimo=="reset"){	// Si el primer parámetro es "reset", reinicia la lista de números y sale.
			if (!this.minimo||!this.maximo) return; // Si el rango no está definido, sale.
			this.numerosAparecidos=[]; // reinicia matriz
			for (i=this.minimo;i<=this.maximo;i++)
				this.numerosAparecidos.push(i); // Introduce los números del rango.
			return;
		}
		if (isNaN(minimo)||isNaN(maximo)) return; // Si los parámetros no son números, sale.

		if (minimo!=this.minimo || maximo!=this.maximo){ // Si cambia el rango, resetea la lista de numeros.
			if (minimo>maximo) { // Si el mínimo es mayor que el máximo, invierte las variables.
				i=minimo;
				minimo=maximo;
				maximo=i;
			}
			this.minimo=minimo; // Guarda el nuevo rango
			this.maximo=maximo;
			this.numerosAparecidos=[]; // reinicia matriz
			for (i=minimo;i<=maximo;i++)
				this.numerosAparecidos.push(i); // Introduce los números del rango.
		}
		var random=Math.floor(Math.random()*this.numerosAparecidos.length); // Elije una posicion aleatoria
		var numero=this.numerosAparecidos[random]; // Guarda el número de la posición.
		this.numerosAparecidos.splice(random,1); // Elimina la posición.
		return numero; // Devuelve el número.
	}
	function ponNumero(){
		var min=parseInt(IDmin.value);
		var max=parseInt(IDmax.value);
		var numero=numAleatorioSinRepetir(min,max);
		IDinfo.innerHTML+=numero+", ";
	}

Mínimo:<input id="IDmin"> Máximo:<input id="IDmax"> <button onclick="numAleatorioSinRepetir('reset')">Reset</button>
<button onclick="ponNumero()">Pon numero</button>
<DIV id="IDinfo"></DIV>

Доставший из SO ENG: https://stackoverflow.com / в / 6274381/3045491

mГ©todo "тасует" это тебе, реорганизует элементы.

function shuffle(a) {
    var j, x, i;
    for (i = a.length; i; i--) {
        j = Math.floor(Math.random() * i);
        x = a[i - 1];
        a[i - 1] = a[j];
        a[j] = x;
    }
}

Первый создай список с количеством числа, которое ты желаешь.

Lis<Integer> numbers = new ArrayList<>();
                for (int i = 0; i < cantidad_que_quieres; i++) {
                    numbers.add(i);
                }

Потом ты помещаешь его shuffle.

                Collections.shuffle(numbers);

И потом ты это пробегаешь (и он будет приведен в беспорядок благодаря shuffle). А именно, что, если в i <tu_variable ты поместил 10, у тебя будет 10 неряшливых чисел.

И потом ты просишь ранг чисел, которые ты хочешь. Что я имею в виду? Чего в пределе наверху может быть 100, потому что, хотя ты захочешь показать в конце концов 3 в общем количестве, ты не хотел, чтобы он также ограничился 3 случайными. Наверху ты определяешь, сколькие ты хочешь и здесь внизу ты определяешь, сколькие ты покажешь, и в каком ранге. Если ты хочешь инициализироваться с 1, j=1, и я схватил.

    for(int j=0;j<total_rango;j++){
 //Muestras el indice j, que será aleatorio y no se repetirá
}

Здесь я размещаю вклад для поколения случайных чисел без того, чтобы они повторялись:

Я приступил к проблеме со следующей точки зрения:

1) максимальная стоимость random должна будет быть равна количеству числа количеству попросивших чисел для того, чтобы имело смысл поколение и не оставалось без чисел.

2) производит случайную стоимость и создается договоренность так называемый "array".

3) сравнивает стоимость договоренности с произведенным числом, если он не существует, он присоединяется.

4) заканчивает цикл с количеством попросивших чисел Array (4) [0, 4, 3, 1]

5) создается пустая договоренность с количеством попросивших чисел договоренность называется "foo"

6) вводятся в договоренности "foo" числа, произведенные и хранившиеся договоренностью "array' deacuerdo в Вашу стоимость и положение в индексе оставаясь неопределенные будки. Пример: Array (5) [0, 1, < 1 empty slot>, 3, 4]

7) делает себе поездку из-за договоренности "foo", чтобы искать будку неопределенные и тех, которые находят, вводит как стоимость расположенное напротив положение, оставаясь конечная договоренность этой формы. Array (5) [0, 4, 3, 1, 2]

Замечает: он не начал производить random каждый раз, когда он находил повторенное число, потому что это в конце концов тратит цикл процесса и даже может входить в неопределенный цикл после того, как старается производить число, которое возможно не выходило бы в random.

ПРИСОЕДИНИЛ КОД:

// declaracion de variables
   var veces = 5;
   var max = veces;

    var array =[];
    for(var l=0; l< veces; l++) {          
            var randomNumber = Math.floor(Math.random()*max); 
                 var repite=false;
                // busca la lista de numeros generados
                array.forEach(function(element) {
                     // si hay un numero repetido  = TRUE
                     if (element==randomNumber) {
                        repite=true;
                        }
                });           
                // si no se repite ningun numero = FALSE
                if (repite==false) {
                    array.push(randomNumber)
                }       
    }

    
    console.log(array); // valor de arreglo array

    // crear array por numero de veces
    var foo = new Array(veces);    
    array.forEach(function(element) {
        foo[element]= element;
    });
    console.log(foo); // arreglo foo

    // buscar campo indefinidos para completar 
    for (let index = 0; index < foo.length; index++) {
       console.log(foo[index]);
       if (foo[index]=== undefined) {
         console.log('indefinido valor');
         array.push(index);
       }
    }
    
    console.log(array); // resultado de arreglo;

    // mostrar valor en mensaje
    array.forEach(function(element) {
        document.writeln(element)
    });   

Следующим может быть хорошее начало для тебя:

Ты определяешь один array с элементами, которые ты хочешь получить случайным способом и определяешь переменную, которая будет содержать последнюю полученную стоимость, хотя он изначально не будет считать присоединенной никакой стоимости.

Потом ты звонишь в функцию getRandomFromArrayNotRepeated происходя с ним, как я доказываю array в выбор. Та же самая Будет искать случайную стоимость array и он это сравнит с последней стоимостью, распределенной в lastRandomValue. Если стоимость совпадает, будет работать снова функция getRandomFromArrayNotRepeated, в случае когда он не совпадал он распределит новую стоимость в lastRandomValue и он возвратит вышеупомянутую стоимость.

Если array будет содержать единственную возможную стоимость, всегда ты получишь этот как результат.

var lastRandomValue, exampleArray = [1,2,3,4,5];

function getRandomFromArrayNotRepeated(array) {
   var item = array[Math.floor(Math.random()*array.length)];
   if(lastRandomValue === item && array.length > 1) {
       return getRandomFromArrayNotRepeated(array, item);
   } 
   return lastRandomValue = item;
}

for(var i = 0, len = 100; i < len; i++) {
    console.log(getRandomFromArrayNotRepeated(exampleArray));
}

Если то, что ты в действительности хочешь сделать, состоит в том, чтобы делать каждую случайную единственную стоимость (мочь получать эту стоимость только однажды), я рекомендую Тебе продолжать это решение: Generating нечетное число - repeating random numbers in JS