llenando una matriz con número aleatorio

Question

Estoy tratando de llenar una matriz de 20 ints con números del 1-20 en secuencia al azar. aquí es mi código:

int lookup[20]={0}; 
int array[20]={0}; 
srand(time(NULL)); 
for(int i=0;i<20;++i){ 
    bool done=false; 
    while(!done){ 
     int n=rand()%20; 
     if(lookup[n]==0){ 
      array[i]=n; 
      lookup[n]=1; 
      done=true; 
     } 
    } 
} 

He creado una matriz de búsqueda para comprobar si el número aleatorio aún no se elige y se almacena en la matriz. Como puede ver, he creado 2 bucles, uno para recorrer una matriz y el otro para elegir el número aleatorio. En cada iteración de bucle while, el número puede reaparecer y causar otro bucle while. ¿Hay una manera más rápida de hacer esto?

Answer 1

Puede llenar la matriz en secuencia y luego mezclarla. Eso evitaría tener que hacer más de 20 generaciones de números aleatorios.

Fisher-Yates shuffle: se puede hacer en O (n) tiempo.

de Wikipedia:

implementado correctamente, el shuffle Fisher-Yates es imparcial, por lo que cada permutación es igualmente probable. La versión moderna del algoritmo también es bastante eficiente, requiriendo solo tiempo proporcional al número de elementos que se barajan y sin espacio de almacenamiento adicional.

Answer 2

pondría los 20 números aleatorios en una matriz, y luego copiar a otra matriz de 20 elementos, ordenar una matriz, y para cada número en la matriz ordenada, encontrar el número correspondiente en la matriz sin clasificar, y poner el índice del género allí.

Answer 3

que podría llenar una matriz con números del 1 al 20 y utilizar std::random_shuffle

nota que no es necesario un vector para el caso de una simple matriz va a hacer.
ejemplo:

#include <iostream> 
#include <algorithm> 

using namespace std; 

int main(void) 
{ 
     int array[] = { 0, 1, 2, 3, 4 }; 

     srand(unsigned(time(NULL))); 

     random_shuffle(array, array+5); 

     for(int i=0; i<5; i++) 
       cout << array[i] << endl; 

     return 0; 
} 

Answer 4

Existe la posibilidad en el código de un bucle de ejecución muy largo. Si estás dentro del ciclo while (! Done), no hay garantía de que termines alguna vez. Obviamente, con una matriz de 20 elementos esto no será un problema en la práctica, pero podría causar problemas si amplía esto a muchos miles de elementos.

Una solución más confiable sería llenar la matriz secuencialmente y luego mezclarla después.

Answer 5

Mire std::random_shuffle y std::vector.

Answer 6

Si puede utilizar contenedores, que acababa de llenar un std :: set con los números del 1 al 20.

Luego se puede tirar un número aleatorio real de la unidad y la inserta en la matriz.

Answer 7

algo como esto?

int n = 20; //total element of array 
int random = 0, temp=0, start=1; 

for(int i=0; i < n; ++i,++start) 
{ 
    array[i] = start; 
} 

for(int i=0; i<n ; ++i) 
{ 
    random=rand()%(n-i)+i; 
    //swapping, you can make it as a function 
    temp = array[i]; 
    array[i] = array [random]; 
    array[random] = temp; 

} 

Answer 8

otra forma posible

int array[20]={0}; 
int values[20]; 
for(int i = 0; i < 20; i++) 
    values[i] = i; 
int left = 20; 
for(int i = 0; i < 20; i++) 
{ 
    int n = rand() % left; 
    array[i] = values[n]; 
    left--; 
    values[n] = values[left]; 
} 

PS llena de nombers 0-19 no de 1 a 20.Igual que el original Ejemplo de código

Answer 9

de Fisher-Yates:

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 

void shuffle(int array[], size_t size) 
{ 
    if(size) while(--size) 
    { 
     size_t current = (size_t)(rand()/(1.0 + RAND_MAX) * (size + 1)); 
     int tmp = array[current]; 
     array[current] = array[size]; 
     array[size] = tmp; 
    } 
} 

int main(void) 
{ 
    srand((int)time(NULL)); 
    rand(); // throw away first value: necessary for some implementations 

    int array[] = { 1, 2, 3, 4, 5 }; 
    shuffle(array, sizeof array/sizeof *array); 

    size_t i = 0; 
    for(; i < sizeof array/sizeof *array; ++i) 
     printf("%i\n", array[i]); 

    return 0; 
} 

Answer 10

espero que ayudará a:

std::generate(array, array + sizeof(array)/sizeof(int), ::rand); 

continuación tienen código completo:

#include<algorithm> 
#include<cstdlib> 
#include<iostream> 
#include<iterator> 

int main() 
{ 
    int array[] = {1, 2, 3, 4}; 
    const unsigned SIZE = sizeof(array)/sizeof(int); 

    cout << "Array before: "; 
    std::copy(array, array+SIZE, std::ostream_iterator<int>(cout, ", ")); 

    std::generate(array, array+SIZE, ::rand); // answer for your question 

    cout << "\nArray arter: "; 
    std::copy(array, array+SIZE, std::ostream_iterator<int>(cout, ", ")); 
} 

Si desea tener números más pequeños que los que puedes hacer después de generar:

std::transform(array, array+SIZE, array, std::bind2nd(std::modulus<int>(), 255));