Vous êtes sur la page 1sur 23

PROYECTO DE ELECTIVA DE PROGRAMACIÓN CON VECTORES Y

FUNCIONES

EDISON FELIPE LEÓN VEGA

UNIVERSIDAD PEDAGÓGICA Y TECNOLOGÍA DE COLOMBIA


INGENIERÍA ELECTRÓNICA
SEDE SOGAMOSO- BOYACÁ
2019
CONTENIDO.

INTRODUCCIÓN. Pág
2. OBJETIVOS..………………………………………………………………………..4
2.1 OBJETIVO GENERAL..…………………………………………………..4
2.2 OBJETIVOS ESPECÍFICOS..…………………..………………………..4
3. JUSTIFICACIÓN. …………………………………………………………………...5
4. MARCO TEÓRICO..………………………………………………………….……..6
5. DESARROLLO……………….…….........………………………………………….8
5.1 PUNTO 1…………………………………..………………………………..8
5.2 PUNTO 2……………………...….…………………………………………12
6. CONCLUSIONES. …………………………………………………………………..22
7.BIBLIOGRAFIA . ……………………………………………………………………..23
INTRODUCCIÓN

La programación juega un papel muy importante en el desarrollo tecnológico del


mundo conocer parte de su funcionamiento es de vital importancia. Vamos a ver la
solución a dos tipos de problemas mediante el uso de arrays y funciones haciendo
uso del lenguaje de programación C++, estos problemas podrán ser de necesidad
para la vida cotidiana.
2. OBJETIVOS.

2.1 Objetivo general:


Resolver dos problemas mediante el lenguaje de programación de C++ usando
arrays y funciones.

2.2 Objetivos Específicos:

 Entender el funcionamiento de los ciclos repetitivos de C++ y su uso en la


operación de arrays.

 Hacer uso de la función rand y srand para la generación números aleatorios

 Aplicar las funciones tipo void, y las varibles tipo char e int para la generación
de códigos en C++

4
3. JUSTIFICACIÓN

La programación es una herramienta muy importante para la solución de problemas


es por esto que se hace necesario conocer como aplicar su lenguaje para poder
entender mejor como funciona. C++ es un lenguaje practico y sencillo para este fin.

5
4. MARCO TEORICO

Programación:
La programación es un proceso que se utiliza para idear y ordenar las acciones que
se realizarán en el marco de un proyecto; al anuncio de las partes que componen
un acto o espectáculo; a la preparación de máquinas para que cumplan con una
cierta tarea en un momento determinado; a la elaboración de programas para la
resolución de problemas mediante ordenadores, y a la preparación de los datos
necesarios para obtener una solución de un problema.
En la actualidad, la noción de programación se encuentra muy asociada a la
creación de aplicaciones informática y videojuegos. Es el proceso por el cual una
persona desarrolla un programa valiéndose de una herramienta que le permita
escribir el código (el cual puede estar en uno o varios lenguajes, como C++, Java y
Python, entre otros) y de otra que sea capaz de “traducirlo” a lo que se conoce como
lenguaje de máquina, que puede comprender el microprocesador.

C++:
C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La
intención de su creación fue extender al lenguaje de programación C mecanismos
que permiten la manipulación de objetos. En ese sentido, desde el punto de vista
de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se
sumaron a los paradigmas de programación estructurada y programación orientada
a objetos. Por esto se suele decir que el C++ es un lenguaje de programación
multiparadigma.

Funciones(en programación):
Las funciones son un conjunto de instrucciones que realizan una tarea específica.
En general toman ciertos valores de entrada, llamados parámetros y proporcionan
un valor de salida o valor de retorno; aunque en C++, tanto unos como el otro son
opcionales, y pueden no existir.
Tal vez parezca un poco precipitado introducir este concepto tan pronto en el
curso. Sin embargo, las funciones son una herramienta muy valiosa, y como se
usan en todos los programas C++, creo que debemos tener, al menos, una

6
primera noción de su uso. A fin de cuentas, todos los programas C++ contienen,
como mínimo, una función.

Arrays:
Los arrays, arreglos o vectores forman parte de la amplia variedad de estructuras
de datos que nos ofrece C++, siendo además una de las principales y más útiles
estructuras que podremos tener como herramienta de programación. Los arrays,
arreglos o vectores (como los quieras llamar), son utilizados para almacenar
múltiples valores en una única variable. En un aspecto más profundo, los arrays,
permiten almacenar muchos valores en posiciones de memoria continuas, lo cual
permite acceder a un valor u otro de manera rápida y sencilla. Estos valores pueden
ser números, letras o cualquier tipo de variable que deseemos incluso tipos de datos
propios.

7
5. Desarrollo

5.1. Punto 1
Generar un vector con 100 letras minúsculas y almacenarlas e un vector de tipo
carácter y contar cuantas veces aparece cada letra en el vector.

Solución:
Insertamos las librerías que vamos a usar seguidas del using namespace std;
para que podamos usar en cin y el cout para imprimir datos en pantalla y
almacenarlos en memoria.
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;

Creamos las funciones que usaremos en nuestro planteamiento a la solución del


problema.

aleatorio
Creamos una función de tipo void llamada aleatorio cuyo argumento con la variable
de tipo entero (int) llamada n para el tamaño del vector y el vector x de tipo
carácter(char).
Definimos la función aleatoria, luego inicializar los números usando la función srand
que llama a la función time usando el parámetro NULL lo que hace que la función
time lea el tiempo interno de la computadora en segundos ara que la función srand
lea ese tiempo que lee y lo convierta en un entero sin signo para inicializar la función
rand.

Con un ciclo for que va desde cero hasta el n incrementándolo en uno, le asignamos
a cada posición un carácter aleatorio, siendo 'a' desde donde comienza el aleatorio
y +rand()%, después de esto especificamos hasta donde va nuestra letra aleatoria
en este caso 26 ya que según la tabla ASCII la letra minúscula 'a' es 97 que va
hasta la 'z' minúscula que es 122.
Imprimimos en pantalla los elementos del vector.
void aleatorio(int n, char x[]){
srand(time(NULL));
for(int i=0;i<n+1;i++){
x[i]='a'+rand()%26;

8
cout<<x[i]<<" ";

}
cout <<endl;
}

calcula
Definimos los argumentos de la función calcula que es de tipo void, int n es el tamaño
del vector y char y[] es el vector de tipo carácter.

Con un for que va desde cero hasta el tamaño del vector incrementando en uno definimos
una variable tipo carácter llamada q a la que le asignamos el valor de y[i]para que
almacene ahí ese carácter, luego con un una condición, si q es diferente del carácter '*'
llame a la función repetidos enviándole y que es el vector, n, que es el tamaño para el for
y q que es la posición y[i].

Para luego llamar a la función elimina enviándole los mismos parámetros que la función
repetidos para que reasigne a la posición y[i] un nuevo carácter.
void calcula(int n, char y[]){
for(int i=0;i<n;i++){
char q;
q=y[i];
if(q != '*')
repetidos(y,n,q);
elimina(y,n,q);
}
}

repetidos
De igual manera que las funciones anteriores repetidos es de tipo void cuyos
argumentos son el vector con los caracteres x[],el entero w que es el tamaño del vector y
el carácter n que la que recibe el valor de q que es enviado desde la función calcula.

Iniciamos un contador en cero llamado c que nos va decir cuantas veces se repite cada
carácter en este caso la primera posición del vector.

Mediante un for comparamos cada posición del vector con el carácter n usando una
condición que es que si n es iguala x[i]incremente el contador y que a la variable y la
haga x[i]cuando el ciclo se sature imprimirá la letra que más se repite y cuantas veces.
void repetidos(char x[], int w, char n){
int c=0;
char y;
for(int i=0;i<w;i++){
if(n == x[i]){

9
c++;
y=x[i];
}
}
cout<<"La letra "<<y<<" se repite :"<<c<<" veces"<<endl;
}

elimina

Al igual que las funciones anteriores elimina es de tipo void cuyos argumentos son los
mismos de la función repetidos; un vector con los caracteres x[], el entero w que es el
tamaño del vector y el carácter n que la que recibe el valor de q que es enviado desde la
función calcula.

Con un for que va desde cero hasta w incrementando de uno en uno con la condición de
que si q es igual a x[i]haga a esa posición '*' lo que remplazaría a todas las posiciones
iguales por '*' rompiendo la condición de la función calcula de que si el elemento es
diferente de '*' en esta caso como es asterisco estaría excluida d ser analizada
nuevamente para que se analice las otras letras.
void elimina(char x[], int w, char q){
for(int i=0;i<w;i++){
if(q == x[i]){
x[i]='*';
}
}
}

El mismo proceso se repetiría para cada elemento del vector.


Por último la función principal.

main()
En la función principal creamos el vector tipo carácter de 110 espacios, luego creamos el
número de caracteres aleatorios que tendrá el vector con la contante n.

Llamamos a la función aleatorio enviándole el tamaño del vector que será el numero de
caracteres que le genere y le mandamos el vector x que este vacío para que lo llene con
letras aleatorias.

Por último, llamamos a la función calcula enviándole el tamaño del vector y el vector x
que ya tiene almacenado los caracteres aleatorios.
La función calcula nos hará el proceso anteriormente descrito.
int main(){
char x[110];

10
int n=100;
aleatorio(n,x);
calcula(n,x);
}

Codigo
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
void aleatorio(int n, char x[]){
srand(time(NULL));
for(int i=0;i<n+1;i++){
x[i]='a'+rand()%26;
cout<<x[i]<<" ";

}
cout <<endl;
}
void repetidos(char x[], int w, char n){
int c=0;
char y;
for(int i=0;i<w;i++){
if(n == x[i]){
c++;
y=x[i];
}
}
cout<<"La letra "<<y<<" se repite :"<<c<<" veces"<<endl;
}
void elimina(char x[], int w, char q){
for(int i=0;i<w;i++){
if(q == x[i]){
x[i]='*';
}
}
}
void calcula(int n, char y[]){
for(int i=0;i<n;i++){
char q;
q=y[i];
if(q != '*')
repetidos(y,n,q);
elimina(y,n,q);
}
}

int main(){
char x[110];
int n=100;
aleatorio(n,x);
calcula(n,x);
}

11
Figura 1. Programa en ejecución punto 1.

5.2. Punto 2
Generar un programa para ubicar 8 damas en un tablero de ajedrez sin que se
ataquen.
Desarrollo:
Para este problema usamos dos librerías usadas en el punto anterior.
#include <iostream>
#include <string.h>
using namespace std;

Creamos una función de tipo void llamada fila cuyo argumento es m que será la
ubicación de la reina en la fila.
Creamos el vector tipo char de 8 espacios que es lo ancho del talero de ajedrez
Con un for le asignamos a todas las posiciones del vector el carácter '.' y
cuando es for se sature a x[m] la haga 'R' que es la posición de la reina para
que luego llame a la función imprime enviándole el vector x para que lo muestre
en pantalla.
void fila(int m1){
char x[8];
for(int i=1;i<=8;i++){
x[i]='.';
}
x[m]='R';

imprime(x);
}

12
La función imprime cuyo argumento es el vector x funciona con un for que va desde 1
hasta 8 que es el tamaño del tablero y para cada paso imprima la posición x[i] del vector.

void imprime(char x[]){


for(int i=1;i<=8;i++){
cout<<x[i]<<" ";
}
cout<<endl;
}

En la función principal main() creamos 8 variables de tipo entero que van a ser la
posición de la reina en las filas y una variable r que va a ser con la cuela funcione
el switch en pantalla nos va a regunatr el programa "Digite la posicion de la
reina, la primera cifra es la columa y la segunda cifra es la
fila" al digitarla el una de las 64 opciones del switch se activara y llamara a la
función fila 8 veces enviándole el valor en cada llamada de la posición de la
reina que ya están definidas para cada una de los 64 casos, existen 92 soluciones
para este enigma de ubicar las ocho reinas.
int main(){
int m1,m2,m3,m4,m5,m6,m7,m8,r;
cout<<"Digite la posicion de la reina, la primera cifra es la
columa y la segunda cifra es la fila"<<endl;
cin>>r;
switch (r){
case 11 :{
m1=1,m2=7,m3=5,m4=8,m5=2,m6=4,m7=6,m8=3;
fila (m1), fila(m2), fila (m3),
fila(m4), fila (m5), fila (m6), fila
(m7),fila (m8);
break;
}
Case nn:{
-------
break;
}

Código:
#include <iostream>
#include <string.h>
using namespace std;
void imprime(char x[]){
for(int i=1;i<=8;i++){
cout<<x[i]<<" ";
}
cout<<endl;
}

13
void fila(int m1){
char x[8];
for(int i=1;i<=8;i++){
x[i]='.';
}
x[m1]='R';

imprime(x);
}
int main(){
int n,m1,m2,m3,m4,m5,m6,m7,m8;
int r;
cout<<"Digite la posicion de la reina, la primera cifra es la
columa y la segunda cifra es la fila"<<endl;
cin>>r;
switch (r){
case 11 :{
m1=1,m2=7,m3=5,m4=8,m5=2,m6=4,m7=6,m8=3;
fila (m1), fila(m2), fila (m3),
fila(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 12:{
m1=6,m2=1,m3=5,m4=2,m5=8,m6=3,m7=7,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila(m5), fila(m6), fila (m7), fila (m8);
break;
}
case 13:{
m1=2,m2=6,m3=1,m4=7,m5=4,m6=8,m7=3,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 14:{
m1=2,m2=5,m3=7,m4=1,m5=3,m6=8,m7=6,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 15:{
m1=4,m2=2,m3=8,m4=6,m5=1,m6=3,m7=5,m8=7;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 16:{
m1=3,m2=6,m3=2,m4=5,m5=8,m6=1,m7=7,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 17:{
m1=4,m2=2,m3=7,m4=3,m5=6,m6=8,m7=1,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;

14
}
case 18:{
m1=3,m2=5,m3=2,m4=8,m5=6,m6=4,m7=7,m8=1;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 22 :{
m1=5,m2=2,m3=4,m4=7,m5=3,m6=8,m7=6,m8=1;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 21:{
m1=2,m2=7,m3=3,m4=6,m5=8,m6=5,m7=1,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila(m7), fila (m8);
break;
}
case 23:{
m1=3,m2=7,m3=2,m4=8,m5=6,m6=4,m7=1,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 24:{
m1=6,m2=3,m3=7,m4=2,m5=4,m6=8,m7=1,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 25:{
m1=4,m2=7,m3=3,m4=8,m5=2,m6=5,m7=1,m8=6;
fila (m1), fila (m2), fila(m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 26:{
m1=6,m2=4,m3=7,m4=1,m5=8,m6=2,m7=5,m8=3;
fila(m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 27:{
m1=6,m2=4,m3=7,m4=1,m5=3,m6=5,m7=2,m8=8;
fila (m1), fila (m2), fila(m3), fila
(m4), fila(m5), fila (m6), fila (m7), fila (m8);
break;
}
case 28:{
m1=3,m2=6,m3=4,m4=1,m5=8,m6=5,m7=7,m8=2;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;
}
case 31 :{
m1=3,m2=8,m3=4,m4=7,m5=1,m6=6,m7=2,m8=5;

15
fila(m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;
}
case 32:{
m1=6,m2=3,m3=7,m4=4,m5=1,m6=8,m7=2,m8=5;
fila (m1), fila (m2), fila (m3),
fila(m4), fila(m5), fila (m6), fila (m7), fila (m8);
break;
}
case 33:{
m1=7,m2=5,m3=3,m4=1,m5=6,m6=8,m7=2,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 34:{
m1=8,m2=2,m3=5,m4=3,m5=1,m6=7,m7=4,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 35:{
m1=5,m2=7,m3=4,m4=1,m5=3,m6=8,m7=6,m8=2;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila(m7), fila (m8);
break;
}
case 36:{
m1=4,m2=2,m3=8,m4=6,m5=1,m6=3,m7=5,m8=7;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 37:{
m1=7,m2=2,m3=4,m4=1,m5=8,m6=5,m7=3,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 38:{
m1=5,m2=8,m3=4,m4=1,m5=7,m6=2,m7=6,m8=3;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 41 :{
m1=4,m2=1,m3=5,m4=8,m5=6,m6=3,m7=7,m8=2;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 42:{
m1=6,m2=4,m3=1,m4=5,m5=8,m6=2,m7=7,m8=3;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila(m7), fila (m8);
break;

16
}
case 43:{
m1=5,m2=1,m3=4,m4=6,m5=8,m6=2,m7=7,m8=3;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 44:{
m1=5,m2=7,m3=1,m4=4,m5=2,m6=8,m7=6,m8=3;
fila (m1), fila(m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 45:{
m1=6,m2=3,m3=1,m4=8,m5=4,m6=2,m7=7,m8=5;
fila(m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila(m8);
break;
}
case 46:{
m1=7,m2=1,m3=3,m4=8,m5=6,m6=4,m7=2,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 47:{
m1=3,m2=1,m3=7,m4=5,m5=8,m6=2,m7=4,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila(m8);
break;
}
case 48:{
m1=2,m2=8,m3=6,m4=1,m5=3,m6=5,m7=7,m8=4;
fila (m1), fila(m2), fila(m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;
}
case 51 :{
m1=5,m2=7,m3=2,m4=6,m5=3,m6=1,m7=4,m8=8;
fila(m1), fila (m2), fila(m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 52:{
m1=2,m2=5,m3=7,m4=4,m5=1,m6=8,m7=6,m8=3;
fila (m1), fila(m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila(m7), fila (m8);
break;
}
case 53:{
m1=2,m2=7,m3=5,m4=8,m5=1,m6=4,m7=6,m8=3;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;
}
case 54:{
m1=4,m2=8,m3=1,m4=5,m5=7,m6=2,m7=6,m8=3;

17
fila(m1), fila (m2), fila(m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 55:{
m1=6,m2=3,m3=1,m4=8,m5=5,m6=2,m7=4,m8=7;
fila (m1), fila (m2), fila (m3), fila
(m4), fila(m5), fila (m6), fila (m7), fila (m8);
break;
}
case 56:{
m1=3,m2=6,m3=4,m4=1,m5=8,m6=5,m7=7,m8=2;
fila(m1), fila (m2), fila (m3), fila
(m4), fila(m5), fila (m6), fila (m7), fila (m8);
break;
}
case 57:{
m1=3,m2=6,m3=8,m4=1,m5=4,m6=7,m7=5,m8=2;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila(m7), fila (m8);
break;
}
case 58:{
m1=2,m2=6,m3=8,m4=3,m5=1,m6=4,m7=7,m8=5;
fila(m1), fila (m2), fila(m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 61 :{
m1=6,m2=3,m3=7,m4=2,m5=8,m6=5,m7=1,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 62:{
m1=3,m2=6,m3=4,m4=2,m5=8,m6=5,m7=7,m8=1;
fila (m1), fila (m2), fila(m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 63:{
m1=2,m2=8,m3=6,m4=1,m5=3,m6=5,m7=7,m8=4;
fila(m1), fila(m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 64:{
m1=7,m2=3,m3=1,m4=6,m5=8,m6=5,m7=2,m8=4;
fila (m1), fila(m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 65:{
m1=7,m2=5,m3=3,m4=1,m5=6,m6=8,m7=2,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;

18
}
case 66:{
m1=4,m2=7,m3=5,m4=3,m5=1,m6=6,m7=8,m8=2;
fila (m1), fila (m2), fila (m3),
fila(m4), fila (m5), fila (m6), fila(m7), fila(m8);
break;
}
case 67:{
m1=2,m2=5,m3=7,m4=1,m5=3,m6=8,m7=6,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 68:{
m1=7,m2=2,m3=4,m4=1,m5=8,m6=5,m7=3,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 71 :{
m1=7,m2=1,m3=3,m4=8,m5=6,m6=4,m7=2,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;
}
case 72:{
m1=5,m2=7,m3=4,m4=1,m5=3,m6=8,m7=6,m8=2;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;
}
case 73:{
m1=2,m2=5,m3=7,m4=1,m5=3,m6=8,m7=6,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 74:{
m1=3,m2=8,m3=4,m4=7,m5=1,m6=6,m7=2,m8=5;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 75:{
m1=4,m2=8,m3=1,m4=5,m5=7,m6=2,m7=6,m8=3;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila(m7), fila(m8);
break;
}
case 76:{
m1=8,m2=2,m3=5,m4=3,m5=1,m6=7,m7=4,m8=6;
fila (m1), fila (m2), fila (m3),
fila(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 77:{
m1=6,m2=4,m3=1,m4=5,m5=8,m6=2,m7=7,m8=3;

19
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 78:{
m1=4,m2=2,m3=8,m4=6,m5=1,m6=3,m7=5,m8=7;
fila (m1), fila(m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 81 :{
m1=8,m2=2,m3=4,m4=1,m5=7,m6=5,m7=3,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 82:{
m1=4,m2=8,m3=5,m4=3,m5=1,m6=7,m7=2,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila(m5), fila (m6), fila (m7), fila (m8);
break;
}
case 83:{
m1=5,m2=2,m3=8,m4=1,m5=4,m6=7,m7=3,m8=6;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 84:{
m1=4,m2=1,m3=5,m4=8,m5=6,m6=3,m7=7,m8=2;
fila(m1), fila (m2), fila(m3), fila
(m4), fila(m5), fila (m6), fila (m7), fila (m8);
break;
}
case 85:{
m1=3,m2=6,m3=4,m4=1,m5=8,m6=5,m7=7,m8=2;
fila(m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 86:{
m1=7,m2=5,m3=3,m4=1,m5=6,m6=8,m7=2,m8=4;
fila (m1), fila (m2), fila (m3), fila
(m4), fila (m5), fila(m6), fila(m7), fila (m8);
break;
}
case 87:{
m1=6,m2=5,m3=7,m4=1,m5=4,m6=2,m7=8,m8=6;
fila (m1), fila(m2), fila (m3),
fila(m4), fila (m5), fila (m6), fila (m7), fila (m8);
break;
}
case 88:{
m1=6,m2=4,m3=7,m4=1,m5=3,m6=5,m7=2,m8=8;
fila(m1), fila (m2), fila(m3), fila
(m4), fila (m5), fila(m6), fila (m7), fila (m8);
break;

20
}
}
}

Figura 2. Ejecución del programa punto 2 caso 35

21
7. CONCLUSIONES

 Concluimos que el ciclo for es muy importante para la operación y el manejo


de arrays así como las condiciones.

 Vimos que la función srand y rand son muy sencillas de utilizar y que al
agregarlas a un ciclo for pueden generar un gran numero de datos
aleatorios ya sea caracteres o valores enteros.

 Las funciones tipo void son muy importante a la hora de trabajar con arrays
ya que al ser un array una cadena de datos y void retorna varios datos,
decimos que es fundamental en el trabajo con estos.

 Las variables tipo char e int son de gran importancia a la hora de manejar
un tipo de datos en un vector de caracteres o numérico.

22
8. BIBLIOGRAFIA

 https://www.programarya.com/Cursos/C++/Estructuras-de-Datos/Arreglos-
o-Vectores

 http://c.conclase.net/curso/?cap=003

 https://es.wikipedia.org/wiki/Programaci%C3%B3n

 https://blog.martincruz.me/2012/09/obtener-numeros-aleatorios-en-c-
rand.html

23

Vous aimerez peut-être aussi