Computación I: parciales y actividades

1. Tarea 1: Uso ético de la inteligencia artificial

La primera actividad fue un informe de reflexión sobre los desafíos y principios del uso ético de la IA en estudiantes universitarios. El punto de partida es una pregunta que define todo el trabajo: ¿realmente estoy aprendiendo o solo estoy dejando que la máquina haga todo por mí?

Entre los beneficios identificados se destacan el ahorro de tiempo, el uso de la IA como tutor personal y el desarrollo del prompt engineering. Entre los riesgos se señalan el plagio involuntario, la dependencia y la pereza mental, las alucinaciones (información inventada) y la privacidad de los datos.

El informe propone tres normativas para el estudiante: ser transparente al declarar el uso de la IA, aprender a citar correctamente (p. ej., APA: OpenAI, 2024) y garantizar que el trabajo final sea propio y defendible con palabras propias. La conclusión central es que la IA puede ser aliada si se usa con criterio, sin externalizar el pensamiento.

Descargar Tarea 1 (PDF)

2. Segundo Parcial: desglose de billetes

Entrega final del Segundo Parcial: un programa en C que, dado un monto entero en bolívares ( $N$ ), desglosa la cantidad en la menor cantidad de billetes posible usando las denominaciones de 50.000, 20.000, 10.000, 5.000, 2.000, 1.000, 500, 200 y 100, e imprime el monto restante sin desglosar. A continuación se muestra el código fuente final y, más abajo, el video de explicación de la entrega.

#include <stdio.h>

int main()
{
    // Declaración de variables

    int B50000, B20000, B10000, B5000, B2000, B1000, B500, B200, B100;
    int monto, total_billetes;
    B50000 = 0;
    B20000 = 0;
    B10000 = 0;
    B5000 = 0;
    B2000 = 0;
    B1000 = 0;
    B500 = 0;
    B200 = 0;
    B100 = 0;
    printf("Ingrese el monto a desglosar: ");
    scanf("%d", &monto);

    // Desglose de Billetes

    while (monto >= 50000)
    {
        B50000++;
        monto -= 50000;
    }
    while (monto >= 20000)
    {
        B20000++;
        monto -= 20000;
    }

    while (monto >= 10000)
    {
        B10000++;
        monto -= 10000;
    }
    while (monto >= 5000)
    {
        B5000++;
        monto -= 5000;
    }
    while (monto >= 2000)
    {
        B2000++;
        monto -= 2000;
    }
    while (monto >= 1000)
    {
        B1000++;
        monto -= 1000;
    }
    while (monto >= 500)
    {
        B500++;
        monto -= 500;
    }
    while (monto >= 200)
    {
        B200++;
        monto -= 200;
    }
    while (monto >= 100)
    {
        B100++;
        monto -= 100;
    }
    printf("Desglose de billetes:\n");
    printf("Billetes de 50000: %d\n", B50000);
    printf("Billetes de 20000: %d\n", B20000);
    printf("Billetes de 10000: %d\n", B10000);
    printf("Billetes de 5000: %d\n", B5000);
    printf("Billetes de 2000: %d\n", B2000);
    printf("Billetes de 1000: %d\n", B1000);
    printf("Billetes de 500: %d\n", B500);
    printf("Billetes de 200: %d\n", B200);
    printf("Billetes de 100: %d\n", B100);
    printf("Monto restante sin desglosar: %d\n", monto);
}

Descargar Segundo Parcial (PDF)

3. Tarea 2: Algoritmo de Euclides

La segunda actividad fue un informe académico sobre el algoritmo de Euclides, uno de los más antiguos que aún se utilizan. Su propósito es calcular el máximo común divisor (MCD) de dos enteros positivos y se basa en la propiedad:

$\gcd(a, b) = \gcd(b, a \bmod b)$

donde $a \bmod b$ es el residuo de dividir $a$ entre $b$ . El proceso se repite hasta llegar a un residuo cero, momento en el cual el último divisor no nulo es el MCD. Por ejemplo, para $\gcd(252, 105)$ :

$252 = 2 \cdot 105 + 42$
$105 = 2 \cdot 42 + 21$
$42 = 2 \cdot 21 + 0$ → $\gcd(252, 105) = 21$

La complejidad del algoritmo es $O(\log \min(a, b))$ , y su variante extendida permite hallar los coeficientes de la identidad de Bézout, pieza clave de sistemas criptográficos como RSA.

Descargar Tarea 2 (PDF)

4. Tercer Parcial

4.1. Problema 1: control del depósito de agua

Entrega final del Tercer Parcial — Problema 1: un programa en C para el control del depósito de agua. Un operador abre y cierra una válvula varias veces durante una jornada; el depósito inicia lleno y su capacidad es conocida. El programa indica el agua restante tras cada operación, emite una advertencia según el rango (entre 1150 y 1500 litros → “Situación Normal”; menos de 1150 → “Situación de Cuidado”) y, al finalizar, muestra el porcentaje restante y recomienda rellenar el depósito si quedó por debajo del umbral.

#include <stdio.h>

int main()
{
    float capacidad_deposito;
    float litros_de_final;
    float agua_restante;
    float porcentaje_agua_restante;
    char respuesta;

    printf("ingrese la capacidad del deposito en litros: ");
    scanf("%f", &capacidad_deposito);

    agua_restante = capacidad_deposito;

    printf("desea iniciar el proceso de apertura y cierre de la valvula? (s/n): ");
    scanf(" %c", &respuesta);

    while ((respuesta == 's' || respuesta == 'S') && agua_restante > 0)
    {
        printf("ingrese la cantidad de litros que paso por la valvula: ");
        scanf("%f", &litros_de_final);

        agua_restante = agua_restante - litros_de_final;

        printf("el agua restante es: %.2f litros\n", agua_restante);

        if (agua_restante >= 1150 && agua_restante <= 1500)
            printf("Situacion Normal\n");
        else if (agua_restante < 1150)
            printf("Situacion de Cuidado\n");

        printf("desea continuar con el proceso de apertura y cierre de la valvula? (s/n): ");
        scanf(" %c", &respuesta);
    }

    porcentaje_agua_restante = (agua_restante / capacidad_deposito) * 100;

    printf("\nel agua restante al final del proceso es: %.2f litros\n", agua_restante);
    printf("el porcentaje de agua restante es: %.2f%%\n", porcentaje_agua_restante);

    if (agua_restante < 1150)
        printf("Advertencia se recomienda rellenar el contenedor\n");
    else
        printf("Que tenga un buen dia\n");

    return 0;
}

4.2. Problema 2: estudio de consumo eléctrico por zonas

Entrega final del Tercer Parcial — Problema 2: un programa en C para el estudio del consumo eléctrico por zonas en hogares de San Cristóbal. En cada zona se visitan 25 hogares y se registra el número de personas, el consumo mensual (Kw) y la condición habitacional (Propia, Alquilada, Comodato). El programa calcula el promedio por persona, el consumo total por zona y general, la cantidad de hogares alquilados con consumo mayor a 350.75 Kw y la zona de mayor consumo (excluyendo “Industrial”).

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

#define MAX_f 350.75f
#define HOGARES 25

int main()
{
    int habitantes;
    int cant_a_consumo = 0;

    char zona[20];
    char zona_max_consumo[20];
    char condicion;
    char respuesta;

    float consumo_kw;
    float consumo_per_capita;
    float consumo_zona;
    float consumo_total = 0.0f;
    float consumo_max = 0.0f;

    strcpy(zona_max_consumo, "ninguna");

    do
    {
        printf("Ingrese el nombre de la zona: ");
        scanf("%s", zona);

        consumo_zona = 0.0f;

        for (int i = 1; i <= HOGARES; i++)
        {
            printf("\nHogar %d\n", i);

            printf("Numero de personas que habitan: ");
            scanf("%d", &habitantes);

            printf("Consumo electrico mensual (Kw): ");
            scanf("%f", &consumo_kw);

            printf("Condicion habitacional (P: propia, A: alquilada, M: comodato): ");
            scanf(" %c", &condicion);

            if (habitantes > 0)
                consumo_per_capita = consumo_kw / habitantes;
            else
                consumo_per_capita = 0.0f;

            printf("Consumo promedio por persona: %.2f Kw\n", consumo_per_capita);

            consumo_zona = consumo_zona + consumo_kw;

            if ((condicion == 'A' || condicion == 'a') && consumo_kw > MAX_f)
                cant_a_consumo++;
        }

        consumo_total = consumo_total + consumo_zona;

        printf("\nConsumo total de la zona %s: %.2f Kw\n", zona, consumo_zona);

        for (int j = 0; zona[j] != '\0'; j++)
            zona[j] = toupper(zona[j]);

        if (consumo_zona >= consumo_max && strcmp(zona, "INDUSTRIAL") != 0)
        {
            consumo_max = consumo_zona;
            strcpy(zona_max_consumo, zona);
        }

        printf("Desea ingresar otra zona? (s/n): ");
        scanf(" %c", &respuesta);
    } while (respuesta == 's' || respuesta == 'S');

    printf("\n=====================================\n");
    printf("Resultados generales:\n");
    printf("Consumo total de todas las zonas estudiadas: %.2f Kw\n", consumo_total);
    printf("Hogares alquilados con consumo mayor a %.2f Kw: %d\n", MAX_f, cant_a_consumo);

    if (strcmp(zona_max_consumo, "ninguna") != 0)
    {
        printf("Zona con mayor consumo (excluyendo industrial): %s\n", zona_max_consumo);
        printf("Consumo maximo: %.2f Kw\n", consumo_max);
    }
    else
        printf("No se ingresaron zonas validas.\n");

    return 0;
}

Descargar Tercer Parcial (PDF)

5. Descargas

Entregable	Archivo
Tarea 1 — Uso ético de la IA	tarea-1-uso-etico-ia.pdf
Tarea 2 — Algoritmo de Euclides	tarea-2-euclides.pdf
Segundo Parcial — Desglose de billetes	segundo-parcial.pdf
Tercer Parcial — Depósito de agua y consumo eléctrico	tercer-parcial.pdf

Referencias

American Psychological Association. (2020). Publication Manual of the American Psychological Association (7th ed.).

Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press.

Koblitz, N. (1994). A Course in Number Theory and Cryptography (2nd ed.). Springer-Verlag.

OpenAI. (2024). GPT-4 Technical Report. https://openai.com/research

Rivest, R. L., Shamir, A., & Adleman, L. (1978). A method for obtaining digital signatures and public-key cryptosystems. Communications of the ACM, 21(2), 120–126.

UNESCO. (2023). Guidance for generative AI in education and research. UNESCO Publishing.