Ejercicio 1: El operador de división (/).
Ejercicio 1: El operador de división (/).
Ejercicio 2: Un repaso a la función printf(
).
Ejercicio 3: Y seguimos con los bucles for.
Ejercicio 4: Volvamos a ordenar sin olvidar el desorden
inicial.
Ejercicio 5: Cálculo del determinante de una
matriz 3x3.
Ejercicio 6: El sultán y el estudiante.
Ejercicio 7: Introducción a la Estadística.
Ejercicio 8: Operación con vectores.
Ejercicio 9: Ejercicio de vectores planos.
Ejercicio 10: Repaso de la tabla de multiplicar.
Ejercicio 1: El operador de división (/). |
|
Ejecuta el siguiente programa para aclarar las ideas sobre cómo funciona este operador con distintos tipos de variables. En él se puede comprobar la diferencia entre la división entera y de punto flotante. Guarda el programa como division.c.
/* fichero division.c*/
# include <stdio.h >
void main(void)
{
printf("división entera: 5/4 es %6d\n", 5/4);
printf("división entera: 6/3 es %6d\n", 6/3);
printf("división entera: 7/4 es %6d\n", 7/4);
printf("división flotante: 7./4. es %6.3f\n", 7./4.);
printf("división mixta: 7./4 es %6.3f\n", 7./4);
}
Comentario: Es importante recordar que el tipo de formato debe estar de acuerdo con el tipo del argumento en la función printf(). Para el formato de salida (%6.3f) se tendrán un total de 6 espacios de salida, de los cuales tres serán decimales.
Ejercicio 2: Un repaso a la función printf( ). |
|
El siguiente programa utiliza la función printf( ) para imprimir distintos tipos de variables. Como recordarás cada tipo de variable precisa de su carácter de conversión precedido del carácter %, pudiendo haber entre ambos caracteres uno o varios elementos para el alineamiento por la izquierda, la anchura mínima del campo, etc. Y como una ejecución vale más que mil palabras aquí tienes el programa para que lo puedas probar. Guárdalo con el nombre formatos.c.
/* fichero formatos.c */
#include <stdio.h>
void main(void)
{
int x = 45;
double y = 23.354;
char z[] = "Esto es vida";
/* utilizamos barras inclinadas (/) para ver claramente
la anchura del campo de caracteres */
printf("Voy a escribir /45/ utilizando el formato %%d: /%d/\n", x);
printf("Voy a escribir /45/ utilizando el formato %%1d: /%1d/\n", x);
printf("Voy a escribir /45/ utilizando el formato %%10d: /%10d/\n\n", x);
printf("Voy a escribir /23.354/ utilizando el formato %%f:/%f/\n", y);
printf("Voy a escribir /23.354/ utilizando el formato %%.3f: /%.3f/\n", y);
printf("Voy a escribir /23.354/ utilizando el formato %%5.1f: /%5.1f/\n", y);
printf("Voy a escribir /23.354/ utilizando el formato%%-10.3f:/%-10.3f/\n", y);
printf("Voy a escribir /23.354/ utilizando el formato %%5f: /%5f/\n\n", y);
printf("Voy a escribir /Esto es vida/ utilizando el formato%%s: /%s/\n", z);
printf("Voy a escribir /Esto es vida/ utilizando el formato %%.7s:/%.7s/\n", z);
printf("Voy a escribir /Esto es vida/ utilizando el formato %%-15.10s: /%-15.10s/\n", z);
printf("Voy a escribir /Esto es vida/ utilizando el formato %%15s: /%15s/\n", z);
}
Comentario: Este ejemplo se presenta en una única columna, debido a la anchura de las sentencias. La mejor forma de enteder los formatos es estudiar con mucho cuidado la salida impersa de cada una de las llamadas a la función printf().
Ejercicio 3: Y seguimos con los bucles for. |
|
Para realizar este ejercicio deberás basarte en el programa suma_for.c de la práctica anterior. Modifica este programa de forma que realice la suma y el producto de los n primeros números, siendo n un número que deberá teclear el usuario. La salida del programa deberá ser idéntica a la que se muestra un poco más adelante, es decir, debe ocupar seis líneas y cada salto de línea ha de realizarse en el lugar indicado. En este caso se ha particularizado para una entrada (en negrita, para indicar que es un número tecleado por el usuario) de n=12. Sálvalo como factorial.c y ¡atención a la declaración de variables!
Este programa suma y multiplica los n primeros números enteros, siendo n el número que tú quieras. n: 12 La suma de los 12 primeros números es: 78 El producto de los 12 primeros números, es decir, el factorial de 12 es: 479001600.
/* fichero factorial.c */
#include <stdio.h>
void main(void)
{
int i, suma, n;
long int factorial;
printf("%s%s\n", "Este programa suma y multiplica",
" los n primeros números enteros");
printf("siendo n el número que tú quieras.\n");
printf("n: ");
scanf("%d", &n);
suma = 0;
factorial = 1;
for (i=1; i<=n; i++) {
suma *= i;
factorial *= i;
}
printf("La suma de los %d primeros enteros es: %d\n", n, suma);
printf("El producto de los %d primeros números, es decir,\n", n);
printf("El factorial de %d es%ld\n", n, factorial);
}
Comentario: Obsérvese la primera llamada a la función printf()se realiza utilizando dos cadenas de caracteres como argumentos, que se escriben con los formatos (%s%s). Este método permite acortar una cadena de control muy larga, que debe ocupar una única línea en el fichero fuente del programa. Puede ser también muy útil cuando se quieren subrayar palabras, si se utiliza un número con el %s (%20s escribe la cadena en 20 espacios, aunque su longitud sea menor).
El otro punto a comentar de este programa es la declaración de variables. Obsérvese que se utiliza un long para el factorial en lugar de un int. Esto es debido a que un factorial pasa con facilidad del máximo valor que puede almacenar un int (factorial de 8 ya es mayor que 32767). Incluso si se quiere obtener un valor muy alto se puede utilizar una variable de tipo double aunque los valores que maneje sean enteros (véase Ejercicio 3 de la práctica nº 8).
Ejercicio 4: Volvamos a ordenar sin olvidar el desorden inicial. |
|
Modifica el programa ordena.c que realizaste en la práctica anterior de manera que, además de mostrar el vector ordenado, muestre también el vector original. Además deberá mostrar la posición que cada número ocupaba en el vector inicial. Guarda este programa con nombre reordena.c. Una salida posible podría ser:
El vector inicial es: {7, 23, 5, 1, 8, 3, 12}
El vector ordenado es: {1, 3, 5, 7, 8, 12, 23}
que ocupaban los lugares {4, 6, 3, 1, 5, 7, 2}, respectivamente.
/* fichero reordena.c */
#include <stdio.h>
#define SIZE 7
void main(void)
{
int vector[SIZE], copia[SIZE], orden[SIZE];
int j, i, temp;
printf("Introduzca los %d valores para ordenar:\n", SIZE);
for(i=0; i<SIZE; i++) {
printf("\n%d: ", i+1);
scanf("%d", &vector[i]);
copia[i] = vector[i];
orden[i] = i+1;
}
for (i=0; i<(SIZE-1); i++)
for (j=i+1; j<SIZE; j++)
if (vector[j] < vector[i]) {
temp = vector[j];
vector[j] = vector[i];
vector[i] = temp;
temp = orden[j];
orden[j] = orden[i];
orden[i] = temp;
}
printf("\nEl vector inicial es: { ");
for (i=0; i<SIZE; i++)
printf("%d, ", copia[i]);
printf("\b\b} \n");
printf("El vector ordenado es: { ");
for (i=0; i<SIZE; i++)
printf("%d, ", vector[i]);
printf("\b\b} \n");
printf("que ocupaban los lugares { ");
for (y=0; i<SIZE; i++)
printf("%d, ", orden[i]);
printf("\b\b}, respectivamente.");
}
Comentario: El funcionamiento de este programa se vió en la práctica anterior (ejercicio 4 de la práctica nº 5). Para evitar perder el vector original con el cambio lo que se hace es una simple copia del mismo con la instrucción copia[i] = vector[i]. Para saber en qué posición estaban los elementos en el vector original, se crea un nuevo vector llamado orden[ ], cuyos elementos son los números naturales 1, 2, 3, 4. ... Este vector sufre las mismas permutaciones que el vector inicial, por lo que, al final de la ordenación, sus elementos indicarán que posición ocupaban al principio los elementos del vector ordenado.
Para obtener exactamente la salida impresa solicitada, hay que imprimir las llaves {} y los blancos y comas que separan los elementos de los vectores. Después de escribir cada elemento de un vector se escribe una coma y un blanco. En realidad esto no hay que hacerlo para el último elemento, que debe ir seguido por el cierre de las llaves. Sin embargo, por simplicidad se escriben también en este caso la coma y el blanco, pero luego se imprimen dos caracteres backspace (\b, espacio hacia atrás), con lo cual el cierre de las llaves se imprime sobre la coma.
Ejercicio 5: Cálculo del determinante de una matriz 3x3. |
|
Realiza un programa que calcule el determinante de una matriz 3x3. En el caso de que la matriz sea singular, el programa deberá advertirlo con un mensaje. Guárdalo con el nombre determin.c. Recuerda que la fórmula para el cálculo del determinante es la siguiente:
En vez de tener que introducir la matriz tecleándola cada vez, crea un fichero llamado matriz.d que contenga una matriz cualquiera y haz que el programa principal lea este fichero empleando la función fscanf( ).
/* fichero determin.c */
#include <stdio.h>
#define SIZE 3
void main(void)
{
double matriz[SIZE][SIZE];
double determinante;
int i, j;
printf("Introduzca los elementos de la matriz 3x3:\n");
for (i=0; i<SIZE; i++)
for (j=0; j<SIZE; j++) {
printf("Elemento(%d,%d):", i+1, j+1);
scanf("%lf", &matriz[i][j]);
}
printf("\n");
determinante = matriz[0][0] * matriz[1][1] * matriz[2][2];
determinante += matriz[0][1] * matriz[1][2] * matriz[2][0];
determinante += matriz[1][0] * matriz[2][1] * matriz[0][2];
determinante -= matriz[0][2] * matriz[1][1] * matriz[2][0];
determinante -= matriz[0][1] * matriz[1][0] * matriz[2][2];
determinante -= matriz[0][0] * matriz[2][1] * matriz[1][2];
printf("La matriz introducida es:\n");
for (i=0; i<SIZE; i++) {
for (j=0; j<SIZE; j++)
printf("%5.2lf", matriz[i][j]);
printf("\n");
}
printf("\nY su determinante es: %12.4lf\n", determinante);
}
Comentario: En principio este programa no existe ninguna dificultad respecto al manejo de las matrices (ya se ha visto en programas anteriores). Lo único que es importante comentar es el algoritmo: tenemos siempre una matriz 3x3 y, por ello, podemos realizar las operaciones "a mano" (sin más complejidades en el algoritmo, es decir, sin introducir bucles o bifurcaciones). Si quisiéramos calcular el determinante de una matriz cualquiera, tendríamos que triangularizar la matriz y, una vez triangularizada, el determinante es el producto de los elementos de la diagonal. En un ejercicio de la práctica 9 se resolverá este problema de modo general.
Es interesante observar como se ha dividido una expresión muy larga en seis expresiones más cortas, utilizando los operadores de suma y diferencia acumulativas (+= y -=).
Ejercicio 6: El sultán y el estudiante. |
|
Habrás oído hablar de la historia de un poderoso sultán que deseaba recompensar a un estudiante que le había prestado un gran servicio. Cuando el sultán le preguntó la recompensa que deseaba, éste le señaló un tablero de ajedrez y solicitó simplemente 1 grano de trigo por la primera casilla, 2 por la segunda, 4 por la tercera, 8 por la siguiente, y así sucesivamente. El sultán, que no debía andar muy fuerte en matemáticas, quedó sorprendido por la modestia de la petición, porque estaba dispuesto a otorgarle riquezas mucho mayores: al menos, eso pensaba él. En el siguiente programa se calcula el número total de granos de trigo que corresponden a cada casilla y se acumula el total. Como el número de granos no es una cantidad que se maneje habituamente, se compara también con una estimación de la producción anual mundial expresada en granos. Guarda este programa con el nombre trigo.c.
/* fichero trigo.c */
#defin3e CUADRADOS 64 /* cuadrados del tablero */
#define COSECHA 4E15 /* cosecha mundial en granos */
#include <stdio.h>
void main(void)
{
double actual, total;
int cont = 1;
printf("Cuadro granos sumados granos totales ");
printf("fraccion de\n");
printf(" ");
printf(" cosecha\n");
total = actual = 1.0; /* comenzamos con un grano */
printf("%4d %15.2e %16.2e %12.2e\n",
cont, actual, total, total/COSECHA);
while (cont<CUADRADOS) {
cont = cont+1;
actual = 2.0*actual; /* duplica granos en cada cuadro */
total = total+actual; /* actualiza total */
printf("%4d %15.2e %16.2e %12.2e\n",
cont, actual, total, total/COSECHA);
}
}
Comentario: El interés de este ejercicio está en ver una forma de disponer los resultados de salida en columnas, formando una tabla. Primero se deben imprimir los encabezamientos de las columnas y lugo las cifras correspondientes a cada línea o fila de la tabla.
Ejercicio 7: Introducción a la Estadística. |
|
Realiza este ejercicio basándote en el programa maximo.c de la práctica anterior y guárdalo con el nombre numeros.c. Este programa deberá realizar las siguientes operaciones:
Tanto el programa principal como las funciones estarán en el mismo fichero numeros.c.
/* fichero numeros.c */
#include <stdio.h>
#define SIZE 20
double media(double*, int);
double maximo(double*, int);
double minimo(double*, int);
double semisuma(double, double);
void main(void)
{
double vector[SIZE];
int n, i;
printf("¨Con cuántos valores desea trabajar?\n");
printf("(el número deberá ser menor de 20)\n");
printf("n: ");
scanf("%d", &n);
printf("\n");
printf("Introduzca los %d valores:\n",n);
for (i=0 ;i<n; i++) {
printf("Valor %d: ", i + 1);
scanf("%lf", &vector[i]);
}
printf("\n");
printf("media= %5.2lf \n", media(vector,n));
printf("maximo= %5.2lf \n", maximo(vector,n));
printf("minimo= %5.2lf \n", minimo(vector,n));
printf("semisuma= %5.2lf \n",
semisuma(maximo(vector, n), minimo(vector, n)));
}
double media(double* valores, int num)
{
double suma=0.0, med;
int i;
for (i=0; i<num ;i++)
suma += valores[i];
med = suma/num;
return (med);
}
double minimo(double* valores, int num)
{
int i;
double min;
min = valores[0];
for (i=1; i<num ;i++)
if (valores[i] < min)
min = valores[i];
return (min);
}
double maximo(double* valores, int num)
{
int i;
double max;
max= valores[0];
for (i=1; i<num ;i++)
if (valores[i] > max)
max = valores[i];
return (max);
}
double semisuma(double max, double min)
{
double semi;
semi = (max+min)/2.0;
return(semi);
}
Comentario: En este fichero se presentan funciones para calcular la media, el máximo, el mínimo, y la semisuma del máximo y el mínimo de los elementos de un conjunto. Cada uno de estos cálculos es muy sencillo. El interés de este ejercicio está en ver cómo se definen, declaran y llaman las distintas funciones que en él aparecen. El resultado de todas estas funciones es un valor único que se devuelve como valor de retorno.
Ejercicio 8: Operación con vectores. |
|
Realiza un programa, que lea dos vectores de 3 componentes, los sume, reste y multiplique, tanto escalar como vectorialmente, imprimiendo después todos estos resultados. Para ello crearás las funciones suma( ), resta ( ), producto_escalar( ) y producto_vectorial( ). Guárdalo como vectores.c.
/* fichero vectores.c */
#include <stdio.h>
void suma( double*, double*, double*);
void resta( double*, double*, double*);
void producto_vectorial(double*, double*, double*);
double producto_escalar(double*, double*);
void main(void)
{
double vector1[3], vector2[3], vecsum[3], vecres[3];
double escalar, prodvect[3];
int i;
printf("Introduzca los valores del primer vector:\n");
for (i=0; i<3; i++) {
printf("\nElmento %d: ", i+1);
scanf("%lf", &vector1[i]);
}
printf("\n");
printf("Introduzca los valores del segundo vector:\n");
for (i=0; i<3; i++) {
printf("\nElemento %d: ", i+1);
scanf("%lf", &vector2[i]);
}
printf("\n");
suma(vector1, vector2, vecsum);
resta(vector1, vector2, vecres);
producto_vectorial(vector1, vector2, prodvect);
printf("\nImprimo resultados: \n\n");
printf("%10s %10s %20s\n", "Suma", "Resta", "Producto Vectorial");
for (i=1; i<=50; i++)
printf("-");
printf("\n");
for (i=0; i<3; i++){
printf("%10.2lf %10.2lf %10.2lf\n", vecsum[i], vecres[i],
prodvect[i]);
printf("\n");
}
printf("Producto escalar = %5.2lf\n",
producto_escalar(vector1,vector2));
printf("----------------\n");
}
void suma(double* vec1, double* vec2, double* sum)
{
int i;
for (i=0; i<3; i++)
sum[i] = vec1[i] + vec2[i];
return;
}
void resta(double* vec1, double* vec2, double* res)
{
int i;
for (i=0; i<3; i++)
res[i] = vec1[i] - vec2[i];
return;
}
void producto_vectorial(double* vec1, double* vec2, double* vectorial)
{
vectorial[0] = vec1[1]*vec2[2] - vec2[1]*vec1[2];
vectorial[1] = vec1[2]*vec2[0] - vec2[2]*vec1[0];
vectorial[2] = vec1[0]*vec2[1] - vec2[0]*vec1[1];
return;
}
double producto_escalar(double* vec1, double* vec2)
{
double escalar = 0.0;
int i;
for (i=0; i<3; i++)
escalar += vec1[i] * vec2[i];
return (escalar);
}
Comentario: Este ejercicio es similar al anterior, pero con algunas diferencias interesantes. La más importante es que el resultado de algunas operaciones con vectores (como la suma, la diferencia o el producto vectorial), son también vectores. Por tanto el resultado de dichas operaciones no es un valor único y no se devuelve como valor de retorno. Lo que se ce es pasar todos los vectores como argumentos por referencia. Como el nombre de un vector es la dirección de su primer elemento, la función es capaz de recibir datos y devolver resultados leyendo y escribiendo en las zonas de memoria adecuadas.
En el momento de imprimir resultados, se puede hacer que los letreros de suma, resta y producto vectorial, sean colocados a la hora de imprimir con cierto espacio el cual le dé un poco más de presentación a los resultados. Esto se hace con instrucciones de cadenas de caracteres reservando los espacios que consideramos necesarios (p.ej: %10s, reserva un espacio mínimo de 10 caracteres para imprimir el letrero correspondiente). Se ha incluido un bucle for que realiza una línea discontinua para subrayar los títulos. Luego, a los resultados se le da el formato indicado para que ocupen un número de espacios acorde con los títulos.
Ejercicio 9: Ejercicio de vectores planos. |
|
Sean dos vectores planos (2 coordenadas) a[ ] y b[ ]. Si a[ ] y b[ ] son linealmente independientes, cualquier vector plano c[ ] podrá ser expresado como combinación lineal de ellos:
c[ ] = alfa * a[ ] + beta * b[ ]
Realizar un programa llamado vector2d.c que lea los vectores a[ ], b[ ] y c[ ] y calcule los coeficientes alfa y beta. El programa deberá distinguir 3 casos:
1.-a[ ] y b[ ] son linealmente independientes (1 solución).
2.-a[ ] y b[ ] son linealmente dependientes y c[ ] es colineal con ellos (infinitas soluciones). Elegir la solución de módulo mínimo.
3.-a[ ] y b[ ] son linealmente dependientes y c[ ] no es colineal con ellos (no hay ninguna solución).
/* fichero vector2d.c */
#include <stdio.h>
void main(void)
{
double a[2], b[2], c[2];
double alfa, beta, aux;
printf("Introduzca los siguientes datos:\n");
printf("a1: ");
scanf("%lf", &a[0]);
printf("a2: ");
scanf("%lf", &a[1]);
printf("b1: ");
scanf("%lf", &b[0]);
printf("b2: ");
scanf("%lf", &b[1]);
printf("c1: ");
scanf("%lf", &c[0]);
printf("c2: ");
scanf("%lf", &c[1]);
aux = a[0]*b[1] - a[1]*b[0];
if (aux!=0.0) {
alfa = (c[0]*b[1] - c[1]*b[0])/aux;
beta = (c[1]*a[0] - c[0]*a[1])/aux;
printf("El problema tiene solución:\n");
printf("alfa=%lf\nbeta=%lf\n", alfa, beta);
}
else {
printf("a y b linealmente dependientes.\n");
if (a[0]*c[1]==c[0]*a[1]){
printf("c es colineal con a y b: infinitas soluciones.\n");
alfa = (a[0]*c[0])/(a[0]*a[0] + a[1]*a[1]);
beta = (a[1]*c[0])/(a[0]*a[0] + a[1]*a[1]);
printf("La solución de módulo mínimo es:\n");
printf("alfa=%lf\nbeta=%lf\n", alfa, beta);
}
else
printf("No hay solución.\n");
}
}
Comentario: El algoritmo para la resolución de este programa (resolución en C de un sistema de dos ecuaciones lineales con dos incógnitas), se ha basado en la descomposición de Cramer y se tienen en cuenta los diferentes valores de la matriz del sistema cuyo valor es la variable aux.
Respecto a la comparación numérica de variables tipo double hay que decir que es preferible realizar la comparación con números muy pequeños que nos marquen un límite, por ejemplo, la sentencia if ( a[0]*c[1] == c[0]*a[1] ) sería más recomendable poner if ( (a[0]*c[1] - c[0]*a[1] ) < 1.0e-10 ). Esto es debido a que en el manejo de números decimales en el ordenador, siempre existe un error correspondiente al número máximo de cifras significativas que puede almacenar la variable. Por ese motivo, consideramos "cero" los valores inferiores a 1.0e-10 en este caso.
Para calcular la solución de modulo mínimo el caso de ser a y b colineales y ser c colineal a su vez con a y b, utilizamos una operación de máximos y mínimos que nos da como solución:
alfa = a[1]*c[1]/(a[1]*a[1] + a[2]*a[2]) beta = a[2]*c[1]/(a[1]*a[1] + a[2]*a[2])
Ejercicio 10: Repaso de la tabla de multiplicar. |
|
Qué mejor momento que éste para recordar aquellos tiernos años en los que aprendimos a multiplicar. Te proponemos este programa que imprime los 21 primeros números y sus repectivos cuadrados de tres formas distintas. Para ejecutar de forma pausada el programa hemos introducido la función getchar( ) que espera que pulses cualquier tecla para capturar el carácter correspondiente (en este caso no se hace nada con dicho carácter, que está disponible como valor de retorno; es un simple truco para que el ordenador espere hasta que pulsemos una tecla cualquiera) y continuar ejecutando el programa.
/* fichero cuadrado.c */
# include <stdio.h>
void main(void)
{
int num=1;
while (num<21) {
printf("%10d %10d\n", num, num*num);
num = num + 1;
}
getchar();
num = 1;
while(num<21) {
printf("%10d %10d\n", num, num*num);
num += 1;
}
getchar();
num = 1;
while(num<21) {
printf("%10d %10d\n", num, num*num);
num++;
}
}
Comentario: En este programa las instrucciones: num=num+1, num +=1 y num++, las podrás utilizar de la forma que más te convenga, es decir, que la utilidad de una sobre otra se dará en la medida que quieras simplificar tus programas que realizarás más adelante. Como ya hemos dicho la macro getchar() espera a el usario teclee un valor cualquiera para continuar ejecutando el programa. Es una forma de espaciar con un intervalo de tiempo definido por el usario para continuar con la solución del programa.