Ejercicio 1

#include <stdio.h>

// Función que determina si un número es par o impar

char* esParOImpar(int numero) {

if (numero % 2 == 0) {

return "par";

} else {

return "impar";

int main() {

int numero;

printf("Ingrese un número para verificar si es par o impar: ");

scanf("%d", &numero);

char *resultado = esParOImpar(numero);

printf("El número %d es %s.\n", numero, resultado);

return 0;

Corrida:
Ejercicio 2:
#include <stdio.h>

// Función para llenar el arreglo

void llenarArreglo(float arreglo[], int n) {

for (int i = 0; i < n; i++) {

printf("Ingrese la calificación %d: ", i + 1);

scanf("%f", &arreglo[i]);

// Función para calcular el promedio

float calcularPromedio(float arreglo[], int n) {

float suma = 0;

for (int i = 0; i < n; i++) {

suma += arreglo[i];

return suma / n;

}
int main() {

int n;

printf("Ingrese el tamaño del arreglo: ");

scanf("%d", &n);

if (n <= 0) {

printf("Tamaño de arreglo no válido.\n");

return 1; // Salir del programa con código de error

float calificaciones[n]; // Declarar un arreglo de tamaño n

llenarArreglo(calificaciones, n); // Llenar el arreglo con calificaciones

float promedio = calcularPromedio(calificaciones, n); // Calcular el promedio

printf("Calificaciones ingresadas:\n");

for (int i = 0; i < n; i++) {

printf("Calificación %d: %.2f\n", i + 1, calificaciones[i]);

printf("El promedio de las calificaciones es: %.2f\n", promedio);

return 0;

Corrida:
Ejercicio 3:
#include <stdio.h>

// Función para llenar una matriz

void llenarMatriz(int matriz[][100], int m, int n) {

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

printf("Ingrese el elemento en la posición (%d, %d): ", i + 1, j + 1);

scanf("%d", &matriz[i][j]);

// Función para calcular la suma de dos matrices

void sumarMatrices(int matriz1[][100], int matriz2[][100], int resultado[][100], int m, int n) {

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

resultado[i][j] = matriz1[i][j] + matriz2[i][j];

}
// Función para mostrar una matriz

void mostrarMatriz(int matriz[][100], int m, int n) {

printf("Matriz resultante:\n");

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

printf("%d\t", matriz[i][j]);

printf("\n");

int main() {

int m, n;

printf("Ingrese el número de filas (m) de las matrices: ");

scanf("%d", &m);

printf("Ingrese el número de columnas (n) de las matrices: ");

scanf("%d", &n);

int matriz1[100][100], matriz2[100][100], resultado[100][100];

printf("Llenar la primera matriz:\n");

llenarMatriz(matriz1, m, n);

printf("Llenar la segunda matriz:\n");

llenarMatriz(matriz2, m, n);

sumarMatrices(matriz1, matriz2, resultado, m, n);

mostrarMatriz(resultado, m, n);

return 0;

}
Ejercicio 4:
#include <stdio.h>

// Definición de la estructura para almacenar los datos del estudiante

struct Estudiante {

int matricula;

char nombre[100];

char carrera[100];

float promedio;

char direccion[100];

};

// Función para capturar los datos de un estudiante

void capturaDatosEstudiante(struct Estudiante *estudiante) {

printf("Ingrese la matrícula del estudiante: ");

scanf("%d", &estudiante->matricula);

printf("Ingrese el nombre del estudiante: ");

scanf(" %[^\n]s", estudiante->nombre);

printf("Ingrese la carrera del estudiante: ");

 scanf(" %[^\n]s", estudiante->carrera);

printf("Ingrese el promedio del estudiante: ");

scanf("%f", &estudiante->promedio);

printf("Ingrese la dirección del estudiante: ");

scanf(" %[^\n]s", estudiante->direccion);

// Función para mostrar los datos de un estudiante

void mostrarDatosEstudiante(struct Estudiante estudiante) {

printf("Matrícula: %d\n", estudiante.matricula);

printf("Nombre: %s\n", estudiante.nombre);

printf("Carrera: %s\n", estudiante.carrera);

printf("Promedio: %.2f\n", estudiante.promedio);

printf("Dirección: %s\n", estudiante.direccion);

int main() {

struct Estudiante estudiante; // Declarar una variable de tipo struct Estudiante

printf("Captura de datos del estudiante:\n");

capturaDatosEstudiante(&estudiante); // Llamar a la función para capturar datos

printf("\nDatos del estudiante:\n");

mostrarDatosEstudiante(estudiante); // Llamar a la función para mostrar datos

return 0;

Corrida:
1. ¿Qué es una función?
2. ¿Qué es la llamada a una función?
3. ¿Cuál es la diferencia entre argumentos formales y argumentos reales?
4. ¿La instrucción return sólo puede aparecer una vez dentro de una
función? Justifica brevemente
5. ¿Podemos llamar a una función más de una vez desde distintas partes
de un programa? Justifica brevemente
6. ¿Qué diferencia existe entre el paso de argumentos por valor y el paso
de argumentos por referencia?
7. ¿De qué se vale C para implementar el paso de argumentos por
referencia?
8. ¿Cuándo es recursiva una función?
9. ¿Qué son las funciones de biblioteca?
10.¿Cómo se pasan los argumentos a la función scanf?

1. Una función es un bloque de código que realiza una tarea específica.

2. La llamada a una función es cuando se ejecuta el código de una función

desde otro lugar del programa.

3. Argumentos formales son los parámetros definidos en la función;

argumentos reales son los valores pasados a la función.
 4. No, la instrucción `return` puede aparecer varias veces en una función.

5. Sí, se puede llamar a una función más de una vez desde diferentes partes del
programa.

6. El paso por valor copia el valor original, el paso por referencia utiliza
punteros para modificar la variable original.

7. En C, se utiliza punteros para implementar el paso de argumentos por

referencia.

8. Una función es recursiva cuando se llama a sí misma dentro de su propio

cuerpo.

9. Las funciones de biblioteca son conjuntos de funciones predefinidas en un

lenguaje de programación.

10. Los argumentos se pasan a `scanf` utilizando la dirección de memoria de las

variables precedidas por `&`. Por ejemplo, `scanf("%d %f", &entero,
&flotante);`.

Conclusión:
La definición de funciones es esencial en programación estructurada ya que
permite modularizar y organizar el código, lo que facilita el manejo de arreglos
y estructuras de datos al dividir tareas en funciones independientes. Esto
mejora la legibilidad, reutilización y mantenibilidad del código, lo que es
fundamental al trabajar con datos complejos en programas.