Dev-C++, clase15 – ejercicios de aplicacion VI

Hola a todos/as,

En la clase anterior vimos lo que son arreglos, su funcion / uso / etc..

Ahora vamos a poner en practica lo que seria implementarlo como nueva manera de manejar variables en nuestros programas.

20.) Hacer un programa que pida: nombre,apellido,cedula y luego lo muestre con el formato:

Eddy | Perdomo | 012012012

Por favor antes de ver ésta entrada recomiendo ver la entrada:

Uso de la aplicacion

ATENCION: en las clases anteriores he explicado las lineas y que hace cada una, entonces les sugiero que vean las entradas anteriores para entender las lineas de las que no voy a hacer mucha enfasis.

Las lineas que ya hayamos visto, les colocaré ” *** “  al final para que sepan que ya lo hemos visto con anterioridad ( entiendase como “anterioridad” a la/las clases anteriores ademas de sus correspondientes entradas en la seccion “General” del mapa de sitio ).

#include <iostream.h>
#include <conio.h>

main()
{
char nombre[10],apellido[10],cedula[10];
cout<<“\nIngrese nombre: “;
cin>>nombre;
cout<<“\nIngrese apellido: “;
cin>>apellido;
cout<<“\nIngrese cedula: “;
cin>>cedula;
cout<<“\n\n”<<nombre<<” | “<<apellido<<” | “<<cedula<<“\n”;
getch();
}

– linea 1 – 2: la cabecera y libreria ***

– linea 3: funcion principal ***

– linea 4 – 14: inicio y fin del programa ***

– linea 5: declaramos variables ***

Estamos declarando variables ya de nueva manera, no como antes que sobrecargabamos nuestros programas con muchas variables, pudiendo declara una sola con diferentes posiciones como es el arreglo, en éste caso vemos que hemos declarado como char:

nombre [10]   —-> ésto significa que tendremos 10 variables char llamadas nombre

apellido [10]   —-> ésto significa que tendremos 10 variables char llamadas apellido

cedula [10]   —-> ésto significa que tendremos 10 variables char llamadas cedula

Ahora se preguntarán:

¿ Y por qué 10 variables nombre si solo quiero ingresar 1 nombre ?

Y la respuesta está en el tipo de dato, nosotros tenemos tanto a nombre,apellido,cedula como variables tipo char lo que significa que almacenarán cada una de ellas un solo dato [ para los que no sepan cuanto almacena cada tipo de dato les sugiero ver: ‘ Espacios de memoria segun tipo de variable ‘ ]

Eso quiere decir que si yo por ejemplo quiero ingresar mi nombre: “Eddy”

Y como tenemos nombre [10] la maquina virtualmente nos va a aceptar 10 caracteres individuales hasta que cumpla 10 “nombres”

más claramente, internamente haria algo asi:

nombre[0] = E

nombre[1] = d

nombre[2] = d

nombre[3] = y

Y de la misma manera con apellido y cedula, entonces recuerden al ser char los valores se capturan de 1 en 1😉

– linea 6: recurso cout ***

– linea 7: recurso cin ***

– linea 8: recurso cout ***

– linea 9: recurso cin ***

– linea 10: recurso cout ***

– linea 11: recurso cin ***

– linea 12: recurso cout ***

Bueno pues aqui ya mostramos las variables ya concatenadas, por eso no usamos el indexado ( los corchetes que contienen la ubicacion )

mostramos directamente: nombre,apellido,cedula. Porque queremos mostrar todo lo que se encuentra en cada una de ellas, como el ejemplo “Eddy” que les puse arriba, de la misma manera. Ya que si ponemos por ejemplo a la hora de mostrar el nombre ésto:

cout<<nombre[10];

Eso nos va a mostrar la letra que contiene en la posicion 10, y en nuestro caso no hay nada porque “Eddy” nos tomó 4 espacios. Por eso se muestra ya en concatenado que es:

cout<<nombre;

Eso nos va a mostrar la union de E+d+d+y = “Eddy”

– linea 13: pausando el programa ***

21.) Hacer un programa que calcule cinco numeros aleatorios entre “1-20” y luego los muestre en pantalla

Bien pues, he querido añadir un ejemplo con los famosos “random” es decir “aleatorios”, se usa mucho y pues a más de uno les ha causado dolor de cabeza entender, saber usarlo, ponerlo en practica, etc.. Pero aqui amigos/as, les voy a explicar lo mejor posible como va ésto, vamos a ello!

ATENCION: en las clases anteriores he explicado las lineas y que hace cada una, entonces les sugiero que vean las entradas anteriores para entender las lineas de las que no voy a hacer mucha enfasis.

Las lineas que ya hayamos visto, les colocaré ” *** “ al final para que sepan que ya lo hemos visto con anterioridad ( entiendase como “anterioridad” a la/las clases anteriores ademas de sus correspondientes entradas en la seccion “General” del mapa de sitio ).

#include <iostream.h>
#include <conio.h>
#include <time.h>

main()
{
int x,n[5];
srand (time(0));
for (x=0; x<=4; x++)
{
n[x]=rand()%20+1;
}
cout<<“Numeros aleatorios: \n”;
for (x=0; x<=4; x++)
{
cout<<n[x]<<“\t”;
}
getch();
}

– linea 1 – 3: la cabecera y libreria ***

Usamos la libreria <time.h> para poder trabajar con el tiempo ( más abajo les daré mas detalles especificamente por el “srand (time(0))” )

– linea 4: funcion principal ***

– linea 5 – 18: inicio y fin del programa ***

– linea 6: declaramos variables ***

– linea 7: randomizamos

Bien, randomizar la generacion de numeros aleatorios es importante, ya que al usar ésta linea:

srand (time(0));

Estamos diciendole al compilador que randomize numeros aleatorios mediante la hora actual, es decir que cada vez que pase el tiempo va a ir generando nuevos numeros aleatorios ( cada vez que se ejecute el programa ).

Pueden notarlo suprimiendo esa linea de codigo: ” srand (time(0)); “ , quitenla y verán que el programa no dará errores y se podra ejecutar tranquilamente, pero una vez ejecutado nos dará siempre los mismos numeros aleatorios ya que los sacó y con esos quedó, en cambio al decirle: ” srand (time(0)); “ estamos encerando el reloj y le decimos que trabaje generando numeros aleatorios a medida que avanza el tiempo entonces siempre va a estar constantemente cambiando ya que como conocemos nuestra unidad minima de tiempo es el segundo y pues hasta que ejecutamos una vez, ya pasaron algunos segundos hasta la proxima y asi.. Vamos a tener siempre numeros diferentes.

– linea 8: instruccion repetitiva ” for ” ***

– linea 9 – 11: inicio y fin del ” for ” ***

– linea 10: operaciones con variables ***

Bien pues tenemos la siguiente linea de codigo:

n[x]=rand()%20+1;

Primero voy a explicar del n[x], asi como vimos en la clase anterior, los arreglos nos ayudan a que mediante a simple vista “una sola variable” nos pueda almacenar diferentes valores dependiendo de su posicion.

En nuestro caso debemos generar cinco numeros aleatorios, pero no vamos a crear cinco variables n1,n2,n3,n4,n5 para calcularlos individualmente, no eso ya no porque conocemos ahora el uso de los arreglos, entonces con un n[5] ya tenemos esos ( n1,n2,n3,n4,n5 ) solo que indexados por su posicion que es lo unico que los diferencia, nuestros cinco numeros indexados serian: n[0] , n[ 1 ] , n[2] , n[ 3 ] , n[ 4 ].

Y para pedirlos nos creamos un ciclo repetitivo como lo es el for y pues..

desde que x vale 0 hasta que x vale 4 de 1 en 1 —-> for (x=0; x<=4; x++)

ahi tenemos que el for nos va a hacer cinco repeticiones, y pues aprovechamos y podemos colocar que:

n[x]=rand()%20+1;

entonces en la primera pasada seria:

n[0]=rand()%20+1;

n[1]=rand()%20+1;

n[2]=rand()%20+1;

Y asi sucesivamente hasta llegar a 4 que es hasta donde le indicamos al for que haga sus repeticiones.

Y entonces ya tendremos almacenados en la memoria cinco variables con numeros aleatorios en su interior: n[0] , n[ 1 ] , n[2] , n[ 3 ] , n[ 4 ].

Ahora.. ¿ Qué es el rand() ?

Bien, pues el rand() es una funcion que nos va a retornar un valor aleatorio entre 0 y rand_max ( el numero maximo que puede ser creado aleatoriamente ), y ese valor es un constante que se sabe es 32.767.

Pero como no queremos nosotros tener un numero random entre 0 y 32.767, queremos tener un numero random entre 1 y 20 pues vamos a indicarle a rand() que no queremos que vaya hasta su “max” si no que queremos indicarle hasta donde queremos recibir aleatorios, entonces por eso colocamos:

n[x]=rand()%20;

ahi le estamos indicando que queremos hasta un maximo de 20.

Pero existe otro detalle y es que como les vengo diciendo rand() retorna valores aleatorios entre 0 y el maximo que le queramos dar ( en éste caso 20 ); pero a nosotros no nos están pidiendo en el enuncia de éste ejercicio generar aleatorios entre 0 y 20, nos dicen entre 1 y 20. Bien para ello solo se le agrega con un “+” el numero desde donde queremos comenzar a generar el aleatorio, entonces ya saben:

%20 —> hasta donde

+1 —> desde donde

Entonces tenemos que: n[x]=rand()%20+1;

Le va a asignar a n[x] un valor entre 1 y 20 aleatorio😉

– linea 12: recurso cout ***

– linea 13: instruccion repetitiva ” for ” ***

– linea 14 – 16: inicio y fin del ” for ” ***

– linea 15: recurso cout ***

Asi mismo como hicimos con el for de arriba, lo volvemos a aplicar pero ésta vez no para generar aleatorios si no, para mostrar los valores que se encuentran en cada uno de los n[x] que son cinco: n[0] , n[ 1 ] , n[2] , n[ 3 ] , n[ 4 ].

Cada uno de ellos tendrá en su interior un numero aleatorio entre 1 y 20, y ese valor será mostrado separado por un “\t” que significa espacio de tabulacion. Para aquellos que no recuerden o no saben que es “\t” les sugiero revisen [ Las secuencias de escape ].

– linea 17: pausando el programa ***

Bueno eso es todo, espero haya sido de ayuda; cualquier comentario/sugerencia/duda la atenderé lo más pronto posible. Saludos!

4 comentarios

  1. ayudanos con un ejercicio que genere 20 numeros aleatorios entre-10 y10, los almacenen en un arreglo y presente en pantalla 20 numeros generados y cuantos de ellos son cero ayudanos urgente con este ejercicio
    atentamente
    maira santos

    • Hola Maira, bienvenida!
      Pues mira, primero aclara las cosas tienes un dominio de -10 a 10, bien.
      ¿que debes hacer?, como vas a usar arreglos crearte una variable y darle
      un almacenamiento de 20 espacios de memoria, entonces n[20]
      Ahora debes hacer un for, que vaya de 0 a 20 de 1en1.
      dentro de ese for, vas a calcular el random. Seria algo asi:
      n[i]=rand()%20-10
      donde i será la posicion que ira avanzando en el for
      donde rand()%20 le indicamos que el dominio es de 20 ( 10 negativos, 10 positivos )
      donde -10 es que especificamos desde donde va a comenzar, entonces que vaya de -10 hasta 10 para completar los 20
      PD. lo he realizado para comprobarlo y funciona, te lo mandare a tu correo revisalo, saludos!

  2. Hola un cordial saludo.

    Necesito realizar un generador de números aleatorios entre 0 y 1, es decir un generador de ceros y unos aleatorio.

    Gracias por su ayuda.

    • Hola Diego, bienvenido!
      lo que debes hacer ahi es usar la expresion rand(); indicar de donde a donde quieres que se genere el numero y el resto es ejecutar dicha funcion, puedes revisar aqui mismo; recuerdo haber hecho un ejercicio usando random. Saludos!

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: