Está en la página 1de 43

- 301 -

a).-Inicializacin de un vector;

#include <conio.h>
#include <stdio.h>
const int n=50;
int main()
{ int i,np=5;
float A[n]={1,2,3,4,5};
for(i=0;i<np;i++) //puede poner i<=10
C no controla el limite.
printf("%8.2f",A[i]);
getch();
}

Puede inicializar tambien de esta manera
#include <conio.h>
#include <stdio.h>
const int n=50;
int main()
{ int i,np=5; float A[n];
A[0]=1;A[1]=2;A[2]=3;A[3]=4;A[4]=5;
for(i=0;i<np;i++) printf("%8.2f",A[i]);
getch();
}

O de esta manera
#include <conio.h>
#include <stdio.h>
const int n=50;
int main()
{ int i,np=5; float A[n];
for(i=0;i<n;i++)A[i]=i+1;
for(i=0;i<np;i++) printf("%8.2f",A[i]);
getch();
}

O usando funciones
#include <conio.h>
#include <stdio.h>
const int n=50;
void IniciarVector(float A[],int np)
{ for(int i=0;i<np;i++)A[i]=i+1;}
void MostrarVector(float A[],int np)
{ for(int i=0;i<np;i++)printf("%8.2f",A[i]);}
int main()
{ int i,np=5;
float A[n];
IniciarVector(A,np);
MostrarVector(A,np);
getch();
}
Puede inicializar tambin en forma aleatoria

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
const int n=50;
void IniciarVectorAleatorio(float A[],int np)
{ for(int i=0;i<np;i++) A[i]=1+rand()%50;}
void MostrarVector(float A[],int np)
{ for(int i=0;i<np;i++)printf("%8.2f",A[i]);}
int main()
{ int i,np=5;
float A[n];
IniciarVectorAleatorio(A,np);
MostrarVector(A,np);
getch();
}

Obtener el valor de un elemento
#include <conio.h>
#include <stdio.h>
const int n=50;
int main()
{ int i,np=5,indice;
float A[n];
for(i=0;i<n;i++)A[i]=i+1;
printf("\n vector original");
for(i=0;i<np;i++) printf("%8.2f",A[i]);
printf("\n ingrese el indice del elemento a obtener 0
%d ",np);
scanf("%d",&indice);
printf("\n el valor obtenido es %f ",A[indice]);
getch();
}

Modificar el valor de un elemento
#include <conio.h>
#include <stdio.h>
const int n=50;
int main()
{ int i,np=5,indice;
float A[n];
for(i=0;i<n;i++)A[i]=i+1;
printf("\n vector original");
for(i=0;i<np;i++) printf("%8.2f",A[i]);
printf("\n ingrese el indice del elemento a modificar 0
%d ",np);
scanf("%d",&indice);
printf("\n ingrese el valor del vector a modificar");
scanf("%f",&A[indice]); // A[indice]=valor;
printf("\n vector modificado");
for(i=0;i<np;i++) printf("%8.2f",A[i]);
getch();
}



Pregunta . obtener y modificar todos los valores

Para leer un vector

#include <conio.h>
#include <stdio.h>
const int n=50;
void Leervector(float A[],int np)
{ for (int i=0;i<np;i++)
- 302 -
scanf("%f",&A[i]);
}
void MostrarVector(float A[],int np)
{ for(int i=0;i<np;i++)
printf("%6.2f",A[i]);
}

int main()
{ int i,np=10,indice,ne;
float A[n];
for(i=0;i<n;i++)A[i]=i+1;
printf("\n vector original");
MostrarVector(A,np);
printf("\n cuantos elementos queire ingresar 1 a %d
",np);
scanf("%d",&ne);
printf("\n ingrese %d elementos",ne);
Leervector(A,ne);
printf("\n vector modificado");
MostrarVector(A,np);
getch();
}


b).-Inicializacin de una matriz.

#include <conio.h>
#include <stdio.h>
const int filas=4,col=5;
int main()
{ int i,j;
float A[filas][col]= { 1, 2, 3, 4, 5,
10, 20, 30, 40, 50,
100, 200, 300, 400,500,
11, 12, 13, 14, 15};
for(i=0;i<filas;i++)
{ printf("\n");
for (j=0;j<col;j++) printf("%8.2f",A[i][j]);
}
getch();
}
Ejecucin

Modifique a obtendr el mismo
resultado

#include <conio.h>
#include <stdio.h>
const int filas=4,col=5;
int main()
{ int i,j;
float A[filas][col]= { {1, 2, 3, 4, 5},
{10, 20, 30, 40, 50},
{100, 200, 300, 400,500},
{11, 12, 13, 14, 15}};
for(i=0;i<filas;i++)
{ printf("\n");
for (j=0;j<col;j++) printf("%8.2f",A[i][j]);
}
getch();
}

Otra manera de inicializar matrices

#include <conio.h>
#include <stdio.h>
const int filas=4,col=5;
int main()
{ int i,j;
float A[filas][col];
A[0][0]=1; A[0][1]=2; A[0][2]=3; A[0][3]=4;
A[0][4]=5;
A[1][0]=10; A[1][1]=20; A[1][2]=30;
A[1][3]=40;A[1][4]=50;
A[2][0]=100;A[2][1]=200;A[2][2]=300; A[2][3]=400;
A[2][4]=500;
A[3][0]=11; A[3][1]=12;A[3][2]=13; A[3][3]=14;
A[3][4]=15;
for(i=0;i<filas;i++)
{ printf("\n");
for (j=0;j<col;j++) printf("%8.2f",A[i][j]);
}
getch();
}

Otra manera de inicializar matrices usando
funciones

#include <conio.h>
#include <stdio.h>
const int maxfilas=10,maxcol=10;
void IniciarMatriz(float A[][maxcol],int nf,int nc);
void MostrarMatriz(float A[][maxcol],int nf,int nc);

int main()
{ int nf=4,nc=5;
float A[maxfilas][maxcol];
IniciarMatriz(A,nf,nc);
MostrarMatriz(A, nf, nc);
- 303 -
getch();
}

void IniciarMatriz(float A[][maxcol],int nf,int nc)
{int fila,col;
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
A[fila][col]=fila*nc+col+1;// A[fila][col]=1+
rand()%20;
}
void MostrarMatriz(float A[][maxcol],int nf,int nc)
{int fila,col;
for (fila=0;fila<nf;fila++)
{ printf("\n");
for (col=0;col<nc;col++)
printf("%8.2f",A[fila][col]);
}
}

Modificar el valor de un elemento de una matriz
int main()
{ int nf=4,nc=5,indicefila,indicecol;
float A[maxfilas][maxcol];
IniciarMatriz(A,nf,nc);
printf("\n valores antiguos ");
MostrarMatriz(A, nf, nc);
printf("\n ingrese la fila y coldel elemento a modificar
fila 0 a %d, col 0 a %d :",nf,nc);
scanf("%d%d",&indicefila,&indicecol);
printf("\n ingrese el nuevo valor para la fila y
columna seleccionada");
scanf("%f",&A[indicefila][indicecol]);
printf("\n valores nuevos ");
MostrarMatriz(A, nf, nc);
getch();
}



Modificar todos los valores leer la matriz

#include <conio.h>
#include <stdio.h>
const int maxfilas=10,maxcol=10;
void IniciarMatriz(float A[][maxcol],int nf,int nc);
void MostrarMatriz(float A[][maxcol],int nf,int nc);
void LeerMatriz(float A[][maxcol],int nf,int nc)
{int fila,col;
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
{ printf("\n ingrese fila %d col %d
:",fila,col);
scanf("%f",&A[fila][col]);
}
}
int main()
{ int nf=4,nc=5,nfilas,ncol;
float A[maxfilas][maxcol];
IniciarMatriz(A,nf,nc);
printf("\n valores antiguos ");
MostrarMatriz(A, nf, nc);
printf("\n cuantas filas y columnas quiere ingresara 0
a %d, col 0 a %d :",nf,nc);
scanf("%d%d",&nfilas ,&ncol);
LeerMatriz(A,nfilas,ncol);
printf("\n valores nuevos ");
MostrarMatriz(A, nf, nc);
getch();
}

Implementar las funciones IniciarMatriz y
MostrarMatriz(float A[][maxcol],int nf,int nc)




Ej. char error[]=" El fichero no puede ser abierto "

int tabla [2][3]={10,12,14,16,5,18}; // matriz de 2 filas y
3 columnas
En este ejemplo se inicializan los arreglos error y
tabla, cuando no se especifica el tamao, C++
automticamente separa un arreglo lo
suficientemente grande, para contener la informacin
presente.

5.3. EJEMPLOS SOBRE VECTORES

Ejemplo 1
a) Ingresar a un vector N datos reales por el teclado
a) Mostrar esos n datos por el teclados
b) Ordenar los n datos C) Mostrar el vector ordenado

#include <conio.h>
#include <stdio.h>
const int limite =20; // hasta 20 datos
void ingresar( float a[],int n); // vector sin limite
void mostrar(float a[],int n);
void ordenar(float a[],int n); //para ordenar
int main()
{ float lista[limite];
int n;
printf("\nIngrese numero de datos 1..%d ",limite);
scanf("%d",&n);
ingresar(lista,n);
printf("\ datos ingresados ");
mostrar(lista,n); ordenar(lista,n);
printf("\n Lista Ordenada \n"); mostrar(lista,n);
getch();
}
void mostrar(float a[] , int n)
- 304 -
{ for (int i=0; i<n;i++) printf("%7.2f",a[i]);
}
void ingresar(float a[],int n)
{ printf("\n ingrese %d datos" ,n);
int i; float dato;
for (i=0;i<n;i++)
{ scanf("%f",&dato); // Probar con
scanf("%f",&lista[i]);
a[i]=dato;
}
}
void ordenar(float a[],int n)
{ int i,j,iter=0;float temp;
for (i=0;i<n-1; i++)
for (j=i+1;j<n;j++,iter++)
{ if (a[j]<a[i])
{ temp=a[i];
a[i]=a[j]; a[j]=temp;
}
printf("\n iter %d ",iter); mostrar(a,n);
}
}

Prueba de datos con = 4

Tarea.- generar n nmeros aleatorios de 0 a 10
1. Generar n(n=5) elementos aleatorios, de -50 a
100
a) Calcular la suma y el promedio de los
elementos
b) Cuanto nmeros negativos hay
c) Encontrar el mayor de los elemento y
en qu lugar se encuentra
d) Cuanto nmeros mltiplos de 7 hay
2. Encontrar rea, longitud , volumen etc. de
nmeros dados en vectores
3. Se tiene n notas encontrar la moda de esas notas
4 Se lee edad , y sexo de n personas, encontrar la
cantidad de personas clasificadas por rangos
de 5 aos

Ejemplo 2 Generar n nmeros aleatorios sin que si
repitan


#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define max 20
void generar(int a[], int b[], int &n,int m) ;
// n cuantos numeros m = cuantos numeros a listar
n>=m
void iniciar(int a[],int n)
{ for (int i=0; i<=n;i++) a[i]=i*10;} // inicializamos de 1
hasta n
void mostrar(int a[], int n)
{ for (int i=0;i<n;i++) printf("%3d",a[i]);}
int main()
{ int a[max],
b[max],n=10,m
=6;
printf("\n
ingrese serie
de numeros
%d ",max);
scanf("%d",&n)
;
iniciar(a,n);
printf("\n
serie de
numeros a escoger ");
mostrar(a,n);
printf("\n ingrese cantidad de numeros a generar ");
scanf("%d",&m);
// inicia el vector puede leer los datos a sortear
generar(a,b, n,m);
printf("\n numeros , generados ");
mostrar(b,m);
printf("\n numeros que quedan ");
mostrar(a,n);
getch(); return 0;
}
void generar(int a[],int b[],int &n,int m)
{ int r,i,ndatos,cont;
srand(time(NULL));
// generar numeros aleatorios
ndatos=n-m;
cont=0;
while (n>ndatos) // si queremos incluir el 0 debe ser
n>=0 */
{ r=rand() % n;
b[cont]=a[r];
cont++;
// acomodar el vector
i=r;
while ( i<n)
{ a[i]= a[i+1]; i++;
}
n--;
}
}

Ejecucin
ingrese serie de numeros 20 10
ingrese cantidad de numeros a generar 6
1 2 3 4 5 6 7 8 9 10
numeros aleatorios generados
6 1 3 8 10 4
i j a[j]<a[i] temp=a[i] a[i]= a[j] a[j]=temp a[0] a[1] a[2] a[3]
0 1 no - - - 3 4 1 2
0 2 si 3 1 3 1 4 3 2
0 3 no - - - 1 4 3 2
1 2 si 4 3 2 1 3 4 2
1 3 si 3 4 3 1 2 4 3
2 3 si 4 3 4 1 2 3 4
- 305 -

Explicacin
1. Se rellena los primeros n( n=10) lugares del vector
con los nmeros que seran los ndices de los
nmeros que van a salir sorteados en este caso
los lugares de 0 a 9 de nmeros de 1 al 10
2. Se llama a la funcin generar pasando los
parmetros vector el vector a ser rellenado de
donde se sacar los nmeros n = cantidad de
nmeros disponibles generar y m cantidad de
nmeros a generar
3. Se genera un numero aleatorio de 1 hasta n( 10)
si sale el numero 5 que es el lugar del numero 6
(quedaran 9 elementos ya no estara el nmero
6)

printf("\n %3d %3d %3d ",n,r,a[r]);... mostrar(a,n);
10 5 6 1 2 3 4 5 7 8 9 10
9 0 1 2 3 4 5 7 8 9 10
8 1 3 2 4 5 7 8 9 10
7 4 8 2 4 5 7 9 10
6 5 10 2 4 5 7 9
5 1 4 2 5 7 9

Tarea.- Generar m letras de n para ello el vector
debe declararse de tipo char
Ejemplo char letras[50]

Ejemplo 2 ingrese n nombres y luego generar m
nombres sin que se repitan
( se realizara con punteros)

Ejemplo 3 Generacin de nmeros aleatorios con
distribucin uniforme

Rellenar un vector de nmeros aleatorios distribuidos
uniformemente dados el valor mximo y valor
mnimo.
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int ndatos=100 ;
int generar(int li, int ls)
{ int r;
r=li +rand() % (ls-li);
return r;
}
void rellenar( int nro[],int li ,int ls, int n)
{ int i;
srand(time(NULL));
for (i=0;i<n;i++)
nro[i]= generar(li,ls);
}
void mostrar( int nro[],int n)
{ for (int i=0;i<n;i++) printf("%3d",nro[i]);
}
void main (void)
{int vector[ndatos],n, li=1, ls=5;
printf("\n Numero de datos a generar de %d a %d
max =%d",li,ls,ndatos);
scanf("%d",&n);
rellenar(vector,li,ls,n);
mostrar(vector,n);
getch();
}
Ejecucin
Numero de datos a generar de 1 a 5 max =100 100
1 3 5 4 2 3 3 1 1 2 2 5 1 5 4 5 5 4 1 3 5 5 1 1 3 3 3 1
5 5 2 3 3 2 4 2 2 3 4 3
5 3 1 5 5 5 3 2 1 2 3 3 3 4 5 1 4 4 5 2 1 1 5 1 5 5 5 4
2 5 3 1 1 3 3 4 5 5 5 2
2 1 4 5 2 3 4 2 4 5 2 2 3 1 2 1 4 2 5 4


Si calculamos la frecuencia encontramos que Cada
clase tiene igual probabilidad de ocurrencia que 1/5 =
20%

Ejemplo 4. Generacin de nmeros aleatorios con
distribucin discreta con probabilidades diferentes de
ocurrencia

El tiempo de procesamiento de un producto sigue la
siguiente distribucin de probabilidad. Rellenar un
vector con Nmeros aleatorios con esa distribucin.

Tiempo(Minutos) x 1 2 3 4 5
Probabilidad P(x) 0.05 0.20 0.4 0.25 0.1

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int ndatos=100, nprob=10; //Maximo 10
probabilidades y 100 datos
int generar( int nro[], float p[], int n)
{ int r, ng,i;
r=rand()% 101;
for ( i=0; i<n;i++)
if (p[i]>r){ ng=nro[i];break;}
return ng;
}
void rellenar(int vector[],int nro[], float p[], int n)
{ int i,na;
srand(time(NULL));
for ( i=0; i<n;i++)
vector[i]= generar(nro,p,n);
}
void mostrar(int vector[], int n)
{ for (int i=0; i<n;i++)printf("%2d",vector[i]);
}
int main()
{ int n;
int vector[ndatos];
int nro[nprob]={1,2,3,4,5};
float p[nprob]= {5, 25,65,90,100};
system ("cls");
printf("\n cuantos Numeros quiere generar max
=%d", ndatos);
scanf("%d",&n);
rellenar(vector,nro,p,n);
mostrar(vector,n);
getch(); return 0;
}

Ejecucin
cuantos Numeros quiere generar max =100 100
Clase Frecuencia %
1 19 0.19
2 19 0.19
3 21 0.21
4 15 0.15
5 26 0.26
Total 100 1
%f
0
0.05
0.1
0.15
0.2
0.25
0.3
1 2 3 4 5
- 306 -
4 4 3 4 2 1 3 2 2 3 1 4 3 3 4 2 4 3 2 3 3 3 4 3 3 4 4 2 4
3 2 3 4 4 2 3 3 4 2 2
3 5 4 3 3 2 4 4 2 2 3 3 5 3 2 2 3 4 4 1 5 2 2 3 3 4 4 4 3
4 4 3 5 3 2 4 4 3 2 3
3 5 5 3 3 3 3 3 3 4 2 2 4 3 2 5 3 4 3 2

Como se ve en la tabla y en el grfico la distribucin
sigue a lo especificado en la pregunta 3.






Como funciona

a) Se aplica la simulacin Montecarlo

b) Se requiere de distribucin de probabilidad
acumulada
c) Se genera un numero aleatorio de 0 a 100 si el
nmero est comprendido entre 0 y 5 devuelve
1, si el nmero aleatorio generado es de 6 a 25
entonces la funcin devuelve 2 y as
sucesivamente por ejemplo si el numero
generado es 53 la funcin devuelve 3 , y si el
nmero generado es 94 la funcin devuelve 5.


5.4. EJEMPLOS SOBRE MATRICES

Ejemplo 1 En una clase hay m alumnos y cada
alumno lleva n cursos elaborar un programa en C
para:
a) Ingresar las notas.
b) Visualizar las notas ingresadas
c) Calcular el promedio por alumno
d) Calcular el promedio por curso.
a) Calcular el promedio general
b) La mxima nota en que fila y columna se
encuentra

#include <conio.h>
#include <stdio.h>
const int filas=10,col=10;
void ingresar( float a[][col], int nf, int nc);
void mostrar ( float a[][col], int nf, int nc);
void pnotas ( float a[][col], int nf, int nc,float pn[]);
void pcursos ( float a[][col], int nf, int ncz,float pc[]);
float pgen ( float a[][col], int nf, int nc);
void mvector (float a[], int n);
float maxnota(float a[][col],int nf, int nc, int &filamax,int
&colmax)
{ float maximo=-1000;
int fila,col;
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
if (a[fila][col]>maximo)
{ maximo=a[fila][col];
filamax= fila;
colmax=col;
}
return maximo;
}
int main()
{ float notas[filas][col],pn[filas],pc[col];
int nf, nc,filamax,colmaxima;
// mostrar(notas,nf,nc);
printf("ingrese cantidad de alumnos(filas) 1..%d
:",filas);
scanf("%d",&nf);
printf("ingrese cantidad de cursos(columnas) 1..%d
:",col);
scanf("%d",&nc);
ingresar(notas,nf,nc);
printf("\n Matriz ingresada "); mostrar(notas,nf,nc);
pnotas(notas,nf,nc,pn);
// encontrar los promedios de cada alumno y
guardar en el vector pnotas
printf("\n Promedios de notas de alumnos \n");
mvector(pn,nf); // imprime el vector de notas
pcursos(notas,nf,nc,pc); // promedio de cursos
printf("\n Promedios de cursos \n");
mvector(pc,nc);
printf("\n Promedios general es %8.4f",
pgen(notas,nf,nc));
printf("\n el maximo valor es %f",
maxnota(notas,nf,nc,filamax,colmaxima));
printf("\n y esta en la fila %d",filamax);
printf("\n y esta en la col %d",colmaxima);
getch();
return 0;
}
void pcursos( float a[][col], int nf, int nc,
float pc[])
{ float snota=0;int i,j;
for(j=0; j<nc; j++)
{ snota=0;
for(i=0; i<nf; i++) snota=snota+a[i][j];
pc[j]=snota/nf;
}
}
float pgen(float a[][col], int nf, int nc)
{ float snota=0;int i,j;
for(i=0; i<nf; i++)
for(j=0; j<nc; j++) snota=snota+a[i][j];
return snota/(nf*nc);
}
void mvector(float a[], int n)
{ for(int i=0; i< n; i++)
printf("\n%3d %8.4f",i,a[i]);
}

void ingresar( float a[][col], int nf, int nc)
{ float nota;int i,j;
printf("Ingrese %d notas por fila ",nc);
for (i=0; i<nf;i++)
{ printf("\n fila %d ",i);
for(j=0; j<nc;j++)
{ scanf("%f",&nota); a[i][j]=nota;}
}
}
void mostrar( float a[][col],
Clase Frecuencia %
1 3 0.03
2 23 0.23
3 39 0.39
4 28 0.28
5 7 0.07
sum 100 1
x p(x) P(x) acum
1 0.05 0.05
2 0.20 0.25
3 0.40 0.65
4 0.25 0.90
5 0.10 1.00
- 307 -
int nf, int nc )
{ int i, j;
for (i=0; i<nf;i++)
{ printf("\n ");
for(j=0; j<nc;j++)
printf("%8.2f", a[i][j]);
}
}

void pnotas( float a[][col], int nf, int nc,float pn[])
{ float snota=0;int i,j;
for(i=0; i<nf; i++)
{ snota=0;
for(j=0; j<nc; j++) snota=snota+a[i][j];
pn[i]=snota/nc;
}
}




Preguntas
a) Que alumno tiene mayor promedio
b) Cuantos aprobados hay
c) En que curso hay mas desaprobados

Explicar sobre trabajos Trabajo 2 metodos
numricos en modo discreto
Ejemplo 2. Rellenar una matriz de n filas por m
columnas de nmeros aleatorios de 0 a 10
c) mostrar la matriz
d) cuantos cuatros hay en la matriz
e) cuantos cuatros hay en la segunda fila
f) cuantos cuatros hay en la segunda columna
g) El elemento mayor en que fila y columna se
encuentra.



#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int Nfilas =11,Ncol=11;
void generar(int a[][Ncol] , int nf , int nc );
void mostrar(int a[][Ncol] , int nf , int nc);
int nroelementosM(int a[][Ncol] , int nf , int nc,int nro);
int nroelementosF(int a[][Ncol] , int nfila , int nc,int
nro);
int nroelementosC(int a[][Ncol] , int nf , int ncol,int
nro);
void eMayor(int a[][Ncol] , int nf , int nc,int &filamayor,
int &colmayor);
int main()
{ int Matriz[Nfilas][Ncol]={ {1,4,4,4},
{1,2,3,4},{1,2,3,4},{1,4,4,4}};
int nf=8,nc=8,filamayor,colmayor;
srand( (unsigned)time( NULL ) );
generar( Matriz , nf , nc );
mostrar( Matriz,nf,nc);
printf("\n nro de cuatros en la matriz
%d",nroelementosM(Matriz,nf,nc,4));
printf("\n nro de cuatros en la fila %d es
%d",2,nroelementosF(Matriz,2,nc,4));
printf("\n nro de cuatros en la col %d es
%d",2,nroelementosC(Matriz,nf,2,4));
eMayor( Matriz,nf,nc,filamayor,colmayor);
printf("\n el elemento mayor se encuentra en la fila
%d y col %d y es %d
",filamayor,colmayor,Matriz[filamayor][colmayor]);
getch();
}
int nroelementosM(int a[][Ncol] , int nf , int nc,int nro)
{ int fila,col,ne=0;
for (fila=0; fila<nf; fila++)
for (col=0; col<nc; col++)
if ( a[fila][col]==nro) ne++;
return ne;
}
void generar(int a[][Ncol] , int nf , int nc )
{ int fila,col;
for (fila=0; fila<nf; fila++)
for (col=0; col<nc; col++)
a[fila][col]=rand()% 10;
}
void mostrar(int a[][Ncol] , int nf , int nc )
{ int fila,col;
for (fila=0; fila<nf; fila++)
{ printf("\n");
for (col=0; col<nc; col++) printf(" %d
",a[fila][col]);
}
}
int nroelementosF(int a[][Ncol] , int nfila , int nc,int nro)
{ int col,ne=0;
for (col=0;col<nc;col++)
if (a[nfila][col]==nro) ne++;
return ne;
}
int nroelementosC(int a[][Ncol] , int nf , int ncol,int nro)
{ int fila,ne=0;
for (fila=0;fila<nf;fila++)
if (a[fila][ncol]==nro) ne++;
return ne;
}
void eMayor(int a[][Ncol] , int nf , int nc,int &filamayor,
int &colmayor)
{ int fila,col,mayor=-100;
for (fila=0; fila<nf; fila++)
for (col=0; col<nc; col++)
if (a[fila][col]>mayor) { mayor=a[fila][col];
filamayor=fila;colmayor=col ;};
}

- 308 -
Ejemplo 3 Problema de los nmeros aleatorios
uniformemente distribuidos

Un avin tiene 40 filas(por motivos didctico
considere 10) por 6 columnas el valor de los asientos
es lo siguiente
0 = asiento vaci
1 = Asiente ocupado por un seor
2 = Asiento ocupado por una seora
3 = Asiento ocupado por un nio
4 = Asiento ocupado por una nia
Elaborar un programa para:
a) Rellenar la matriz con nmeros aleatorios de 0 al
4 simulando la condicin del asiento
b) Mostrar la matriz rellenada
c) Quien est sentado en el asiento de la fila m y
columna n y por cuantos nios(nios y nias
estn rodeados)
d) Cuantos nias ( 4) hay en la primera columna
e) Cuantas seoras(2) hay en la segunda fila

#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "e:\datos\milib.h"
const int Nfilas =11,Ncol=6;
void generar(int a[][Ncol] , int nf , int nc );
void mostrar(int a[][Ncol] , int nf , int nc,int cx, int cy,
int ex, int ey );
int rodear(int a[][Ncol],int fila,int col, int nf, int nc,int
ne);
int neMatriz(int a[][Ncol], int nf, int nc,int ne);
int neMatrizfila(int A[][Ncol], int fila, int nc,int ne);
int neMatrizCol(int A[][Ncol], int col, int nf,int ne);
int main()
{ int m=2, n=1,i;
int avion[Nfilas][Ncol], nf=10, nc=6;
int cx=30,cy=2,ex=5,ey=1,Q;
generar( avion , nf , nc );
mostrar( avion , nf , nc,cx,cy,ex,ey );
textcolor(0,15);
printf("\n la fila %d y col %d esta rodeado de %d
nias",2,3,rodear(avion,2,3,nf,nc,3));
for (i=0;i<=4;i++)
printf("\n hay elementos de tipo %d hay
%d",i, neMatriz(avion,nf,nc,i));
int j;
for (j=0;j<=4;j++)
for (i=0;i<=9;i++)
printf("\n elemento de tipo %d ==en la fila
%d es = %d",j,i,neMatrizfila(avion,i,nc,j));
for (j=0;j<=4;j++)
for (i=0;i<=5;i++)
printf("\n elemento de tipo %d ==en la col
%d es = %d",j,i,neMatrizCol(avion,i,nf,j));
getch();
}
int rodear(int a[][Ncol],int fila,int col, int nf, int nc,int
ne)
{ int s=0,y1,y2,x1,x2,x,y;
if (fila==0 ) y1=0; else y1=fila-1;
if (col==0 ) x1=0; else x1=col-1;
if (fila==nf ) y2=nf; else y2=fila+1;
if (col==nc ) x2=nc; else x2=col+1;
for (y= y1; y<=y2; y++)
for (x= x1; x<=x2; x++)
{ if (y==fila && x==col)continue ;
else
if (a[y][x]==ne) s++;
}
return s ;
}

void mostrar(int a[][Ncol] , int nf , int nc,int cx, int cy ,
int ex, int ey )
{ int fila,col;
for (fila=0; fila<nf; fila++)
for (col=0; col<nc; col++)
{ gotoxy(cx+col*ex,cy+fila*ey);
textcolor(0,9+a[fila][col]);
cprintf(" %d ",a[fila][col]);
}
}
void generar(int a[][Ncol] , int nf , int nc )
{ int fila,col;
srand( (unsigned)time( NULL ) );
for (fila=0; fila<nf; fila++)
for (col=0; col<nc; col++)
a[fila][col]=rand()% 5;
}
int ncol(int a[][Ncol],int ncolumna, int nf)
{ int f,nn;
nn=0;
for (f=0;f< nf; f++)
if (a[f][ncolumna]==4)nn++;
return nn;
}
int neMatriz(int a[][Ncol], int nf, int nc,int ne)
{ int fila,col,se=0;
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
if (a[fila][col]==ne) se++;
return se;
}

int neMatrizfila(int A[][Ncol], int fila, int nc,int ne)
{ int i, se=0;
for (i=0;i<nc;i++)
if(A[fila][i]==ne) se++;
return se;
}
int neMatrizCol(int A[][Ncol], int col, int nf,int ne)
{ int i, se=0;
for (i=0;i<nf;i++)
if(A[i][col]==ne) se++;
return se;
}

- 309 -


Preguntas
a) Si el pasaje adulto cuesta 60 dlares y el nio
paga 40 dlares a cuanto asiende el monto total
b) Cuantos nios(3 y 4) viajan en el avin
c) En que columna hay mas seoras
d) Encontrar la Posicin de cada seor y por
cuantos nios est rodeado

Ejemplo 3. El procesamiento de un producto consta
de 3 etapas la primera etapa dura 10 minutos la
segunda 20 minutos y la tercera de 15 minutos (que
no varan) cuantos minutos necesito para fabricar 5
productos

Programacin en tabla


Programacin en hoja de clculo

Este caso se puede resolverse analticamente

Ejercicio 1. en el ejercicio 3 la variacin de la
duracin de las actividades en cada estacin es
aleatorio pudiendo variar el tiempo en Media +- una
desviacin.


Programacin asumiendo los nmeros aleatorios
mostrados


Ejercicio 1. Programar la siguiente secuencia
Ejercicio 2. Programar la secuencia con la variacin
del 20%
Ejercicio 3. Programar otras secuencias

Programa aplicativo al Ejemplo 3. el procesamiento
de un producto consta de 2 etapas.- El tiempo de
procesamiento de la etapa es aleatorio y la
distribucin de probabilidad es similar al problema 3,
En la etapa 2 el producto se procesa de 1 a 5 minutos
distribuidos uniformemente (igual probabilidad para
todos)

Tiempo(Minutos) x 1 2 3 4 5
Probabilidad P(x) 0.05 0.20 0.4 0.25 0.1

Elaborar un programa para saber en cuanto tiempo
se puede procesar n productos}
(n = 10).

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int filas=20,col=5,ndatos=5;
int generar( int nro[], float p[], int n);
void procesar(int w[][col],int nro[], float p[], int n, int
np);
void mostrar(int w[][col], int nf, int nc);
int main()
{ int nro[ndatos]={1,2,3,4,5},np=10,w[filas][col];
float p[ndatos]= {5, 25,65,90,100};
int nf=10,nc=5; // 10 productos y 5 probabilidades
system("cls");
procesar(w,nro,p,ndatos,np);
printf("\n Nro1 r1 s1 r2 s2 ");
mostrar( w, nf, nc);
getch();
return 0;
}
int generar( int nro[], float p[], int n)
{ int r, ng,i;
r= rand() % 101;
for ( i=0; i<n;i++)
if (p[i]>r){ ng=nro[i]; break;}
return ng;
}
void procesar(int w[][col],int nro[], float p[], int n, int
np)
{ int i,na,s1=0;
srand(time(NULL));
for ( i=0; i<np;i++)
{ na= generar(nro,p,n); s1=s1+na;
w[i][0]= i;
w[i][1]= na; w[i][2]= s1; w[i][3]= rand()% 5 +1;
w[i][4]= 0;
}
// rellenar la ultima columna
w[0][4]= w[0][2]+ w[0][3];
for ( i=1; i<np;i++)
if (w[i][2]>w[i-1][4]) w[i][4]=w[i][2]+ w[i][3];
else w[i][4]=w[i-1][4]+ w[i][3];
}
void mostrar(int w[][col], int nf, int nc)
- 310 -
{ int i,j,na;
for ( i=0; i<nf;i++)
{ printf("\n ");
for ( j=0; j<nc;j++) printf("%5d",w[i][j]);
}
}

Preguntas
1. En el problema cuanto tiempo se espera en 10
productos
2. Si el tiempo de procesamiento de la etapa 2 es
de 10 minutos cuantos productos de la etapa 1
forman cola para procesarse en la etapa 2 al
cabo de una hora
3. Problema similar para tres etapas
4. Problema similar para n etapas

Ejemplo 4.- Procesamiento de un producto en n
etapas en forma secuencial para el procesamiento
de un producto se requiere n (n = 5)etapas cada
etapa es aleatorio de 1 a 6 minutos (tirada de dados)
elaborar la programacin para m(m=10) productos

#include <conio.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
const int filas=10,col=20;
void procesar(int w[][col],int n, int np);
void mostrar (int w[][col], int nf, int nc);
int main()
{int i,nf=10, netapas= 5;
int nc= netapas*2+1;
int w[filas][col];
printf("\n Procesamiento de un producto en %d
etapas ",netapas);
procesar(w,nf,nc);
printf("\n Nro");
for(i=1; i<netapas;i++) printf("%5s%d
%5s%d","r",i,"s",i);
mostrar( w, nf, nc);
getch();
return 0;
}
void procesar(int w[][col], int nf, int nc)
{ int i,j,r,s1=0;
srand(time(NULL));
// generamos los tiempos de servicio y guardamos
en la columnas impares
// en la primera columna guardamos el numero del
producto
// la segunda columna los tiempos de llegada
for ( i=0; i<nf;i++)
{for (j=0;j<nc;j++)
if (j%2==1){r=rand() % 6+1;w[i][j] =r;}else w[i][j]=0;
w[i][0] =i;
s1= s1+w[i][1];
w[i][2] =s1;
}
//inicializamos para el primer producto
for (i=4;i <nc;i=i+2)
w[0][i]=w[0][i-2]+ w[0][i-1];
// rellenamos los demas servicios
for (i=1;i<nf;i++)
for( j=4;j<nc;j=j+2)
if (w[i][j-2]>w[i-1][j]) w[i][j]=w[i][j-2]+ w[i][j-1];
else w[i][j]=w[i-1][j]+ w[i][j-1];
}
void mostrar(int w[][col], int nf, int nc)
{ int i,j,na;
for ( i=0; i<nf;i++)
{ printf("\n ");
for ( j=0; j<nc;j++) printf("%5d",w[i][j]);
}
}


METODOS NUMERICOS DISCRETOS

AREAS Se tiene los siguientes puntos X y Y
encontrar la integral bajo la curva



Nota no se aplicara el mtodo del punto medio por
que se esta trabajando con vectores
No se puede aplicar el mtodo simpson por que el
ancho dx es diferente ( no son iguales) Por lo tanto el
mejor mtodo seria el mtodo trapecial
El mtodo Simpson es mas exacto pero solo se
puede aplicar cuando las distancias de dx sean
iguales por ejemplo de la pagina 41( aqu se puede
aplicar Simpson)

#include <conio.h>
#include <stdio.h>
const int tam=20;
float circunscritos(float X[],float Y[],int n);
float inscritos(float X[],float Y[],int n);
float trapecial(float X[],float Y[],int np);
float simpson(float X[],float Y[],int np);
void Ingresar(float X[],float Y[],int np);
int main()
{float X[tam]={1,3,4,5,8,9,10,12};
float Y[tam]={2,2,3,4,4,3,3,4};
int np=8;
int n,opcion; float a=0, b=1,area=0;
do
{printf ("\n1. ingresar datos 2 circunscrito 3 inscritos 4
trapecial 5 todas 6:salirr ");
printf ("\nIngrese opcion :"); scanf("%d",&opcion);
switch (opcion)
{ case 1: printf("\n Ingrese numero de puntos: 1...
%d ",tam-1);scanf("%d",&np);
Ingresar(X,Y,np);break;
case 2: printf(" \n integrales por el metodo de
Rcircunscritos %f",circunscritos(X,Y,np));break;
case 3: printf(" \n integrales por el metodo de
Rinscritos %f",inscritos(X,Y,np));break;
case 4 :printf(" \n integrales por el metodo trapecial
%f",trapecial(X,Y,np));break;
case 5:
printf(" \n integrales por el metodo de Rcircunscritos
%f",circunscritos(X,Y,np));
- 311 -
printf(" \n integrales por el metodo de Rinscritos
%f",inscritos(X,Y,np));
printf(" \n integrales por el metodo trapecial
%f",trapecial(X,Y,np));
break;
}
} while (opcion !=6);
}
float circunscritos(float X[],float Y[],int np)
{ float at=0, ap,dx, fx;
for (int i=1; i<np;i++)
{ dx=X[i]-X[i-1];
fx=Y[i]; ap=dx*fx; at=at+ap;
}
return at;
}
float inscritos(float X[],float Y[],int np)
{ float at=0, ap,dx, fx;
for (int i=0; i<np-1;i++)
{ dx=X[i+1]-X[i]; fx=Y[i]; ap=dx*fx; at=at+ap;
}
return at;
}
float trapecial(float X[],float Y[],int np)
{ float at=0, ap,dx, fx1,fx2;
for (int i=0; i<np-1;i++)
{ dx=X[i+1]-X[i];
fx1=Y[i];
fx2=Y[i+1];
ap=dx*(fx1+fx2)/2; at=at+ap;
}
return at;
}
void Ingresar(float X[],float Y[],int np)
{ float datox,datoy;
for (int i=0;i<np;i++)
{ printf("\n ingrese punto x y %d ",i);
scanf("%f%f",&datox,&datoy);
X[i]=datox; Y[i]=datoy;
}
}



Se queremos la figura cerrada la modificacin en el
programa seria
Y se obtiene el mismo rea


int main()
{float X[tam]={1,3,4,5,8,9,10,12,12,1,1,};
float Y[tam]={2,2,3,4,4,3,3,4,0,0,2};
int np=11;



La ubicacin del grafico puede estar en cualquier
punto por ejemplo



Si se una traslacion de -4 a X Y -1 Y se tendra las
siguinetes coordenadas y modificando en el
programa

float X[tam]={-3,-1,0,1,4,5,6,8,8,-3,-3};
float Y[tam]={1,1,2,3,3,2,2,3,-1,-1,1};
int np=11;
se obtiene lo mismo
puede recorrer en sentido de las agujas del reloj o
en contrario
float X[tam]={1,1,12,12,10,9,8,5,4,3,1};
float Y[tam]={2,0,0,4,3,3,4,4,3,2,2};
int np=11;
sale negativo pero sale igual tomar valor absoluto

I X[i] Y[i]
0 0 5
1 5 10
2 10 5

Modifique en el programa
float X[tam]={0,5,10};
float Y[tam]={5,10,5};
int np=3


Se cierra la figura
float X[tam]={0,5,10,0};
float Y[tam]={5,10,5,5};
int np=4;
que se puede comprobar por el area del triangulo
=b*h/2= 10*5/2=25

Se puede poner cualquier figura por mas complicada
que sea el porgrama determinar su area
Mover la figura anterior a cualquier punto del eje de
las coordendas y comenzar con cualquier y el area
no debe variar

Ejemplo de una figura complicada


- 312 -

float X[tam]={0,0,16,16,10,10,12,12,4,4,8,8,0};
float Y[tam]={0,5,5,0,0,2,2,4,4,2,2,0,0};
int np=14;
como solo el mas efectivo es el metodos trapecial
los demas calculos se hara por ese metodo

VOLUMENES POR EL METODO DEL DISCO
De la siguiente figura obtenga el volumen de
revolucin por el mtodo del disco


probado con el problema 15.20

#include <conio.h>
#include <stdio.h>
#include <math.h>
#define pi 3.1416
const int tam=20;
float Voltrapecial(float X[],float Y[],int np);
int main()
{ float X[tam]={0,0,2,2,8,8,5,5,0};
float Y[tam]={0,2,2,4,4,2,2,0,0};
int np=9;
printf("\n el volumen del solido es
%8.4f",Voltrapecial(X,Y,np));
getch(); return 0;
}
float Voltrapecial(float X[],float Y[],int np)
{
float vt=0, vp,dx, fx1,fx2,r;
for (int i=0; i<np-1;i++)
{ dx=X[i+1]-X[i];
fx1=Y[i];
fx2=Y[i+1];
r= r=(fx1+fx2)/2;
vp= r*r*pi*dx;
vt=vt+vp;
}
return vt;
}

OBTENER VOLUMEN DE REVOLUCION POR EL
METODO DE CASQUETES CILINDRICOS Obtener
el volumen de la figura por el mtodo de casquetes
cilndricos



#include <conio.h>
#include <stdio.h>
#include <math.h>
#define pi 3.1416
const int tam=20;
float VolCilindro(float X[],float Y[],int np);
int main()
{ float X[tam]={0,4,8,12,12,0,0};
float Y[tam]={6,6,4,4,2,2,6};
int np=7;
printf("\n el volumen del solido es
%8.4f",VolCilindro(X,Y,np));
getch(); return 0;
}
float VolCilindro(float X[],float Y[],int np)
{
float vt=0, vp, r,R,h,rp;
for (int i=0; i<np-1;i++)
{ r=X[i];
R=X[i+1];
rp=(r+R)/2 ;
h=(Y[i]+Y[i+1])/2; // altura promedio
vp=pi*h*(R*R-r*r);
vt=vt+vp;
}
return vt;
}

PERIMETRO obtener el permetro de la figura


#include <conio.h>
#include <stdio.h>
#include <math.h>
const int tam=20;
float Longitud(float X[], float Y[], int np);
int main()
{ float X[tam]={0,3,3,10,10,3,3,0,0};
float Y[tam]={10,10,6,6,2,2,0,0,10};
int np=9;
printf("\n el perimetro es s
%8.4f",Longitud(X,Y,np));
getch();
return 0;
}
float
Longitud(floa
t X[], float Y[],
int np)
{ float
lt=0,lp,x1,y1,
x2,y2;
for (int i=0; i<np-1;i++)
{ x1=X[i]; x2=X[i+1];
y1=Y[i]; y2=Y[i+1];
lp=sqrt(pow((x2-x1),2)+pow((y2-y1),2)) ;
lt=lt+lp;
}
return lt;
}

AREA LATERAL DEL SOLIDO DE REVOLUCION
Obtener el rea lateral de la figura


Nota si solo se trabaja hasta el punto 3 que es 12 ,0
la superficie de revolcuion es 235 cuando la
superficie es cerrada tambien se agrega el area de
las tapas

#include <conio.h>
#include <stdio.h>
#include <math.h>
#define pi 3.1416
const int tam=20;
- 313 -
float SuperficieRevolucion(float X[], float Y[], float np)
{ float x,dx,R,r,alp,alt=0,g;
for (int i=0; i<np-1;i++)
{ dx=X[i+1]-X[i];
r=Y[i];
R=Y[i+1];
g= sqrt(pow(dx,2)+pow((R-r),2));
alp=pi*(R+r)*g;
alt=alt+alp;
}
return alt;
}
int main()
{
float
X[tam]={0,4,8,12,12,0,0};
float Y[tam]={4,4,2,2, 0,0,4};
int np=7;
printf("\n Superficie de revolucion
%8.4f",SuperficieRevolucion(X,Y,np));
getch();
return 0;
}

Modifique y compruebe



Encuentre el centroide de la figura y ubicar un punto
de tal manera que desde ese punto la distancia sea
minima



Localize una planta para abastecer a los siguientes
pueblos con sus habitantes

#include <conio.h>
#include <stdio.h>
#include <math.h>
const int tam=20;
float maximo(float A[], float np);
float minimo(float A[], float np);
void puntominimo(float X[], float Y[], float W[], float
np,float xmin, float ymin, float xmax, float ymax, float
&cx, float &cy);
float centro(float X[],int np);
int main()
{
float X[tam]={0,3,3,10,10,3,3,0,0};
float Y[tam]={10,10,6,6,2,2,0,0,10};
float W[tam]={1,1,1,10,5,10,1,1,1};
int np=9;
float xmin,xmax,ymin,ymax,cy,cx;
xmax=maximo(X,np);
ymax=maximo(Y,np);
xmin=minimo(X,np);
ymin=minimo(Y,np);
puntominimo(X,Y,W,np, xmin, ymin, xmax, ymax,
cx, cy);
printf("\n el punto cx= %f cy= %f",cx,cy);
printf("\n el centro de x es %f",centro(X,np));
printf("\n el centro de y es %f",centro(Y,np));
getch();
return 0;
}

float maximo(float A[], float np)
{ int mayor=-1000;
for (int i=0; i<np;i++)
if (A[i]>mayor)mayor=A[i];
return mayor;
}
float minimo(float A[], float np)
{ int menor=1000;
for (int i=0; i<np;i++)
if (A[i]<menor)menor=A[i];

return
menor;
}
void
puntom
inimo(fl
oat X[],
float
Y[], float W[], float np,float xmin, float ymin, float
xmax, float ymax, float &cx, float &cy)
{ float menor=10000,x1,y1,x2,y2,dist,sumadist=0, fila
,col;
int i;
for (fila=ymin; fila<ymax;fila=fila+0.1)
{
y1=fila;
for
(col=xmi
n;col<x
max;col
=col+0.
1)
{
x1=col;
sumadist=0;
for (i=0;i<np;i++)
{ x2=X[i]; y2=Y[i];
dist=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
sumadist=sumadist+dist*W[i];
}
if( sumadist<menor)
{ cx=x1; cy=y1;
menor=sumadist;
}
}
}
}
float centro(float X[],int np)
{ float suma=0;
for (int i=0;i<np;i++) suma=suma+X[i];
return suma/np;
}

TRABAJO DE INVESTIGACION Elabore problemas
de traslacion,rotacin, escalado, extrucion,torno en
3d

Ejercicio En excel genere 40 puntos x e y para
graficar una circunferencia de radio 4 use
coordenadas polares

Celda d6 = =$E$1*COS(B7) x= r*cos(alfa)
Celda D7 =$E$1*SENO(B7) Y=r*sin(alfa)

- 314 -


Grabe como circulo40.txt con block de notas


Para recuperar el archivo grabado en dos vectores
implemente el siguiente programa

// ****** programa principal
#include <conio.h>
#include <stdio.h>
#include <math.h>
const int tam=50;
#define pi 3.1416
void generar ( float X[],float Y[], float radio,int np);
void recuperar ( float X[],float Y[], int np);
void Mostrar(float X[],float Y[],int np);
int main()
{ float X[tam],Y[tam],radio=4;
int np=40;
// generar (X,Y,radio,np);
recuperar ( X,Y,np);
printf("\n valores recuperados");
Mostrar(X,Y,np);
getch();
}

void generar ( float X[],float Y[], float radio,int np)
{ float dx=2*pi/np,alfa; int fila;
for (
fila=0,alfa=0;alfa<=2*pi;alfa=alfa+dx,fila++)
{ X[fila]= radio*cos(alfa);
Y[fila]=radio*sin(alfa);
}
}

void Mostrar(float X[],float Y[],int np)
{ for (int i =0;i<np; i++)
printf("\n %3d %8.2f %8.2f ", i,X[i],
Y[i]);
}

void recuperar ( float X[],float Y[], int np)
{FILE *p;
float nx,ny,nz;
p=fopen("E:\\datos\\circulo40.txt","r");
for (int fila =0;fila<np; fila++)
{ fscanf(p,"%f%f",&nx,&ny);
X[fila]=nx;
Y[fila]=ny;
}
fclose(p);
}



Tambien se puede generar los puntos Con la funcin
generar (X,Y,radio,np);

Proyeccin sobre la pantalla del computador

En el desarrollo de un programa para representar
objetos slidos en la pantalla de un computador, un
punto que posee 3 dimensiones (x,y,z), dentro de la
pantalla que tiene 2(PX,PY) [2]. Se usa la frmula

PX= (x*D)/(D+z)
PY= (y*D/(D+z)

Entre ms grande sea D, la proyeccin obtenida se
acerca a la proyeccin paralela, y entre ms cerca se
acerca a la proyeccin en perspectiva,

Transformaciones tridimensionales
Las principales transformaciones de
modelado 3D son:
Rotacin
Traslacin
Escalado

La matriz de transformacin, representa una posicin
y orientacin del objeto 3D en el espacio, posee 3
vectores que representan los 3 ejes coordenados del
objeto, el primer vector representa el eje x del objeto,
y est formado por los 3 primeros nmeros de la
primera fila, el eje y, los 3 primeros nmeros de la
segunda fila y el eje z los 3 primeros nmeros de la
tercera fila. La matriz se muestra en la figura 1. [3]


Figura 1 Elementos de la matriz de transformacin
2.3.1 Rotacin

(
(
(
(
(

1
0
0
0
z y x
z y x
z y x
z y x
C C C
Z Z Z
Y Y Y
X X X
Eje x del objeto
Eje y del objeto
Eje z del objeto
Centro del objeto
- 315 -
Cada punto rota alrededor de un punto pivote. El
pivote no necesariamente tiene que estar en el centro
del objeto
Si se tiene el punto original x1,y1,z1 y se quiere rotar
un ngulo se debe usar las siguientes frmulas [3]

- Rotacin alrededor del eje z

| | | | 1 cos 1 1 1 cos 1
1 0 0
0 cos
0 cos
1 1 1 z y sen x sen y x sen
sen
z y x o o o o o o
o o
+ =
(
(
(



- Rotacin alrededor del eje x:

(
(
(

o o
o o
cos 0
cos 0
0 0 1
sen
sen

- Rotacin alrededor del eje y:

(
(
(


o o
o o
cos 0
0 1 0
0 cos
sen
sen


2.3.2Traslacion.- Es el proceso de mover el objetos
en el eje x, y i z . Para ello se debe modificar el centro
del objeto Cx, Cy ,Cz (Cx=Cx+k, Cy=cy+k,
Cz=cz+k)

2.3.3 Escalado.- es el proceso de aumentar o
disminuir el tamao del objeto tanto en el eje x ,eje y ,
o el eje z para ello se debe modificar las escalas por
un factor de escala el eje correspondiente (Ex=Ex*k,
Ey=Ey*k, Ez=Ez*k)
Si las escalas son negativas ocurre la reflexin



Archivo de cabecera otros.h

//********* otros.h
void linea(float x1,float y1,float x2,float y2)
{ int i,vel=10;
float mayor,ancho,alto,partex,partey,px,py,dx,dy;
ancho=fabs(x2-x1);
alto=fabs(y2-y1);
if (x1<=x2)dx=1;else dx=-1;
if (y1<=y2)dy=1;else dy=-1;
if (ancho>alto)mayor=ancho;else mayor=alto;
partex=ancho/mayor;
partey=alto/mayor;
for (i=0;i<=mayor;i++)
{ px=i*partex*dx;
py=i*partey*dy;
gotoxy(x1+px,y1+py);
printf("*");
// Sleep(vel);
}
}
void Mostrar(float X[],float Y[],float Z[],int np)
{ for (int i =0;i<np; i++)
printf("\n %3d %8.2f %8.2f %8.2f",
i,X[i], Y[i],Z[i]);
}

void graficar(float X[],float Y[],int np,int cx,int cy)
{ float x1,y1,x2,y2;
for (int i =0;i<np-1; i++)
{ x1= cx+X[i];
y1=cy+Y[i];
x2= cx+X[i+1]; y2=cy+Y[i+1];
linea(x1,y1,x2,y2);
}
}
void recuperar ( float X[],float Y[], float Z[],int np)
{FILE *p; int fila;
float nx,ny,nz;
p=fopen("E:\\datos\\cubo.txt","r");
for (fila =0;fila<np; fila++)
{ fscanf(p,"%f%f%f",&nx,&ny,&nz);
X[fila]=nx;
Y[fila]=ny;
Z[fila]=nz;
}
fclose(p);
}

void Escalado ( float X[],float Y[], float Z[],float
ex,float ey,float ez,int np)
{ for (int fila=0;fila<np;fila++)
{ X[fila]=X[fila]*ex;
Y[fila]=Y[fila]*ey;
Z[fila]=Z[fila]*ez;
}
}
void traslacion ( float X[],float Y[], float Z[],float tz,float
tx,float ty,int np)
{ for (int fila=0;fila<np;fila++)
{ X[fila]=X[fila]+tx;
Y[fila]=Y[fila]+ty;
Z[fila]=Z[fila]+tz;
}
}
void Rotacion ( float X[],float Y[], float Z[],float az,float
ax,float ay,int np)
{ float x1,y1,z1,azr,axr,ayr ;
azr=az*pi/180;
axr=ax*pi/180;
ayr=ay*pi/180;
for (int fila=0;fila<np;fila++)
{// rotando alrededor del eje z
x1=X[fila];
y1=Y[fila];
z1=Z[fila];
X[fila]=x1*cos(azr)-
y1*sin(azr);
Y[fila]=x1*sin(azr)+ y1 *cos(azr);
Z[fila]=z1;
// rotando alrededor del eje x
x1=X[fila];
y1=Y[fila];
z1=Z[fila];
X[fila]=x1;
Y[fila]=y1*cos(axr)- z1
*sin(axr);
Z[fila]=y1*sin(axr)+z1*cos(axr);
// rotando alrededor del eje y
x1=X[fila];
y1=Y[fila];
z1=Z[fila];
- 316 -

X[fila]=x1*cos(ayr)+z1*sin(ayr);
Y[fila]=y1;
Z[fila]=-x1*sin(ayr)+z1*cos(ayr);
}
}
Programa principal

#include <conio.h>
#include <stdio.h>
#include <math.h>
#include "e:\datos\milib.h"
const int tam=50;
#define pi 3.1416
#include "otros.h"
int main()
{ float X[tam],Y[tam], Z[tam];
float radio=4,cx=40,cy=5,np=17;
recuperar (X,Y,Z, np);
Rotacion ( X,Y,Z,45,45,0,np);
traslacion (X,Y,Z,0,0,0, np);
Escalado (X,Y,Z,30,15,30,np);
// Mostrar(X,Y,Z, np);
graficar(X,Y,np,cx,cy);
getch();
}



Notas:- el angulo de rotacion es en grados

Tarea.- trabaje con otro tipo de graficos, yrealice
opercion de torno , exgtrusion ,etc

5.5 ORDENACION BUSQUEDA Y MEZCLA

4.5.1- Ordenacin.- O clasificacin de datos (Sort en
ingls); es una operacin consistente en disponer un
conjunto (Estructura) de datos, en algn determinado
orden con respecto a uno de los campos de
elementos del conjunto. Los mtodos de ordenacin
se suelen dividirse generalmente en:

- Directo: Burbuja, seleccin, insercin (aplicables
para listas pequeas).
- Indirecto(avanzado): shell, ordenacin rpida,
ordenacin por mezcla (utilizado para listas
grandes).
a) Ordenacin por el mtodo de la burbuja.- Los
valores ms pequeos "burbujean" hacia la parte
superior de la lista (hacia el primer elemento).
Funcionamiento Comienzo d c a b
paso 1 a d c b
paso 2 a b d c
paso 3 a b c d

b) Ordenacin por seleccin.- Se selecciona los
elementos, con el valor mas bajo y los cambia con
el primer elemento.

Funcionamiento Comienzo b d a c
paso 1 a d b c
paso 2 a b d c
paso 3 a b c d
c) Ordenacin por insercin.- Ordena los dos
primeros elementos miembros del arreglo; el
tercer miembro se inserta en la correspondiente
posicin en relacin a los dos primeros
miembros. El cuarto elemento se inserta en la
lista de los tres elementos y as sucesivamente.
Funcionamiento Comienzo d c a b
paso 1 c d a b
paso 2 a c d b
paso 3 a b c d

d) Ordenacin Shell.- Consiste en dividir la lista en
dos partes ( a los que llamaremos intervalos).
Ejemplo.- Si la lista tiene diez elementos, cada
intervalo tendr cinco elementos, de ellos el
primer elemento se compara con el sexto, el
segundo con el sptimo, y as sucesivamente. En
el siguiente paso el intervalo ser de cuatro (de 4
en 4 ; luego tres y despus dos, hasta llegar a
uno, donde la lista ya est ordenada.

Funcionamiento Comienzo f d a c b e
paso 1 c b a f d e

paso 2 a b c e d f

paso 3 a b c d e f

e) Ordenacin rpida.- Se basa en el mtodo de
ordenacin por cambio y se construye a partir de
la idea de las particiones. El procedimiento
general, selecciona una valor llamado
comparando, y entonces divide el array en dos
partes; en un lado todos los elementos mayores
o iguales que el valor de la particin, y en otro
lado todos los menores; este proceso se repite
para cada grupo restante, hasta que se ordene el
arreglo.

Funcionamiento Comienzo f e d a c b
Valor de particin d
paso 1 b c a d e f
Valor de particin en el primer grupo es c
paso 2 a b c d e f

Para el ordenamiento rpido se utilizan programas
con funciones recursivas. En el ejemplo anterior
tenemos el listado del programa de ordenamiento por
el mtodo de seleccin.

- 317 -
5.5.2.- Bsqueda.- Consiste en la localizacin de un
elemento especifico, y la recuperacin de alguna
informacin asociada al mismo. Ej. las palabras en el
diccionario, dado un cdigo localizar los dems
elementos de la lista.

a) Bsqueda secuencial.- Consiste en buscar
registro a registro desde el comienzo hasta el fin,
la clave especificada. Para la bsqueda
secuencial no es necesario que el vector est
ordenado.
El programa C405 realiza la bsqueda secuencial.

b) Bsqueda binaria.- Se necesita que los datos
estn ordenados (generalmente de menor a
mayor). Este mtodo primero consulta el elemento
del medio; si esta es mayor que la clave, entonces
consulta el elemento mitad de la primera mitad; de
lo contrario se consulta el elemento mitad de la
segunda parte. Se repite este proceso, hasta que
una pareja se encuentre o hasta que no haya ms
elementos que consultar.
El programa C406 realiza la bsqueda binaria.

5. 5. 3 Mezcla.- El proceso de mezcla, fusin o
intercalacin (Merge en Ingls). Consiste en tomar
dos vectores ordenados A y B y luego obtener un
nuevo vector (C), tambin ordenado.

5.6 PILAS

Una pila (Stack) es una lista de informacin al que se
accede en el orden: ltimo en entrar es el primero en
salir (llamado lifo Last-in first-out que significa ltimo
elemento introducido primero sacado). Imaginemos
una pila de platos, el plato de abajo de la pila ser el
ltimo en usarse, y el plato de arriba (el ltimo plato
puesto en la pila es el primero en utilizarse. Las pilas
tienen bastante aplicacin en los sistemas de
software.

Las operaciones que se pueden realizar con pilas se
muestran a continuacin.

Accin Contenido de la
pila
----------------------------------------------------
Poner en pila (A) A
Poner en pila (B) B, A
Poner en pila (C) C, B, A
Sacar de la pila (devuelve C) B,A
Poner en pila (F) F,B,A
Sacar de la pila (devuelve F) B,A
Sacar de la pila (devuelve B) A
Sacar de la pila (devuelve A) Vaca
------------------------------------------------------
Las operaciones de aadir o quitar datos de una pila
se hace por un extremo llamado cima. La cima tiene
una capacidad llegado al cual ya no se puede meter
ms elementos. Lo mismo no se puede sacar
elementos de una pila vaca (Una pila se podra
comparar con un saco en donde se introducen cosas
por un extremo, y se vuelve a sacar por el mismo
extremo. El saco tiene una capacidad llegado al cul
ya no se puede sacar m s cosas, lo mismo no se
puede sacar nada de un saco vacio. El problema
C506 Ilustra un men de pilas

5.7 COLAS.

Una cola es una lista de informacin a la que se
accede en el orden primero que entra es el primero
que sale (llamado tambin FIFO First-in First -Out). El
primer elemento situado en la cola es el primero que
se saca, el segundo que se pone en la cola es el
segundo que se saca, y as sucesivamente. Esta
orden es la nica manera de almacenar y recuperar,
no se permite acceder a un determinado elemento de
la cola de forma aleatoria.

Las colas son comunes en la vida diaria por Ej. una
cola en banco, una cola de autos en una gasolinera
para ser atendidos, una cola de materiales en espera
de ser procesados, etc.

La evolucin de una cola se muestra a continuacin.

Accin Contenido de la
cola
----------------------------------------------------
Poner en cola (A) A
Poner en cola (B) A,B
Poner en cola (C) A,B,C
Sacar de la cola (devuelve A) B,C
Poner en cola (D) B,C,D
Sacar de la cola (devuelve F) C,D
Sacar de la cola (devuelve B) D
Sacar de la cola (devuelve A) Vaca
----------------------------------------------------
En las colas los elementos entran por un extremo y
salen por el otro extremo. Y lo mismo que las pilas
tiene su capacidad. Por Ej. los autos que esperan
para ser reparados pueden formar cola si es que hay
sitio en la playa de espera. Una cola es vaca cuando
no hay elementos esperando. El problema C507 trata
sobre un Men de colas.

5.8.- OPERACIONES CON VECTORES Y
MATRICES

Con vectores y matrices se pueden realizar las
siguientes operaciones:
a) Suma de vectores.
b) Producto de un escalar por un vector.
c) Depuracin y intercalacin de listas.
d) Conversin de una matriz en vector y viceversa.
e) Suma de matrices.
f) Multiplicacin de matrices
g) Matriz inve
h) Matriz transpuesta
i) Determinante, etc.
El problema C504 realiza multiplicacin de 2
matrices.

5.9 SIMULACION

Los arreglos se pueden utilizar para simular un
proceso en la pantalla Ej. Simulacin de servicio de
carros en una gasolinera, el caso de procesamiento
de productos en forma secuencial, simulacin de
atencin de clientes en un restaurante, etc.

5.10 JUEGOS

Con los arreglos se pueden hacer diferentes juegos
como son:
a) Juegos tcticos.- Se debe programar al
computador para que pueda reaccionar de forma
adecuada a las jugadas que realiza el usuario,
m s aun, el computador debera llegar a ganar a
- 318 -
su contrincante. El programa no puede elegir sus
jugadas a partir del principio del azar sino
siguiendo un fin muy bien definido. Ej. juego de
ajedrez, tres en raya, de aventuras, etc.
b) Juegos de simulacin.- Por Ej. el juego de la vida
inventado por Conway que simula como cambia
los nacimientos y muertes de un microorganismo
en una rejilla acotada.
c) Juegos operativos.- Son juegos donde interviene
el azar y tambin una decisin estratgica. Ej.
simulacin de una guerra.

5.11. PROBLEMAS RESUELTOS
Programa C501.- Generar burbujas de asteriscos en
pantalla de colores forma aleatoria. en un cuadro
(x1,y1,x2,y2).

#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include "e:\datos\milib.h"
const int maxcol=80; /* por que la pantalla tiene 80
columnas */
void burbuja(int a[],int x1, int y1, int x2, int y2,int
color);
int main()
{ int a[maxcol];
int b[maxcol];
burbuja(a,10,5,40,20,32);
//burbuja(b,50,5,70, 20,16+128);
}
void burbuja(int a[], int x1, int y1,int x2, int y2, int
color)
{ int i,r;
for (i=x1;i<=x2;i++) a[i]=y2; // inicializamos
while (!kbhit()) /*hasta que se presione una tecla */
{
r=x1+ 1+rand() %(x2-x1);
textcolor(color,r%15 );
if (a[r]>y1)
{
gotoxy(r,a[r] ); printf(" ");
gotoxy(r,--a[r]); printf("*");
// Sleep(1);
}
else
{ gotoxy(r,a[r] ); printf(" ");
a[r]=y2;
Sleep(1);
}
}
}

De izquierda a derecha

void burbuja(int a[], int x1, int y1,int x2, int y2, int
color)
{ int i,r;
for (i=y1;i<=y2;i++) a[i]=x2; // inicializamos
while (!kbhit()) /*hasta que se presione una tecla */
{
r=y1+1+rand() %(y2-y1);
textcolor(color,r%15 );
if (a[r]>x1)
{
gotoxy(a[r],r ); printf(" ");
a[r]=a[r]-1;
gotoxy(a[r],r); printf("*");
// Sleep(1);
}
else
{ gotoxy(a[r],r ); printf(" ");
a[r]=x2;
Sleep(1);
}
}
}
Mostrar varios cuadros de burbuja



#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include "e:\datos\milib.h"
const int maxcol=80; /* por que la pantalla tiene 80
columnas */
void burbuja(int a[],int x1, int y1, int x2, int y2,int
color,int r);
void iniciar( int A[], int x1,int x2,int valor)
{ for (int i=x1;i<=x2;i++) A[i]=valor;}
int main()
{ int A[maxcol],x1=1,y1=1,x2=25,y2=20,r;
int B[maxcol],x1b=30,y1b=10,x2b=45,y2b=20,r2;
int C[maxcol],x1c=45,y1c=1,x2c=60,y2c=10,r3;
int D[maxcol],x1d=60,y1d=4,x2d=78,y2d=20,r4;
iniciar(A,x1,x2,y2);
iniciar(B,x1b,x2b,y2b);
iniciar(C,x1c,x2c,y2c);
iniciar(D,x1d,x2d,y2d);
while (!kbhit())
{ r=x1+ 1+rand() %(x2-x1);
- 319 -
burbuja(A,x1,y1,x2,y2,16,r);
r2=x1b+ 1+rand() %(x2b-x1b);
burbuja(B,x1b,y1b,x2b,y2b,64+128,r2);
r3=x1c+ 1+rand() %(x2c-x1c);
burbuja(B,x1c,y1c,x2c,y2c,32+128,r3);
r4=x1d+ 1+rand() %(x2d-x1d);
burbuja(B,x1d,y1d,x2d,y2d,64+128+32,r4);
}
}
void burbuja(int a[], int x1, int y1,int x2, int y2, int
color,int r)
{ int i;
textcolor(color,r%15 );
if (a[r]>y1)
{
gotoxy(r,a[r] ); printf(" ");
gotoxy(r,--a[r]); printf("*");
}
else
{ gotoxy(r,a[r] ); printf(" ");
a[r]=y2;
Sleep(1);
}
}

Modificar el programa para simular una copa de vino
osea las burbujas se muestran en una superficie
parabolica

Simular el parpadeo de las estrellas

#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "e:\datos\milib.h"
const int Nfilas =24,Ncol=80,NElem=200;
void generar(int A[][Ncol],int X[],int Y[],int Z[],int nf,int
nc,int &ne );
int main()
{ int
nc=60,nf=20,cx=10,cy=1,ex=1,ey=1,ne=40,r,fila,col;
int A[Nfilas][Ncol],X[NElem],Y[NElem],Z[NElem];
srand( (unsigned)time( NULL ) );
generar(A,X,Y,Z, nf, nc,ne );
while(!_kbhit())
{
r= rand()%ne;
if (Z[r]>8) Z[r]=Z[r]-8;else Z[r]=Z[r]+8;
fila=Y[r];
col=X[r];
if (Z[r]>0&& Z[r]<16)
{gotoxy(cx+col*ex,cy+fila*ey);
textcolor(0,Z[r]);
printf("*");
}
Sleep(1);
}
getch();
}


void generar(int A[][Ncol],int X[],int Y[],int Z[],int
nf,int nc,int &ne )
{ int fila,col,r,valor=nf*nc;
int cont=0;
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
{ r= rand()%valor;
if (r<ne) {
A[fila][col]= 1+ rand()%8;
X[cont]=col;
Y[cont]=fila;
Z[cont]=A[fila][col];
cont++;
}
else A[fila][col]=0;
}
}

Programa C502.- Mostrar la frecuencia de n
nmeros.

#include <conio.h>
#include <stdio.h>
int main()
{ const int max=20;
int num[max+1];// vector de nmeros originales
int fn[max+1];// vector para guardar los Nros. que no
se repiten.
int frec[max+1];// frecuencia con que se repiten esos
nmeros
int ctr; // variable para controlar
int c,i,j; // c=contador de nmeros que se repiten
int n; //n= numero de datos
// el C permite que n sea = max y esta mal
// ingreso de datos
printf("\n cuantos datos 1...20 :");scanf("%d",&n);
printf("\ningrese %d datos \n",n);
for (i=1; i<=n; i++) scanf("%d",&num[i]);
fn[1]=num[1]; frec[1]=1; c=1;
printf("\n los nmeros originales son ");
for (i=1;i<=n;i++) printf("%4d",num[i]);
// ***** calculo de las frecuencias
for(i=2;i<=n; i++)
{ ctr=0;
for (j=1; j<=c;j++)
if(num[i]==fn[j])
{ frec[j]++; ctr=1; break;}
if(ctr==0)
{ c++;
fn[c]=num[i];
frec[c]=1;
}
}
printf("\n las frecuencias son ");
for(i=1;i<=c; i++)
printf("\n %4d ==%4d",fn[i],frec[i]);
getch();
}

- 320 -


Programa C503.- Multiplicacin de matrices
#include <conio.h>
#include <stdio.h>
const int maxfilas=5,maxcol=5;
void IngresarMatriz(float a[][maxcol],int nf,int nc )
{int col,fila;
float dato;
printf("Ingrese %d datos por fila \n" ,nc);
for (fila=0;fila<nf;fila++)
{ printf("Fila %d ",fila);

for (col=0;col<nc;col++)
{ scanf("%f",&dato);
a[fila][col]=dato;
}
}
}
void mostrarMatriz(float a[][maxcol],int nf,int nc )
{int col,fila;
for (fila=0;fila<nf;fila++)
{ printf("\n");
for (col=0;col<nc;col++)
printf("%6.2f",a[fila][col]);
}
}
void MultiplicarMatriz(float a[][maxcol], float
b[][maxcol], float c[][maxcol],int p, int q , int r )
{ int i,j,k;
float aux;
for (i=0; i<p;i++)
for (k=0; k<r; k++)
{
aux=0;
for (j=0;j<q;j++)
aux=aux+a[i][j]*b[j][k];
c[i][k]=aux;
}
}
int main()
{ float aux,a[maxcol][maxfilas],b[maxcol][maxfilas];
float c[maxcol][maxfilas],dato;
int p,q,r,i,j,k;
printf("\n multiplicacion de matrices de A(p*q)*
B(q*r)");
printf("\n ingrese p,q,r ");
scanf("%d%d%d",&p,&q,&r);
printf("\nIngreso de la primera matriz \n");
IngresarMatriz(a,p,q);
mostrarMatriz(a,p,q);
printf("\n Ingreso de la segunda matriz\n");
IngresarMatriz(b,q,r);
mostrarMatriz(b,q,r);
MultiplicarMatriz(a,b,c,p,q,r);
printf("\n MATRIZ PRODUCTO \n");
mostrarMatriz(c,p,r);
getch();
return 0;
}


Programa C504.- Bsqueda secuencial
#include
<conio.h>
#include
<stdio.h>
int main()
{ const int
n=10;
int
a[n+1]={0,1
0,20,30,40,
50,60,70,80,90,100};
// inicializamos con esos nmeros la base
int i,num,lug,ctr=0;
printf("\n ingrese un numero a buscar
");scanf("%d",&num);
for(i=1;i<=n;i++) if (num==a[i]){ ctr=1,lug=i; break;}
if (ctr==1) printf("\n %d esta en %d lugar ",num,lug);
else printf("\n el Nro %d no se encuentra ",num);
getch();
return 0;
}

Programa C505.- Bsqueda binaria.

#include <stdio.h>
#include <conio.h>
int main()
{ const int max=30;
int num,n,p=0,li,ls,med,i;
int lista[max+1];
printf("\n ingrese numero de elementos del
vector1..%d ...",max);
scanf("%d",&n);
printf("\n ingrese %d elemntos en la lista\n",n);
for (i=1; i<=n;i++) scanf("%d",&lista[i]);
printf("\n ingrese el Nro a buscar en la lista ");
scanf("%d",&num);
// algoritmo de bsqueda
li=1; ls=n;
- 321 -
while (li<=ls)
{ if (lista[li]==num)
{
printf(" \n numero encontrado en lugar %d ",li);
p=1; break;
}
else
{
if (lista[ls]==num)
{ printf("\n numero encontrado en lugar %d ",ls);
p=1; break;
}
else
{ med=(int)(ls-li)/2;
if (num>lista[med]) { li=med; ls=(ls-1);}
else {li=li+1; ls=med; }
}
}
}
if (p==0) printf(" \nel numero no se encuentra ");
getch();
}


Programa C506.- Men de Pilas

#include <conio.h>
#include <stdio.h>
int main()
{ const int max =30;//consistenciar para solo ingrese
30 datos
int pila[max],ne=0,op,i;
do
{ printf( "\n menu de pilas ");
printf( "\n 1. ingresar datos ");
printf( "\n 2. sacar elementos de la pila ");
printf( "\n 3. listar datos ");
printf( "\n 4. salir ");
printf( "\n Ingrese opcin ======> ");
scanf("%d",&op);
switch (op)
{
case 1: { for (i=ne; i>0; i--)
pila[i]=pila[i-1];
printf(" \n ingrese elemento %d a la pila ",ne);
scanf("%d",&pila[0]);
ne++;
break;
}
case 2: { if(ne>0)
{
printf("\n sale el elemento %d de la pila ",
pila[0]);
for (i=0; i<ne; i++)
pila[i]=pila[i+1];
ne--;
}
else printf(" \n pila vacia ");
break;
}

case 3: {if (ne>0)
{ printf(" elementos en la pila \n");
for (i=0; i<ne; i++)
printf("%5d",pila[i]);
}
else printf("\npila vacia ");
break;
}
case 4: break;
default: printf(" \n no es numero correcto");
}
} while (op!=4);
}

Programa C507.- Men de colas.-

#include <conio.h>
#include <stdio.h>
int main()
{ const int max =30;
int cola[max],ne=0,op,i;
do
{ printf( "\n menu de colas ");
printf( "\n 1. ingresar datos ");
printf( "\n 2. sacar elementos de la cola ");
printf( "\n 3. listar datos ");
printf( "\n 4. salir ");
printf( "\n Ingrese opcin ======> ");
scanf("%d",&op);
switch (op)
{
case 1:{ for (i=ne; i>0; i--)
cola[i]=cola[i-1];
printf(" \n ingrese elemento %d a la cola ",ne);
scanf("%d",&cola[0]); ne++;
break;
}
case 2: { if(ne>0)
{ ne--;
printf("\n sale el elemento %d de la cola ",
cola[ne]);
}
else printf(" \n cola vacia "); break;
}
case 3: {if (ne>=0)
{
printf(" elementos en la cola \n");
for (i=0; i<ne; i++) printf("%5d",cola[i]);
- 322 -
}
else printf("\ncola vacia ");
break;
}
case 4: break;
default: printf(" \n no es numero correcto");
}
} while (op!=4);
}

Problema C508 .- Juego de la selva
Se tiene las siguientes probabilidades
rellenar una matriz de 20*30 de 0 a 4 de acuerdo a
las probabilidades de ocurrencia que representa el
juego de la selva
a) visualizar la matriz generada b) cuantos elefantes
hay
c) Cuantos exploradores hay y por cuantos leones
est rodeado cada uno

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int nf=8,nc=8;// para los datos del examen
cambie nf=20 y nc=30
int rodear(int A[nf][nc], int fila, int columna)
{ int i,j, x1, y1, x2,y2,leones=0;
if (fila==0 ) y1=0; else y1=fila-1;
if (columna==0 ) x1=0; else x1=columna-1;
if (fila==nf-1 ) y2=nf-1; else y2=fila+1;
if (columna==nc-1 ) x2=nc-1; else x2=columna+1;
for (i= y1; i<=y2; i++)
for (j= x1; j<=x2; j++) if(A[i][j]==3)leones=leones+1;
return leones;
}
void rellenar(int A[nf][nc])
{ int i,j,r;
for(i=0;i<nf;i++)
for (j=0;j<nc;j++)
{r=rand() % 100+1;
if (r>0&&r<=40)A[i][j]=0;
if (r>40&&r<=60)A[i][j]=1;
if (r>60&&r<=75)A[i][j]=2;
if (r>75&&r<=90)A[i][j]=3;
if (r>90&&r<=100)A[i][j]=4;
}
}
void visualizar (int A[nf][nc])
{ int i,j;
for(i=0;i<nf;i++)
{ printf("\n");
for (j=0;j<nc;j++)printf("%2d",A[i][j]);
}
}
int elefantes (int A[nf][nc])
{ int i,j,ele=0;
for(i=0;i<nf;i++)
for (j=0;j<nc;j++)if(A[i][j]==2)ele++;
return ele;
}
int exploradores (int A[nf][nc])
{ int i,j,explo=0;
for(i=0;i<nf;i++)
for (j=0;j<nc;j++)
if(A[i][j]==4)
{ explo++;
printf("\n explorador en fila %d columna %d ",i,j);
printf("\n rodeado por %d leones ",rodear(A,i,j));
}

return explo;
}
int main()
{ int selva[nf][nc];
srand(time(NULL));
rellenar(selva);
visualizar(selva);
printf("\n hay %d elefantes ", elefantes(selva));
printf("\n hay %d exploradores ",
exploradores(selva));
getch();
return 0;
}

Problema C509 Usando funciones definidas por el
usuario convertir un numero de base decimal a
nmeros de bases de de 2 a 10 o cualquier base.

#include <stdio.h>
#include <conio.h>
void alrevez( int a[], int n)
{ int i,temp,cont=0;
int b[20];
N. Significado probabilidad
0 rbol 40 %
1 mono 20 %
2 elefante 15 %
3 len 15 %
4 explorador 10 %

- 323 -
for ( i=0;i<n;i++)
b[i] =a[n-1-i];
for ( i=0;i<n;i++)
a[i] =b[i];
}
void imprimir(int a[], int n)
{ for (int i=0;i< n;i++)
printf("%4d",a[i]);
}
void DecABase(int a[],int nro,int base, int &n)
{ int resto,cont=0;
while (nro>0)
{ resto= nro % base;
a [cont]=resto;
nro=nro/base;
cont++;
}
n=cont;
alrevez(a,n);
}
int main()
{
int i,nro=8 , base =8,cont=0,resto,n;
int a[20];
printf("\n ingrese un numero en base decimal ");
scanf("%d",&nro);
for (i=2;i<=10;i++)
{ DecABase(a,nro,i,n);
printf ("\n el numero %3d en base %3d es ",nro,i);
imprimir(a,n);
}
getch();
return 0;
}

Problema C510 Se lee un numero de una tarjeta de
datos y se almacena en un arreglo mostrar el nmero
ledo
#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <math.h>
#include "e:\datos\milib.h"
void imprimirMatriz(int cx,int cy, int A[][4], int nf, int
nc, int ex, int ey );
int MatrizNumero(int A[][4], int nf, int nc ) ;
int main()
{ int A[10][4]={0,1,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,1,0,
0,0,0,0,
0,0,0,0,
0,0,0,1,
0,0,0,0,
1,0,0,0} ;
int cx=10, cy=2, nc=4, nf=10, ex= 8,
ey=2;
long nro=8109,
millares,centenas,decenas,unidades,resto;
millares= nro/1000;
resto= nro % 1000;
centenas=resto/100;
resto=resto %100;
decenas=resto/10;
unidades=resto %10;
clrscr(); gotoxy(cx,cy+1);
printf("Millares Centenas Decenas , unidades");
cy=cy+3;
imprimirMatriz(cx,cy,A,nf,nc,ex,ey);
gotoxy(1,1);
printf("\n el numero es %d",MatrizNumero(A,nf,nc));
getch();
}
void imprimirMatriz(int cx,int cy, int A[][4], int nf, int
nc, int ex, int ey )
{ int fila, col;
for (col=0;col<nc;col++)
for (fila=0;fila<nf;fila++)
{ if (A[fila][col]==1)textcolor(0,14);else textcolor(0,7);
gotoxy(cx+col*ex,cy+fila+ey);
printf("%3d",fila);//A[fila][col]);
}
}
int MatrizNumero(int A[][4], int nf, int nc )
{ int fila, col,valor,suma=0;
for (col=0;col<nc;col++)
{ valor=int( pow(float(10),float(nc-col-1)));
for (fila=0;fila<nf;fila++)
{ if (A[fila][col]==1)
suma= suma+valor*fila;
}
}
return suma;
}

Problema C511 JUEGO DE LA TINKA
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
const int ne=6;
int aciertos(int jugadas[],int juego[],int n)
{ int i,j,nj=0;
for (i=0;i<n ;i++)
{ for (j=0;j<n;j++)
if (jugadas[i]==juego[j])nj++;
}
return nj;
- 324 -
}
void Sorteo(int juego[],int n)
{ int bolos[40]={0,1,2,3};
int ne=40,r,i,j;
for (i=1;i<ne;i++)
bolos[i]=i;
srand(time(NULL));
for( int i=0;i<n;i++)
{ r= 1+rand()%ne;
juego[i]=bolos[r];
ne--;
for (j=r;j<ne;j++)
bolos[j]=bolos[j+1];
}
}
void ingresar( int A[], int n)
{ for(int i=0;i<n;i++) scanf("%d", &A[i]);
}
void ordenar(int A[], int n)
{ int i,j,temp;
for (i=0; i<n-1; i++)
for (j=i+1; j<n;j++)
if (A[j]<A[i])
{ temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}
void Mostrar( int A[], int n)
{ int i;
for(i=0;i<n;i++) printf(" %2d", A[i]);
}
int main()
{ int nro,n=6,nj=2,i ;
int jugadas[ne];
int juego[ne];
int va[ne+1]={0,0,0,0,0,0,0};
printf("\n Nro de tarjetas a procesar :");
scanf("%d",&nj);
Sorteo(juego,n);
ordenar(juego,n);
for (i=1;i<=nj;i++)
{ printf("\n Ingrese 6 jugadas tarjeta %d :",i);
ingresar(jugadas,n);
nro=aciertos(jugadas,juego,n);
va[nro]=va[nro]+1;
}
printf("\n la jugada de la tinka fue \n");
Mostrar(juego,n);
// mostrar nro de aciertos
for (i=0;i<=n;i++)
{ printf("\n jugadas con %d aciertos= %d",i,va[i]);
}
getch();
}



Problema C512 Generar una matriz de n filas por m
columnas y mostrar su matriz transpuesta
#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int nfilas=20, ncol =20;
void RellenarMatriz(int a[][ncol], int nf,int nc);
void MatrizTranspuesta(int a[][ncol], int b[][ncol],int
nf,int nc);
void MostrarMatriz(int a[][ncol],int nf,int nc);
int main()
{ int Matriz[nfilas][ncol],MatrizT[nfilas][ncol];
srand(time(NULL));
int nf=3,nc=4,Nfila,Ncol;
RellenarMatriz(Matriz,nf,nc);
printf("\n Matriz Original");
MostrarMatriz(Matriz,nf,nc);
MatrizTranspuesta(Matriz,MatrizT, nf,nc);
printf("\n Matriz Tranpuesta");
MostrarMatriz(MatrizT,nc,nf);
getch();
}
void RellenarMatriz(int a[][ncol],int nf, int nc)
{ int fila, col;
for
(fila=0;fila<nf;fi
la++)
for
(col=0;col<nc;
col++)

a[fila][col]=ran
d() % 6;
}
void
MostrarMatriz(
int a[][ncol],int
nf, int nc)
{
int fila, col;
for (fila=0;fila<nf;fila++)
{ printf("\n");
for (col=0;col<nc;col++)
printf (" %4d", a[fila][col]);
}
}
void MatrizTranspuesta(int a[][ncol], int b[][ncol],int
nf,int nc)
{ int fila, col;
for (fila=0;fila<nf;fila++)
- 325 -
for (col=0;col<nc;col++)
b[col][fila]=a[fila][col];
}

Problema C513.rellenar una matriz cuadrada de n
lados de nmeros aleatorios de 1 a 10 , imprimir la
matriz cuadrada ,matriz diagonal superior , matriz
diagonal inferior , matriz diagonal, tambin obtener la
suma de esa matrices como se muestra en la figura
#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

const int nfilas=20, ncol =20;
void RellenarMatrizCuadrada(int a[][ncol], int ne);
void MostrarMatrizCuadrada(int a[][ncol],int ne);
void MostrarMatrizSuperior(int a[][ncol],int ne);
void MostrarMatrizInferior(int a[][ncol],int ne);
void MostrarMatrizDiagonal(int a[][ncol],int ne);
int SumaDiagonal(int a[][ncol],int ne);
int SumaMatrizSuperior(int a[][ncol],int ne);
int SumaMatrizInferior(int a[][ncol],int ne);
int main()
{ int Matriz[nfilas][ncol],ne;
srand(time(NULL));
printf("\n ingrese lado de la matriz cuadrada");
scanf("%d",&ne);
RellenarMatrizCuadrada(Matriz,ne);
printf("\n Matriz Original");
MostrarMatrizCuadrada(Matriz,ne);
printf("\n Matriz Superior");
MostrarMatrizSuperior(Matriz,ne);
printf("\n Matriz Inferior");
MostrarMatrizInferior(Matriz,ne);
printf("\n Matriz Diagonal");
MostrarMatrizDiagonal(Matriz,ne);
printf("\n La suma de la diagonal es
%d",SumaDiagonal(Matriz,ne));
printf("\n La suma de Matriz superior es
%d",SumaMatrizSuperior(Matriz,ne));
printf("\n La suma de Matriz inferior es
%d",SumaMatrizInferior(Matriz,ne));
getch();
}
void RellenarMatrizCuadrada(int a[][ncol],int ne)
{ int fila, col;
for (fila=0;fila<ne;fila++)
for (col=0;col<ne;col++)
a[fila][col]=rand()%10;
}
void MostrarMatrizCuadrada(int a[][ncol],int ne)
{
int fila, col;
for (fila=0;fila<ne;fila++)
{ printf("\n");
for (col=0;col<ne;col++)
printf (" %3d", a[fila][col]);
}
}
void MostrarMatrizInferior(int a[][ncol],int ne)
{
int fila, col;
for (fila=0;fila<ne;fila++)
{ printf("\n");
for (col=0;col<fila;col++)
printf (" %3d", a[fila][col]);
}
}
void MostrarMatrizSuperior(int a[][ncol],int ne)
{
int fila, col;
for (fila=0;fila<ne;fila++)
{ printf("\n");
for (col=0;col<ne;col++)
{ if (col<=fila) printf (" %3c",32);
else printf (" %3d", a[fila][col]);
}
}
}
void MostrarMatrizDiagonal(int a[][ncol],int ne)
{
int fila, col;
for (fila=0;fila<ne;fila++)
{ printf("\n");
for (col=0;col<ne;col++)
if (fila!=col) printf (" %3c",32);
else printf (" %3d", a[fila][col]);
}
}
int SumaDiagonal(int a[][ncol],int ne)
{
int fila, col, suma=0;
for (fila=0;fila<ne;fila++)
for (col=0;col<ne;col++)
if (fila==col)suma=suma+ a[fila][col];
return suma;
}
int SumaMatrizSuperior(int a[][ncol],int ne)
{
int fila, col,suma=0;
for (fila=0;fila<ne;fila++)
for (col=0;col<ne;col++)
if (col>fila)suma=suma+ a[fila][col];
return suma;
}
int SumaMatrizInferior(int a[][ncol],int ne)
{
int fila, col,suma=0;
for (fila=0;fila<ne;fila++)
for (col=0;col<ne;col++)
if (col<fila)suma=suma+ a[fila][col];
return suma;
}

- 326 -

Problema C514 Se tiene ingresado las repuestas
claves de un examen de ingreso ,elaborar un
programa que permita ingresar el cdigo de
postulante y sus respuestas y luego calificar como se
muestra en el figura. Modificar el programa para
sacar el ranking

#include<conio.h>
#include<stdio.h>
const int Maxfilas=20, Maxcol=20;
void Ingresar(char c[][10],char R[][Maxcol], int np,int
nr);
void Mostrar(char c[][10],char R[][Maxcol], int np,int
nr);
void AsignarNombre(char a[],char b[] );
void Calificar(char c[][10],char R[][Maxcol],char
claves[],int np,int nr);
int main(int argc, char **argv)
{char claves[Maxcol]={'A', 'B','C','D','E'};
int nf=3, nr=5;
char Codigos[Maxfilas][10];
char Respuestas[Maxfilas][Maxcol];
printf("\n ingresos de codigos y respuestas ");
Ingresar(Codigos,Respuestas,nf, nr);
printf("\n Los datos ingresados son");
Mostrar(Codigos,Respuestas,nf, nr);
printf("\n Los PUNTAJES OBTENIDOS SON son");
Calificar(Codigos,Respuestas, claves,nf, nr);
getch();
}
void Ingresar(char c[][10],char R[][Maxcol], int np,int
nr)
{ int fila,col;
char nombre[10];
char car;
for(fila=0;fila<np;fila++)
{
printf("\n ingrese Codigo postulante %d ",fila);
scanf("%s",&nombre);
AsignarNombre(nombre,c[fila] );
for(col=0;col<nr;col++)
{ printf("\n ingrese Respuesta %d ", col);
car=getche(); // scanf("%c\n",&car);
R[fila][col]=car;
}
}
}
void Mostrar(char c[][10],char R[][Maxcol], int np,int
nr)
{ int fila,col;
for(fila=0;fila<np;fila++)
{ printf("\n %d %10s ",fila, c[fila]);
for(col=0;col<nr;col++)
printf(" %4c",R[fila][col]);
}
}
void AsignarNombre(char a[],char b[] )
{ int i;
for (i=0;a[i]!='\0';i++)
b[i]=a[i];
b[i]='\0';
}
void Calificar(char c[][10],char R[][Maxcol], char
claves[],int np,int nr)
{ int fila,col;
char nombre[10]; char car;
int suma;
for(fila=0;fila<np;fila++)
{ printf("\n %10s",c[fila]);
suma=0;
for(col=0;col<nr;col++)
if (R[fila][col]==claves[col])suma++;
printf(" %10d",suma);
}
}



Ejercicios mover un ser en forma
aleatoria

- 327 -


#include <conio.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include "e:\datos\milib.h"
const int maxcol = 10;
struct punto
{ int nro,color;
char caracter;
float x,y ;
};
punto A[maxcol];
void ImprimirSer(punto A[],int n);
float distancia(float x1,float y1, float x2,
float y2);
int main()
{ int n =8, colgana,filagana,fila,col;
float x1 ,y1,x2,y2,menor ,d;
A[0].x = 12 ; A[0].y = 10 ; A[0].color = 9 ;
A[0].caracter = 219;
A[1].x = 11 ; A[1].y = 10 ; A[1].color = 10 ;
A[1].caracter = 219;
A[2].x = 10 ; A[2].y = 10 ; A[2].color = 12 ;
A[2].caracter = 219;
A[3].x = 9 ; A[3].y = 10 ; A[3].color = 13 ;
A[3].caracter = 219;
A[4].x = 8 ; A[4].y = 10 ; A[4].color = 14 ;
A[4].caracter = 177;
A[5].x = 7 ; A[5].y = 10 ; A[5].color = 15 ;
A[5].caracter = 178;
A[6].x = 6 ; A[6].y = 10 ; A[6].color = 11 ;
A[6].caracter = 177;
A[7].x = 5 ; A[7].y = 10 ; A[7].color = 7 ;
A[7].caracter = 220;
ImprimirSer(A, n);
srand( (unsigned)time( NULL ) );
x1 = A[0].x;
y1 = A[0].y;
while( !_kbhit() )
{ x2 = rand()%78 + 2;
y2 = rand()%23 + 2;
menor = 1000;
while (menor > 1)
{ clrscr();
gotoxy(x2,y2); printf("*");
for (fila = y1 - 1;fila<= y1 +
1;fila++)
for( col = x1 - 1;col<= x1 + 1;col++)
{ if( fila == y1 && col == x1)
continue;
else
{ d = distancia(col, fila, x2, y2);
if (d < menor)
{ menor = d;
filagana = fila;
colgana = col;
}
} // del else
} // for interno
x1 = colgana;
y1 = filagana;
// ' modificamos el ser
for (fila = n - 1 ;fila>0;fila--)
{ A[fila].x = A[fila - 1].x;
A[fila].y = A[fila - 1].y;
}
A[0].x = x1;
A[0].y = y1;
ImprimirSer(A, n);
//getch();
Sleep(50);
} // while externo
x1 = x2;
y1 = y2;
} // while interno
getch();
}
void ImprimirSer(punto A[],int n)
{ int fila;
for (fila = 0;fila<n;fila++)
{ textcolor(0,A[fila].color );
gotoxy(A[fila].x,A[fila].y);
printf("%c",A[fila].caracter );
}
}
float distancia(float x1,float y1, float x2,
float y2)
{ return sqrt(pow(x2-x1,2)+pow(y2-y1,2));
}


5.12 PROBLEMAS PROPUESTOS

1. Se tiene dos vectores A y B de la misma
dimensin, se pide elaborar un programa en C
que realice las siguientes operaciones:
a) Sume los vectores A y B. b) Multiplique el
vector A por un escalar.
c) Invierta el vector B. d) Encontrar los
elementos comunes ambos vectores.
2. En el programa de burbuja de asteriscos, los
asteriscos mover de arriba abajo, de izquierda a
derecha, de derecha a izquierda, que se crucen,
etc
3. a) Ingresar n nmeros a un vector b) Listar los
nmeros ingresado c) Encontrar el menor de los
nmeros ingresados y en que lugar se encuentra
d) cuantos nmeros impares hay
4. Usando funciones realizar en modo grafico una
copa de vino (rojo) una copa de gaseosa
(verde), y uno de agua (azul)
5. En una clase hay n alumnos las notas de 0 a 20
encontrar la frecuencia de las notas y la moda
6. Se tiene dos matrices cuadradas A y B se pide:
a) Sumar las dos matrices. b) Restar la matriz
B de la Matriz A.
d) Multiplicar la matriz B por un escalar k; d)
Invertir la matriz B
- 328 -
7. Elaborar men de pilas y colas usando funciones
8. Se tiene un vector de n elementos. Elimine los
elementos repetidos del vector, al final en el
vector solo deben quedar los elementos
diferentes.
9 Usando funciones resuelva
a) Ingresar n datos a un vector b)
visualiza los datos ingresados
c) Insertar en el vector un elemento dado en un
lugar especificado para ello use una funcin de la
forma: Insertar(a, elem, lugar, n);
donde a: Es el nombre del vector donde se quiere
insertar
elem.- Es el elemento que queremos insertar
Lugar.- En que lugar queremos insertar
n.- Cuantos elementos tiene el vector
10 Se tiene una matriz de F filas y c columnas (Ej. 5
filas por 5 columnas) que representa la
disposicin de los asientos en una funcin de un
cine donde 1 significa asiento ocupado y ) asiento
vaco se pide:
a) Rellenar la matriz con ceros y unos en forma
aleatoria.
b) Visualizar la matriz.
c) En que fila hay ms personas.
d) En que columna hay menos persona.
e) Cantidad total de personas que asistieron al
cine.
f) Si cada boleto de cine cuesta 2 soles las 10
primeras filas y un sol las restantes cuanto
fue la recaudacin final.
g) La persona de la fila m y columna n por
cuantos personas esta rodeado.
11. Se ingresa el nmero de preguntas clave y sus
correspondientes respuesta, luego se ingresa las
preguntas contestadas por cada estudiante, si la
respuesta del estudiante coincide con la pregunta
clave se agrega dos puntos para el alumno y nada
en caso contrario, al final deber listar los
nombres de los estudiantes con su respectivo
puntaje en orden descendente.
12. Calcular el cuadro de requerimientos totales de
materiales dado la matriz de requerimientos
unitarios (diagrama de Gozinto) La matriz de
requerimientos totales se calcula por la formula ;
MR = I+ N
2
+ N
3
+ ... N
n-1
. Donde:
MR = Matriz de requerimientos totales.
I = Matriz de identidad.
N = Matriz de requerimientos unitarios
n = Niveles de rbol de Gozinto.
N, I y MR son matrices cuadradas de A*A, A es el
Nmero de elementos de la
matriz.
13.- Usando vectores elaborar el juego de 3 en raya.
14. rea para estimar la superficie de un estanque
se han realizado las medidas que muestra la figura.
Estimar esa superficie mediante a) la regla de los
trapecios b) la regla de Simpson c) si se quiere
determinar la cantidad de agua que hay en el
estanque como se debera medir las profundidades y
con esas medidas como determinar el volumen
(cantidad de agua que hay en el estanque)

15. Estimar con la regla de los trapecios el nmero de
metros cuadrados de tierra en un campo como el
de la figura, con x e y medidos en metros. El
campo est acotado por un rio y dos caminos
rectos perpendiculares


16 Un delineante tiene que determinar la cantidad de
material requerida para fabricar una pieza de una
mquina (vase figura). La tabla recoge en
centmetros, los dimetros de la pieza en puntos
uniformemente espaciados entre s.










17. para tomar las
dimensiones de un terreno
se tomo las siguientes
coordenadas de acuerdo a
un punto de referencia

a) Calcular el rea del terreno ( use regla
trapecial o Simpson)
b) Calcule el permetro del terreno
c) Calcular el rea del terreno por el mtodo de
triangulacin para ello use la frmula de
Hern.
Donde
p = (a + b + c)
d) Encuentre el
centroide del terreno
e) Ubique un punto de tal manera que las
distancia de ese punto a los vrtices se la
mnima
f) Una toma de agua se encuentra en el punto
(8,7) en que parte de las aristas de triangulo
se debe hacer el canal de tal manera que la
distancia sea mnima.
g) Cul es la distancia mxima entre dos
vrtices
h) Cul es la distancia mxima entre el punto
de referencia y un vrtice
i) Que vrtices tiene la menor distancia.
j) Cambie los puntos (ej. n=10) y vea los
resultados

18.- suponiendo que la
distancia sea en km y
teniendo los mismos
puntos que representan
poblaciones cuyos
valores son

Punto X Y w
1 1 2 5000
2 5 1 2000
3 12 3 4000
4 10 5 3000
5 4 6 8000
- 329 -

a) Se desea intalar un centro de salud para atender
a esas poblaciones en que lugar se debe instalar
el centro ( coordinadas x,y)
b) Sabiendo que un centro de salud no se puede
intalar en cualquier lugar si no solamante en
poblacion en que pueblo se debe localizar el
centro de salud ( use distancia rectelinea)
c) Si desea instalar dos centros de salud cuales
serian sus coordinadas
d) Pruebe su programa para muchas poblaciones
ej. N=10

18. Determine el centro de masa del sistema de
cuatro partculas cuyas masas tienen medidas de
2,6,4,1 y las cuales se ubican en los puntos (5,-2),(-
2,1), (0,3) y (4,-1) ,respectivamente

Solucin de acuerdo al libro Calculo con geometra
de Leithold)

Conclusin: El centro de masa se encuentra en
(2/13,1)
Resuelva este problema con lenguaje C

19 Un producto pasa por 3 etapas (armado = 10
minutos, soldado = 20 minutos, terminado 10
minutos) .elaborar un programa donde se
muestre el estado de cada producto en la forma
que si indica. Modifique el programa para otras
situaciones

20 .El estanque de la figura es aproximadamente
circular , con un dimetro de 400 pies ,
partiendo de su centro se ha medido su
profundidad cada 25 pies , la tabla da cuenta de
los resultados

X 0 25 50 75 100 125 150 175 200
Profundidad 20 19 19 17 15 14 10 6 0

a) Estimar su volumen mediante la regla de
Simpson ( use el mtodo del disco o el de
las capas)
b) Con el resultado de a) aproximar cuntos
galones de agua contiene el estanque (1 pie
cbico = 7.48 galones)


21.- Se tiene un vector con los nombres del cdigo
de los productos y otro vector con los nombres
de los productos, y un tercer vector el precio
unitario de cada producto
a) buscar por el cdigo del producto
b) Buscar por el nombre del producto
c) Listar Todos los productos
d) Listar aquellos productos cuyo precio
unitario sea mayor que una cantidad
determinada (*)
e) se ingresar N nmeros de ventas de di, En
cada venta se ingresa cdigo (de los
cdigo existentes) y la cantidad vendida
La computadora debe listar los dems datos y
elaborar la venta total
22. Una tienda vende un determinado tipo de
producto y cada da puede vender
aleatoriamente de 0 a 10 productos, el
propietario hace pedidos de 10 unidades a un
costo de 50 soles, apenas se acaban los
productos en almacn, si los productos no se
venden en el da se guardan para el da
siguiente en el almacn a un costo de 1 sol por
producto, la utilidad de cada producto es 5
soles, el costo unitario(del producto) es de 10
soles y el precio de Venta de 20 soles, se desea
saber cunto gasta el propietario en costo de
mantenimiento (guardar en el almacn), costo
de aprovisionamiento(pedido) y el costo de
escasez ( cuanto no hay productos para vender
) y el costo total de inventarios que es la suma
de las anteriores , la simulacin debe hacerse
para un mes (*)

23 Una empresa tiene n almacenes y m productos
se tiene una ,matriz de m filas (almacenes ) m
columnas ( productos) se desea saber
a) Imprimir la matriz
b) En que Almacenes y para que productos ya no
existe inventario
c) Dado un almacn se desea saber cuntos
producto hay en ese almacn
d) Se toma en cuenta que existe 10 tipos de
producto y el costo es proporcional al tipo de
producto, que Almacn tiene mayor valoracin
e) Si deseo saber un tipo de producto cualquiera
programar que a la computadora diga en que
almacenes se encuentra ese productos ( en
cantidades ) y cul es la cantidad total
f) Se sabe el costo de traslado unitario de cada
almacn a la fabrica y se necesita r productos de
que almacn se debe traer los productos (*)
24. La tasa de crecimiento de la poblacin de cierta
comunidad es proporcional a la poblacin. En 1970 la
poblacin fue de 50 000 y en el 2000 fue de 75 000
a) si Y es la poblacin t aos a partir de 1970,a)
elabore una tabla de la poblacin de los aos 1970
hasta 2010 b) grafique la funcin c) confirme
analticamente la estimacin del inciso b

Preguntas y respuestas

1. puedo usar las funciones de Microsoft Excel
para realizar clculos de vectores y matrices
La hoja de clculo se considera como una matriz de
256 filas 65536 filas por 256 columnas se puede
programar con la funcin en visual Basic , para ello
use Herramientas /macro /editor de Visual Basic

JUEGO DE AJEDREZ
1. Se conoce la fila y columna donde se encuantra
ubicado el caballo en un tablero de ajedrez ,
- 330 -
mostrar todos los posibles movimientos del
caballo en el tablero

#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <math.h>
#include "e:\datos\milib.h"
bool validarcaballo(int x1, int y1, int x2, int y2)
{ if ((abs (x2-x1)==2 && abs(y2-y1)==1) ||
(abs(x2-x1)==1 && abs(y2-y1)==2)) return true ; else
return false;
}
void iniciar (int A[][8]);
void MovCaballo( int A[][8],int px, int py);
void cuadro(int ,int ,int ,int ); // prototipo
void main(void)
{ int A[8][8];
clrscr();
int fila,col, cx=1,
cy=1,ancho=3,alto=3,color=15,px=4,py=3;
iniciar(A);
MovCaballo(A,px,py);
A[py][px]=51; // para que salga esl 3 que es cdigo
del caballo
for (fila=0;fila<8;fila++)
for (col=0;col<8;col++)
{ if ((fila+col)% 2==0)color=64+128;else
color=16+128;
textcolor(color,15);
cuadro(cx+col*ancho,cy+fila*alto,ancho,alto);
gotoxy(cx+col*ancho+1,cy+fila*alto+1);
printf("%c",A[fila][col]);
}
getch();
}
void iniciar (int A[][8])
{ int fila,col;
for (fila=0;fila<8;fila++)
for (col=0;col<8;col++)
A[fila][col]=0;
}
void cuadro(int cx,int cy , int ancho, int alto)
{ int fila, col;
for (fila=0;fila<alto;fila++)
for (col=0;col<ancho;col++)
{ gotoxy(cx+col,cy+fila);
printf(" ");
}
}
void MovCaballo( int A[][8],int px, int py)
{ int fila,col;
for (fila=0;fila<8;fila++)
for (col=0;col<8;col++)
{ if (validarcaballo(col,fila,px,py) ==true )
A[fila][col]=1; else A[fila][col]= 0;
}
}
Realice las mismas acciones para las demas piezas

TRABAJO DE INVESTIGACION PROGRAMA
MUEVE ESCENAS

Usando arreglos ya se puede crear animacion en el
siguiene ejercicio
Se disea el fondo del paisaje en este caso el mar
con sus nubes y se almacena en una matriz en este
caso de 24x 80
En la matriz BARCO se almacena la imagen del
barco que en este caso tiene dimensiones de 10 x
17
En el plano tres llamado SOMBRILLA se almacena
la imgen 3
El barco debe mover por detrs de la sombrilla y por
delante de mar



#include<windows.h>
#include<conio.h>
#include <stdio.h>
#include "e:\datos\milib.h"
const int nf1=24, nc1=80;



















const int nf2=10, nc2=17;
const int nf3=24, nc3=18;
int MAR[nf1][nc1]; //mar 1 incluye la nube
int BARCO[nf1][nc1]; // barco 1
int SOMBRILLA[nf1][nc1]; // sombrilla

void MostrarColor ( int a1[nf1][nc1],int cx, int cy,int nf,
int nc, int plano);
void recuperar ( int a1[nf1][nc1],int nf, int nc, int
plano);
int main()
{
int nfilas1=24,ncol1=80;
int nfilas2=10,ncol2=17;
int nfilas3=23,ncol3=16;
int plano1=1,plano2=2,plano3=3,i,pasox=3;
int limite=64,contador;
recuperar(MAR,nfilas1,ncol1,plano1); // recuepra
escena 1 mar fijo
recuperar(BARCO,nfilas2,ncol2,plano2); // recupera
escena 2 barco mueve
recuperar(SOMBRILLA,nfilas3,ncol3,plano3); //
recupera escena 2 sombrilla fijo
MostrarColor (MAR,1,1,nfilas1,ncol1,plano1); //
muestra la escena 1 mar
MostrarColor (BARCO,1,3,nfilas2,ncol2,plano2); //
muestra la escena 2 barco
- 331 -
MostrarColor
(SOMBRILLA,23,1,nfilas3,ncol3,plano3); // muestra la
escena 3 sombrilla

getch();
while(!_kbhit())
{
for (i=1; i<limite;i=i+pasox)
{
MostrarColor (MAR,1,1,nfilas1,ncol1,plano1); //
muestra la escena 1 mar
MostrarColor (BARCO,i,3,nfilas2,ncol2,plano2); //
muestra la escena 2 movible
MostrarColor
(SOMBRILLA,23,1,nfilas3,ncol3,plano3); // muestra la
escena 3 sombrilla fijo
Sleep(20);
}
}
getch();
return 0;
}
void MostrarColor( int a1[nf1][nc1], int cx, int cy,int nf,
int nc, int plano)
{ int f,c;
for (f=0;f<nf;f++)
for (c=0;c<nc;c++)
if (a1[f][c]<=15)
{ textcolor(0,a1[f][c]);
gotoxy(cx-
1+c,cy+f);
printf("%c",219);
}
}
void recuperar ( int a1[nf1][nc1],int nf, int nc, int
plano)
{FILE *p;
int fila,col, nro,n;
switch (plano)
{ case 1: p=fopen("E:\\datos\\MAR1.txt","r"); break;
case 2: p=fopen("E:\\datos\\BARCO1.txt","r");
break;
case 3:
p=fopen("E:\\datos\\SOMBRILLA1.txt","r"); break;
}
for (fila =0;fila<nf; fila++)
for (col=0;col<nc;col++)
{ fscanf(p,"%d",&nro);
a1[fila][col]=nro;
}
fclose(p);
}

Nota el programa es muy lento para hacerlo rpido
Use Opengl
Ver pagina 888 capitulo 15 opengl del libro para ver la
aplicacin
Mover el barquito de la capitulo 5
El barco se mueve con clic izquierdo y se detiene con
clic derecho



TRABAJOS DE INVESTIGACION
1. Hacer un juego donde se mueve el fondo de
la pantalla por ejemplo carrera de autos

Calendario

#include <conio.h>
#include <stdio.h>
int main()
{ char *dsem[7]={"D","L","M","M","J","V","S"};
int dia =28,ds=6,ndias=31, i;
printf("\n ingrese la fecha del mes ");
scanf("%d",&dia);
printf("\n ingrese dia de la semana de 0 a 6");
scanf("%d",&ds);
printf("\n ingrese dias que tiene el mes ");
scanf("%d",&ndias);
// dias anteriores
int vdias[31],vdiasem[31];
for(i=dia;i>0;i--)
{ vdias[i]=i;
vdiasem[i]=ds;
if (ds>0) ds--;else ds=6;
}
// dias posteriores
for(i=dia;i<=ndias;i++)
{ vdias[i]=i;
vdiasem[i]=ds;
if (ds<6) ds++;else ds=0;
}
//
for (i=0;i<7;i++)
printf("%5s",dsem[i]);
printf("\n");
for (i=1;i<=ndias;i++)
{
printf("%5d",vdias[i]);
if (i % 7 ==0) printf("\n");
}
getch();
}
- 332 -


1. SIMETRIAS mostrar las 4 simitrias

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
const int Nfilas=24, Ncol=80;

int A[Nfilas][Ncol];
int B[Nfilas][Ncol];

void RecuperarMatriz( int A[][Ncol], int nf, int nc)
{ int fila, col;
FILE *p;
p= fopen("E:\\DATOS\\Matriz10x10.TXT","r");
for ( fila=0;fila<nf; fila++)
for ( col=0;col<nc; col++)
fscanf(p,"%d",&A[fila][col]);
fclose(p);
}
void Izquierda (int A[][Ncol], int B[][Ncol], int nf, int nc)
{ int fila, col;
for ( fila=0;fila<nf; fila++)
for ( col=0;col<nc; col++)
B[fila][col]=A[fila][nc-1-col];

}
void transpuesta (int A[][Ncol], int B[][Ncol], int nf, int
nc)
{ int fila, col;
for ( fila=0;fila<nf; fila++)
for ( col=0;col<nc; col++)
B[fila][col]=A[col][fila];
}

void Inversa (int A[][Ncol], int B[][Ncol], int nf, int nc)
{ int fila, col;
for ( fila=0;fila<nf; fila++)
for ( col=0;col<nc; col++)
B[fila][col]=A[nf-1-fila][col];
}
void Inversa2 (int A[][Ncol], int B[][Ncol], int nf, int nc)
{ int fila, col;
for ( fila=0;fila<nf; fila++)
for ( col=0;col<nc; col++)
B[fila][col]=A[nf-1-fila][nc-1-col];
}
void MostrarMatriz (int A[][Ncol], int nf, int nc)
{ int fila, col;
for ( fila=0;fila<nf; fila++)
{ printf("\n");
for (
col=0;col<nc; col++)
printf("%3d",A[fila][col]);
}
}

int main()
{ int nf=5, nc=5;
RecuperarMatriz(A, nf, nc);
MostrarMatriz (A,nf,nc);
// imprimer las 4 simetrias
printf("\n izquierda");

Izquierda(A,B,nf,nc);
MostrarMatriz (B,nf,nc);
printf("\n transpuesta");
transpuesta (A,B,nf,nc);
MostrarMatriz (B,nf,nc);
printf("\n inversa");
Inversa (A,B,nf,nc);

MostrarMatriz (B,nf,nc);
printf("\n Inversa2");
Inversa2 (A,B,nf,nc);
MostrarMatriz (B,nf,nc);
getch();
}

2. Aplicaciones de arreglos con
recursividad

- 333 -


const int maxcol=40, maxfilas=24;
int A[maxfilas][maxcol];
int nf=24,nc=40;
void impar (int cx,int cy, int cont,int ne);
void par (int cx,int cy, int cont, int ne);
void IniciarMatriz(int A[][maxcol], int nf, int nc)
{int fila,col;
for (fila=0;fila<nf; fila++)
for (col=0;col<nc;col++)
A[fila][col]=0;
}
void MostrarMatriz(int A[][maxcol], int nf, int nc)
{int fila,col;
for (fila=0;fila<nf; fila++)
for (col=0;col<nc;col++)
{ gotoxy(col,fila);
if (A[fila][col]>0 )
{textcolor(0,A[fila][col]);
printf("%d",A[fila][col]);
}
}
}
void par (int cx,int cy, int cont, int ne)
{ textcolor(0,cont);
if (A[cy][cx] <=0) A[cy][cx]=cont;
if ( A[cy][cx]<= 0) A[cy][cx]= cont;
MostrarMatriz(A,nf,nc);
if (cont< ne)
{ impar(cx, cy-1,cont+1,ne);
impar(cx,cy+1,cont+1,ne);
}
}
void impar (int cx,int cy, int cont,int ne)
{textcolor(0,cont);
if (A[cy][cx] <=0) A[cy][cx]=cont;
if ( A[cy][cx]<= 0) A[cy][cx]= cont;
MostrarMatriz(A,nf,nc);
if (cont<ne)
{par(cx-1,cy,cont+1,ne);
par(cx+1,cy,cont+1,ne);
}
}
3. crecimiento

#include <conio.h>
#include <stdio.h>
#include "E:\datos\milib.h"
int const maxfilas=32,maxcol=40;
int F[maxfilas][maxcol];
void IniciarMatriz(int A[][maxcol], int nf, int nc);
void MostrarMatriz(int cx, int cy,int F[][maxcol], int nf,
int nc);
void CopiarMatriz(int A[][maxcol], int B[][maxcol],int nf,
int nc)
{ int fila,col;
for (fila=0;fila<nf; fila++)
for (col=0;col<nc;col++)
B[fila][col]=A[fila][col];
}
void Crecer( int F[][maxcol], int &nf, int &nc)
{ int B[maxfilas][maxcol];
int fila, col,cf=0, cc=0;
for (fila=0;fila<nf; fila++)
{ cc=0;
for (col=0;col<nc;col++)
{ B[cf][cc++]=F[fila][col];
B[cf][cc++]=F[fila][col];}
cf++; cc=0;
for (col=0;col<nc;col++){
B[cf][cc++]=F[fila][col]; B[cf][cc++]=F[fila][col];}
cf++;
}
nf=cf; nc=cc;
CopiarMatriz(B,F, nf, nc);
}

int main()
{ int F[maxfilas][maxcol];
int cx=20, cy=2,cont=1,ne=3,nf=2,nc=2;
IniciarMatriz(F,maxfilas,maxcol);
F[0][0]=1; F[0][1]=2;
F[1][0]=3; F[1][1]=4;
for (cont=0; cont<ne; cont++)
{MostrarMatriz(cx,cy,F,nf,nc);
Sleep(200);
Crecer(F,nf,nc);
MostrarMatriz(cx,cy,F,nf,nc);
}
getch();
}
void IniciarMatriz(int A[][maxcol], int nf, int nc)
{int fila,col;
for (fila=0;fila<nf; fila++)
for (col=0;col<nc;col++)
A[fila][col]=0;
}
void MostrarMatriz(int cx, int cy,int F[][maxcol], int nf,
int nc)
{int fila,col;
for (fila=0;fila<nf; fila++)
for (col=0;col<nc;col++)
{ gotoxy(cx+col,cy+fila);
if (F[fila][col]>0 )
{ textcolor(0,F[fila][col]);
printf("%d",F[fila][col]);
}
}
}
4. Permutaciones
- 334 -



const int maxfilas=1000; // cantidad de permutaciones
const int maxcol=10; // cantidad de elementos a
combinar poner hasta 7
int ne=3; //nro elementos que se va a permutar
int contador =0; // variable global usado en
recusividad
int A[maxfilas][maxcol];// matriz para pruebas
int tcombi=0; //total de combinaciones
void ImpMatrizEntera(int A[][maxcol], int nf,int nc)
{ int fila,col;
for ( fila=0;fila<nf;fila++)
{printf("\n fila %2d ==>",fila );
for (col=0;col<nc;col++)
printf("%2d",A[fila][col]);
}
}

void permutaciones(int A[][maxcol], int B[],int B1[],int
n,int ncam, int ne )
{ int i,k;
if (n>0)
{for (k=0;k<ncam;k++)
{ B[n]=B1[k];
permutaciones(A,B,B1,n-1,ncam,
ne);
}
}
else
{ for (k=0;k<ncam;k++)
{ B[n]=B1[k];
for (i=0;i<=ne;i++)
A[contador][i]= B[i];
contador++;
}
}
}

void permutacionesSR(int A[][maxcol], int B[],int
B1[],int n,int ncam, int ne )
{ int i,j,k,valor=0;
if (n>0)
{for (k=0;k<ncam;k++)
{ B[n]=B1[k];
permutacionesSR(A,B,B1,n-
1,ncam, ne);
}
}
else
{ for (k=0;k<ncam;k++)
{ B[n]=B1[k];
valor=1;
for ( i=0; i<ne; i++)
for (j=i+1;j<=ne; j++)
if (B[i]==B[j]){ valor =0;
break;};
if (valor==1)
{ for (i=0;i<=ne;i++)
A[contador][i]= B[i];
contador++;
}
}
}
}


Ejercicio 5. Programar un algoritmo recursivo que
permita sumar los elementos de un vector

#include <conio.h>
#include <stdio.h>
const int maxcol=20;
int suma_vec(int v [], int n)
{ if (n == 0)
return v [n];
else
return suma_vec(v, n - 1) + v [n];
}
int main()
{ int V[maxcol]={1,2,3,4,5,6,7,8,9};
int n=4;
printf("\n la suma de los elementos del vector de 1 a
%d es %d", n, suma_vec(V,n));
getch();
}

Ejercicio 6. Programar un algoritmo recursivo que
permita multiplicar los elementos de un vector

#include <conio.h>
#include <stdio.h>
const int maxcol=20;
int multiplicar (int vec [], int tam)
{ if (tam == 0) return (vec [0]);
return (vec [tam] * multiplicar (vec, tam -
1));
}
int main()
{ int V[maxcol]={1,2,3,4,5,6,7,8,9};
int n=4;
printf("\n la suma de los elementos del vector de 1 a
%d es %d", n, multiplicar(V,n));
getch();
}
- 335 -
Ejercicio 7. Programar un algoritmo recursivo que
permita sumar los elementos de una matriz.

#include <conio.h>
#include <stdio.h>
const int maxcol =3;
int suma (int fila, int col, int orden, int mat []
[maxcol])
{
if (fila == 0 && col == 0)
return mat [0] [0];
else
if (col < 0)
return suma (fila - 1, orden, orden,
mat);
else
return mat [fila] [col] + suma (fila,
col - 1, orden, mat);
}
int main()
{ int n=3;
int A[maxcol][maxcol]={{1,2,3},{4,5,6},{7,8,9}};
printf("\n la suma de los elementos de la matriz es
%d", suma(n-1,n-1,n-1,A));
getch();
}

Ejercicio 8. Programar un algoritmo recursivo que
permita resolver el cuadro latino. Ejemplo de cuadro
latino:

0 0 0 0 1
0 0 0 1 2
0 0 1 2 3
0 1 2 3 4
1 2 3 4 5

#include <conio.h>
#include <stdio.h>
const int maxcol =6;
void Iniciar(int A[][maxcol], int nf, int nc)
{ int fila, col;
for ( fila=0; fila<nf;fila++)
for (col=0;col<nc;col++)
A[fila][col]=0;
}

void Imprimir(int A[][maxcol], int nf, int nc)
{ int fila, col;
for ( fila=0; fila<nf;fila++)
{ printf("\n");
for (col=0;col<nc;col++)
printf("%d ", A[fila][col]);
}
}
void latino (int fila, int col, int cont, int orden, int
mat [] [maxcol])
{
if (fila == 0 && col == 0)
mat [0] [0] = 1;
else
if (fila == col)
latino (fila - 1, orden - 1, orden,
orden, mat);
else
{
mat [fila] [col] = cont;
latino (fila, col - 1, orden + 1,
orden, mat);
}
}

int main()
{ int n=5;
int A[maxcol][maxcol];
Iniciar(A,n+1,n+1);

latino (n,n,1,n,A);
Imprimir(A,n,n);
getch();
}

Ejercicio 9. Programar un algoritmo recursivo que
ejecute la matriz del cubo mgico.

#include <conio.h>
#include <stdio.h>
const int maxcol =8;
void Iniciar(int A[][maxcol], int nf, int nc)
{ int fila, col;
for ( fila=0; fila<nf;fila++)
for (col=0;col<nc;col++)
A[fila][col]=0;
}

void Imprimir(int A[][maxcol], int nf, int nc)
{ int fila, col;
for ( fila=0; fila<nf;fila++)
{ printf("\n");
for (col=0;col<nc;col++)
printf("%3d ", A[fila][col]);
}
}

void magico(int mat [] [maxcol], int fil, int
colmedio, int c, int n)
{
if (c == n * n)
{
mat [n-1] [colmedio] = c;
}
else
{
if (fil < 0 && colmedio == n)
{
magico(mat, fil + 2, n - 1, c, n);
}
else
{
- 336 -
if (fil < 0)
{
magico(mat, n - 1, colmedio, c,
n);
}
else
{
if (colmedio == n)
{
magico(mat, fil, 0, c, n);
}
else
{
if (mat [fil] [colmedio] ==
0)
{
mat [fil] [colmedio] = c;
magico(mat, fil - 1,
colmedio + 1, c + 1, n);
}
else
{
magico(mat, fil + 2,
colmedio - 1, c, n);
}
}
}
}
}
}
int main()
{ int n=5;
int A[maxcol][maxcol];
Iniciar(A,n+1,n+1);
magico(A,2,2,n,n);
Imprimir(A,n,n);
getch();
}

Ejercicio 11. Programar un algoritmo recursivo que
muestre el numero menor de un vector.

#include <conio.h>
#include <stdio.h>
const int maxcol =8;
int menorvec (int x [], int n, int menor)
{
if (n == 0)
if (menor > x [n]) return x [0];
else return menor;
else
if (menor > x [n]) return menorvec (x, n - 1, x
[n]);
else return menorvec (x, n - 1, menor);
}

int main()
{ int n=5,menor=1000;
int V[maxcol]={20,4,7,4,3,15,16};
printf("\n el menor elemento del vector es %d",
menorvec(V, n, menor));
getch();
}

Ejercicio 12. Programar un algoritmo recursivo que
muestre el numero mayor de un vector.

#include <conio.h>
#include <stdio.h>
const int maxcol =8;
int mayor (int numeros [], int posicion)
{
int aux;
if (posicion == 0) return numeros [posicion];
else {
aux = mayor (numeros, posicion - 1);
if (numeros [posicion] > aux) return numeros
[posicion];
else return mayor (numeros, posicion - 1);
}
}
int main()
{ int n=5, V[maxcol]={20,4,75,4,3,15,16};
printf("\n el numero mayor del vector es %d",
mayor(V, n));
getch();
}





- 337 -
// ********** calculos.h
void IniciarMatriz (int A[][ncol], int nf, int nc)
{ int fila ,col;
for (fila=0; fila<nf; fila++)
for (col=0;col<nc;col++)
A[fila][col]=0;
}
void ImprimirEnPantalla(int x,int y,int z, int modo)
{ gotoxy(x,y);
if (modo==1){ textcolor(0,z); printf("*");}
else { textcolor(0,z); printf(" ");}
}
void ImprimirEnMatriz(int x, int y,int modo , int
Matriz[][ncol])
{ Matriz[y][x]=modo;}

float distancia( float x1,float y1, float x2, float y2)
{ return sqrt(pow((x2-x1),2)+pow((y2-y1),2)) ;
}
void modificar ( int &x1, int &y1, int x2, int y2, float
&dmenor, int A[][ncol])
{ int xmenor=x1, ymenor=y1,x,y;
int lix, lsx, liy,lsy;
float d=1;
if (x1>=xmin)lix=x1-1; else lix=x1;
if (x1<=xmax)lsx=x1+1; else lsx=x1;
if (y1>=ymin)liy=y1-1; else liy=y1;
if (y2<=ymax)lsy=y1+1; else lsy=y1;
for (x=lix; x<=lsx;x++)
for (y=liy;y<=lsy;y++)
{ if (x==y) continue;
if (A[y][x]==0)
{ d= distancia(
x,y,x2,y2);
if (d<dmenor) { dmenor=d;
xmenor = x, ymenor=y;}
}
}
x1=xmenor;
y1=ymenor;
}


#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
#include <time.h>
#include "E:\datos\milib.h"
int xmin=3, ymin=3, xmax=78, ymax=23;
const int nfilas=24, ncol =80;
const int maxcol=102;
#include "calculos.h"
int main()
{ int Matriz[nfilas][ncol], nf=24, nc=80;
int X1[maxcol], Y1[maxcol], Z1[maxcol];
int X2[maxcol], Y2[maxcol], Z2[maxcol];
float D[maxcol];
int np=100,i;
int rx,ry;
IniciarMatriz(Matriz, nf,nc);
// inicializaciones
srand( (unsigned)time( NULL ) );
for (i=0;i<np;i++)
{ X1[i]=1+rand()%(xmax-xmin);
Y1[i]=1+rand()%(ymax-ymin);
Z1[i]=1+rand()%15;
D[i]=1000;
}
int xmenor, ymenor,fin=1;
float d ;
for (i=0;i<np;i++)
{
ImprimirEnPantalla(X1[i],Y1[i],Z1[i],1);
ImprimirEnMatriz(X1[i],Y1[i],1,Matriz);

fin =1;
while(fin==1)
{rx=1+rand()%(xmax-xmin);
ry=1+rand()%(ymax-ymin);
if (Matriz[ry][rx] ==0)
{ X2[i]=rx; Y2[i]=ry; fin=0;
ImprimirEnMatriz(X2[i],Y2[i],1,Matriz);

}
}
}
while (!kbhit())
{ for (i=0;i<np;i++)
{ if (D[i]>1)
{
ImprimirEnPantalla(X1[i],Y1[i],Z1[i],0);
ImprimirEnMatriz(X1[i],Y1[i],0,Matriz);

modificar
(X1[i],Y1[i],X2[i],Y2[i],D[i],Matriz);
ImprimirEnPantalla(X1[i],Y1[i],Z1[i],1);
ImprimirEnMatriz(X1[i],Y1[i],1,Matriz);

//
Sleep(20);
}
else
{
ImprimirEnPantalla(X1[i],Y1[i],Z1[i],0);
ImprimirEnMatriz(X1[i],Y1[i],0,Matriz) ;

//
ImprimirEnPantalla(X2[i],Y2[i],Z1[i],0);
ImprimirEnMatriz(X2[i],Y2[i],0,Matriz);

X1[i]=X2[i];
Y1[i]=Y2[i];

ImprimirEnPantalla(X1[i],Y1[i],Z1[i],1);
ImprimirEnMatriz(X1[i],Y1[i],1,Matriz);

X2[i]=1+rand()%(xmax-xmin);
Y2[i]=1+rand()%(ymax-
ymin);

ImprimirEnMatriz(X2[i],Y2[i],1,Matriz) ;

D[i]=1000;
}
} // del for
}
getch();
}

Movimiento 3d en opengl ver pagina 1042

- 338 -


Mover un ser que tiene varias partes







///******** calculos.h
const int limite=20,longitud=20;
const int maxfilas=24, maxcol=80;
struct punto
{ int nro,longitud, dx,dy;
int X[limite],Y[limite],color[limite];
float dmenor;
};
punto Ser;
int Matriz[maxfilas][maxcol];
float distancia( float x1,float y1, float x2, float y2)
{ return sqrt(pow(x2-x1,2)+pow(y2-y1,2));
}
void IniciarMatriz (int Matriz[][maxcol], int nf, int nc)
{ int fila ,col;
for (fila=0; fila<nf; fila++)
for (col=0;col<nc;col++)
Matriz[fila][col]=0;
}
void MostrarMatriz (int Matriz[][maxcol], int nf, int
nc)
{ int fila ,col;
for (fila=1; fila<nf; fila++)
for (col=1;col<nc;col++)
{ gotoxy(col,fila);
if (Matriz[fila][col]>0) textcolor(0,12); else
textcolor(0,10);
printf("%d",Matriz[fila][col]);
}
}
void IniciarSer(punto &Ser)
{// srand( (unsigned)time( NULL ) );
Ser.nro=1;
Ser.dx =50;
Ser.dy =20;
Ser.longitud =15;
Ser.dmenor=1000;
for ( int col=0;col<Ser.longitud ;col++)
{ Ser.X[col] =40-col;
Ser.Y[col] =12;
Ser.color[col]=col+1;
}
}
void ImprimirSer(punto Ser)
{ printf("\n ser %d i x1
y1 x2,y2, color ",Ser.nro);
for (int i=0;i<Ser.longitud ;i++)
printf("\n %d %d %d %d %d %d
",i,Ser.X[i], Ser.Y[i], Ser.dx, Ser.dy , Ser.color);
}

void MostrarSer(punto Ser, int modo )
{
for ( int col=0;col<Ser.longitud ; col++)
{ gotoxy(Ser.X[col],Ser.Y[col]);
if (modo>0) textcolor(0,Ser.color[col]); else
textcolor(0,0);
printf("%c",219);
}
gotoxy(Ser.X[0],Ser.Y[0]); printf("%d",Ser.nro );
}

void MostrarSerMatriz(punto Ser, int modo , int
Matriz[][maxcol] )
{ int valor;
if (modo>0) valor= 1; else valor =0;
for ( int col=0;col<Ser.longitud ; col++)
Matriz[Ser.Y[col]][Ser.X[col]] =valor;
}

int ModificarSer (punto &Ser, int Matriz[][maxcol])
{ ///1
int xmenor, ymenor, x,y,x1,y1,x2,y2,
resultado=0,largo=0,col;
float d=1, dmenor;
x1=Ser.X[0]; // cabeza
y1=Ser.Y[0];
x2=Ser.dx ;
- 339 -
y2=Ser.dy;
largo=Ser.longitud;
dmenor=Ser.dmenor;
xmenor=x1; ymenor=y1;
for (x=x1-1; x<=x1+1;x++)
for (y=y1-1;y<=y1+1;y++)
{ // 2
if (x==y) continue;
if (Matriz[y][x]==1) continue;
d= distancia(
x,y,x2,y2);
if (d<dmenor)
{ // 3

dmenor=d; xmenor = x, ymenor=y;
resultado=1;
} // 3
} // 2
// pasar los datos a los demas puntos
for (col=largo; col>0;col--)
{ // 2
Ser.X[col]=Ser.X[col-1];
Ser.Y[col]=Ser.Y[col-1];
} // 2

Ser.X[0]=xmenor;
Ser.Y[0]=ymenor;
Ser.dmenor=dmenor;
return resultado;
}


#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include "e:\datos\milib.h"
int xmin=3, ymin=3, xmax=78, ymax=23;
#include "calculos.h"
int main()
{ ///1
int
nro=0,nf=23,nc=78,fin=1,rx,ry,resultado=0;
IniciarMatriz (Matriz,maxfilas,maxcol);
IniciarSer(Ser);
//ImprimirSer(Ser);
MostrarSerMatriz(Ser,1,Matriz );
MostrarSer(Ser,1);
while (!kbhit())
{ /// 2
while (Ser.dmenor >1)
{ ////3
MostrarSerMatriz(Ser,0,Matriz );
MostrarSer(Ser,0);
// MostrarMatriz(Matriz,nf,nc);
resultado=ModificarSer(Ser,Matriz);
// if (resultado >0)
MostrarSer(Ser,1);
MostrarSerMatriz(Ser,1,Matriz );
Sleep(50);
} /// 3
MostrarSerMatriz(Ser,0,Matriz );
MostrarSer(Ser,0 );
for (int col=1; col<Ser.longitud ;col++)
{
Ser.X[col]=Ser.X[col-1];
Ser.Y[col]=Ser.Y[col-1];
} // 2
Ser.X[0]=Ser.dx;
Ser.Y[0]=Ser.dy;
fin =1;
while(fin==1)
{ ////3
rx=1+rand()%(xmax-xmin);
ry=1+rand()%(ymax-ymin);
if (Matriz[ry][rx] ==0)
{Ser.dx=rx; Ser.dy=ry; fin=0; }
} ////3
// modificamos los valores del ser
Ser.dmenor=1000;
MostrarSerMatriz(Ser,1,Matriz );
} // del otro while ///2
getch();
return 0;
} // 1

Varios seres de diferentes colors




// ************* calculos.h
const int limite=21,longitud=21;
const int maxfilas=24, maxcol=80;
struct punto
{ int nro,longitud, color,dx,dy;
int X[limite],Y[limite];
float dmenor;
};
punto Seres[limite];
int Matriz[maxfilas][maxcol];
float distancia( float x1,float y1, float x2, float y2)
{ return sqrt(pow(x2-x1,2)+pow(y2-y1,2));
}
void IniciarMatriz (int Matriz[][maxcol], int nf, int nc)
{ int fila ,col;
for (fila=0; fila<nf; fila++)
for (col=0;col<nc;col++)
Matriz[fila][col]=0;
}
void MostrarMatriz (int Matriz[][maxcol], int nf, int nc)
{ int fila ,col;
for (fila=1; fila<nf; fila++)
- 340 -
for (col=1;col<nc;col++)
{ gotoxy(col,fila);
if (Matriz[fila][col]>0) textcolor(0,12); else
textcolor(0,10);
printf("%d",Matriz[fila][col]);
}
}
void IniciarSer(punto &Ser, int nro)
{// srand( (unsigned)time( NULL ) );
Ser.nro=nro;
Ser.dx=1+rand()%(xmax-xmin);
Ser.dy=1+rand()%(ymax-ymin);
if (nro <8)
Ser.color=8+nro; else Ser.color= nro-7;
Ser.longitud =10;
Ser.dmenor=1000;
for ( int col=0;col<Ser.longitud ;col++)
{ Ser.X[col] =40-col;
Ser.Y[col] =2+nro;
}
}
void ImprimirSer(punto Ser)
{ printf("\n ser %d i x1
y1 x2,y2, color ",Ser.nro);
for (int i=0;i<Ser.longitud ;i++)
printf("\n %d %d %d %d %d %d
",i,Ser.X[i], Ser.Y[i], Ser.dx, Ser.dy , Ser.color);
}

void MostrarSer(punto Ser, int modo )
{ if (modo>0) textcolor(0,Ser.color ); else
textcolor(0,0);
for ( int col=0;col<Ser.longitud ; col++)
{ gotoxy(Ser.X[col],Ser.Y[col]); printf("*");}
gotoxy(Ser.X[0],Ser.Y[0]); printf("%d",Ser.nro );
}

void MostrarSerMatriz(punto Ser, int modo , int
Matriz[][maxcol] )
{ int valor;
if (modo>0) valor= 1; else valor =0;
for ( int col=0;col<Ser.longitud ; col++)
Matriz[Ser.Y[col]][Ser.X[col]] =valor;
}

int ModificarSer (punto &Ser, int Matriz[][maxcol])
{ ///1
int xmenor, ymenor, x,y,x1,y1,x2,y2,
resultado=0,largo=0,col;
float d=1, dmenor;
x1=Ser.X[0]; // cabeza
y1=Ser.Y[0];
x2=Ser.dx ;
y2=Ser.dy;
largo=Ser.longitud;
dmenor=Ser.dmenor;
xmenor=x1; ymenor=y1;
for (x=x1-1; x<=x1+1;x++)
for (y=y1-1;y<=y1+1;y++)
{ // 2
if (x==y) continue;
if (Matriz[y][x]==1) continue;
d= distancia( x,y,x2,y2);
if (d<dmenor)
{ // 3

dmenor=d; xmenor = x, ymenor=y;
resultado=1;
} // 3
} // 2
// pasar los datos a los demas puntos
for (col=largo; col>0;col--)
{ // 2
Ser.X[col]=Ser.X[col-1];
Ser.Y[col]=Ser.Y[col-1];
} // 2
Ser.X[0]=xmenor;
Ser.Y[0]=ymenor;
Ser.dmenor=dmenor;
return resultado;
} // 1



/// programa principal
#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include "e:\datos\milib.h"
int xmin=3, ymin=3, xmax=78, ymax=23;
#include "calculos.H"
int main()
{ ///1
int
nro=0,nf=23,nc=78,fin=1,rx,ry,resultado=0,np=15,col,
k;
IniciarMatriz (Matriz,maxfilas,maxcol);
for (col=0;col<np;col++)
IniciarSer(Seres[col],col+1);
// for (col=0;col<np;col++)
ImprimirSer(Seres[col]);
for (col=0;col<np;col++)
{ // 2

MostrarSerMatriz(Seres[col],1,Matriz );
MostrarSer(Seres[col],1);
} // 2
while (!kbhit())
{ /// 2
for (col=0;col<np;col++)
{ // 3
if (Seres[col].dmenor >1)
{ ////4
MostrarSerMatriz(Seres[col],0,Matriz );
MostrarSer(Seres[col],0);

resultado=ModificarSer(Seres[col],Matriz);
// if (resultado >0)
MostrarSer(Seres[col],1);

MostrarSerMatriz(Seres[col],1,Matriz );
// Sleep(20);
} /// 4
else
{ /// 4
MostrarSerMatriz(Seres[col],0,Matriz );
MostrarSer(Seres[col],0 );
// acomodar
for ( k=1; k<Seres[col].longitud
;k++)
{ /// 5
Seres[col].X[k]=Seres[col].X[k-1];
Seres[col].Y[k]=Seres[col].Y[k-1];
} // 5
Seres[col].X[0]=Seres[col].dx;
Seres[col].Y[0]=Seres[col].dy;
fin =1;
- 341 -
while(fin==1)
{ ////5
rx=1+rand()%(xmax-xmin);
ry=1+rand()%(ymax-ymin);
if (Matriz[ry][rx] ==0)
{//6
Seres[col].dx=rx;
Seres[col].dy=ry; fin=0;
} //6
} // 5
// modificamos los valores del ser
Seres[col].dmenor=1000;
MostrarSerMatriz(Seres[col],1,Matriz );
} // 4 del else
} // 3 del for
} // del otro while ///2
getch();
return 0;
} // 1


Ver en 3d pag 1046

Hacerlo con matrices


#include <stdio.h>
#include <conio.h>
#include "E:\datos\milib.h"
int x1=1, x2=78, y1=1, y2=22;
int const max=102;
void Objeto(int &x, int &y)
{ int r;
r= 1+rand() % 8;
switch(r)
{ case 1: if (x<x2)x++; break;
case 2: if (x<x2)x++; if(y>y1)y--; break;
case 3: if(y>y1)y--; break;
case 4: if (x>x1)x--; if(y>y1)y--; break;
case 5: if (x>x1)x--;; break;
case 6: if (x>x1)x--;if(y<y2)y++; break;
case 7: if (y<y2)y++; break;
case 8: if (x<x2)x++;if(y<y2)y++; break;
}
}

void Imprimir( int X[], int Y[], int Z[], int np)
{ for (int i=0; i<np;i++)
{ gotoxy(X[i],Y[i ]);
textcolor(0,Z[i]);
printf("*");
}
}
int main()
{int X[max], Y[max], Z[max],np=100,i,punto;
for (i=0; i<max;i++)
{ X[i]= 1+rand() % (x2-x1);
Y[i]= 1+rand() % (y2-y1);
Z[i]= 1+rand() % 15;
}
Imprimir( X,Y,Z,np);
while (!kbhit())
{ punto=rand() %np;
textcolor(0,0); gotoxy( X[punto], Y[punto]) ;
printf(" ");
Objeto(X[punto], Y[punto]);
textcolor(0,Z[punto]); gotoxy( X[punto], Y[punto])
; printf("*");
Sleep(2);
}
getch();
return 0;
}

Trabajo de dezplazamiento de pantalla




// ************* calculos .h
void IniciarMatriz(int A[][maxcol], int nf , int nc)
{ int fila,col,dato;
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
A[fila][col]=0;
}
- 342 -
void RecuperarMatriz(int A[][maxcol], int nf , int nc)
{ FILE *p; int fila,col,dato;
p=fopen("E:\\DATOS\\casita40x20.TXT","r");

for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
fscanf(p,"%d",&A[fila][col]);
fclose(p);
}
void RecuperarObjeto(int A[][3], int nf , int nc)
{ FILE *p; int fila,col,dato;
p=fopen("E:\\DATOS\\objeto3x3.TXT","r");
for (fila=0;fila<nf;fila++)
for (col=0;col<nc;col++)
fscanf(p,"%d",&A[fila][col]);
fclose(p);
}
void MostrarMatrizEnPantalla(int Cx, int Cy, int
A[][maxcol], int nfilas, int ncol)
{ int fila,col;
for (fila=0;fila<nfilas;fila++)
for (col=0;col<ncol;col++)
{ gotoxy(Cx+col, Cy+fila);
textcolor(0, A[fila][col]);
printf("%c",219);
}
}
void MostrarObjetoEnPantalla(int Cx, int Cy, int
A[][3], int nfilas, int ncol)
{ int fila,col;
for (fila=0;fila<nfilas;fila++)
for (col=0;col<ncol;col++)
{ gotoxy(Cx+col, Cy+fila);
textcolor(0, A[fila][col]);
if (A[fila][col]>=0)printf("%c",219);
}
}


void LeerCopiaObjetoDeMatriz(int
Matriz[][maxcol], int cx, int cy, int Copia[][maxcol],
int nf1, int nc1)
{int fila , col;
for (fila=0;fila<nf1; fila++)
for (col=0;col<nc1;col++)

Copia[fila][col]=Matriz[cy+fila][cx+col];
}

#include <conio.h>
#include <stdio.h>
#include "E:\datos\milib.h"
const int maxfilas=100,maxcol=100;
int Matriz[maxfilas][maxcol];
int Muestra[maxfilas][maxcol];
int Objeto[3][3];

#include "calculos.h"
int main()
{ char ch, ch1;
int nf =20,
nc=40,Cx=1,Cy=1,nf1=10,nc1=20,Cx1=50,Cy1=10;
RecuperarMatriz(Matriz,nf,nc);
RecuperarObjeto(Objeto,3,3);

//ImprimirMatriz(Matriz, nf,nc);
MostrarMatrizEnPantalla( Cx, Cy, Matriz,nf,nc);
LeerCopiaObjetoDeMatriz(Matriz, 0,0, Muestra,
nf1, nc1);
MostrarMatrizEnPantalla( Cx1, Cy1, Muestra,
nf1,nc1);
MostrarObjetoEnPantalla( Cx1+10, Cy1+5,
Objeto, 3,3);

int x1=0,y1=0, x2=30, y2=10;
int x=x1,y=y1;
do
{ ch=getch();
switch (ch)
{ case 'x' : if (x<x2) x++;break; //
flecha arriba
case 'X': if (x>x1) x--;break; //flecha
izquierda
case 'y': if (y<y2)y++;break; // flecha
derecha;
case 'Y': if (y>y1)y-- ;break; // flecha
abajo
}
gotoxy(60,1);printf(" %d %d ",x,y);
LeerCopiaObjetoDeMatriz(Matriz, x,y,
Muestra, nf1, nc1);
MostrarMatrizEnPantalla( Cx1, Cy1, Muestra,
nf1,nc1);
// if (x < x2-3x)
MostrarObjetoEnPantalla( Cx1+10,
Cy1+5, Objeto, 3,3);
}while(ch!=27);
}

Grabar puntos en excel




#include <conio.h>
#include <stdio.h>
#include <math.h>
#include "e:\datos\milib.h"
const int maxfilas=50,maxcol=3;
float f( float x)
{ return (x+2)*(x-1)*(x-2);}

void GrabarMatriz(float A[][maxcol], int nf , int nc)
{ FILE *p; int fila,col;
p=fopen("E:\\DATOS\\funcion.TXT","w");
for (fila=0;fila<nf;fila++)
{
for (col=0;col<nc;col++)
fprintf(p,"%f\t",A[fila][col]);
fprintf(p,"\n");
}
fclose(p);
}

int main ()
{float dx,x,y,li=-2.5,ls=3.5;
int i, nf=40, nc=3;
float Matriz[maxfilas][maxcol];
dx=(ls-li)/nf;
for (i=0,x=li;i<nc;i++,x=x+dx)
{ y=f(x);
- 343 -
Matriz[i][0]=i;
Matriz[i][1]=x;
Matriz[i][2]=y;
}
GrabarMatriz(Matriz, nf,nc);
printf("\n el archivo ha sido grabado
correctamente");
getch();
}

El problemas los almacenes







#include <windows.h>
#include <conio.h>
#include <stdio.h>
#include <math.h>
#include "e:\datos\milib.h"
void imprimir(int A[], int n)
{ for (int i=0; i< n;i++) printf(" %3d", A[i]);}
int main()
{int A[20]={
0,0,11,11,12,13,13,13,12,14,14,2,2,1,2,10};
int B[20];
int n=16,i, cont=0, nro=A[0];
B[cont]=nro;
for (i=0;i<n;i++)
{if(A[i]!=nro){nro=A[i]; B[++cont]=nro;}
}
printf("\n vector original"); imprimir(A,n);
printf("\n vector unico"); imprimir(B,cont+1);
getch();
}