Menu

 1 ingresar alumnos n
 2 buscar 1 alumno(x apelldo
 3 alumno con nota mas baja
 4 alumno con nota mas alta
 5 cantidad de reprobados(nota<60)
 6 cantidad de aprobados(nota>60)
 7 salir
De los alumnos se desea registrar: nombre, apellido, nota (estructura).
El programa debe tener al menos 1 llamada a la función.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Definimos la estructura para un alumno
typedef struct {
char nombre[50];
char apellido[50];
float nota;
} Alumno;
// Función para ingresar los datos de los alumnos
void ingresarAlumnos(Alumno *alumnos, int n) {
for (int i = 0; i < n; i++) {
printf("Ingrese nombre del alumno %d: ", i + 1);
scanf("%s", alumnos[i].nombre);
printf("Ingrese apellido del alumno %d: ", i + 1);
scanf("%s", alumnos[i].apellido);
printf("Ingrese nota del alumno %d: ", i + 1);
scanf("%f", &alumnos[i].nota);
// Validar que la nota esté en un rango válido
while (alumnos[i].nota < 0 || alumnos[i].nota > 100) {
printf("Nota inválida. Ingrese una nota entre 0 y 100: ");
scanf("%f", &alumnos[i].nota);
}
}
}
// Función para buscar un alumno por su apellido
void buscarAlumno(Alumno *alumnos, int n, char *apellido) {
int encontrado = 0;
for (int i = 0; i < n; i++) {
if (strcmp(alumnos[i].apellido, apellido) == 0) {
printf("Alumno encontrado: %s %s con nota %.2f\n", alumnos[i].nombre,
alumnos[i].apellido, alumnos[i].nota);
encontrado = 1;
break;
}
}
if (!encontrado) {
printf("No se encontró un alumno con el apellido %s\n", apellido);

1
 }
}
// Función para encontrar el alumno con la nota más baja
void alumnoNotaMasBaja(Alumno *alumnos, int n) {
int index = 0;
for (int i = 1; i < n; i++) {
if (alumnos[i].nota < alumnos[index].nota) {
index = i;
}
}
printf("El alumno con la nota más baja es: %s %s con nota %.2f\n", alumnos[index].nombre,
alumnos[index].apellido, alumnos[index].nota);
}
// Función para encontrar el alumno con la nota más alta
void alumnoNotaMasAlta(Alumno *alumnos, int n) {
int index = 0;
for (int i = 1; i < n; i++) {
if (alumnos[i].nota > alumnos[index].nota) {
index = i;
}
}
printf("El alumno con la nota más alta es: %s %s con nota %.2f\n", alumnos[index].nombre,
alumnos[index].apellido, alumnos[index].nota);
}
// Función para contar la cantidad de alumnos reprobados
int contarReprobados(Alumno *alumnos, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (alumnos[i].nota < 60) {
count++;
}
}
return count;
}
// Función para contar la cantidad de alumnos aprobados
int contarAprobados(Alumno *alumnos, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (alumnos[i].nota >= 60) {
count++;
}
}
return count;
}
int main() {
int opcion;
Alumno *alumnos = NULL; // Puntero para almacenar los alumnos
int n = 0; // Número de alumnos

2
do {
printf("\nMenu\n");
printf("1. Ingresar alumnos\n");
printf("2. Buscar alumno por apellido\n");
printf("3. Alumno con nota más baja\n");
printf("4. Alumno con nota más alta\n");
printf("5. Cantidad de reprobados (nota < 60)\n");
printf("6. Cantidad de aprobados (nota >= 60)\n");
printf("7. Salir\n");
printf("Seleccione una opción: ");
scanf("%d", &opcion);
switch (opcion) {
case 1:
printf("Ingrese el número de alumnos: ");
scanf("%d", &n);
// Reservar memoria para los alumnos
alumnos = (Alumno *)malloc(n * sizeof(Alumno));
if (alumnos == NULL) {
printf("Error al asignar memoria.\n");
exit(1);
}
ingresarAlumnos(alumnos, n);
break;
case 2: {
if (n > 0) {
char apellido[50];
printf("Ingrese el apellido a buscar: ");
scanf("%s", apellido);
buscarAlumno(alumnos, n, apellido);
} else {
printf("Primero debe ingresar alumnos.\n");
}
break;
}
case 3:
if (n > 0) {
alumnoNotaMasBaja(alumnos, n);
} else {
printf("Primero debe ingresar alumnos.\n");
}
break;
case 4:
if (n > 0) {
alumnoNotaMasAlta(alumnos, n);
} else {
printf("Primero debe ingresar alumnos.\n");
}
break;

3
 case 5:
if (n > 0) {
printf("Cantidad de reprobados: %d\n", contarReprobados(alumnos, n));
} else {
printf("Primero debe ingresar alumnos.\n");
}
break;
case 6:
if (n > 0) {
printf("Cantidad de aprobados: %d\n", contarAprobados(alumnos, n));
} else {
printf("Primero debe ingresar alumnos.\n");
}
break;
case 7:
printf("Saliendo...\n");
break;
default:
printf("Opción no válida. Intente de nuevo.\n");
break;
}
} while (opcion != 7);
// Liberar la memoria asignada para los alumnos
if (alumnos != NULL) {
free(alumnos);
}
return 0;
}

Realice 1 función que utilizando punteros lea 1 frase y la encrypte, para ello deberá
reemplazar las vocales por nros:
a->4, e->3, i-> 1, o -> 0, u->6
#include <stdio.h>
#include <string.h>
void encrypt(char *str) {
while (*str != '\0') {
// Reemplaza las vocales por los números correspondientes
switch (*str) {
case 'a': case 'A':
*str = '4';
break;
case 'e': case 'E':
*str = '3';
break;
case 'i': case 'I':
*str = '1';
break;
case 'o': case 'O':

4
 *str = '0';
break;
case 'u': case 'U':
*str = '6';
break;
}
str++; // Avanza al siguiente carácter
}
}
int main() {
char frase[100];
printf("Introduce una frase: ");
fgets(frase, 100, stdin); // Lee la frase desde la entrada estándar
// Elimina el salto de línea que agrega fgets al final de la cadena
frase[strcspn(frase, "\n")] = '\0';
// Llama a la función para encriptar la frase
encrypt(frase);
printf("Frase encriptada: %s\n", frase);
return 0;
}

Explicación de cada tema:

1. Estructuras de control (repetitivas y condicionales):

Condicionales: Permiten tomar decisiones en el flujo del programa usando if, else if y
else.
Repetitivas: Permiten ejecutar un bloque de código múltiples veces usando bucles
como for, while y do-while.
Ejemplo de uso:

int x = 5;
if (x > 0) {
printf("x es positivo\n");
} else {
printf("x es negativo o cero\n");
}

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

printf("%d ", i);
}

#include <stdio.h>
int main() {
int i = 0;
// Bucle while: imprimimos números del 0 al 4
while (i < 5) {
printf("El valor de i es: %d\n", i);

5
 i++;
}
return 0;
}

#include <stdio.h>
int main() {
int i = 0;
// Bucle do-while: imprimimos números del 0 al 4
do {
printf("El valor de i es: %d\n", i);
i++;
} while (i < 5);
return 0;
}

#include <stdio.h>
int main() {
int dia = 3;
// Estructura switch: determinamos el día de la semana
switch (dia) {
case 1:
printf("Lunes\n");
break;
case 2:
printf("Martes\n");
break;
case 3:
printf("Miércoles\n");
break;
case 4:
printf("Jueves\n");
break;
case 5:
printf("Viernes\n");
break;
case 6:
printf("Sábado\n");
break;
case 7:
printf("Domingo\n");
break;
default:
printf("Día inválido\n");
break;
}
return 0;
}

2. Arreglos:

6
Son colecciones de elementos del mismo tipo almacenados en ubicaciones de
memoria contiguas.
Se accede a los elementos por índices, comenzando desde 0.
Ejemplo de uso:

int arr[5] = {1, 2, 3, 4, 5};

printf("El primer elemento es: %d\n", arr[0]);

3. Strings:

Son arreglos de caracteres terminados en un carácter nulo ('\0').

En C, se pueden manipular usando funciones de la biblioteca estándar como
strlen, strcpy, strcat, etc.
Ejemplo de uso:

char str[20] = "Hola";

printf("La longitud de la cadena es: %lu\n", strlen(str));

Los strings en C son un tema fundamental, ya que manejarlos correctamente

implica trabajar con arreglos de caracteres y entender cómo terminan en un
carácter nulo ('\0'). Vamos a ver un ejemplo más completo que muestra cómo
manipular strings en C usando funciones comunes de la biblioteca string.h.

Ejemplo completo de manejo de strings

En este ejemplo, veremos cómo:
 Leer una cadena de caracteres desde el usuario.
 Determinar la longitud de la cadena.
 Copiar una cadena a otra.
 Comparar dos cadenas.
 Concatenar dos cadenas.

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

int main() {
char str1[100]; // Buffer para la primera cadena
char str2[100]; // Buffer para la segunda cadena
char str3[200]; // Buffer para la cadena concatenada
// Leer la primera cadena desde el usuario
printf("Ingrese la primera cadena: ");
fgets(str1, sizeof(str1), stdin);
str1[strcspn(str1, "\n")] = '\0'; // Eliminar el carácter de nueva línea

// Leer la segunda cadena desde el usuario

printf("Ingrese la segunda cadena: ");
fgets(str2, sizeof(str2), stdin);
str2[strcspn(str2, "\n")] = '\0'; // Eliminar el carácter de nueva línea

// Calcular y mostrar la longitud de ambas cadenas

printf("Longitud de la primera cadena: %lu\n", strlen(str1));
printf("Longitud de la segunda cadena: %lu\n", strlen(str2));

7
 // Copiar la primera cadena a str3
strcpy(str3, str1);
printf("Copia de la primera cadena en str3: %s\n", str3);

// Comparar las dos cadenas

if (strcmp(str1, str2) == 0) {
printf("Las cadenas son iguales.\n");
} else {
printf("Las cadenas son diferentes.\n");
}

// Concatenar las dos cadenas y almacenarlas en str3

strcat(str3, " "); // Añadir un espacio entre las cadenas
strcat(str3, str2);
printf("Concatenación de ambas cadenas en str3: %s\n", str3);

return 0;
}

Explicación:
1. Lectura de Cadenas (fgets):

 fgets se utiliza para leer una línea de texto desde la entrada estándar (stdin).
 fgets incluye el carácter de nueva línea ('\n') al final de la cadena si hay espacio
suficiente en el buffer, por lo que se elimina con strcspn y se reemplaza con '\0'
para terminar correctamente la cadena.

2. Calcular Longitud (strlen):

 strlen devuelve la longitud de la cadena, excluyendo el carácter nulo.

3. Copiar Cadena (strcpy):

 strcpy copia la cadena de origen a la cadena de destino. En este caso, copia

str1 a str3.

4. Comparar Cadenas (strcmp):

 strcmp compara dos cadenas lexicográficamente. Retorna 0 si son iguales, un

valor negativo si la primera es menor que la segunda, y un valor positivo si es
mayor.

5. Concatenar Cadenas (strcat):

 strcat añade la cadena de origen al final de la cadena de destino. En el

ejemplo, str2 se concatena a str3 después de añadir un espacio para separar
las dos cadenas.

Uso de la Biblioteca string.h

8
Incluimos la librería string.h para acceder a las funciones estándar para manipulación
de cadenas:

 fgets: Para leer líneas de texto de la entrada estándar.

 strlen: Para obtener la longitud de una cadena.
 strcpy: Para copiar una cadena a otra.
 strcmp: Para comparar dos cadenas.
 strcat: Para concatenar dos cadenas.

4. Funciones:

Son bloques de código que realizan una tarea específica y pueden ser reutilizados.
Pueden recibir parámetros y devolver valores.
Ejemplo de uso:

int sumar(int a, int b) {

return a + b;
}

int main() {
int resultado = sumar(5, 3);
printf("La suma es: %d\n", resultado);
return 0;
}

5. Punteros:

Son variables que almacenan la dirección de memoria de otras variables.

Permiten la manipulación directa de la memoria y son esenciales para trabajar con
arreglos y funciones.
Ejemplo de uso:

int x = 10;
int *p = &x; // p es un puntero a un entero
printf("El valor de x es: %d\n", *p); // Uso de puntero para acceder al valor de x

6. Array de estructuras:
Permiten almacenar múltiples estructuras del mismo tipo en un arreglo.
Útil para manejar colecciones de datos más complejos, como registros de estudiantes,
productos, etc.
Ejemplo de uso:
struct Estudiante {
char nombre[50];
int edad;
};

9
struct Estudiante clase[3] = {{"Juan", 20}, {"Ana", 22}, {"Luis", 21}};
printf("El primer estudiante es: %s\n", clase[0].nombre);

7. Ordenamientos:
Son algoritmos que organizan los elementos de un arreglo en un orden específico
(ascendente o descendente).
Ejemplos comunes incluyen el ordenamiento por burbuja, selección y inserción.
Ejemplo de uso: (Ordenamiento burbuja)
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
// Intercambiar arr[j] y arr[j+1]
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
8. Recursividad:

 Es una técnica donde una función se llama a sí misma.

 Útil para resolver problemas que pueden ser divididos en subproblemas
similares, como el cálculo del factorial, la serie de Fibonacci, etc.
Ejemplo de uso:
int factorial(int n) {
if (n == 0) return 1;
else return n * factorial(n-1);
}

int main() {

10
 int num = 5;
printf("El factorial de %d es: %d\n", num, factorial(num));
return 0;
}

Ejemplo de código integrando varias librerías:

#include <stdio.h> // Para printf y otras operaciones de entrada/salida
#include <stdlib.h> // Para malloc, free y qsort
#include <string.h> // Para operaciones con cadenas de caracteres
#include <math.h> // Para funciones matemáticas
#include <time.h> // Para operaciones con el tiempo

int main() {
// Ejemplo de uso de cada biblioteca
printf("Hola, Mundo!\n"); // stdio.h
int *arr = (int *)malloc(5 * sizeof(int)); // stdlib.h
if (arr != NULL) {
for (int i = 0; i < 5; i++) {
arr[i] = i * i;
}
free(arr); // Liberar memoria
}
char str[50];
strcpy(str, "Programación en C"); // string.h
printf("Cadena copiada: %s\n", str);
double result = sqrt(25.0); // math.h
printf("Raíz cuadrada de 25: %.2f\n", result);
time_t now = time(NULL); // time.h
printf("Tiempo actual: %s", ctime(&now));
return 0;
}

11
 1. Ejemplo de Punteros
Los punteros son fundamentales en C y permiten manipular directamente la memoria.
Vamos a ver cómo trabajar con punteros, incluyendo cómo cambiar el valor de una
variable a través de su dirección de memoria.
#include <stdio.h>
void intercambiar(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 10;
int y = 20;
int *p; // Puntero a entero
p = &x; // p apunta a la dirección de x
printf("Valor de x a través de p: %d\n", *p);
p = &y; // p ahora apunta a la dirección de y
printf("Valor de y a través de p: %d\n", *p);
// Intercambiamos los valores de x e y usando punteros
intercambiar(&x, &y);
printf("Después de intercambiar, x = %d, y = %d\n", x, y);
return 0;
}
Explicación:

 Definimos una función intercambiar que toma dos punteros a enteros y los
intercambia.
 En el main, declaramos dos enteros, x y y, y un puntero a entero p.
 Asignamos p a la dirección de x e imprimimos el valor de x a través de p.
 Luego, cambiamos p para que apunte a la dirección de y y mostramos el valor
de y.
 Finalmente, usamos la función intercambiar para intercambiar los valores de x
y y.

2. Ejemplo de Array de Estructuras

12
Los arrays de estructuras permiten manejar colecciones de datos más complejos. Aquí
veremos cómo definir una estructura para almacenar información sobre estudiantes y
cómo manipular un array de estas estructuras.
#include <stdio.h>
#include <string.h>
struct Estudiante {
char nombre[50];
int edad;
float calificacion;
};
int main() {
// Array de estructuras de estudiantes
struct Estudiante clase[3];
// Asignar valores a cada estudiante
strcpy(clase[0].nombre, "Juan");
clase[0].edad = 20;
clase[0].calificacion = 88.5;
strcpy(clase[1].nombre, "Ana");
clase[1].edad = 22;
clase[1].calificacion = 91.0;
strcpy(clase[2].nombre, "Luis");
clase[2].edad = 21;
clase[2].calificacion = 85.0;
// Imprimir información de los estudiantes
for (int i = 0; i < 3; i++) {
printf("Estudiante %d:\n", i + 1);
printf("Nombre: %s\n", clase[i].nombre);
printf("Edad: %d\n", clase[i].edad);
printf("Calificación: %.2f\n", clase[i].calificacion);
printf("\n");
}
return 0;
}

13
Explicación:

 Definimos una estructura Estudiante con tres campos: nombre, edad y

calificacion.
 Declaramos un array de 3 estructuras Estudiante.
 Usamos strcpy para copiar los nombres en el campo nombre y asignamos
valores a edad y calificacion.
 Recorremos el array y mostramos la información de cada estudiante.

3. Ejemplo de Ordenamiento (Burbuja y Quicksort)

a) Ordenamiento Burbuja (Bubble Sort)
El algoritmo de ordenamiento burbuja es simple pero ineficiente para grandes
conjuntos de datos. Consiste en recorrer el arreglo repetidamente y "burbujeando" el
elemento más grande hacia el final en cada pasada.
#include <stdio.h>
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Arreglo ordenado con burbuja: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;

14
}
Explicación:

 El bubbleSort recorre el arreglo n-1 veces.

 En cada pasada, compara elementos adyacentes y los intercambia si están en
el orden incorrecto.
 Después de cada pasada, el elemento más grande "burbujea" al final del
arreglo.
b) Ordenamiento Rápido (Quicksort)
El algoritmo quicksort es más eficiente que el burbuja y utiliza la técnica de "divide y
vencerás". Elige un "pivote" y organiza los elementos en dos subarreglos, uno con
elementos menores al pivote y otro con elementos mayores.
#include <stdio.h>
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return (i + 1);

15
}
int main() {
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
printf("Arreglo ordenado con quicksort: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
Explicación:

 La función quickSort aplica recursivamente el algoritmo para ordenar los

elementos a la izquierda y a la derecha del pivote.
 La función partition organiza los elementos alrededor del pivote y devuelve su
posición final en el arreglo.

4. Ejemplo de Recursividad
La recursividad es una técnica en la que una función se llama a sí misma. Es útil para
resolver problemas que pueden ser descompuestos en subproblemas más pequeños,
como el cálculo del factorial o la secuencia de Fibonacci.
#include <stdio.h>
int factorial(int n) {
if (n == 0) {
return 1; // Caso base: el factorial de 0 es 1
} else {
return n * factorial(n - 1); // Llamada recursiva
}
}
int main() {
int num = 5;
printf("El factorial de %d es: %d\n", num, factorial(num));
return 0;
}

16
Explicación:

 La función factorial calcula el factorial de un número n llamándose a sí misma

con n-1 hasta que n llega a 0, momento en el que devuelve 1.
 Cada llamada recursiva multiplica el número actual por el factorial de su
predecesor, acumulando el resultado final.
#include <stdio.h>
// Función recursiva para imprimir números desde n hasta 1
void imprimirDescendente(int n) {
// Caso base: si n llega a 0, no hacemos nada (termina la recursión)
if (n <= 0) {
return;
}
// Imprimir el número actual
printf("%d ", n);
// Llamar recursivamente a la función con n-1
imprimirDescendente(n - 1);
}
int main() {
int numero;
printf("Ingrese un número entero positivo para comenzar la cuenta regresiva: ");
scanf("%d", &numero);
// Verificar si el número ingresado es positivo
if (numero <= 0) {
printf("El número debe ser positivo.\n");
return 1;
}
// Llamar a la función recursiva
printf("Contando desde %d hasta 1:\n", numero);
imprimirDescendente(numero);
printf("\n");
return 0;
}
Explicación del Código

17
 1. Función imprimirDescendente:
 Esta es la función recursiva que imprime los números desde n hasta 1.
 Caso base: Si n es menor o igual a 0, la función simplemente retorna sin hacer
nada, lo que detiene la recursión.
 Paso recursivo: Imprime el número n y luego llama a imprimirDescendente(n -
1) para imprimir el número siguiente en orden descendente.
2. Función main:

 En main, se lee un número entero positivo desde el usuario.

 Se verifica si el número ingresado es positivo. Si no lo es, el programa muestra
un mensaje de error y termina.
 Llama a imprimirDescendente con el número ingresado para iniciar la cuenta
regresiva.
 Imprime los números en orden descendente.

Resumen

 Punteros: Permiten manipular datos y memoria de forma eficiente.

 Array de Estructuras: Facilitan la gestión de datos complejos y estructurados.
 Ordenamientos (Burbuja y Quicksort): Algoritmos para organizar datos en un
orden específico.
 Recursividad: Técnica poderosa para resolver problemas dividiéndolos en
subproblemas más pequeños.

void menu(){
int op=10;
do{
printf("****MENU DE OPCIONES*****\n");
printf("1.Ingresar Cantidad de Jugadores\n");
printf("2.Tirar Dado\n");
printf("3.Extraer Dinero\n");
printf("0.Cero para salir\n");
printf("Ingrese una opcion:\n");
scanf("%d",&op);
switch(op){
case 1:printf("INGRESO A LA OPCION 1\n:"); break;
case 2:printf("INGRESO A LA OPCION 2\n:"); break;
case 3:printf("INGRESO A LA OPCION 3\n:"); break;
case 0:printf("SALIENDO...\n"); break;
default:printf("INGRESO UNA OPCION NO VALIDA 2\n:");
break;
}
}while(op !=0);
printf("UD SALIO DEL MENU");
}
int main() {
menu();
return 0;
}

18
#include <stdio.h>
#include <string.h>
// Definición de la estructura Alumno
typedef struct {
char nombre[50];
char apellido[50];
float nota;
} Alumno;
// Función para ingresar los datos de varios alumnos
void ingresarAlumnos(Alumno alumnos[], int *numAlumnos) {
int n;
printf("Ingrese la cantidad de alumnos a registrar: "); // Solicita el número de
alumnos a registrar
scanf("%d", &n);
// Bucle para ingresar los datos de cada alumno
for (int i = 0; i < n; i++) {
printf("Alumno %d\n", *numAlumnos + 1); // Muestra el número del alumno que
se está ingresando
printf("Nombre: ");
scanf("%s", alumnos[*numAlumnos].nombre); // Lee el nombre del alumno
printf("Apellido: ");
scanf("%s", alumnos[*numAlumnos].apellido); // Lee el apellido del alumno
printf("Nota: ");
scanf("%f", &alumnos[*numAlumnos].nota); // Lee la nota del alumno
(*numAlumnos)++; // Incrementa el contador de alumnos
}
}
// Función para buscar un alumno por su apellido
void buscarAlumno(Alumno alumnos[], int numAlumnos) {
char apellido[50];

19
 printf("Ingrese el apellido del alumno a buscar: "); // Solicita el apellido a buscar
scanf("%s", apellido);

// Bucle para buscar el alumno en la lista

for (int i = 0; i < numAlumnos; i++) {
if (strcmp(alumnos[i].apellido, apellido) == 0) { // Compara el apellido actual con
el buscado
printf("Alumno encontrado: %s %s, Nota: %.2f\n", alumnos[i].nombre,
alumnos[i].apellido, alumnos[i].nota);
return; // Si lo encuentra, muestra la información y sale de la función
}
}
printf("Alumno no encontrado.\n"); // Si no lo encuentra, muestra un mensaje
}
// Función para encontrar y mostrar al alumno con la nota más baja
void alumnoNotaMasBaja(Alumno alumnos[], int numAlumnos) {
if (numAlumnos == 0) {
printf("No hay alumnos registrados.\n"); // Verifica si hay alumnos registrados
return;
}
int indice = 0; // Inicializa el índice del alumno con la nota más baja
for (int i = 1; i < numAlumnos; i++) {
if (alumnos[i].nota < alumnos[indice].nota) { // Compara las notas para
encontrar la más baja
indice = i;
}
}
printf("Alumno con la nota mas baja: %s %s, Nota: %.2f\n", alumnos[indice].nombre,
alumnos[indice].apellido, alumnos[indice].nota);
}
// Función para encontrar y mostrar al alumno con la nota más alta
void alumnoNotaMasAlta(Alumno alumnos[], int numAlumnos) {
if (numAlumnos == 0) {
printf("No hay alumnos registrados.\n"); // Verifica si hay alumnos registrados

20
 return;
}

int indice = 0; // Inicializa el índice del alumno con la nota más alta
for (int i = 1; i < numAlumnos; i++) {
if (alumnos[i].nota > alumnos[indice].nota) { // Compara las notas para
encontrar la más alta
indice = i;
}
}
printf("Alumno con la nota mas alta: %s %s, Nota: %.2f\n", alumnos[indice].nombre,
alumnos[indice].apellido, alumnos[indice].nota);
}
// Función para contar y mostrar la cantidad de alumnos reprobados
void cantidadReprobados(Alumno alumnos[], int numAlumnos) {
int contador = 0;
for (int i = 0; i < numAlumnos; i++) {
if (alumnos[i].nota < 60) { // Cuenta las notas menores a 60
contador++;
}
}
printf("Cantidad de reprobados: %d\n", contador);
}
// Función para contar y mostrar la cantidad de alumnos aprobados
void cantidadAprobados(Alumno alumnos[], int numAlumnos) {
int contador = 0;
for (int i = 0; i < numAlumnos; i++) {
if (alumnos[i].nota >= 60) { // Cuenta las notas iguales o mayores a 60
contador++;
}
}
printf("Cantidad de aprobados: %d\n", contador);
}

21
// Función que muestra el menú y gestiona las opciones del usuario
void menu() {
Alumno alumnos[100]; // Array para almacenar los datos de los alumnos
int numAlumnos = 0; // Contador de alumnos registrados
int opcion;
// Bucle que muestra el menú hasta que el usuario decida salir
do {
printf("* MENU *\n");
printf("1. Ingresar Alumnos\n");
printf("2. Buscar un Alumno\n");
printf("3. Alumno con Nota más Baja\n");
printf("4. Alumno con Nota más Alta\n");
printf("5. Cantidad de Reprobados\n");
printf("6. Cantidad de Aprobados\n");
printf("7. Salir\n");
printf("Ingrese una opción: ");
scanf("%d", &opcion);
// Gestión de las opciones del menú
switch (opcion) {
case 1:
ingresarAlumnos(alumnos, &numAlumnos); // Llama a la función para
ingresar alumnos
break;
case 2:
buscarAlumno(alumnos, numAlumnos); // Llama a la función para buscar
un alumno
break;
case 3:
alumnoNotaMasBaja(alumnos, numAlumnos); // Llama a la función para
mostrar el alumno con la nota más baja
break;
case 4:
alumnoNotaMasAlta(alumnos, numAlumnos); // Llama a la función para
mostrar el alumno con la nota más alta

22
 break;
case 5:
cantidadReprobados(alumnos, numAlumnos); // Llama a la función para
mostrar la cantidad de reprobados
break;
case 6:
cantidadAprobados(alumnos, numAlumnos); // Llama a la función para
mostrar la cantidad de aprobados
break;
case 7:
printf("Saliendo del Sistema...\n"); // Opción para salir del programa
break;
default:
printf("Opción no válida\n"); // Mensaje en caso de opción inválida
break;
}
printf("\n");
} while (opcion != 7); // Repite el menú hasta que el usuario elija salir
}
// Función principal que inicia el programa llamando al menú
int main() {
menu(); // Llama a la función del menú
return 0;
}
Explicación de cada parte del código:
1. Definición de la Estructura Alumno:
 La estructura Alumno se define con tres campos: nombre, apellido y nota.

2. Funciones para Manejo de Alumnos:

 ingresarAlumnos:
 Permite al usuario ingresar la cantidad de alumnos especificada y sus datos
(nombre, apellido, nota).
 Los datos se almacenan en un array de estructuras alumnos.
 La cantidad de alumnos se incrementa conforme se añaden nuevos registros.

 buscarAlumno:
 Permite buscar un alumno en la lista por su apellido.

23
  Si se encuentra, se muestran sus datos; si no, se indica que no se encontró.

 alumnoNotaMasBaja:
 Encuentra y muestra al alumno con la nota más baja.
 Compara las notas de todos los alumnos registrados.

 alumnoNotaMasAlta:
 Encuentra y muestra al alumno con la nota más alta.
 Compara las notas de todos los alumnos registrados.

 cantidadReprobados:
 Cuenta y muestra la cantidad de alumnos con una nota menor a 60
(reprobados).

 cantidadAprobados:
 Cuenta y muestra la cantidad de alumnos con una nota igual o mayor a 60
(aprobados).

3. Menú:

 menu:
 Muestra un menú de opciones al usuario.
 Cada opción permite realizar una operación diferente sobre la lista de alumnos.
 El menú sigue apareciendo hasta que el usuario decide salir seleccionando la
opción 7.

 main:
Función principal del programa que inicia llamando a la función menu.

#include <stdio.h>
#include <string.h>
// Función para encriptar una frase cambiando las vocales por números
void encriptarFrase(char *frase) {
char *ptr = frase;
while (*ptr) {
switch (*ptr) {
case 'a': *ptr = '4'; break; // Cambia 'a' por '4'
case 'e': *ptr = '3'; break; // Cambia 'e' por '3'
case 'i': *ptr = '1'; break; // Cambia 'i' por '1'
case 'o': *ptr = '0'; break; // Cambia 'o' por '0'
case 'u': *ptr = '6'; break; // Cambia 'u' por '6'
}

24
 ptr++; // Avanza al siguiente carácter
}
}
int main() {
char frase[100]; // Array para almacenar la frase ingresada
printf("Introduce una frase: ");
fgets(frase, sizeof(frase), stdin); // Lee la frase ingresada por el usuario
// Elimina el carácter de nueva línea al final de la frase si existe
char *nuevalinea = strchr(frase, '\n');
if (nuevalinea) {
*nuevalinea = '\0';
}
encriptarFrase(frase); // Llama a la función para encriptar la frase
printf("Frase encriptada: %s\n", frase); // Muestra la frase encriptada
return 0;
}
Explicación de cada parte del código:
1. Función encriptarFrase:
 Recibe una cadena de caracteres (char *frase) como parámetro.
 Usa un puntero ptr para recorrer cada carácter de la cadena.
 Dentro de un bucle while, reemplaza cada vocal con un número específico
usando una instrucción switch:
 'a' se convierte en '4'
 'e' se convierte en '3'
 'i' se convierte en '1'
 'o' se convierte en '0'
 'u' se convierte en '6'
 Avanza al siguiente carácter en cada iteración del bucle.

2. Función main:
 Declara un array frase para almacenar la entrada del usuario.
 Usa fgets para leer la frase completa, incluyendo espacios, hasta el tamaño del
buffer o hasta que se encuentra un salto de línea.
 Elimina el carácter de nueva línea (\n) si se encuentra al final de la cadena,
reemplazándolo con el carácter nulo (\0).
 Llama a la función encriptarFrase para procesar la frase.
 Muestra la frase encriptada al usuario.

25