TheWhiteCode

En esta ocación veremos que posibles mejoras se pueden hacer en el siguiente codigo:

Este codigo es utilizado para llenar e imprimir un array con numeros aleatorios

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
#include <iomanip>

using namespace std;
void printArray(int* arreglo, size_t TAM)
{
    cout << "+----------+---------+" << endl;
    cout << "+ Indice | Valor |" << endl;    
    cout << "+----------+---------+" << endl;
    for(size_t i = 0; i < TAM; ++i)
    {
        cout << "|";
        cout << setw(10) << i;
        cout << "|";
        cout << setw(10) << arreglo[i];
        cout << "|" << endl;
    }    
    cout << "+----------+---------+" << endl;
}

void fillArrayRandomly(int* arreglo, size_t TAM)
{
    int MAXIMO = 50, MINIMO = 0;
    for(size_t i=0; i < TAM; ++i)
    arreglo[i] = (rand() % (MAXIMO - MINIMO + 1)) + MINIMO;
}

int main()
{
    int ar[20];
    fillArrayRandomly(ar, 20);
    printArray(ar, 20);
    return 0;
}

Que si quiero un array dinamico?:

En C++11 y versiones posteriores se puede usar la biblioteca <random> para generar números aleatorios y la biblioteca <vector> para trabajar con vectores dinámicos.

Aquí hay un ejemplo de cómo llenar un vector dinámico con números aleatorios y luego imprimir sus elementos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <iostream>
#include <vector>
#include <random>

int main() {
  // Creamos un motor de números aleatorios y una distribución uniforme
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<> dis(0, 50);

  // Creamos un vector dinámico de tamaño 20 e inicializamos sus elementos con números aleatorios
  std::vector<int> vec(20);
  for (auto& el : vec) {
    el = dis(gen);
  }

  // Imprimimos los elementos del vector
  std::cout << "+----------+---------+" << std::endl;
  std::cout << "+ Indice | Valor |" << std::endl;
  std::cout << "+----------+---------+" << std::endl;
  for (std::size_t i = 0; i < vec.size(); ++i) {
    std::cout << "|" << std::setw(10) << i << "|"
              << std::setw(10) << vec[i] << "|" << std::endl;
  }
  std::cout << "+----------+---------+" << std::endl;

  return 0;
}

  Este código utiliza la biblioteca <random> para generar números aleatorios y la biblioteca <vector> para trabajar con vectores dinámicos. Primero se crea un motor de números aleatorios y una distribución uniforme para generar números aleatorios entre 0 y 50. Luego se crea un vector dinámico de tamaño 20 y se llenan sus elementos con números aleatorios utilizando el motor de números aleatorios y la distribución uniforme. Finalmente, se imprime el vector utilizando un bucle for y la función std::setw() de la biblioteca <iomanip> para dar formato a la salida.  

Mejoras

El código presentado parece estar correctamente estructurado y cumple su objetivo de llenar un array con números aleatorios y luego imprimirlos en forma de tabla. Sin embargo, hay algunas sugerencias para mejorarlo:

• 1. En lugar de usar la función rand(), se recomienda utilizar una librería moderna para generar números aleatorios en C++, como por ejemplo la librería <random>.

• 2. En la función fillArrayRandomly, se debería comprobar que el tamaño del array no sea cero para evitar errores. Esto se puede hacer fácilmente añadiendo una verificación al inicio de la función, como if (TAM == 0) return;.

• 3. La tabla impresa por la función printArray podría mejorarse visualmente si se agregan líneas horizontales en la parte superior e inferior de la tabla.

• 4. Para mejorar la legibilidad del código, se podría utilizar una constante en lugar de un número mágico para el tamaño del array, por ejemplo const size_t TAM = 20;.

Un consejo: en C++20 se introdujo una nueva biblioteca de generación de números aleatorios llamada "random". Esta biblioteca ofrece un mayor control y flexibilidad en la generación de números aleatorios.Aquí está el código actualizado utilizando la biblioteca "random" en C++20:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
#include <iomanip>
#include <random>

using namespace std;

void printArray(int* arreglo, size_t TAM)
{
    cout << "+----------+---------+" << endl;
    cout << "| Indice   | Valor   |" << endl;    
    cout << "+==========+=========+" << endl;
    for(size_t i = 0; i < TAM; ++i)
    {
        cout << "|";
        cout << setw(10) << i;
        cout << "|";
        cout << setw(10) << arreglo[i];
        cout << "|" << endl;
    }    
    cout << "+----------+---------+" << endl;
}

void fillArrayRandomly(int* arreglo, size_t TAM)
{
    if (TAM == 0) return;
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(0, 50);
    for(size_t i = 0; i < TAM; ++i)
        arreglo[i] = dis(gen);
}

int main()
{
    const size_t TAM = 20;
    int ar[TAM];
    fillArrayRandomly(ar, TAM);
    printArray(ar, TAM);
    return 0;
}

En cuanto a la comparación de tiempo de ejecución entre el código A y el código B, es difícil hacer una comparación precisa sin saber el entorno y las especificaciones de la máquina.

Sin embargo, en general, el código B debería ser más rápido que el código A debido al uso de la biblioteca "random" en lugar de la función "rand". Además, el código B utiliza una declaración de tamaño de array constante y utiliza el operador de resolución de ámbito para llamar a las funciones en lugar del espacio de nombres global, lo que se considera una buena práctica en C++.

Dejame saber tus dudas en los comentarios. Comparte esta publicación y dale me gusta!