Implementación de Algoritmos Fundamentales en C: Perceptrón, Tic-Tac-Toe y Circuitos Eléctricos

Implementación de Algoritmos Fundamentales en C

A continuación, se presentan tres implementaciones de algoritmos fundamentales desarrollados en lenguaje C: la simulación de una neurona artificial (Perceptrón simple), la lógica de detección de victoria en el juego Tres en Raya (Tic-Tac-Toe) y el cálculo de la resistencia equivalente en circuitos eléctricos.

1. Simulación de una Neurona Artificial (Perceptrón)

Este programa simula el funcionamiento básico de una neurona artificial (Perceptrón) que determina su activación basándose en un vector de entradas, un vector de pesos y un umbral predefinido. La neurona se activa si el producto punto de las entradas y los pesos supera el umbral.

Código Fuente: Neurona Activa

#include <stdio.h>
#include <stdlib.h>

void leer_vector (int v[]);
int Neurona_activa(int X[], int W[], int umbral);

int main ()
{
    int x[5], w[5];
    int j, umbral;

    printf("Introduzca los valores del vector de entradas (5 elementos):\n");
    leer_vector(x);

    printf("Introduzca los valores del vector de pesos (5 elementos):\n");
    leer_vector(w);

    printf("Introduzca el valor del umbral: ");
    scanf("%d", &umbral);

    j = Neurona_activa(x, w, umbral);

    /* Imprime el valor de j. Si j es 1, la neurona se activa; si es 0, no se activa. */
    printf("\nResultado de la activación: %d\n\n", j);

    system("PAUSE");
    return 0;
}

void leer_vector (int v[])
{
    int i;
    for (i = 0; i < 5; i++)
    {
        printf("Posicion %d: ", i + 1);
        scanf("%d", &v[i]);
    }
}

int Neurona_activa(int X[], int W[], int umbral)
{
    int c;
    // Cálculo del producto punto (dot product)
    c = (X[0] * W[0]) + (X[1] * W[1]) + (X[2] * W[2]) + (X[3] * W[3]) + (X[4] * W[4]);

    if (c > umbral)
        return 1;
    else
        return 0;
}

2. Lógica de Detección de Victoria en Tres en Raya (Tic-Tac-Toe)

Esta función en C está diseñada para determinar si hay un ganador en un tablero de Tres en Raya (3x3). Asume que los jugadores están representados por valores (por ejemplo, 1 y -1). Retorna 1 si gana el jugador 1, -1 si gana el jugador 2, y 0 si no hay ganador en la posición actual.

Función: tres_en_raya

int tres_en_raya (int **tablero) {
    int i, j, goalh, goalv;

    // 1. Revisión de filas (goalh) y columnas (goalv)
    for (i = 0; i < 3; i++) {
        goalh = 0;
        goalv = 0;

        for (j = 0; j < 3; j++) {
            // Se corrige la sintaxis de indexación de arrays 2D en C: [i][j]
            goalh = goalh + tablero[i][j];
            goalv = goalv + tablero[j][i];
        }

        // Comprobación de victoria en fila o columna (suma total de 3 o -3)
        if ((goalh == -3) || (goalh == 3)) return (goalh / 3);
        if ((goalv == -3) || (goalv == 3)) return (goalv / 3);
    }

    // 2. Revisión de diagonales

    // Diagonal principal: (0,0), (1,1), (2,2)
    goalh = 0;
    goalh = tablero[0][0] + tablero[1][1] + tablero[2][2];
    if ((goalh == -3) || (goalh == 3)) return (goalh / 3);

    // Diagonal secundaria: (0,2), (1,1), (2,0)
    goalv = 0;
    goalv = tablero[0][2] + tablero[1][1] + tablero[2][0];
    if ((goalv == -3) || (goalv == 3)) return (goalv / 3);

    // Si no hay ganador
    return 0;
}

3. Cálculo de Resistencia Equivalente

Esta sección presenta tres programas para calcular la resistencia equivalente en diferentes configuraciones de circuitos, utilizando la librería estándar de entrada/salida de C.

3.1. Resistencia Equivalente en Paralelo (3 Resistores)

Calcula la resistencia equivalente $R_{eq}$ para tres resistencias conectadas en paralelo, donde $1/R_{eq} = 1/R_1 + 1/R_2 + 1/R_3$. Se asegura el uso de división flotante para obtener resultados precisos.

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    float R1, R2, R3, suma, res_eq;
    suma = 0.0;

    printf("Introduzca la resistencia R1: ");
    scanf("%f", &R1);
    suma = suma + 1.0 / R1;

    printf("Introduzca la resistencia R2: ");
    scanf("%f", &R2);
    suma = suma + 1.0 / R2;

    printf("Introduzca la resistencia R3: ");
    scanf("%f", &R3);
    suma = suma + 1.0 / R3;

    res_eq = 1.0 / suma;

    printf("La resistencia equivalente es %.3f\n\n", res_eq);

    system("PAUSE");
    return 0;
}

3.2. Resistencia Equivalente en Paralelo (N Resistores)

Permite al usuario introducir un número $N$ de resistencias y calcula la resistencia equivalente total en conexión paralela.

#include <stdio.h>
#include <stdlib.h>
#define MAX 100

int main ()
{
    float v[MAX];
    int i, N;
    float suma, res_eq;
    suma = 0.0;

    printf("Introduzca el numero de resistencias a conectar en paralelo: ");
    scanf("%d", &N);

    if (N > MAX || N <= 0) {
        printf("Error: Numero de resistencias invalido o excede el limite (%d).\n", MAX);
        system("PAUSE");
        return 1;
    }

    for (i = 0; i < N; i++)
    {
        printf("Introduzca el valor de la resistencia %d: ", i + 1);
        scanf("%f", &v[i]);
        suma = suma + (1.0 / v[i]);
    }

    res_eq = 1.0 / suma;

    printf("El valor de la resistencia equivalente es %.3f\n\n", res_eq);

    system("PAUSE");
    return 0;
}

3.3. Resistencia Equivalente en Serie (N Resistores)

Calcula la resistencia equivalente $R_{eq}$ para $N$ resistencias conectadas en serie, donde $R_{eq} = R_1 + R_2 + \dots + R_N$. La resistencia equivalente es simplemente la suma de las resistencias individuales.

#include <stdio.h>
#include <stdlib.h>
#define MAX 100

int main ()
{
    float v[MAX];
    int i, N;
    float suma;
    suma = 0.0;

    printf("Introduzca el numero de resistencias a conectar en serie: ");
    scanf("%d", &N);

    if (N > MAX || N <= 0) {
        printf("Error: Numero de resistencias invalido o excede el limite (%d).\n", MAX);
        system("PAUSE");
        return 1;
    }

    for (i = 0; i < N; i++)
    {
        printf("Introduzca el valor de la resistencia %d: ", i + 1);
        scanf("%f", &v[i]);
        suma = suma + v[i];
    }

    printf("El valor de la resistencia equivalente es %.3f\n\n", suma);

    system("PAUSE");
    return 0;
}