- Prog046
/* Prog046.cpp */
/**************************
Programa que analiza un texto terminado en un punto y
contabiliza los siguientes aspectos:
número de caracteres.
número de vocales
número de 'a' o 'A'
número de 'e' o 'E'
número de 'i' o 'I'
número de 'o' o 'O'
número de 'u' o 'U'
**************************/
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
char c;
int n,v,a,e,i,o,u;
printf("nEscribe un texto, y acaba con un puntonn");
c=' ';n=0;v=0;a=0;e=0;i=0;o=0;u=0;
while(c != '.')
{
c=toupper(getche());
if (c=='A')
{
v=v+1;
a=a+1;
}
if (c=='E')
{
v=v+1;
e=e+1;
}
if (c=='I')
{
v=v+1;
i=i+1;
}
if (c=='O')
{
v=v+1;
o=o+1;
}
if (c=='U')
{
v=v+1;
u=u+1;
}
n=n+1;
}
printf("n Caracteres = %d Vocales = %d",n,v);
printf("nA = %d E = %d I = %d O = %d U = %d ",a,e,i,o,u);
}
- Variable auxiliar
- Prog047
/* Prog047.cpp */
/********************************
Programa que lee la longitud de los 3 lados de un triángulo
y analiza qué tipo de triángulo es: no es triángulo,
equilátero, isósceles, escaleno, rectángulo.
********************************/
#include <stdio.h>
void main()
{
float lado1,lado2,lado3,auxiliar;
printf("nPrimer lado : ");scanf("%f",&lado1);
printf("nSegundo lado : ");scanf("%f",&lado2);
printf("nTercer lado : ");scanf("%f",&lado3);
/* Ordenación de los tres valores
toma nota del uso de una variable auxiliar */
if (lado1>lado2)
{
auxiliar=lado1;
lado1=lado2;
lado2=auxiliar;
}
if (lado3<lado1)
{
auxiliar=lado3;
lado3=lado2;
lado2=lado1;
lado1=auxiliar;
};
if (lado3<lado2)
{
auxiliar=lado2;
lado2=lado3;
lado3=auxiliar;
}
/* Comprobemos la ordenación: */
printf("n lado 1: %f",lado1);
printf("n lado 2: %f",lado2);
printf("n lado 3: %f",lado3);
/* Clasificación del triángulo */
if (lado3>=lado1+lado2) printf("nEsto no es un triángulo");
else if ((lado1==lado2) && (lado2==lado3)) printf("nTriángulo Equilátero");
else if ((lado1==lado2)||(lado1==lado3)||(lado2==lado3)) printf("nTriángulo Isósceles");
else printf("nTriángulo Escaleno");
if ((lado3<lado1+lado2)&&(lado3*lado3==lado1*lado1+lado2*lado2)) printf("nY además RECTANGULO");
}
En el Prog040 ya utilizábamos una variable auxiliar.
- Dibujando con ‘C'
- Prog048
/* Prog048.cpp */
/**********************************
Programa: Triángulo.
Este programa imprime el borde de un triángulo
usando asteriscos.
**********************************/
#include <stdio.h>
void main()
{
const int n=7; /* Altura del triángulo */
int j,k; /* Contadores */
for (k=1;k<=n-1;k++) printf(" ");
printf("*");
printf("n");
for (k=2;k<=n-1;k++)
{
for (j=1;j<=n-k;j++) printf(" ");
printf("*");
for (j=1;j<=2*k-3;j++) printf(" ");
printf("*");
printf("n");
}
printf("*");
for (k=1;k<=n-1;k++)
{
printf(" *");
};
}
- Prog049
/* Prog049.cpp */
/*********************************
Programa: Triángulo Bis
Este programa imprime el borde de un triángulo
usando asteriscos. La altura del triángulo,
en lineas de escritura se lee como dato.
*********************************/
#include <stdio.h>
void main()
{
int n,j,k;
printf("Altura: ");scanf("%d",&n);
printf("n");
if (n>0)
{
for (k=1;k<=n-1;k++) printf(" ");
printf("*");
printf("n");
}
for (k=2;k<=n-1;k++)
{
for (j=1;j<=n-k;j++) printf(" ");
printf("*");
for (j=1;j<=2*k-3;j++) printf(" ");
printf("*");
printf("n");
}
if (n>1)
{
printf("*");
for (k=1;k<=n-1;k++)
{
printf(" ");
printf("*");
}
printf("n");
};
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog049.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
- Prog050
/* Prog050.cpp */
/***********************************
Programa: Rombo de asteriscos
Dibuja un rombo simétrico de asteriscos.
Tomando como dato
el número de asteriscos que tiene el lado.
***********************************/
#include <stdio.h>
void main()
{
int fila,j,n;
printf("nLado? ");scanf("%d",&n);
printf("nn");
for (fila=1;fila<=n;fila++)
{
for (j=1;j<=n-fila;j++) printf(" ");
for (j=1;j<=fila;j++) printf("* ");
printf("n");
}
;
for (fila=1;fila<=n-1;fila++)
{
for (j=1;j<=fila;j++) printf(" ");
for (j=1;j<=n-fila;j++) printf("* ");
printf("n");
};
}
AUTOEVALUACIÓN 2
- El siguiente programa tiene errores. Escríbelo (grábalo con el nombre EVAL2A en TuCarpeta) y corrígelo para que funcione:
/* eval2a */
#include <stdio.h>
/* Conversión de Temperaturas
void main()
{
int cuenta;
int farenheit;
int celsius;
printf("Temperaturas Farenheit y Celsius /nn");
for(cuenta=-2;cuenta<=12;cuenta=cuenta+1)
{
celsius=10*cuenta;
farenheit=32+(celsius*9)/5;
printf(" C= %4d F= %4f",celsius,farenheit);
if(celsius==0) printf(" Punto de congelación del AGUA");
if(celsius==100) printf(" Punto de ebullición del AGUA");
printf("n");
}
}
- Haz un programa que funcione de la siguiente manera:
- El programa nos pide que escribamos dos números positivos menores de 57
- El programa nos da como resultado el producto de los dos números.
- Si los números no son positivos o son mayores o iguales a 57, el programa nos lo dice y se acaba la ejecución del mismo.
- El programa nos pregunta al final si queremos volver a empezar.
Graba el programa con el nombre EVAL2B en TuCarpeta.
- Escribe un programa que nos vaya pidiendo números. Si escribimos el número 9999 se acaba; por último el programa nos da como resultado el número de números introducidos, exceptuando el 9999.
Graba el programa con el nombre EVAL2C
Graba el programa con el nombre EVAL2D.
- Haz un programa que haga lo mismo que el anterior, pero además nos dé la suma de todos los números introducidos, exceptuando el 9999.
Graba el programa con el nombre EVAL2E.
- Haz un programa que haga lo mismo que el anterior, pero además que nos dé el producto de los números introducidos, exceptuando el 9999.
Graba el programa con el nombre EVAL2F, en TuCarpeta.
- Haz un programa que escriba todos los múltiplos de 23 inferiores a 1000 y por último nos dé la suma de todos ellos.
- Haz un programa que sirva para hacer una tabla de valores de la función: Y=sen(7X-5)
- El programa nos pide los dos valores de "x" (valores máximo y mínimo)
- El programa nos pide el incremento (variación) de la X.
Graba el programa con el nombre EVAL2G, en TuCarpeta.
- Haz un programa que sirva para calcular un cateto de un triángulo rectángulo a partir del otro cateto y la hipotenusa, de la siguiente forma:
- El programa nos pide el valor de la hipotenusa.
- El programa nos pide el valor de un cateto.
- Si el cateto es mayor que la hipotenusa, el programa nos da un mensaje de error y se acaba
- El programa nos da como resultado el valor del otro cateto y nos pregunta si queremos volver a empezar.
Graba el programa con el nombre EVAL2H, en TuCarpeta.
- Haz un programa que sirva para resolver ecuaciones de 2º grado del tipo ax2 + bx =0
Graba el programa con el nombre EVAL2I
ax + by = c
a’x + b’y=c’
Graba el programa con el nombre EVAL2J
- Haz un programa que sirva para resolver sistemas de ecuaciones del tipo:
Graba el programa con el nombre EVAL2K, en TuCarpeta.
- Haz un programa con la posibilidad de hacer el EVAL2I o el EVAL2J (debes utilizar la estructura SWITCH)
Graba el programa con el nombre EVAL2L, en TuCarpeta.
- Haz un programa que escriba la tabla de valores de la función y=ax2+bx+c, el programa nos pide los valores de a, b, c entre los valores "-v" y "v" (el programa nos pide el valor del numero natural "v").
Graba el programa con el nombre EVAL2M, en TuCarpeta.
- Haz un programa que escriba los 15 primeros múltiplos de 7, su suma y su producto. El programa ha de tener la posibilidad de volver a empezar.
#include <stdio.h>
void main()
{
int I; I=0;
while(I<5);
{
printf("nN=%f",I);
I++;
}
}
Graba el programa con el nombre EVAL2N, en TuCarpeta.
- El siguiente programa tiene errores, indícalos y explica detalladamente lo que hace el programa:
Graba el programa con el nombre EVAL2O, en TuCarpeta.
- Haz un programa que sirva para calcular el área de un triángulo o el área de un rectángulo o el área de un círculo. El programa ha de tener la posibilidad de volver a empezar.
Graba el programa con el nombre EVAL2P, en TuCarpeta.
- Haz un programa tal que: dados 2 vectores del espacio, calcule su producto escalar, producto vectorial y además nos dé el módulo de los dos vectores y también el módulo del producto vectorial.
Graba el programa con el nombre EVAL2Q, en TuCarpeta.
- Haz un programa que "dibuje" un rectangulo de asteriscos a partir de la base y la altura.
Graba el programa con el nombre EVAL2R, en TuCarpeta.
- Haz un programa que dibuje un cuadrado, con el carácter que quieras, a partir del lado.
Graba el programa con el nombre EVAL2S, en TuCarpeta.
- Haz un programa que "analice" las vocales, consonantes y espacios en blanco de un texto.
Graba el programa con el nombre EVAL2T, en TuCarpeta.
- Haz un programa que nos pida un número y dé como resultado la tabla de multiplicar del número introducido.
1/(3!) + 1/(4!) + …
Graba el programa con el nombre EVAL2U, en TuCarpeta.
- Haz un programa que calcule el número "e" mediante el desarrollo en serie: e = 1 + 1/(1!) + 1/(2!) +
- Haz un programa que calcule la anualidad, a partir del capital, el tanto por ciento anual, y los años de amortización de un crédito:
Cap*(1+i/100)^años *i/100
Anualidad = —————————————
(1+i/100)^años – 1
El programa también debe calcular para todos los años, la parte de la anualidad dedicada al pago de intereses y la parte dedicada a la amortización de la deuda.
Graba el programa con el nombre EVAL2V, en TuCarpeta.
III.- Funciones
Matrices. Vectores. Arrays.
- Prog051
/* Prog051.cpp */
#include <stdio.h>
void main()
{
int i;
char nom[6];
printf("nEscribe una palabra de exactamente 6 letras: ");
scanf("%s",nom);
for(i=0;i<6;i++)
{
printf("nnom[%d]= ",i);
printf("%c",nom[i]);
}
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog051.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Estudio del PROG051
- La variable nom, es una variable compuesta (por esta razón en el scanf no hemos de poner el símbolo & antes del nombre de la variable).
- A este tipo de variables se les llama también vectores, matrices o arrays, porque una sóla variable (nom), contiene diferentes valores (en nuestro caso 6 caracteres).
- Observa la diferencia con los identificadores de formato (string – char)
%s : si queremos mostrar la palabra (todos los valores de la matriz).
%c : si queremos mostrar uno de los valores de la matriz.
- Observa también la forma de acceder a uno de los valores de la matriz: nom[2] indica el 3r. valor, ya que empieza por 0 (el llamado índice de la matriz).
Es decir:
char nom[6]: define una matriz de 6 caracteres.
nom[0]: indica el 1º
nom[1]: indica el 2º
———————–
nom[5]: indica el último (6º).
El array del programa anterior era una matriz de caracteres, veamos que también podemos construir "arrays" de números:
- Prog052
/* Prog052.cpp */
#include <stdio.h>
void main()
{
int valors[12];
int i;
for(i=0;i<12;i++) valors[i]=2*(i+4);
for(i=0;i<12;i++)
printf("n El valor de valors[%d] es %d",i,valors[i]);
}
Estudio del PROG052:
- int valors[12]
Definimos una variable (matriz, vector o array) de 12 valores enteros.
- Asignamos valores a la matriz anterior:
i = 0 : valors[0] = 2*(0+4) = 8
i = 1 : valors[1] = 2*(1+4) = 10
……………………………………
……………………………………
i = 11 : valors[11] = 2*(11+4) = 30
- Observa que en una matriz entera (int) no hay problema en cuanto al identificador: siempre es %d.
- Prog053
/* Prog053.cpp */
#include <stdio.h>
void main()
{
float vector1[3],vector2[3];
int i;
float proesc;
/* Introducción del primer vector */
printf("n Introduce las componentes del primer vectorn");
scanf("%f %f %f",&vector1[0],&vector1[1],&vector1[2]);
/* Introducción del segundo vector */
printf("n Introduce las componentes del segundo vectorn");
scanf("%f %f %f",&vector2[0],&vector2[1],&vector2[2]);
printf(" Vector 1= ( %f, %f, %f )",vector1[0],vector1[1],vector1[2]);
printf(" Vector 2= ( %f, %f, %f )",vector2[0],vector2[1],vector2[2]);
/* Cálculo del producto escalar */
for(i=0;i<3;i++) proesc=proesc+vector1[i]*vector2[i];
/* Resultado */
printf("nn El producto escalar es = %f",proesc);
}
La utilidad de los arrays está clara: observa de que forma más fácil calculamos el producto escalar.
- Prog054
/* Prog054.cpp */
#include <stdio.h>
void main()
{
float f1[3],f2[3],f3[3];
int i;
float det;
/* Introducción de la primera fila del determinante */
printf("n Introduce los elementos de la primera filan");
scanf("%f %f %f",&f1[0],&f1[1],&f1[2]);
/* Introducción de la segunda fila del determinante */
printf("n Introduce los elementos de la segunda filan");
scanf("%f %f %f",&f2[0],&f2[1],&f2[2]);
/* Introducción de la tercera fila del determinante */
printf("n Introduce los elementos de la tercera filan");
scanf("%f %f %f",&f3[0],&f3[1],&f3[2]);
printf("n | %11f %11f %11f |",f1[0],f1[1],f1[2]);
printf("n | %11f %11f %11f |",f2[0],f2[1],f2[2]);
printf("n | %11f %11f %11f |",f3[0],f3[1],f3[2]);
/* Cálculo del determinante */
det=f1[0]*f2[1]*f3[2]+f2[0]*f3[1]*f1[2]+f1[1]*f2[2]*f3[0]-f1[2]*f2[1]*f3[0]-f2[0]*f1[1]*f3[2]-f3[1]*f2[2]*f1[0];
/* Resultado */
printf("nn El Determinante es = %f",det);
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog054.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Funciones
- Prog055
/* Prog055.cpp */
#include <stdio.h>
#include <math.h>
void mediageo();
void main()
{
printf("n Programa Principal que llama a una ");
printf("nn función de nombre mediageo");
mediageo();
printf("nnn Se acabó lo que se daba");
}
void mediageo()
{
float a,b;
printf("n Introduce los dos números: n");
scanf("%f %f",&a,&b);
printf("nn La Media Geométrica de %f y %f es %f",a,b,sqrt(a*b));
}
Estudio del PROG055:
- La sentencia void mediageo(); indica al compilador, que el programa contiene una función definida por nosotros de nombre mediageo (llamado también subrutina o subprograma).
- El programa principal (void main()), llama al subprograma en la línea: mediageo();
- Observa de qué forma construimos el subprograma: void mediageo() sin punto y coma, y a continuación, entre llaves, las líneas o sentencias del programa.
- Observa también que cuando se acaba la ejecución del subprograma, el control pasa al programa principal, en la línea siguiente a la llamada del subprograma. En nuestro caso se ejecuta la línea: printf("nnn Se acabó lo que se daba");
- Prog056
/* Prog056.cpp */
#include <stdio.h>
#include <math.h>
void suma();
void raiz();
void logaritmo();
void ayuda();
void main()
{
char c[1];
c[1]='x';
while(c[0] != 'T')
{
printf("n ===============================");
printf("n Pulsa S, para SUMAR");
printf("n Pulsa R, para RAIZ CUADRADA");
printf("n Pulsa L, para LOGARITMO");
printf("n Pulsa A, para AYUDA");
printf("n Pulsa T, para TERMINAR n");
scanf("%s",c);
if (c[0]=='S') suma();
if (c[0]=='R') raiz();
if (c[0]=='L') logaritmo();
if (c[0]=='A') ayuda();
}
}
void suma()
{
float a,b;
printf("n Sumandos: n");
scanf("%f %f",&a,&b);
printf("n %f + %f = %f",a,b,a+b);
}
void raiz()
{
float x;
printf("n Radicando: n");
scanf("%f",&x);
printf("n Raiz cuadrada de %f = %f",x,sqrt(x));
}
void logaritmo()
{
float l;
printf("n Logaritmo de : n");
scanf("%f",&l);
printf("n El logaritmo neperiano de %f es %f",l,log(l));
}
void ayuda()
{
printf("n Es bastante tonto que me pidas ayuda,");
printf("n pero aquí la tienes:");
printf("nnn Pulsa S, para SUMAR");
printf("n Pulsa R, para RAIZ CUADRADA");
printf("n Pulsa L, para LOGARITMO");
printf("n Pulsa A, para AYUDA");
printf("n Pulsa T, para TERMINAR n");
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog056.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Funciones que retornan parámetros
- Prog057
/* Prog057.cpp */
#include <stdio.h>
int cuenta(char nom[25]);
void main()
{
int longit;
char palabra[25];
printf("n Escribe una palabra de 25 caracteres como máximo: ");
scanf("%s",palabra);
longit=cuenta(palabra);
printf("nn Longitud de %s = %d",palabra,longit);
}
int cuenta(char nom[25])
{
int i;
i=0;
while(nom[i] != '') i++;
return i;
}
Estudio del PROG057:
- La línea de programa int cuenta(char nom[25]); indica al compilador que además del programa principal (void main), hay una función de nombre cuenta(), que utilizará una variable tipo string con un máximo de 25 caracteres y además dicho subprograma retornará un valor tipo int, a diferencia de las funciones anteriores que no retornaban nada (void).
- La línea de programa: longit= cuenta(palabra);, llama al subprograma cuenta() y en número entero que retorna, se asigna a la variable entera longit
- Observa de qué forma contamos los caracteres ocupados por la variable nom: nom[i] != ‘’
- Observa que la variable utilizada por la función cuenta(), no tiene porqué ser la misma: En el programa principal es palabra y en la función es nom. De todas formas es imprescindible que sea del mismo tipo: en los dos casos es char de 25 caracteres.
- El valor retornado por la función, no tiene porqué corresponder a la misma variable: en el programa principal es longit y en la función es i. De todas formas es imprescindible que sean del mismo tipo: en los dos casos es int.
- Prog058
/* Prog058.cpp */
#include <stdio.h>
#include <math.h>
void trigon(double inicial,int num,double paso);
void main()
{
int num;
double ini,paso;
printf("n Valor inicial,número de valores,paso ?");
scanf("%lf %d %lf",&ini,&num,&paso);
trigon(ini,num,paso);
}
void trigon(double inicial,int num,double paso)
{
int i;
double v,s,c;
for(i=0;i<num;i++)
{
v=inicial+i*paso;
s=sin(v);
c=cos(v);
printf("n%lf %lf %lf",v,s,c);
}
}
- Estudio del PROG058:
- La línea: void trigon(double inicial, int num, double paso); indica al compilador que el programa contiene una función (trigon), que no retorna ningún valor (void), pero que trabaja con tres variables: la primera y última double y la 2ª int.
- La llamada a la función por parte del programa principal (main), se encuentra en la línea: trigon(ini, num, paso);
En efecto: ini y paso son variables double y num es int.
- En la función trigon, utilizamos los valores entrantes: ini, num y paso y definimos otros: i, v, s, c.
Vamos a "programar" otra función con retorno de parámetro:
- Prog059
/* Prog059.cpp */
#include <stdio.h>
int diasmes(int mes);
void main()
{
printf("n Enero tiene %d días",diasmes(1));
printf("n Febrero tiene %d días",diasmes(2));
printf("n Marzo tiene %d días",diasmes(3));
printf("n Abril tiene %d días",diasmes(4));
printf("n Mayo tiene %d días",diasmes(5));
printf("n Junio tiene %d días",diasmes(6));
printf("n Julio tiene %d días",diasmes(7));
printf("n Agosto tiene %d días",diasmes(8));
printf("n Septiembre tiene %d días",diasmes(9));
printf("n Octubre tiene %d días",diasmes(10));
printf("n Noviembre tiene %d días",diasmes(11));
printf("n Diciembre tiene %d días",diasmes(12));
printf("n El mes 13 tiene %d días, porque no existe",diasmes(13));
}
int diasmes(int mes)
{
int dias;
switch(mes)
{
case 2:
dias=28;
break;
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
dias=31;
break;
case 4:
case 6:
case 9:
case 11:
dias=30;
break;
default:
dias=0;
break;
}
return dias;
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog059.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Estudio del PROG059:
- int diames( int mes);
Indicamos al compilador que nuestro programa contiene una función que necesita un valor int (mes) y devolverá un valor int.
- El programa principal, con la sentencia diames(1) llama a la función diames y ésta devuelve el número 31.
- Observa la estructura switch: si el case 1, 3, 5, 7, 8, 10 no contienen nada, se ejecuta el siguiente case que sí contiene algo: en nuestro caso el case 12, que da a la variable dias el valor 31.
El operador "resto de la división entera"
- Prog060
/* Prog060.cpp */
#include <stdio.h>
void main()
{
int n,i,resto;
printf("Escribe un número: "); scanf("%d",&n);
for(i=2;i<n-1;i++)
{
resto=n % i;
if ((resto==0) && (n != 2))
{
printf("n No es primo");
return;
}
}
printf("n %d es un número primo",n);
}
Estudio del PROG060:
n % i
Nos da el resto de la división entera entre n y i (% es un operador como lo es la suma o el producto).
Vamos a hacer el mismo programa que el anterior pero a través de una función: int primo(int num)
- Prog061
/* Prog061.cpp */
#include <stdio.h>
int primo(int num);
void main()
{
int n;
printf("n Escribe un número: ");scanf("%d",&n);
if (primo(n)==1) printf("nn Es primo");
else printf("nn No es primo");
}
int primo(int num)
{
int resto,i,result;
for(i=2;i<num-1;i++)
{
resto=num % i;
if((resto==0) && (num != 2)) return 0;
}
return 1;
}
- Prog062
/* Prog062.cpp */
/* Programa que dado un número 'N' escribe todos los
números comprendidos entre 1 y 10.000, que cumplen
las siguientes reglas:
– La suma de sus cifras debe ser un divisor de N
– El producto de sus cifras debe ser un múltiplo de 'N' */
#include <stdio.h>
void main()
{
int n,i,c1,c2,c3,c4,suma,producto;
printf("nEscribe un número: ");scanf("%d",&n);
for (i=1;i<=9999;i++)
{
c1=int(i/1000);
c2=int((i % 1000)/100);
c3=int(((i % 1000) % 100)/10);
c4=(((i % 1000) % 100) % 10);
suma=c1+c2+c3+c4;
producto=c1*c2*c3*c4;
if ((n % suma == 0) && (producto % n == 0) &&
(suma <= n) && (producto >= n))
{
printf("%5d",i);
printf("n");
}
}
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog062.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Bibliotecas de programas.
Crea, utilizando tu editor favorito un fichero de nombre Fich001 y extensión c y grábalo como siempre en TuCarpeta:
- Fich001.c
/* Fich001.c */
/* Determinación de un número primo */
int primo(int num)
{
int resto,i,result;
for(i=2;i<num-1;i++)
{
resto=num % i;
if ((resto==0) && (num != 2)) return 0;
}
return 1;
}
Acabamos de crear un fichero biblioteca de nombre Fich001.c que contiene de momento una sóla función, no lo ejecutes porque entre otras cosas no te funcionará.
- Prog063
/* Prog063.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich001.c"
void main()
{
int n;
printf("n Escribe un número: ");scanf("%d",&n);
if (primo(n)==1) printf("nn Es primo");
else printf("nn No es primo");
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog063.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Observa de qué forma decimos al compilador que utilice las funciones que tenemos en Fich001.c:
#include "c:TuCarpetaFich001.c"
Vamos a hacer un programa que escribe el listado de números primos inferiores a uno dado (utiliza la función primo() de Fich001.c
- Prog064
/* Prog064.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich001.c"
void main()
{
int n,i;
int j,panta;
char c;
printf("nHasta qué número quieres la lista de números primos: ");
scanf("%d",&n);
printf("n");
c=getchar();
printf("n1n");
j=0;panta=1;
for(i=2;i<n;i++)
if(primo(i)==1)
{
printf("%10d",i);
j++;
if(j==160*panta)
{
printf("n Pulsa [Return] para continuar n");
c=getchar();
panta++;
}
}
if(primo(n)==1) printf("n%10d",n);
}
Descomposición de un número en factores primos (utiliza la función primo() de Fich001.c)
- Prog065
/* Prog065.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich001.c"
void main()
{
int n,i;
int k;
printf("n Escribe el número a descomponer: n");
scanf("%d",&n);
for(i=2;i<n;i++)
{
k=1;
while ((primo(i)==1) && (n % (k*i) ==0))
{
printf("%d-",i);
k=k*i;
}
}
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog065.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Cálculo del máximo común divisor MCD por el método de Euclides.
- Prog066
/* Prog066.cpp */
/* Cálculo del M.C.D de dos números */
#include <stdio.h>
void main()
{
int x,y;
int aux;
int resto;
printf("n Escribe un número x: "); scanf("%d",&x);
printf("n Escribe otro número y: "); scanf("%d",&y);
if(x<y)
{
aux=x;
x=y;
y=aux;
}
if((x % y) == 0) resto=y;
while ((x % y) != 0)
{
resto=x-y*(x/y);
x=y;
y=resto;
}
printf("n El M.C.D es: %d",resto);
}
El programa anterior pero utilizando una función
- Prog067
/* Prog067.cpp */
#include <stdio.h>
int MCD(int,int);
void main()
{
int a,b;
int mcd;
printf("n Número: "); scanf("%d",&a);
printf("n Número: "); scanf("%d",&b);
mcd=MCD(a,b);
printf("nn El MCD de %d y %d es %d",a,b,mcd);
}
int MCD(int x,int y)
{
int aux;
int resto;
if(x<y)
{
aux=x;
x=y;
y=aux;
}
if((x % y) == 0) resto=y;
while ((x % y) != 0)
{
resto=x-y*(x/y);
x=y;
y=resto;
}
return resto;
}
A partir del Fich001.c escribe el siguiente fichero, que deberás grabar donde siempre
- Fich002.c
/* Fich002.c */
/* Determinación de un número primo */
int primo(int num)
{
int resto,i,result;
for(i=2;i<num-1;i++)
{
resto=num % i;
if ((resto==0) && (num != 2)) return 0;
}
return 1;
}
/* Determinación del M.C.D de dos números */
int MCD(int x,int y)
{
int aux;
int resto;
if (x<y)
{
aux=x;
x=y;
y=aux;
}
if ((x % y)==0) resto=y;
while ((x % y) != 0)
{
resto=x-y*(x/y);
x=y;
y=resto;
}
return resto;
}
No compiles el fichero anterior ya que se trata de un fichero biblioteca
Vamos a probar la función MCD, que acabamos de incluir en Fich002.c
- Prog068
/* Prog068.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich002.c"
void main()
{
int a,b;
int mcd;
char otra[1];
otra[0]='s';
while (otra[0]=='s')
{
printf("n Número: "); scanf("%d",&a);
printf("n Número: "); scanf("%d",&b);
mcd=MCD(a,b);
printf("nn El MCD de %d y %d es %d",a,b,mcd);
printf("nn Quieres otro MCD (s/n)? ");
scanf("%s",otra);
}
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog068.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Vamos a hacer el mismo programa anterior pero que calcule también el mínimo común múltiplo.
- Prog069
/* Prog069.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich002.c"
void main()
{
int a,b;
int mcd;
int prod;
char otra[1];
otra[0]='s';
while (otra[0]=='s')
{
printf("n Número: "); scanf("%d",&a);
printf("n Número: "); scanf("%d",&b);
prod=a*b;
mcd=MCD(a,b);
printf("nn El MCD de %d y %d es %d",a,b,mcd);
printf("nn El mcm de %d y %d es %d",a,b,prod/mcd);
printf("nn Quieres otro cálculo (s/n)? ");
scanf("%s",otra);
}
}
Programa que simplifica una fracción, utilizando la función MCD, que tenemos en Fich002.c
- Prog070
/* Prog070.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich002.c"
void main()
{
int a,b;
int div;
printf("n Escribe el numerador: ");
scanf("%d",&a);
printf("n Escribe el denominador: ");
scanf("%d",&b);
div=MCD(a,b);
printf("n Fracción simplificada: %d / %d",a/div,b/div);
}
Vamos a hacer el programa anterior pero con arrays.
- Prog071
/* Prog071.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich002.c"
void main()
{
int f[2],fs[2];
int i,div;
printf("n Escribe el numerador: ");
scanf("%d",&f[0]);
printf("n Escribe el denominador: ");
scanf("%d",&f[1]);
div=MCD(f[0],f[1]);
for(i=0;i<2;i++) fs[i]=f[i]/div;
printf("n Fracción simplificada: %d / %d",fs[0],fs[1]);
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog071.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Vamos a hacer el mismo programa pero a través de una función: simplifica
- Prog072
/* Prog072.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich002.c"
void simplifica(int ,int );
void main()
{
int f[1];
int i;
printf("n Escribe el numerador: ");
scanf("%d",&f[0]);
printf("n Escribe el denominador: ");
scanf("%d",&f[1]);
simplifica(f[0],f[1]);
}
void simplifica(int a,int b)
{
int div;
div=MCD(a,b);
printf("n Fracción Simplificada: %d / %d",a/div,b/div);
}
A partir del Fich002.c escribe el siguiente:
- Fich003.c
/* Fich003.c */
/* Determinación de un número primo */
int primo(int num)
{
int resto,i,result;
for(i=2;i<num-1;i++)
{
resto=num % i;
if ((resto==0) && (num != 2)) return 0;
}
return 1;
}
/* Determinación del M.C.D de dos números */
int MCD(int x,int y)
{
int aux;
int resto;
if (x<y)
{
aux=x;
x=y;
y=aux;
}
if ((x % y)==0) resto=y;
while ((x % y) != 0)
{
resto=x-y*(x/y);
x=y;
y=resto;
}
return resto;
}
/* Simplifica una fracción */
void simplifica(int a,int b)
{
int div;
div=MCD(a,b);
printf("nFracción Simplificada: %d / %d",a/div,b/div);
}
Vamos a probar la función simplifica que tenemos en Fich003.c
- Prog073
/* Prog073.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich003.c"
void main()
{
int f[1];
int i;
printf("n Escribe el numerador: ");
scanf("%d",&f[0]);
printf("n Escribe el denominador: ");
scanf("%d",&f[1]);
simplifica(f[0],f[1]);
}
Vamos a hacer un programa que sume dos fracciones.
- Prog074
/* Prog074.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich003.c"
void main()
{
int f1[2],f2[2];
int mcd,num;
printf("Escribe la 1ª fracción: n"); scanf("%d %d",&f1[0],&f1[1]);
printf("Escribe la 2ª fracción: n"); scanf("%d %d",&f2[0],&f2[1]);
mcd=(f1[1]*f2[1])/MCD(f1[1],f2[1]);
num=(mcd/f1[1])*f1[0]+(mcd/f2[1])*f2[0];
printf("nn Suma de %d/%d + %d/%d = ",f1[0],f1[1],f2[0],f2[1]);
printf(" %d / %d",num,mcd);
printf("nn");
simplifica(num,mcd);
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog074.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Macros
- Prog075
/* Prog075.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich003.c"
#define mcm(x,y) ((x*y)/MCD(x,y))
void main()
{
int f1[2],f2[2];
int mcd,num;
printf("Escribe la 1ª fracción: n"); scanf("%d %d",&f1[0],&f1[1]);
printf("Escribe la 2ª fracción: n"); scanf("%d %d",&f2[0],&f2[1]);
mcd=mcm(f1[1],f2[1]);
num=(mcd/f1[1])*f1[0]+(mcd/f2[1])*f2[0];
printf("nn Suma de %d/%d + %d/%d = ",f1[0],f1[1],f2[0],f2[1]);
printf(" %d / %d",num,mcd);
printf("nn");
simplifica(num,mcd);
}
Estudio del PROG075:
- El programa suma dos funciones pero utiliza una macro para el cálculo del m.c.m.
- La macro está definida en la línea:
#define mcm(x,y) ((x*y)/MCD(x,y))
Y no es más que una función, pero resumida, es decir no es necesario definir el tipo de variables.
- Observa que la macro contiene una llamada a la función MCD que tenemos en Fich003.c, que funciona sin ningún problema siempre y cuando tengamos en el programa la línea: #include "c:TuCarpetaFich003.c"
Escribe a partir del Fich003 el siguiente:
- Fich004.c
/* Fich004.c */
/* Determinación de un número primo */
int primo(int num)
{
int resto,i,result;
for(i=2;i<num-1;i++)
{
resto=num % i;
if ((resto==0) && (num != 2)) return 0;
}
return 1;
}
/* Determinación del M.C.D de dos números */
int MCD(int x,int y)
{
int aux;
int resto;
if (x<y)
{
aux=x;
x=y;
y=aux;
}
if ((x % y)==0) resto=y;
while ((x % y) != 0)
{
resto=x-y*(x/y);
x=y;
y=resto;
}
return resto;
}
/* Simplifica una fracción */
void simplifica(int a,int b)
{
int div;
div=MCD(a,b);
printf("nFracción Simplificada: %d / %d",a/div,b/div);
}
/* Macro que calcula el m.c.m. */
#define mcm(x,y) ((x*y)/MCD(x,y))
Vamos a hacer el mismo programa PROG075, pero con la macro en el fichero Fich004.c
- Prog076
/* Prog076.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich004.c"
void main()
{
int f1[2],f2[2];
int mcd,num;
printf("Escribe la 1ª fracción: n"); scanf("%d %d",&f1[0],&f1[1]);
printf("Escribe la 2ª fracción: n"); scanf("%d %d",&f2[0],&f2[1]);
mcd=mcm(f1[1],f2[1]);
num=(mcd/f1[1])*f1[0]+(mcd/f2[1])*f2[0];
printf("nn Suma de %d/%d + %d/%d = ",f1[0],f1[1],f2[0],f2[1]);
printf(" %d / %d",num,mcd);
printf("nn");
simplifica(num,mcd);
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog076.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Crea a partir del Fich004.c el siguiente fichero:
- Fich005.c
/* Fich005.c */
/* Determinación de un número primo */
int primo(int num)
{
int resto,i,result;
for(i=2;i<num-1;i++)
{
resto=num % i;
if ((resto==0) && (num != 2)) return 0;
}
return 1;
}
/* Determinación del M.C.D de dos números */
int MCD(int x,int y)
{
int aux;
int resto;
if (x<y)
{
aux=x;
x=y;
y=aux;
}
if ((x % y)==0) resto=y;
while ((x % y) != 0)
{
resto=x-y*(x/y);
x=y;
y=resto;
}
return resto;
}
/* Simplifica una fracción */
void simplifica(int a,int b)
{
int div;
div=MCD(a,b);
printf("nFracción Simplificada: %d / %d",a/div,b/div);
}
/* Macro que calcula el m.c.m. */
#define mcm(x,y) ((x*y)/MCD(x,y))
/* Macro que calcula el numerador de la suma de dos
fracciones */
#define SumaFracNum(n1,d1,n2,d2)
(((mcm(d1,d2)/d1)*n1+(mcm(d1,d2)/d2)*n2))
- Prog077
/* Prog077.cpp */
#include <stdio.h>
#include "c:TuCarpetaFich005.c"
void main()
{
int f1[2],f2[2];
int den,num;
printf("Escribe la 1ª fracción: n"); scanf("%d %d",&f1[0],&f1[1]);
printf("Escribe la 2ª fracción: n"); scanf("%d %d",&f2[0],&f2[1]);
num=SumaFracNum(f1[0],f1[1],f2[0],f2[1]);
den=mcm(f1[1],f2[1]);
printf("nn Suma de %d/%d + %d/%d = ",f1[0],f1[1],f2[0],f2[1]);
printf(" %d / %d",num,den);
printf("nn");
simplifica(num,den);
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog077.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
Está claro lo que hemos conseguido en el Fich005.c, una biblioteca de funciones y macros que podemos utilizar en nuestros programas sin más que incluir: #include "c:TuCarpeta.Fich005.c".
Todo programador, según el tipo de programas que debe hacer dispone de su propia biblioteca de funciones y macros, de todas formas hay muchas "bibliotecas de funciones y macros" que son de dominio público y que puedes bajarte de Internet.
Bases de numeración
- Prog078
/* Prog078.cpp */
/* Programa que convierte un número hexadecimal a decimal*/
#include <stdio.h>
#include<math.h>
#include<string.h>
#include<conio.h>
float hex_dec(char cadena[]);
void main()
{
char hexa[10];
float numero;
clrscr();
printf("Numero hexadecimal (mayúsculas): ");
gets(hexa);
printf("nCadena= %s",hexa);
numero=hex_dec(hexa);
printf("nEn decimal es : %.0f",numero);
}
float hex_dec(char cadena[])
{
int i,j;
char letra;
float decimal=0;
float temp;
temp=0;
i=strlen(cadena);
/* La función "strlen", que se encuentra en <string.h>
devuelve la longitud de la cadena. */
for (j=0;i>0;j++,i–)
{
letra=cadena[i-1];
printf("n Letra= %c",letra);
switch(letra){
case '1':temp=(1*pow(16,j));
break;
case '2':temp=(2*pow(16,j));
break;
case '3':temp=(3*pow(16,j));
break;
case '4':temp=(4*pow(16,j));
break;
case '5':temp=(5*pow(16,j));
break;
case '6':temp=(6*pow(16,j));
break;
case '7':temp=(7*pow(16,j));
break;
case '8':temp=(8*pow(16,j));
break;
case '9':temp=(9*pow(16,j));
break;
case '0':temp=(0*pow(16,j));
break;
case 'A':temp=(10*pow(16,j));
break;
case 'B':temp=(11*pow(16,j));
break;
case 'C':temp=(12*pow(16,j));
break;
case 'D':temp=(13*pow(16,j));
break;
case 'E':temp=(14*pow(16,j));
break;
case 'F':temp=(15*pow(16,j));
break;
}
decimal+=temp;
}
return(decimal);
}
- Prog079
/* Prog079.cpp */
/* Función que cuenta las cifras en binario de un número decimal */
#include <stdio.h>
int numerocifras(int n);
void main()
{
int n;
printf("nEscribe un número natural: ");scanf("%d",&n);
printf("nnEl número de cifras en binario es: %d",numerocifras(n));
}
int numerocifras(int n)
{
int i;
i=1;
while (n>=2)
{
n=int(n/2);
i=i+1;
}
return i;
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog079.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
- Prog080
/* Prog080.cpp */
/* Programa que escribe un número decimal en binario */
#include <stdio.h>
#include <conio.h>
int numerocifras(int n);
void main()
{
int numci,n,i,cifra;
printf("nEscribe un número natural: ");scanf("%d",&n);
printf("nnEl número en binario es:");
numci=numerocifras(n);
i=0;
while (n>=2)
{
cifra=n%2;
gotoxy(numci-i,8);
printf("%d",cifra);
n=int(n/2);
i++;
}
gotoxy(numci-i,8);
printf("%d",n);
}
int numerocifras(int n)
{
int i;
i=1;
while (n>=2)
{
n=int(n/2);
i=i+1;
}
return i;
}
La función gotoxy(a,b) que se encuentra en el fichero conio.h, sitúa el cursor en la columna a, fila b. De forma que si escribimos:
gotoxy(3,9);printf("Hola");
aparecerá en la columna 3, fila 9 la palabra Hola.
- Prog081
/* Prog081.cpp */
/* Programa que escribe un número decimal en base 3 */
#include <stdio.h>
#include <conio.h>
int numerocifras(int n);
void main()
{
int numci,n,i,cifra;
printf("nEscribe un número natural: ");scanf("%d",&n);
// printf("nnEl número en base 3 es:");
numci=numerocifras(n);
i=0;
while (n>=3)
{
cifra=n%3;
gotoxy(numci-i,8);
printf("%d",cifra);
n=int(n/3);
i++;
}
gotoxy(numci-i,8);
printf("%d",n);
}
int numerocifras(int n)
{
int i;
i=1;
while (n>=3)
{
n=int(n/3);
i=i+1;
}
return i;
}
- Prog082
/* Prog082.cpp */
/* Programa que escribe un número decimal en base 4 */
#include <stdio.h>
#include <conio.h>
int numerocifras(int n);
void main()
{
int numci,n,i,cifra;
printf("nEscribe un número natural: ");scanf("%d",&n);
printf("nnEl número en base 4 es:");
numci=numerocifras(n);
i=0;
while (n>=4)
{
cifra=n%4;
gotoxy(numci-i,8);
printf("%d",cifra);
n=int(n/4);
i++;
}
gotoxy(numci-i,8);
printf("%d",n);
}
int numerocifras(int n)
{
int i;
i=1;
while (n>=4)
{
n=int(n/4);
i=i+1;
}
return i;
}
Recuerda:
- Escribe el programa anterior utilizando tu compilador.
- Grábalo con el nombre Prog082.cpp en TuCarpeta.
- Ejecútalo un par o tres de veces
| Página siguiente |