Programación en C: Manejo de Cadenas, Algoritmos de Ordenamiento y Vectores de Estructuras

1. Funciones de Conversión de Cadenas: Mayúsculas y Minúsculas

Implementación de funciones para convertir caracteres alfabéticos entre mayúsculas y minúsculas manipulando directamente sus valores en la tabla ASCII.

Conversión a Mayúsculas

char* mayus(char *strin) {
    int i = 0;
    while (strin[i] != '\0') {
        if (strin[i] >= 97 && strin[i] <= 122) {
            strin[i] -= 32;
        }
        i++;
    }
    return strin;
}

Conversión a Minúsculas

char* minus(char *strin) {
    int i = 0;
    while (strin[i] != '\0') {
        if (strin[i] >= 65 && strin[i] <= 90) {
            strin[i] += 32;
        }
        i++;
    }
    return strin;
}

2. Control de Flujo: Confirmación de Salida

Ejemplo de ciclo interactivo para validar la salida del usuario mediante una condición lógica:

char sal;
int band = 0, i = 0;

do {
    printf("¿Desea salir? (Y/N): ");
    scanf(" %c", &sal);
    if (sal == 'Y' || sal == 'y') {
        band = 1;
    } else {
        i++;
    }
} while (band != 1);

3. Gestión de Vectores de Estructuras

Primitivas básicas para la creación, carga, búsqueda y cálculo de estadísticas sobre una colección de estructuras de tipo datos.

Definición de la Estructura y Carga de Datos

struct datos {
    int dni;
    int edad;
    char apellido[20];
};

struct datos * carga(struct datos *estructura, int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("Ingrese apellido: ");
        scanf("%s", estructura[i].apellido);
        printf("Ingrese edad: ");
        scanf("%d", &estructura[i].edad);
        printf("Ingrese DNI: ");
        scanf("%d", &estructura[i].dni);
    }
    return estructura;
}

Búsqueda Secuencial por DNI

void buscar(int n, struct datos *estructura) {
    int dnibusq;
    int i, noexiste = 1;
    printf("Ingrese DNI a buscar: ");
    scanf("%d", &dnibusq);
    for (i = 0; i < n; i++) {
        if (estructura[i].dni == dnibusq) {
            printf("El DNI es: %d\n", estructura[i].dni);
            noexiste = 0;
            break;
        }
    }
    if (noexiste == 1) {
        printf("Ese DNI no existe.\n");
    }
}

Cálculo del Promedio de Edad

int calculo(int n, struct datos *estructura) {
    int i;
    int promedio = 0;
    int edadtot = 0;
    for (i = 0; i < n; i++) {
        edadtot = edadtot + estructura[i].edad;
    }
    if (n > 0) {
        promedio = edadtot / n;
    }
    return promedio;
}

4. Ordenamiento y Modificación en Vectores de Estructuras

Operaciones sobre un vector de estructuras con nombres y edades: carga, ordenamiento alfabético mediante el método de burbuja, modificación y consulta.

Estructura y Algoritmo de Ordenamiento Alfabético

struct datos {
    char nombre[80];
    int edad;
};

struct datos vector[30]; // Declaración global

void ordenarYMostrar() {
    int i, j, k;
    struct datos aux;
    for (i = 0; i < 5; i++) {
        printf("Ingrese un nombre: ");
        scanf("%s", vector[i].nombre);
        printf("Ingrese la edad: ");
        scanf("%d", &vector[i].edad);
    }
    for (j = 0; j < 4; j++) {
        for (k = j + 1; k < 5; k++) {
            if (strcmp(vector[j].nombre, vector[k].nombre) > 0) {
                aux = vector[j];
                vector[j] = vector[k];
                vector[k] = aux;
            }
        }
    }
    for (i = 0; i < 5; i++) {
        printf("%s - %d\n", vector[i].nombre, vector[i].edad);
    }
    getchar();
}

Función Modificar

void modificar() {
    char nombremod[20];
    int i;
    printf("Ingrese nombre a modificar: ");
    scanf("%s", nombremod);
    for (i = 0; i < 30; i++) {
        if (strcmp(vector[i].nombre, nombremod) == 0) {
            printf("Ingrese nombre nuevo: ");
            scanf("%s", vector[i].nombre);
            break;
        }
    }
}

Función Buscar por Nombre

void buscarNombre() {
    char nombremod[20];
    int i;
    printf("Ingrese nombre a buscar: ");
    scanf("%s", nombremod);
    for (i = 0; i < 30; i++) {
        if (strcmp(vector[i].nombre, nombremod) == 0) {
            printf("El nombre es: %s\n", vector[i].nombre);
            break;
        }
    }
}

5. Extracción y Separación de Cadenas Delimitadas

Procedimiento para leer una cadena combinada en formato nombre;edad y separar los componentes en vectores independientes:

char nombre[20];
char edad[20];
char ingreso[40];
int a = 0, b = 0;

printf("Ingrese los datos en formato nombre;edad: ");
scanf("%s", ingreso);

while (ingreso[a] != ';' && ingreso[a] != '\0') {
    nombre[a] = ingreso[a];
    a++;
}
nombre[a] = '\0';

if (ingreso[a] == ';') {
    a++;
    while (ingreso[a] != '\0') {
        edad[b] = ingreso[a];
        a++;
        b++;
    }
    edad[b] = '\0';
}

6. Ordenamiento de Caracteres en un Vector

Función para ordenar alfabéticamente los caracteres de una cadena. Retorna 1 si el vector contenía elementos o 0 en caso de encontrarse vacío:

int ingresar(char *vector) {
    char temp;
    int i = 0, a = 0, cont = 0, asd = 0;
    while (vector[i] != '\0') {
        i++;
        cont++;
    }
    for (i = 0; i < cont - 1; i++) {
        for (a = i + 1; a < cont; a++) {
            if (vector[i] > vector[a]) {
                temp = vector[i];
                vector[i] = vector[a];
                vector[a] = temp;
            }
        }
    }
    if (cont != 0) {
        asd = 1;
    }
    return asd;
}