Código fuente para sumar números enteros aleatorios

[UmbraNoche]

Damas y caballeros, este es mi primer aporte. Se trata de un programa que me habían dejado en la universidad como tarea. El enunciado de la tarea dice así: Realice un programa que llene dos arreglos unidimensionales de 10 elementos con valores aleatorios enteros de 1 a 15. En cada arreglo no puede existir el mismo número repetido, pero si puede existir en el otro arreglo. Cuando termina de llenar los arreglos debe mostrar su contenido uno a la par del otro, como se muestra a continuación:

Posicion        Arreglo 1            Arreglo 2
     1                 10                     8
     2                 15                     7
     3                  1                      6
     4                  6                      4
     5                 12                     9
     6                  9                    11
     ....

Luego deberá sumar los resultados en un tercer arreglo tomando el primer elemento del arreglo 1 y sumarlo con el último elemento del arreglo 2, valore que irá en la posición 1 del arreglo 3.
Al finalizar la suma de los elementos debe mostrar el resultado del tercer vector como se muestra a continuación:

Posicion      Arreglo 3
      1                     21
      2                     24
      3                      5
      4                     12
      5                     19
      6                     17

A cada les dejo el código fuente del programa. Me gustaría que opinen, den sugerencias. Yo apenas estoy empezando en el mundo de la programación. Así que todas sus sugerencias serán bienvenidas


//Suma de arreglos.

#include <iostream>

using std::cout;
using std::endl;

#include <iomanip>

using std::setw;

#include <cstdlib>

#include <ctime>

// la función main comienza la ejecución del programa

int main()
{
    // se declara los arreglos

    int x[ 11 ] ;
    int y[ 11 ] ;
    int z[ 11 ] ;

    // se declara las variables

    int a1 = 0;
    int a2 = 0;

   srand( time( 0 ) ); // semilla generadora de números aleatorios

   cout << "Posicion" << setw( 17 ) << "Arreglo 1"
    << setw( 17 ) << "Arreglo 2" << "\n" << endl;

    for ( int i = 1; i < 11; i++ )
    {
        a1 = (1 + rand() % 15);

        a2 = (1 + rand() % 15);

    int h = 0;
    int p = 0;

    // se declara estructuras de control para evitar que los números aleatorios se repitan

    while (h < i)
        {
              if (a1 != x[h])
              {
                  h++;
              }
              else
              {
                  a1 =(1 + rand() % 15);
                  h = 0;
              }
        }

        while (p < i)
        {
              if (a2 != y[p])
              {
                  p++;
              }
              else
              {
                  a2 =(1 + rand() % 15);
                  p = 0;
              }
        }

        //los arreglos se les asigna las varables

        x = a1;
        y = a2;


      cout << setw ( 9 ) << i
           << setw ( 16 ) << x[ i ]
           << setw ( 18 ) << y[ i ] << endl;



    }

cout << "\n La suma de los Arreglos es:\n ";

       int haciaAdelante = 1;
       int haciaAtras = 11;

    // se declara una estructura de control para hacer la suma de los arreglos de forma diagonal

    for (haciaAdelante = 0; haciaAdelante < 11; haciaAdelante++)
    {
        z [haciaAdelante] = x[haciaAdelante] + y[haciaAtras];
        haciaAtras--;
    }

cout << "\nPosicion" << setw( 17 ) << "Arreglo 3" << "\n" << endl;

for ( int n = 1; n <= 10; n++ )
      cout << setw ( 9 ) << n  << setw ( 16 ) << z[ n ] << endl;

    system("PAUSE");
    return 0;

} //fin de la función main

[s00rk]

Oooh nice, me gusto la forma que lo haces hehee mas esta partesita:

Código (cpp) [Seleccionar] Expandir


       int haciaAdelante = 1;
       int haciaAtras = 11;

    // se declara una estructura de control para hacer la suma de los arreglos de forma diagonal

    for (haciaAdelante = 0; haciaAdelante < 11; haciaAdelante++)
    {
        z [haciaAdelante] = x[haciaAdelante] + y[haciaAtras];
        haciaAtras--;
    }

Lo que yo cambiaria es al rellenar los arreglos y checar no repetidos, lo haria de la forma siguiente:

Código (cpp) [Seleccionar] Expandir


for(int x = 0; x < 10; x++)
{
do{
existe = false;
arr1[x] = (1 + rand() % 15);
for(int i = 0; i < x; i++)
if(arr1[x] == arr1[i])
existe = true;
}while(existe);

do{
existe = false;
arr2[x] = (1 + rand() % 15);
for(int i = 0; i < x; i++)
if(arr2[x] == arr2[i])
existe = true;
}while(existe);
cout << (x+1) << setw(17) << arr1[x] << setw(17) << arr2[x] << endl;
}


Aunque pues yo lo hice de 0 a 9, y tu de 1 a 10 hehehe al parecer no usas el index 0 hehehehe

[Runex]

Aquí te posteo el code en Python, he visto el tuyo y me he animado a hacer el mio en 10 minutitos antes de volver al instituto.

Código (python) [Seleccionar] Expandir

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random

class arrays:
def __init__(self):
self.arrax()
self.arrat()
self.sumarrays()
# Generador Array1, mientras su longitud sea menor que 10 se genera un aleatorio entre 0 y 15, si el numero no existe
# en la lista se añade, de lo contrario la lista se vacia y se vuelve a iniciar el bucle :)
def arrax(self):
self.array1 = []
while len(self.array1)<10:
self.aleatorio = random.randint(0,15)
if self.aleatorio not in self.array1:
self.array1.append(self.aleatorio)
else:
self.array1 = []
print "---Array 1---"
for self.numerox in self.array1:
print self.numerox
# Generador Array2, mientras su longitud sea menor que 10 se genera un aleatorio entre 0 y 15, si el numero no existe
# en la lista se añade, de lo contrario la lista se vacia y se vuelve a iniciar el bucle :)
def arrat(self):
self.array2 = []
while len(self.array2)<10:
self.aleatorio = random.randint(0,15)
if self.aleatorio not in self.array2:
self.array2.append(self.aleatorio)
else:
self.array2 = []
print "---Array 2---"
for self.numerox in self.array2:
print self.numerox
# Generador Array1, de la suma de arrays, mientras su longitud sea menor que 10
# se inicializa una variable y que indicara la posicion de las listas a sumar, con cada iteracion se eleva 1
def sumarrays(self):
self.sumarrays = []
self.y = 0
while len(self.sumarrays) < 10:
self.suma = self.array1[self.y] + self.array2[self.y]
self.sumarrays.append(self.suma)
self.y +=1
print "---Suma Arrays---"
for self.elemento in self.sumarrays:
print self.elemento
if __name__ == "__main__":
instancia = arrays()
instancia
Por cierto, que año es y que carrera estás haciendo?
Un saludo

[do-while]

¡Buenas!

Buf... Esa forma de generar numeros aleatorios distintos en un intervalo es muy farragosa. Te propongo esta otra:

Código (c) [Seleccionar] Expandir


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

#define LONGITUD_INTERVALO_FUENTE 20
#define MIN_FUENTE 1
#define NUMERO_VALORES 15

int main(int argc, char *argv[])
{
   int vector_fuente[LONGITUD_INTERVALO_FUENTE];
   int v1[NUMERO_VALORES] , v2[NUMERO_VALORES] , i , indice , aux;

   srand(time(NULL));

   /* inicializamos la fuente de los datos */
   for(i = 0 ; i < LONGITUD_INTERVALO_FUENTE ; i++)
       vector_fuente[i] = MIN_FUENTE + i;

   /* Reordenamos los valores*/
   for(i = 0 ; i < NUMERO_VALORES ; i++)
   {
       aux = vector_fuente[i];
       vector_fuente[i] = vector_fuente[indice = rand() % LONGITUD_INTERVALO_FUENTE];
       vector_fuente[indice] = aux;
   }

   /* copiamos los valores en el primer vector */
   for(i = 0 ; i < NUMERO_VALORES ; i++)
       v1[i] = vector_fuente[i];

   /* reordenar de nuevo y asignar al segundo vector */
}


Aunque parezca mas largo, imagina que tienes que asignar N valores aleatorios distintos en un vector de N posiciones, en este caso, una vez que hayas introducido n valores, la probabilidad de repetir alguno de los valores introducidos es de n/N, es decir, cuanto mayor sea n, mayores posibilidades tendras de repetir alguno de los numeros introducidos, por lo que vuestros bucles se pueden repetir una cantidad de veces considerablemente mas alta de la necesaria. Por ejemplo en un vector de 100 posiciones, una vez introducidos 99 numeros, 99 de cada 100 veces generareis un numero repetido.

Sin embargo, con el metodo que he propuesto, quitando la inicializacion del vector que contiene el origen de los datos, siempre realizareis la misma cantidad de iteraciones, asegurandoos de que nunca se repetiran los valores.

La contrapartida del metodo que he utilizado es que utiliza mas memoria al tener un vector para almacenar todos los posibles datos.

Si quereis luego hago una simulacion con vuestro metodo y dejo las estadisticas para que las veais.

¡Saludos!

PD: Aqui una salida de la simulacion:

Código [Seleccionar] Expandir


10 valores entre 1 y 16. Media 86.00 iteraciones

Vector resultante:
11   9   6  14  10   7  15   1   3   4

15 valores entre 1 y 16. Media 358.11 iteraciones

Vector resultante:
13  15  14   2   5   9   3  10  11   4   1   6   8  12   7

25 valores entre 1 y 51. Media 432.91 iteraciones

Vector resultante:
46  20  28  40  43  17  22  42  36   7  16  10  47   6  34  18  49  30  33   8
26  13  27  25  38

50 valores entre 1 y 51. Media 5217.88 iteraciones

Vector resultante:
39  42  36  25   7  19  23  22  50  41  44  26   2  45  29  18   8  31  28  33
14   4  20  46  30  48  27  10  47  15  40   6  32  16  24   3  21  43  38  49
12   9  13  17  11   1   5  35  37  34


Y aqui el codigo fuente que he utilizado para hacerla:

Código (c) [Seleccionar] Expandir


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

#define RANGO_1 15
#define RANGO_2 50

#define MINIMO 1

#define NUMERO_VALORES_1 10
#define NUMERO_VALORES_2 15
#define NUMERO_VALORES_3 25
#define NUMERO_VALORES_4 50

#define REPETICIONES 2000

int main(int argc, char *argv[])
{
   int numero_valores[] = {NUMERO_VALORES_1,NUMERO_VALORES_2,NUMERO_VALORES_3,NUMERO_VALORES_4};
   int rangos[] = {RANGO_1,RANGO_2};
   int v[NUMERO_VALORES_4];
   int total_iteraciones, n_iteraciones , i,j,k, valores_introducidos,valor;

   srand(time(NULL));

   for(i = 0 ; i < 4 ; i++)
   {
       total_iteraciones = 0;

       for(j = 0 ; j < REPETICIONES ; j++)
       {
           n_iteraciones = 0;

           valores_introducidos = 0;

           while(valores_introducidos != numero_valores[i])
           {
               if(valores_introducidos == 0)
                   v[0] = rand() % rangos[i / 2] + MINIMO;
               else
               {
                   do{
                       valor = rand() % rangos[i / 2] + MINIMO;

                       for(k = 0 ; k < valores_introducidos && v[k] != valor ; k++)
                           n_iteraciones++;

                       n_iteraciones++;

                   }while(k < valores_introducidos);

                   v[valores_introducidos] = valor;
               }

               valores_introducidos++;
               n_iteraciones++;
           }

           total_iteraciones += n_iteraciones;
       }

       printf("%d valores entre %d y %d. Media %.2f iteraciones\n\n",
               numero_valores[i], MINIMO , MINIMO + rangos[i / 2], ((float) total_iteraciones) / REPETICIONES);

       printf("Vector resultante:\n");

       for(k = 0 ; k < numero_valores[i] ; k++)
           printf("%3d ",v[k]);
       printf("\n\n");
   }

   return 0;
}


¡Saludos de nuevo!

[Sagrini]

Wow! Jajaja...

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#define TAM 10
#define RAND 15

int main ()
{ srand (time (0)); int nums [3][TAM], a, b, x, flag;
for (x=0; x<2; x++) for (a=0; a<TAM; a++)
{ do
{ nums [x][a]=rand ()%RAND+1; flag=0;
for (b=0; b<a; b++) if (nums [x][b]==nums [x][a]) { flag=1; break; }
} while (flag == 1);
}

for (a=0; a<10; a++) nums [2][a]=nums [0][a]+nums[1][9-a];
for (a=0; a<10; a++) printf ("Posición %02d --> %02d + %02d = %02d\n", a+1, nums [0][a], nums [1][9-a], nums [2][a]);
return 0;
}


[do-while]

¡Buenas!

Sagrini, si prestas atencion a los post anteriores, veras que esa es la forma en la que ellos estaban generando numeros aleatorios (no la misma, pero si basada en busquedas de numeros repetidos). Si miras la tabla que he dejado, veras que es muy ineficiente y cuanto mas crece el tamaño de los datos mas ineficiente se vuelve.

Cuenta tu mismo las iteraciones que esta realizando el codigo que has puesto y luego las que realiza el codigo que he indicado, y comprobaras tu mismo, que estas generando muchisimas mas de las necesarias.

¡Saludos!