16/11/2022 ; 5:28 PM

4. Funciones/Programas/Programa 4.1/Programa 4.1.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+/* Cubo-1.
+El programa calcula el cubo de los 10 primeros números naturales con la
+ayuda de una función. En la solución del problema se utiliza una variable
+global, aunque esto, como veremos más adelante, no es muy recomendable. */
+
+int cubo(void);     /* Prototipo de función. */
+int I;              /* Variable global. */
+
+void main(void)
+{
+int CUB;
+for (I = 1; I <= 10; I++)
+{
+CUB = cubo(); /* Llamada a la función cubo. */
+printf("\nEl cubo de %i es: %i", I, CUB);
+}
+}
+int cubo(void) /* Declaración de la función. */
+/* La función calcula el cubo de la variable global I. */
+{
+return (I*I*I);
+}

4. Funciones/Programas/Programa 4.10/Programa 4.10.c

@@ -0,0 +1,30 @@
+# include <stdio.h>
+/* Múltiplo.
+El programa, al recibir como datos dos números enteros, determina si
+➥ el segundo es múltiplo del primero. */
+
+int multiplo(int, int); /* Prototipo de función. */
+
+void main(void)
+{
+int NU1, NU2, RES;
+printf("\nIngresa los dos numeros: ");
+scanf("%d %d", &NU1, &NU2);
+RES = multiplo(NU1, NU2);
+
+if (RES)
+printf("\nEl segundo numero es multiplo del primero");
+else
+printf("\nEl segundo numero no es multiplo del primero");
+}
+
+int multiplo(int N1, int N2)
+/* Esta función determina si N2 es múltiplo de N1. */
+{
+int RES;
+if ((N2 % N1) == 0)
+RES = 1;
+else
+RES = 0;
+return (RES);
+}

4. Funciones/Programas/Programa 4.11/Programa 4.11.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+/* Mayor divisor. 
+El programa, al recibir como dato un número entero positivo, calcula
+➥ su mayor divisor. */
+
+int mad(int); /* Prototipo de función. */
+
+void main(void)
+{
+int NUM = 0, RES;
+printf("\nIngresa el numero: ");
+
+scanf("%i", &NUM);
+RES = mad(NUM);
+printf("\nEl mayor divisor de %d es: %d", NUM, RES);
+}
+
+int mad(int N1)
+/* Esta función calcula el mayor divisor del número N1. */
+{
+int I = (N1 / 2); 
+/* I se inicializa con el máximo valor posible que puede ser divisor
+➥ de N1. */
+while (N1 % I) 
+/* El ciclo se mantiene activo mientras (N1 % I) sea distinto de cero.
+➥ Cuando el resultado sea 0, se detiene, ya que se habrá encontrado
+➥ el mayor divisor de N1. */
+I--;
+return I;
+}

4. Funciones/Programas/Programa 4.12/Programa 4.12.c

@@ -0,0 +1,35 @@
+# include <stdio.h>
+/* Máximo común divisor.
+El programa, al recibir como datos dos números enteros, calcula el máximo
+➥ común divisor de dichos números. */
+
+int mcd(int, int);
+
+void main(void)
+{
+int NU1, NU2, RES;
+printf("\nIngresa los dos numeros enteros: ");
+scanf("%d %d", &NU1, &NU2);
+RES = mcd (NU1, NU2);
+printf("\nEl maximo comun divisor de %d y %d es: %d", NU1, NU2, RES);
+}
+
+int mcd(int N1, int N2)
+/* Esta función calcula el máximo común divisor de los números N1
+➥ y N2. */
+{
+int I;
+if (N1 < N2)
+I = N1 / 2;
+else
+I = N2 / 2;
+/* I se inicializa con el máximo valor posible que puede ser divisor
+➥ de N1 y N2. */
+
+while ((N1 % I) || (N2 % I))
+/* El ciclo se mantiene activo mientras (N1 % I) o (N2 % I) sean
+➥ distintos de cero. Cuando el resultado de la evaluación sea 0, el
+➥ ciclo se detiene ya que se habrá encontrado el máximo común divisor. */
+I--;
+return I;
+}

4. Funciones/Programas/Programa 4.13/Programa 4.13.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <math.h>
+/* Pares e impares.
+El programa, al recibir como datos N números enteros, calcula cuántos
+➥ de ellos son pares y cuántos impares, con la ayuda de una función. */
+
+void parimp(int, int *, int *); /* Prototipo de función. */
+
+void main(void)
+{
+int I, N, NUM, PAR = 0, IMP = 0;
+printf("Ingresa el numero de datos: ");
+scanf("%i", &N);
+
+for (I =1; I <= N; I++)
+{
+printf("Ingresa el numero %i: ", I);
+scanf("%i", &NUM);
+parimp(NUM, &PAR, &IMP);
+/* Llamada a la función. Paso de parámetros por valor y por
+➥ referencia. */
+}
+printf("\nNumero de pares: %d", PAR);
+printf("\nNumero de impares: %d", IMP);
+}
+
+void parimp(int NUM, int *P, int *I)
+/* La función incrementa el parámetro *P o *I, según sea el número par
+➥ o impar. */ 
+{
+int RES;
+RES = pow(-1, NUM);
+if (RES > 0)
+*P += 1;
+else
+if (RES < 0)
+*I += 1;
+}

4. Funciones/Programas/Programa 4.14/Programa 4.14.c

@@ -0,0 +1,53 @@
+#include<stdio.h>
+/* Rango de calificaciones.
+El programa, al recibir como dato una serie de calificaciones, obtiene
+➥ el rango en el que se encuentran.*/
+
+void Rango(int); /* Prototipo de función. */
+
+int RA1 = 0;
+int RA2 = 0;
+int RA3 = 0; /* Variables globales de tipo entero. */
+int RA4 = 0;
+int RA5 = 0;
+/* El uso de variables globales no es muy recomendable. En estos
+➥ problemas se utilizan únicamente con el objetivo de que el lector
+➥ pueda observar la forma en que se aplican. */
+
+void main(void)
+{
+	float CAL;
+	printf("Ingresa la primera calificacion del alumno: ");
+	scanf("%f", &CAL);
+	while (CAL != -1)
+	{
+		Rango(CAL); /* Llamada a la función Rango. Se pasa un parámetro
+		por valor. */
+		printf("Ingresa la siguiente calificacion del alumno: ");
+		scanf("%f", &CAL);
+	}
+	printf("\n0..3.99 = %d", RA1);
+	printf("\n4..5.99 = %d", RA2);
+	printf("\n6..7.99 = %d", RA3);
+	printf("\n8..8.99 = %d", RA4);
+	printf("\n9..10 = %d", RA5);
+}
+
+void Rango(int VAL)
+/* La función incrementa una variable dependiendo del valor del
+➥ parámetro VAL. */
+{
+	if (VAL < 4)
+		RA1++;
+	else
+		if (VAL < 6)
+			RA2++;
+		else
+			if (VAL < 8)
+				RA3++;
+			else
+				if (VAL < 9)
+					RA4++;
+				else
+					RA5++;
+}

4. Funciones/Programas/Programa 4.15/Programa 4.15.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+/* Productoria.
+El programa calcula la productoria de los N primeros números naturales. */
+
+int Productoria(int); /* Prototipo de función. */
+
+void main(void)
+{
+	int NUM;
+	/* Se escribe un do-while para verificar que el número del cual se
+	➥ quiere calcular la productoria sea correcto. */
+	
+	do
+	{
+		printf("Ingresa el numero del cual quieres calcular la productoria : ");
+		scanf("%i", &NUM);
+	} while (NUM > 100 || NUM < 1);
+	
+	printf("\nLa productoria de %i es: %i", NUM, Productoria(NUM));
+}
+int Productoria(int N)
+/* La función calcula la productoria de N. */
+{
+	int I, PRO = 1;
+	for (I = 1; I <= N; I++)
+		PRO *= I;
+	return (PRO);
+}

4. Funciones/Programas/Programa 4.16/Programa 4.16.c

@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <math.h>
+
+/* Temperaturas.
+El programa recibe como datos 24 números reales que representan las
+➥ temperaturas en el exterior en un período de 24 horas. Calcula el
+➥ promedio del día y las temperaturas máxima y mínima con la hora en la
+➥ que se registraron. */
+
+void Acutem(float);
+void Maxima(float, int); /* Prototipos de funciones. */
+void Minima(float, int);
+
+float ACT = 0.0;
+float MAX = -50.0; /* Variables globales. */
+float MIN = 60.0;
+int HMAX = 0;
+int HMIN = 0;
+
+/* Variables globales. ACT se utiliza para acumular las temperaturas,
+➥ por esa razón se inicializa en cero. MAX se utiliza para calcular la
+➥ máxima; se inicializa en –50 para que el primer valor que se ingrese
+➥ modifique su contenido. MIN se usa para calcular la mínima; se
+➥ inicializa con un valor muy alto para que el primer valor ingresado
+➥ modifique su contenido. HMAX y HMIN se utilizan para almacenar el
+➥ horario en que se produjeron las temperaturas máxima y mínima,
+➥ respectivamente. */
+
+void main(void)
+{
+	float TEM;
+	int I;
+	for (I = 1; I <= 24; I++)
+	{
+		printf("Ingresa la temperatura de la hora %d: ", I);
+		scanf("%f", &TEM);
+		Acutem(TEM);
+		Maxima(TEM, I); /* Llamada a las funciones. Paso de parámetros por valor. */
+		Minima(TEM, I);
+	}
+
+	printf("\nPromedio del dia: %.2f", (ACT / 24));
+	printf("\nMaxima del dia: %.2f \tHora: %d", MAX, HMAX);
+	printf("\nMinima del dia: %.2f \tHora: %d", MIN, HMIN);
+}
+void Acutem(float T)
+/* Esta función acumula las temperaturas en la variable global ACT
+➥ para posteriormente calcular el promedio. */
+{
+	ACT += T;
+}
+
+void Maxima(float T, int H)
+/* Esta función almacena la temperatura máxima y la hora en que se
+➥ produjo en las variables globales MAX y HMAX, respectivamente. */
+{
+	if (MAX < T)
+	{
+		MAX = T;
+		HMAX = H;
+	}
+}
+
+void Minima(float T, int H)
+/* Esta función almacena la temperatura mínima y la hora en que se
+➥ produjo en las variables globales MIN y HMIN. */
+{
+	if (MIN > T)
+	{
+		MIN = T;
+		HMIN = H;
+	}
+}
+

4. Funciones/Programas/Programa 4.17/Programa 4.17.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+/* Lluvias.
+El programa permite calcular el promedio mensual de las lluvias caídas en
+➥ tres regiones importantes del país. Determina también cuál es la región
+➥ con mayor promedio de lluvia anual. */
+void Mayor(float, float, float); /* Prototipo de función. */
+void main(void)
+{
+	int I;
+	float GOL, PAC, CAR, AGOL = 0, APAC = 0, ACAR = 0;
+	for (I = 1; I <= 12; I++)
+	{
+		printf("\n\nIngresa las lluvias del mes %d", I);
+		printf("\nRegiones Golfo, Pacifico y Caribe: ");
+		scanf("%f %f %f", &GOL, &PAC, &CAR);
+		AGOL += GOL;
+		APAC += PAC;
+		ACAR += CAR;
+	}
+	printf("\n\nPromedio de lluvias Region Golfo: %.2f", (AGOL / 12));
+	printf("\nPromedio de lluvias Region Pacifico: %.2f", (APAC / 12));
+	printf("\nPromedio de lluvias Region Caribe: %.2f \n", (ACAR / 12));
+	
+	Mayor(AGOL, APAC, ACAR);
+	/* Se llama a la función Mayor. Paso de parámetros por valor. */
+}
+void Mayor(float R1, float R2, float R3)
+/* Esta función obtiene la región con mayor promedio de lluvia anual. */
+{
+	if (R1 > R2)
+		if (R1 > R3)
+			printf("\nRegion con mayor promedio: Region Golfo. Promedio: %.2f", R1 / 12);
+		else
+			printf("\nRegion con mayor promedio: Region Caribe. Promedio: %.2f", R3 / 12);
+	else if (R2 > R3)
+		printf("\nRegion con mayor promedio: Region Pacifico. Promedio: %.2f", R2 / 12);
+	else
+		printf("\nRegion con mayor promedio: Region Caribe. Promedio: %.2f", R3 / 12);
+}

4. Funciones/Programas/Programa 4.2/Programa 4.2.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+/* Mayor divisor. 
+El programa, al recibir como dato un número entero positivo, calcula
+➥ su mayor divisor. */
+
+int mad(int); /* Prototipo de función. */
+
+void main(void)
+{
+int NUM = 0, RES;
+printf("\nIngresa el numero: ");
+
+scanf("%i", &NUM);
+RES = mad(NUM);
+printf("\nEl mayor divisor de %d es: %d", NUM, RES);
+}
+
+int mad(int N1)
+/* Esta función calcula el mayor divisor del número N1. */
+{
+int I = (N1 / 2); 
+/* I se inicializa con el máximo valor posible que puede ser divisor
+➥ de N1. */
+while (N1 % I) 
+/* El ciclo se mantiene activo mientras (N1 % I) sea distinto de cero.
+➥ Cuando el resultado sea 0, se detiene, ya que se habrá encontrado
+➥ el mayor divisor de N1. */
+I--;
+return I;
+}

4. Funciones/Programas/Programa 4.3/Programa 4.3.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+/* Conflicto de variables con el mismo nombre. */
+
+void f1(void); /* Prototipo de función. */
+
+int K = 5; /* Variable global. */
+
+void main (void)
+{
+int I;
+for (I = 1; I <= 3; I++)
+f1();
+}
+
+void f1(void)
+/* La función utiliza tanto la variable local I como la variable
+➥global I. */ 
+{
+int K = 2; /* Variable local. */
+K += K;
+printf("\n\nEl valor de la variable local es: %d", K);
+/*Revisar*/K = K + K; /* Uso de ambas variables. */
+printf("\nEl valor de la variable global es: %d", K);
+}

4. Funciones/Programas/Programa 4.4/Programa 4.4.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+/* Prueba de variables globales, locales y estáticas.
+El programa utiliza funciones en las que se usan diferentes tipos de
+➥ variables. */
+
+int f1(void);
+int f2(void);
+int f3(void); /* Prototipos de funciones. */
+int f4(void);
+int K = 3; /* Variable global. */
+void main(void)
+{
+int I;
+for (I = 1; I <= 3; I++)
+{
+printf("\nEl resultado de la función f1 es: %d", f1());
+printf("\nEl resultado de la función f2 es: %d", f2());
+printf("\nEl resultado de la función f3 es: %d", f3());
+printf("\nEl resultado de la función f4 es: %d", f4());
+}
+}
+int f1(void)
+/* La función f1 utiliza la variable global. */
+{
+K += K; 
+return (K);
+}
+int f2(void)
+/* La función f2 utiliza la variable local. */
+{
+int K = 1;
+K++; 
+return (K);
+}
+int f3(void)
+/* La función f3 utiliza la variable estática. */
+{
+static int K = 8;
+K += 2; 
+return (K);
+}
+int f4(void)
+/* La función f4 utiliza dos variables con el mismo nombre: local
+➥ y global. */
+{
+int K = 5;
+/*Revisar*/K = K + ::K; /* Uso de la variable local (K) y global (::K) */
+return (K);
+}

4. Funciones/Programas/Programa 4.5/Programa 4.5.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+/* Cubo-3.
+El programa calcula el cubo de los 10 primeros números naturales con la
+➥ ayuda de una función y utilizando parámetros por valor. 
+int cubo(int); /* Prototipo de función. El parámetro es de
+➥ tipo entero. */
+
+void main(void)
+{
+
+int I; 
+for (I = 1; I <= 10; I++)
+printf("\nEl cubo de I es: %d", cubo(I)); 
+/* Llamada a la función cubo. El paso del parámetro es por valor. */ 
+}
+int cubo(int K) /* K es un parámetro por valor de tipo entero. */
+/* La función calcula el cubo del parámetro K. */
+{
+return (K*K*K);
+}

4. Funciones/Programas/Programa 4.6/Programa 4.6.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+/* Prueba de parámetros por referencia. */
+void f1(int *);
+/* Prototipo de función. El parámetro es de tipo entero y por referencia
+—observa el uso del operador de indirección. */
+
+void main(void)
+{
+int I, K = 4;
+for (I = 1; I <= 3; I++)
+{
+printf("\n\nValor de K antes de llamar a la función: %d", ++K);
+printf("nValor de K después de llamar a la función: %d", f1(&K));
+/* Llamada a la función f1. Se pasa la dirección de la variable K,
+➥ por medio del operador de dirección: &. */ 
+}
+}
+
+void f1(int *R) 
+/* La función f1 recibe un parámetro por referencia. Cada vez que el
+➥ parámetro se utiliza en la función debe ir precedido por el operador de
+➥ indirección. */
+{
+*R += *R;
+}

4. Funciones/Programas/Programa 4.7/Programa 4.7.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+/* Prueba de parámetros por valor. */
+
+int f1 (int); /* Prototipo de función. El parámetro es por valor
+➥ y de tipo entero. */ 
+
+void main(void)
+{
+int I, K = 4;
+for (I = 1; I <= 3; I++)
+{
+printf("\n\nValor de K antes de llamar a la función: %d", ++K);
+printf("\nValor de K después de llamar a la función: %d", f1(K));
+/* Llamada a la función f1. Se pasa una copia de la variable K. */
+}
+}
+
+int f1(int R)
+{
+R += R;
+return (R);
+}

4. Funciones/Programas/Programa 4.8/Programa 4.8.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+/* Combinación de variables globales y locales, y parámetros por valor
+➥ y por referencia. */
+
+int a, b, c, d; /* Variables globales. */
+
+void funcion1(int *, int *);
+/* Prototipo de función. Observa que los dos parámetros son por
+➥ referencia. */
+
+int funcion2(int, int *);
+/* En este prototipo el primer parámetro es por valor y el segundo por
+➥ referencia. */
+
+void main(void)
+{
+int a; /* Nota que a es una variable local. */
+a = 1; /* Se asigna un valor a la variable local a. */
+b = 2; /* Se asignan valores a las variables globales b, c y d. */
+c = 3;
+d = 4;
+printf("\n%d %d %d %d", a, b, c, d);
+funcion1 (&b, &c);
+printf("\n%d %d %d %d", a, b, c, d);
+a = funcion2(c, &d);
+printf("\n%d %d %d %d", a, b, c, d);
+}
+
+void funcion1(int *b, int *c)
+{
+int d;
+a = 5; /* Observa que se hace referencia a la variable global a. */
+d = 3; /* Nota que se hace referencia a la variable local d. */
+(*b)++;
+(*c) += 2;
+printf("\n%d %d %d %d", a, *b, *c, d);
+}
+
+int funcion2(int c, int *d)
+{
+int b;
+a++;
+b = 7;
+c += 3;
+(*d) += 2;
+printf("\n%d %d %d %d", a, b, c, *d);
+return (c);
+}

4. Funciones/Programas/Programa 4.9/Programa 4.9.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+/* Paso de una función como parámetro por referencia. */
+
+int Suma(int X, int Y)
+/* La función Suma regresa la suma de los parámetros de tipo entero
+➥ X y Y. */
+{
+return (X+Y);
+}
+
+int Resta(int X, int Y)
+/* Esta función regresa la resta de los parámetros de tipo entero
+➥ X y Y. */
+{
+return (X-Y);
+}
+
+int Control(int (*apf) (int, int), int X, int Y)
+/* Esta función recibe como parámetro otra función —la dirección— y
+➥ dependiendo de cuál sea ésta, llama a la función Suma o Resta. */
+{
+int RES;
+RES = (*apf) (X, Y); /* Se llama a la función Suma o Resta. */
+return (RES);
+}
+
+void main(void)
+{
+int R1, R2;
+R1 = Control(Suma, 15, 5); /* Se pasa como parámetro la función Suma. */
+R2 = Control(Resta, 10, 4); /* Se pasa como parámetro la función Resta.*/
+printf("\nResultado 1: %d", R1);
+printf("\nResultado 2: %d", R2);
+}