1

Escuela Superior de Ingeniería

Mecánica y Eléctrica.
(ESIME)

Fundamentos de la Programación

Ingeniería en Comunicaciones y Electrónica.

(ICE)
Integrantes:
 Aguirre Juárez Alejandro.

 Minguela Rodríguez Jesús Alberto.

EQUIPO: 6

GRUPO: 1CV3

Profesor: Garduño Medina Jorge Adrián

MATERIA: FUNDAMENTOS DE PROGRAMACION

 2

Índice
Contenido

Introducción ........................................................................................................................... 3

Códigos ............................................................................ Error! Bookmark not defined.

PRACTICA 2. “TECLAS DIRECCION”. ................................................................................... 4
PRACTICA 3. “PIANO”......................................................................................................... 5
PRACTICA 4. “RESISTENCIAS”. ........................................................................................... 6
PRACTICA 5. “CARÁCTER DESPLAZAMIENTO HORIZONTAL”. .......................................... 7
PRACTICA 6. “CARÁCTER DESPLAAMIENTO CIRCULAR”. .................................................. 7
PRACTICA 7. “ESCALERA” ................................................................................................... 8
PRACTICA 8. “CODIGO ASCII”. ........................................................................................... 8
PRACTICA 9. “ESTATURAS”. ............................................................................................... 9
PRACTICA 10. “SERIE DE ULAM”. ....................................................................................... 9
PRACTICA 11. “SERIE FIBONACCI”. .................................................................................. 10
PRACTICA 12. “MCD Y MCM”. ......................................................................................... 10
PRACTICA 15. “NUMERO FACTORIAL”. ........................................................................... 11
PRACTICA 17. “CARÁCTER RANDOM PANTALLA”. .......................................................... 11
PRACTICA 18. “CARÁCTER RANDOM DESPLIEGUE VERTICAL”. ...................................... 12
PRACTICA 19. “CARÁCTER CHOQUE/REBOTE”. ............................................................... 12
PRACTICA 20. “NUMERO FACTORIAL CON WHILE”. ....................................................... 13
PRACTICA 21.“SERIE ULAM DO WHILE”. ......................................................................... 13
PRACTICA 22. “CARÁCTER RANDOM PANTALLA CON WHILE Y EVENTUAL”. ................ 13
PRACTICA 23. “MCD Y MCM CON DO WHILE Y EVENTUAL”........................................... 14
CONCLUSIONES ................................................................................................................. 15
 3

Introducción

Una vez empleado lo principal de aquellos conceptos que influyen a la hora de hacer
un programa, como Visores; que básicamente te muestran el tipo de formato en el
que quieres ver tu dato, otro serían los Operadores Aritméticos, Relaciones y
Lógicos; los cuales indican al compilador realizar manipulación matemáticas o
lógicas especiales, Conocer de igual forma los Tipos de Variables, Conocer las
Funciones y su acción, las funciones de las Bibliotecas como la “math.h” que es
donde se emplean funciones trigonométricas, lógicas, exp,etc, Sentencia Selectiva
if, else; para una o más preguntas condicionales, nuestras Funciones de Usuario;
que juegan un papel muy importante en la programación modular y en la forma en
como desarrollamos nuestros programas , con esto Juntamos suficiente
experiencia de lógica para utilizar nuevas funciones como la sentencia Swtich, en
la cual nos permite comparar una variable por igualdad frente a una lista de
constantes o casos y los ciclos, que sería lo fundamental en casi cualquier
programa pues en base a esto nos permiten repetir una acción determinado número
de veces a partir de los diferentes campos que cada tipo de ciclo nos presentan,
aprendimos cada uno de los pasos a seguir para la implementación de un correcto
ciclo con su respectiva acción dependiendo si era “For”,”While!,”Do While” .
 4

Códigos
PRACTICA 2. “TECLAS DIRECCION”.
PRACTICA 1. “PANTALLA COLORES
(MENU)”.
#include <stdio.h>
#include <stdio.h> #include <conio.h>
#include <conio.h> #include "Terminado.c"
#include "Terminado.c" char menu(void)
char menu(void) {
{char opcion;
char opcion;
gotoxy(40,25);printf("Presione la tecla [ESC]
gotoxy(40,25);printf("Presione la tecla [ESC]
Para cerrar el programa");
Para cerrar el programa");
gotoxy(30,2);printf("Seleccione el Número
Correspondiente para el fondo de pantalla");
gotoxy(4,4);printf("Oprimir cualquier tecla de
gotoxy(3,4);printf("0= (Fondo Negro)"); direccion");
gotoxy(3,6);printf("1= (Fondo Azul)"); gotoxy(4,6);printf("\30");
gotoxy(3,8);printf("2= (Fondo Verde)"); gotoxy(4,8);printf("\31 ");
gotoxy(3,10);printf("3= (Fondo AzulMarino)"); gotoxy(4,10);printf("\32 ");
gotoxy(3,12);printf("4= (Fondo Rojo)"); gotoxy(4,12);printf("\33 ");
gotoxy(3,14);printf("5= (Fondo Purpura)"); opcion=getch();
gotoxy(3,16);printf("6= (Fondo Amarillo)"); return (opcion);
gotoxy(3,18);printf("7= (Fondo Blanco)"); }
gotoxy(3,20);printf("8= (Fondo Gris)"); void Direccion(char p)
gotoxy(3,22);printf("9= (fondo Azul LLoroso)"); {
opcion=getch(); switch(p)
return (opcion); {
}void Fondos(char p) case 72:gotoxy(8,6);printf("Arriba");break;
{switch(p) case 80:gotoxy(8,8);printf("Abajo");break;
{case‘0':textcolor(15);textbackground(0);break; case
case '1':textbackground(1);break; 75:gotoxy(8,12);printf("Izquiera");break;
case '2':textbackground(2);break; case
case '3':textbackground(3);break;
77:gotoxy(8,10);printf("Derecha");break;
case '4':textbackground(4);break;
case 27:exit(0);break;
case '5':textbackground(5);break;
case '6':textbackground(6);break;
case '7':textbackground(7);break;
}
case '8':textbackground(8);break; }
case '9':textbackground(9);break; int main(void)
case 27:exit(0);break; {
default:gotoxy(60,10);printf("Valor char Flecha;
incorrecto");sleep(200); Caratula();clrscr();textcolor(0);
}clrscr(); while(1)
} {
int main(void) Flecha=menu();clrscr();
{ char tecla; Direccion(Flecha);
Caratula();clrscr();;textcolor(0); }
while(1){ tecla=menu(); //getch();
Fondos(tecla); //return 0;
} } }
 5

gotoxy(118,20); printf("\274");
PRACTICA 3. “PIANO”. gotoxy(17,20); printf("\312");
gotoxy(34,20); printf("\312");
gotoxy(51,20); printf("\312");
#include <stdio.h>
gotoxy(68,20); printf("\312");
#include <conio2.h>
gotoxy(85,20); printf("\312");
#include <windows.h>
gotoxy(102,20); printf("\312");
#include <math.h>
gotoxy(17,2);printf("\334");
gotoxy(34,2);printf("\334");
int z=5;int h=3; int p=2; int c=1; int t=1;
gotoxy(68,2);printf("\334");
gotoxy(85,2);printf("\334");
void edicion(void){
gotoxy(102,2);printf("\334");}
switch (c){
//horizontales
char menu(void){char opcion;
case 1:
opcion = getch();}
if(t==3){h=2; p=3; t=1; c++; edicion();}
else{
if(h==118){h=3; p=20; t++; edicion();}
int frec (int a, int b){
else {gotoxy(h,p); printf("\315"); h++;
return (440* exp((((10.0-a)/12)+b-
edicion();}} break;
4)*log(2)));}
//paralelas
case 2:
void teclado (char a){
if (t==3){h=17; p=20; t=1; c++;
switch(a){
edicion();}
case 'a': Beep(frec(1,z),180);break;
else{
case 's': Beep(frec(3,z),180);break;
if (p==20){h=118; p=3; t++; edicion();}
case 'd': Beep(frec(5,z),180);break;
else {gotoxy(h,p);printf("\272"); p++;
case 'f': Beep(frec(6,z),180);break;
edicion();}}break;
case 'g': Beep(frec(8,z),180);break;
//teclas
case 'h': Beep(frec(10,z),180);break;
case 3:
case 'j': Beep(frec(12,z),180);break;
if(t==7){c++; p=10; h=15; t=1;
case 'w': Beep(frec(2,z),180);break;
edicion();}
case 'e': Beep(frec(4,z),180);break;
else{
case 't': Beep(frec(7,z),180);break;
if(p==10){p=19; h+=17; t++; edicion();}
case 'y': Beep(frec(9,z),180);break;
else{gotoxy(h,p);printf("\272");p--;
case 'u': Beep(frec(11,z),180);break;
edicion();}break; }
case 27 : exit(0);
//negras
case '+': z++; break;
case 4:
case '-': z--; break;}}
if(t==6){}
else{
int main(void)
if(p==2){p=10; h++; t++; edicion();}
{ char tecla;
else{gotoxy(h,p); printf("\333");p--
textbackground(15);textcolor(0);clrscr();
;edicion();}}
gotoxy(50,1); printf("Teclado");
break;}}
edicion (); edicion2();
void edicion2(void){
while (1){ tecla = menu();
gotoxy(2,2); printf("\311");
teclado (tecla);
gotoxy(118,2); printf("\273");
edicion();}
gotoxy(2,20); printf("\310");
}
 6

PRACTICA 4. “RESISTENCIAS”. gotoxy(60,20);printf("Presione cualquier tecla

para continuar");getch();clrscr();}
clrscr();}}
#include <stdio.h>
#include <conio.h>
void valor(int a, int b, int c){
#include <math.h>
gotoxy(55,14);printf("%d%d",a,b);
void menu(void){
switch (c){
gotoxy(40,2);printf("Calculo de Resistencias");
case 0: gotoxy(57,14);printf(" ohms"); break;
gotoxy(30,4);printf("a. Negro.");
case 1: gotoxy(57,14);printf("0 ohms"); break;
gotoxy(30,6);printf("b. Cafe.");
case 2: gotoxy(57,14);printf("00 ohms");
gotoxy(30,8);printf("c. Rojo.");
break;
gotoxy(30,10);printf("d. Naranja.");
case 3: gotoxy(57,14);printf(" Kohms"); break;
gotoxy(30,12);printf("e. Amarillo.");
case 4: gotoxy(57,14);printf("0 Kohms");
gotoxy(30,14);printf("f. Verde.");
break;
gotoxy(30,16);printf("g. Azul.");
case 5: gotoxy(57,14);printf("00 Kohms");
gotoxy(30,18);printf("h. Violeta.");
break;
gotoxy(30,20);printf("i. Gris.");
case 6: gotoxy(57,14);printf(" Mohms");
gotoxy(30,22);printf("j. Blanco.");
break;
}char leer(void){char opcion;
case 7: gotoxy(57,14);printf("0 Mohms");
opcion = getch();}
break;
int color(char a,int *b){
case 8: gotoxy(57,14);printf("00 Mohms");
if((a>='a'&&a<='z')||a==27){
break;
switch(a){
case 9: gotoxy(57,14);printf(" Gohms");
case 'a': *b=0; break;
break;}}
case 'b': *b=1; break;
int main(void)
case 'c': *b=2; break;
{ char tecla; int b,c,d;
case 'd': *b=3; break;
textbackground(3);clrscr(); textcolor(0);
case 'e': *b=4; break;
menu();
case 'f': *b=5; break;
gotoxy(57,9); printf("Primer banda de color");
case 'g': *b=6; break;
tecla = leer();
case 'h': *b=7; break;
color(tecla,&b);
case 'i': *b=8; break;
if (b<=9&&b>=0){}
case 'j': *b=9; break;
else{
default: gotoxy(60,13);printf("Elija una opcion
gotoxy(57,9); printf("Primer banda de color");
de a hasta j");
tecla = leer();
gotoxy(60,20);printf("Presione cualquier
color(tecla,&b);}
tecla para ctinuar");getch();clrscr();menu();}}
gotoxy(57,9); printf("Segunda banda de color");
else if ((a>='A'&&a<='Z')||a==27){
tecla = leer();
switch(a){
color(tecla,&c);
case 'A': *b=0; break;
gotoxy(57,9); printf(" ");
case 'B': *b=1; break;
gotoxy(57,9); printf("Tercer banda de color");
case 'C': *b=2; break;
tecla = leer();
case 'D': *b=3; break;
color(tecla,&d);
case 'E': *b=4; break;
gotoxy(1,27);printf("%d",b);
case 'F': *b=5; break;
gotoxy(1,28);printf("%d",c);
case 'G': *b=6; break;
gotoxy(1,29);printf("%d",d);
case 'H': *b=7; break;
valor(b,c,d);
case 'I': *b=8; break;
gotoxy(85,28);printf("Presione cualquier tecla
case 'J': *b=9; break;
para salir");
case 27 : exit(0);
getch();
default: gotoxy(60,13);printf("Elija una opcion
return 0;
de a hasta j");
}
 7

PRACTICA 5. “CARÁCTER PRACTICA 6. “CARÁCTER

DESPLAZAMIENTO HORIZONTAL”. DESPLAAMIENTO CIRCULAR”.

#include <stdio.h>
#include <stdio.h> #include <conio.h>
#include <conio.h> #include <math.h>
#include <stdlib.h> #include "P.1.c"
#include "Terminado.c"
char menu(void){char opcion;
char Leer(void) textcolor(0);
{char opcion; gotoxy(1,1);printf("Caracter: ");
gotoxy(97,30); printf("Presione Esc para
printf("Caracter= "); salir");
opcion=getch(); opcion = getch();
return(opcion);} return(opcion);}

void tabla(char x) void ciclo(int a){ int x; int y;

{char t; for (x=1, y=2; x<=119;x++){
for(t=1;t<120;t++) gotoxy(x,y);textcolor(4); printf(" %c",a);
{gotoxy(t,10);printf(" %c");sleep(40);} sleep(20);}
for (y=2; y<29; y++){
for (;t>0;t--) gotoxy(x,y);textcolor(2); printf("%c",a);
{gotoxy(t,10);printf("%c ");sleep(40);} sleep(20);
} gotoxy(x,y);printf(" ");}
for(;x>=1;x--){
gotoxy(x,y);textcolor(3);printf("%c
",a);sleep(20);}
for(x=1;y>1;y--){
int main(void)
{Caratula();textcolor(0);clrscr(); gotoxy(x,y);textcolor(5);printf("%c",a);sleep(
char z; 20);
z=Leer(); gotoxy(x,y);printf(" ");}}
tabla(z);
int main()
{ int tecla;
getch(); portada(); textbackground(15);clrscr();
return 0; for(;1;){
} tecla=menu();
switch(tecla){
case 27: exit(0); break;
default:ciclo(tecla);}}
}
 8

PRACTICA 7. “ESCALERA” PRACTICA 8. “CODIGO ASCII”.

#include <stdio.h>
#include <conio.h> #include <stdio.h>
#include "P.1.c" #include <conio.h>
#include <math.h>
void escalera(int x, int y, int L, int c, int b){ #include "P.1.c"
textcolor(c); void columna(void){
switch(b){ int x=1, y=1; unsigned char c=0;
case 1: for (;c<256;c++,y++){
L=x+L; gotoxy(x,y); printf("%d.%c",c,c);
for(;x<L;x++){ if(y==25){x+=11; y=0;}
gotoxy(x+1,y); printf("\315");} break; if (c==255){
gotoxy(85,27); printf("Presione una
case 2: tecla para salir.");
for(;y>2;y--){ getch();}}}
gotoxy(x,y); printf("\272");}
x=x+L+1;
for(y=3;y<16;y++){ int main()
gotoxy(x,y); printf("\272");}break; {
}} portada();textbackground(4); textcolor(15);
clrscr();
int main(void) columna();
{ int b=1, a=3; }
portada();textbackground(15);clrscr();
for(;a<=15;a+=2){
escalera(40,a,10,1,b);
}b=2;
//for(;b<=2;b++){
escalera(40,a-2,10,1,b);
//}
getch();
return 0;
}
 9

PRACTICA 9. “ESTATURAS”.
PRACTICA 10. “SERIE DE ULAM”.

#include <conio.h>
#include <stdio.h> #include <stdio.h>
#include <conio.h> #include "Terminado.c"
#include <math.h> int NUM(void)
#include "P.1.c" {int num;gotoxy(50,2);printf("Serie de
ULAM");
void leer(int *a){ gotoxy(5,5);printf(" Ingresa un Numero: ");
gotoxy(40,5);printf("Numero de personas: scanf("%d",&num);
");scanf("%d",a);} return(num);
}
void promedio(int a){ int b=1; float c,d=0; void Sentencia(int num)
for(b=1;b>=a;b++){ {
gotoxy(40,7); printf("Altura No.%d : for(;num!=1;)
",b);scanf("%f",&c); {
gotoxy(53,7);printf(" "); d+=c;} if(num%2==0)
d/=a; {num/=2;}
gotoxy(40,10); printf("Estatura else{num*=3;num+=1;}
Promedio: %.3f m",d);} printf(",%d",num);
int main(void) }
{ int a,
portada();textbackground(4); }
textcolor(15);clrscr();
gotoxy(40,2); printf("Promedio de estatura int main()
de n Personas"); {
leer(&a); Caratula();textcolor(0);clrscr();
promedio(a); int z;
getch(); z=NUM();
return 0; Sentencia(z);
} getch();
}
 10

PRACTICA 12. “MCD Y MCM”.

PRACTICA 11. “SERIE FIBONACCI”.
#include <stdio.h>
#include <conio.h>
#include <stdio.h>
#include "Terminado.c"
#include <conio.h>
void Leer(int *a,int *b)
{gotoxy(50,2);printf("MINIMO COMUN
int Leer(void){
MULTIPLO y MAXIMO COMUN DIVISOR");
int numero;
gotoxy(5,5);printf("Valor [A]=
gotoxy(50,2);printf("SERIE DE FIBONACCI");
");scanf("%d",a);
gotoxy(30,4);printf("Indique hasta que
gotoxy(5,6);printf("Valor [B]=
numero quiere ver la serie de fibonacci: ");
");scanf("%d",b);}
scanf("%d",&numero);
return(numero);
int mcd(int a,int b)
}
{int c,aux;

for(;a%b;){
int Operacion(int num){
c=a%b;
int i,par=0,imp=1;
a=b;
b=c;
int anterior1=1,anterior2=1,fibo=1;
if(a<b){aux=a;a=b;b=aux;}gotoxy(10,10);
}printf("[MCD]= %d",c);
printf("%d,",anterior1);
return(c);
}
for(i=2;i<=num;i++)
{
void mcm(int a,int b,int c)
printf("%d,",fibo);
{
fibo=anterior1+anterior2;
int mcm;
anterior1=anterior2;
mcm=(a*b)/c;gotoxy(9,9);printf("[MCM]=
anterior2=fibo;
%d",mcm);
if(fibo%2==0){par++;}
else{imp++;}
}
int main(void)
{
}
int a, b,z;
gotoxy(40,7);printf("Numeros pares =
Caratula();textcolor(0);clrscr();
%d",par);
Leer(&a,&b);
gotoxy(40,8);printf("Numeros impares =
z=mcd(a,b);
%d",imp);
mcm(a,b,z);
}
getch();
int main(void)
{
}
int z;
z=Leer();
Operacion(z);
getch();

}
 11

PRACTICA 15. “NUMERO FACTORIAL”. PRACTICA 17. “CARÁCTER RANDOM

PANTALLA”.
#include <stdio.h>
#include <conio.h> #include <stdio.h>
#include "Terminado.c" #include <conio.h>
int Leer(void) #include <math.h>
{int num;gotoxy(40,2);printf("Programa para #include "P.1.c"
saber el numero [FACTORIAL] ");
gotoxy(6,6);printf("Ingresar un numero void leer(char *a){
entero positivo: "); gotoxy(50,1); printf("Ingrese un caracter:
scanf("%d",&num);return(num); ");
} *a=getch();printf("%c",*a);}
void Operacion(int num)
{ void ciclo(char a){
double factorial=1,z; for(;!kbhit();){
for(z=1;z<=num;z++){ gotoxy(2+rand()%118,2+rand()%29);
factorial=factorial*z;} textcolor(rand()%15);
textcolor(0);gotoxy(8,8);printf("La Respuesta printf("%c",a);}}
es: %f",factorial);
} int main(void)
{ char a;
int main(void)
{ portada();textcolor(0);textbackground(15);clr
int z; scr();
Caratula();textcolor(0);clrscr(); leer(&a);
z=Leer(); ciclo(a);
Operacion(z); getch();
return 0;
getch(); }

}
 12

PRACTICA 18. “CARÁCTER RANDOM PRACTICA 19. “CARÁCTER

DESPLIEGUE VERTICAL”. CHOQUE/REBOTE”.

#include <stdio.h> #include <stdio.h>

#include <conio.h> #include <conio.h>
#include <math.h> #include <math.h>
#include "P.1.c" #include "P.1.c"
void leer(char *a){
void leer(char *a){ gotoxy(50,1); printf("Ingrese un caracter:
gotoxy(50,1); printf("Ingrese un caracter: ");
"); *a=getch();printf("%c",*a);}
*a=getch();printf("%c",*a);} int ciclo(char a){ int n=1,m=1;
int x1=1+rand()%119, y1=1+rand()%29;
void ciclo(char a){ int y,x; gotoxy(x1,y1); printf("\333");
for(;!kbhit();){ int x=1+rand()%119, y=1+rand()%29;
x=2+rand()%118; for(;!kbhit();){
for(y=2;y<=30;y++) switch (n){
{ case 1: x++; y++; break;
gotoxy(x,y);textcolor(15);printf("%c",a); case 2: x++; y--; break;
sleep(70); case 3: x--; y--; break;
gotoxy(x,y);printf(" ");} case 4: x--; y++; break;}
} if (x==119){m=2;}
} if(x==1){m=1;}
switch(m){
case 1: if(x==1&&n==3){n=2;}
int main(void) if(x==1&&n==4){n=1;}
{ char a; else if(y==29){n=2;}
else if(y==2){n=1;} break;
portada();textcolor(15);textbackground(4);clr case 2: if(x==119&&n==1){n=4;}
scr(); else if(x==119&&n==2){n=3;}
leer(&a); else if(y==29){n=3;}
ciclo(a); else if(y==2){n=4;} break;}
}
gotoxy(x,y); printf("%c",a);sleep(25);
gotoxy(x,y); printf(" ");

if(x==x1&&y==y1){gotoxy(50,15);
printf("Ha chocado");return 0;}
if((x==1&&y==1)||(x==119&&y==1)||(x==1&
&y==29)||(x==119&&y==29)){return 0;}
}}int main(void)
{ char a;

portada();textcolor(15);textbackground(4);clr
scr();
leer(&a); ciclo(a); getch(); }
 13

PRACTICA 20. “NUMERO FACTORIAL PRACTICA 21.“SERIE ULAM DO WHILE”.

CON WHILE”.
#include <stdio.h>
#include <conio.h>
#include <stdio.h> #include <math.h>
#include <conio.h> #include"P.1.c"
#include "Terminado.c"
int Leer(void) void leer(int *a){
{int num; gotoxy(40,5);printf("Ingrese un numero: ");
gotoxy(40,2);printf("Programa para saber el scanf("%d",a);}
numero [FACTORIAL] ");
void serie(int a){int b=40;
gotoxy(6,6);printf("Ingresar un numero
entero positivo: "); do
{gotoxy(b,7);printf("%d",a);
scanf("%d",&num); if(a==1){a--;}
else {
return(num); if (a%2==0){a=a/2;}
else{a=(a*3)+1;}}
} b+=3;}
void Operacion(int num) while(a);
{ }
double factorial=1,z=1;
int main()
while(z<=num){ { int x;
portada();textbackground(4);textcolor(15);
factorial=factorial*z;z++;
gotoxy(6,8);printf("La Respuesta es: clrscr();
%f",factorial); gotoxy(50,2); printf("Serie de Ulam");
} leer(&x);
serie(x);
} }

int main(void)
{int z;
Caratula();textcolor(7);
textbackground(0);clrscr();
z=Leer();
Operacion(z);
getch();

PRACTICA 22. “CARÁCTER RANDOM

PANTALLA CON WHILE Y EVENTUAL”.
 14

#include <stdio.h>
#include <stdio.h> #include <conio.h>
#include <conio.h> #include "Terminado.c"
#include <math.h> void Leer(int *a,int *b)
#include "P.1.c" {textcolor(7);gotoxy(45,2);printf("MINIMO
COMUN MULTIPLO y MAXIMO COMUN
void leer(char *a){ DIVISOR");
gotoxy(50,1); printf("Ingrese un caracter: textcolor(7);gotoxy(5,5);printf("Valor [A]=
"); ");scanf("%d",a);
*a=getch();printf("%c",*a);} textcolor(7);gotoxy(5,6);printf("Valor [B]=
");scanf("%d",b);}
void ciclo(char a){ int mcd(int a,int b)
while(!kbhit()) {int c,aux;
{ do{
gotoxy(2+rand()%118,2+rand()%29); c=a%b;
textcolor(rand()%15); a=b;
printf("%c",a);}} b=c;
if(a<b){aux=a;a=b;b=aux;}gotoxy(10,10);
}while(a%b);
textcolor(7);printf("[MCD]= %d",c);
int main(void) return(c);
{ char a; }
portada(); void mcm(int a,int b,int c)
textcolor(0);textbackground(15);clrscr(); {
leer(&a); int mcm;
ciclo(a); mcm=(a*b)/c;textcolor(7);gotoxy(9,9);printf(
gotoxy(50,15); printf("Desea repetir? "[MCM]= %d",mcm);
[S\\N]"); }int main(void)
{ int a, b,z;
} Caratula();textcolor(0);
textbackground(0);clrscr();
char repetir='s';
do
{ Leer(&a,&b);
z=mcd(a,b);
mcm(a,b,z);
// getch();
gotoxy(5,13);printf("Quiere repetir el
programa S/N?");
repetir=getch();clrscr();
}while((repetir=='s') || (repetir=='S'));
}

PRACTICA 23. “MCD Y MCM CON DO

WHILE Y EVENTUAL”.
 15

CONCLUSIONES