Suma de Números Naturales y Ordenamiento de Vectores en C: Códigos Explicados

Suma de los Primeros Números Naturales en C

Código 1: Suma de los Primeros *n* Números Naturales

Este programa calcula la suma de los primeros números naturales hasta un límite especificado por el usuario.

#include <stdio.h>
#include <conio.h>

unsigned short int Num;
unsigned short int Limite;
unsigned short int Sum;

void main() {
    Num = 1;
    Sum = 0;
    printf("Introduzca el valor límite para calcular la suma de todos los naturales: ");
    scanf("%hu", &Limite);
    while (Num <= Limite) {
        Sum = Sum + Num; // Sum += Num;
        Num = Num + 1; // Num++; (post-incremento) o ++Num; (pre-incremento)
        // incrementa el valor de la variable en una unidad
        // Sum = Sum + (Num++); // Suponiendo que Num vale 5 y Sum = 0
        // Sum += (Num++); Suma quedaría con 5 y Num quedaría con 6
        // Sum += (++Num); Suma quedaría con 6 y Num quedaría con 6
    }
    printf("La suma de los %hu primeros números naturales es: %hu", Limite, Sum);
    getch();
}

Explicación del Código

• Se incluyen las bibliotecas stdio.h para funciones de entrada/salida estándar y conio.h para la función getch().
• Se declaran las variables Num, Limite y Sum como enteros sin signo (unsigned short int).
• Se inicializan Num en 1 y Sum en 0.
• Se solicita al usuario que introduzca el valor límite (Limite).
• Se utiliza un bucle while para iterar mientras Num sea menor o igual a Limite.
• Dentro del bucle:
  • Se acumula el valor de Num en Sum.
  • Se incrementa Num en 1.
• Se imprime el resultado de la suma.
• getch() espera que el usuario presione una tecla antes de finalizar el programa.

Cálculo y Ordenamiento de Vectores en C

Código 2: Cálculo de Valores de *y* y Ordenamiento de Vectores

Este programa calcula los valores de *y* para una serie de valores de *x* dados, utilizando la ecuación de una recta (*y = mx + b*), y luego ordena los pares (*x*, *y*) de menor a mayor según los valores de *y*.

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

unsigned short int pos_x, pos_y;
float m, b, vector_x[10], vector_y[10], ayuda_x, ayuda_y;

void main() {
    printf("Introduzca un valor m: \n");
    scanf("%f", &m);
    printf("Introduzca un valor b: \n");
    scanf("%f", &b);

    for (pos_x = 0; pos_x < 10; pos_x++) {
        printf("Introduzca un valor de x: \n");
        scanf("%f", &vector_x[pos_x]);
    }

    for (pos_y = 0; pos_y < 10; pos_y++) {
        vector_y[pos_y] = m * vector_x[pos_y] + b;
        // printf("%2.2f", vector_y[pos_y]); --> Muestra los resultados de las y
    }

    for (pos_x = 0; pos_x < 10 - 1; pos_x++) {
        for (pos_y = 0; pos_y < 10 - 1 - pos_x; pos_y++) {
            if (vector_y[pos_y] > vector_y[pos_y + 1]) {
                ayuda_x = vector_x[pos_y + 1];
                vector_x[pos_y + 1] = vector_x[pos_y];
                vector_x[pos_y] = ayuda_x;
                ayuda_y = vector_y[pos_y + 1];
                vector_y[pos_y + 1] = vector_y[pos_y];
                vector_y[pos_y] = ayuda_y;
            }
        }
    }

    for (pos_x = 0; pos_x < 10; pos_x++) {
        printf("x= %2.2f y= %2.2f\n", vector_x[pos_x], vector_y[pos_x]);
    }
    getch();
}

Explicación del Código

• Se incluyen las bibliotecas stdio.h, string.h y conio.h.
• Se declaran variables: pos_x y pos_y como enteros sin signo, y m, b, vector_x, vector_y, ayuda_x y ayuda_y como flotantes. vector_x y vector_y son arreglos de tamaño 10.
• Se solicitan al usuario los valores de m y b (pendiente y ordenada al origen de la recta).
• Se utiliza un bucle for para solicitar al usuario 10 valores de *x* y almacenarlos en vector_x.
• Se utiliza otro bucle for para calcular los correspondientes valores de *y* usando la ecuación *y = mx + b* y almacenarlos en vector_y.
• Se implementa el algoritmo de ordenamiento burbuja para ordenar los vectores vector_x y vector_y de acuerdo con los valores de vector_y en orden ascendente.
• Finalmente, se imprimen los pares (*x*, *y*) ordenados.
• getch() espera que el usuario presione una tecla.