Ejercicios y prácticas de programación en C.

Suma números impares entre un valor 1 y N – Lenguaje C

El ejercicio o práctica con solución que se propone, para realizar con el lenguaje de programación C, es desarrollar un algoritmo y su solución que realice la suma y el factorial de un numero entre 1 y 19 que tiene que ser impar.

/*
    Segun un usuario del blog, desarrollamos el siguiente ejercicio propuesto.
    la practica que se plantea con su solución es la siguiente.
    recordaros que no es la unica forma en la que se puede realizar el ejercicio.

– Desarrollar un programa con las siguientes opciones:

a) Introducir un valor entero impar comprendido entre 1 y 19 (Validar que sea impar antes de continuar)

b) Calcular la serie numérica 1 + 3 + 5 + ··· + n (Número introducido por el usuario)

c) Calcular 1 * 3 * 5 * ··· * n (Número introducido por el usuario)

d) Salir del programa.

*/

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

// Definicion de funciones
int solicitar_Numero(void);
int serie_Numerica(int);
int serie_Multiplicacion(int);

int main()
{
    // Creacion de variables a utilizar
    int numero=0;
    char opcion;
    int sistema=0;

    // Solicitar opcion hasta que introduzcan salir
    do {
        printf("\n a) - Introducir No.");
        printf("\n b) - Calcular Serie Numerica.");
        printf("\n c) - Calcular Multiplicacion");
        printf("\n d) - Salir");
        printf("\n ================================ Opcion: ");
        scanf(" %c",&opcion);
        // llamada a las funciones segun la opcion elegida
        switch(opcion) {
            case 'a':
                numero = solicitar_Numero();
                break;
            case 'b':
                if(numero>0) {
                    sistema = serie_Numerica(numero);
                }
                break;
            case 'c':
                if(numero>0) {
                    sistema = serie_Multiplicacion(numero);
                }
                break;
        }
    } while(opcion!='d');

    return 0;
}

// Funcion para solicitar numero por pantalla
int solicitar_Numero(void) {
    int impar;
    do {
        printf("\nNo. (Entre 1 y 19) : ");
        scanf(" %d",&impar);
    } while(impar<0 || impar>19 || impar%2==0);

    return impar;
}

// Funcion para calcular el sumatorio del numero

int serie_Numerica(numero) {
    int x;
    int suma=0;
    printf("\nSerie Numerica ");
    for(x=1;x<=numero;x+=2) {
        suma+=x;
        printf("%d",x);
        if(x<numero) printf("+");
    }
    printf(" = %d\n",suma);
    return 0;
}


// Función para calcular el factorial del numero

int serie_Multiplicacion(numero) {
    int x;
    int multiplica=1;
    printf("\nSerie Multiplicacion ");
    for(x=1;x<=numero;x+=2) {
        multiplica*=x;
        printf("%d",x);
        if(x<numero) printf("*");
    }
    printf(" = %d\n",multiplica);
    return 0;
}

Una vez compilado y ejecutado el codigo se ha de mostrar similar a la imagen siguiente la solución de la práctica en C.

Práctica con solución con lenguaje C – Sumatorio y Factorial

Gracias por vuestra visita y un saludo, esperamos veros de nuevo por aquí!!!

Respondiendo a la petición de una usuario del blog y con mucho agrado por atender su problema. Planteamos un ejercicio en el cual se han de solicitar siete números, una vez finalizada la introducción de los números se ha de indicar cuantos números primos se han tecleado entre los siete números introducidos.

La solución a la práctica o ejercicio que se plantea, se ha de tener en cuenta que no es la única solución posible, y si tenéis algún tipo de aportación o mejora que queráis realizar, enviad las mismas utilizando el formulario de comentarios situado al final de la página.

La solución al algoritmo y práctica planteado es la siguiente:

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

int main()
{
    /*
        Solicitar siete numeros. Solución sin utilizar vectores
        utilizamos bucles en este caso el bucle for.
    */

    /*
        Declaracion y creacion de variables
    */
    int contador;
    int numero;
    int divisores;
    int sumaprimos = 0;
    int banderaprimo = 0;

    /* Solicitar con un bucle for los siete numeros */
    for(contador = 0 ; contador < 7 ; contador++ ) {
        printf("No. : ");
        scanf("%d",&numero);
        // Comprobar si el numero es primo o no
        // para realizar esta accion se utiliza otro bucle que
        // determina el numero de divisores del numero introducido
        banderaprimo = 0;
        for(divisores=numero-1; divisores>1 && banderaprimo!=1 ; divisores--) {
            // comprobar si el numero es divisible entre el divisor
            if( numero%divisores==0) {
                banderaprimo=1;
            }
        }
        // si banderaprimo ha salido del bucle con un valor 0 es que el numero es primo
        if(banderaprimo==0) {
            sumaprimos+=1;
        }
    }
    printf("\nSe han encontrado %d numeros primos.",sumaprimos);

    return 0;
}

Una vez realizada la solución de la práctica planteada y posteriormente a su compilación y ejecución el resultado ha de ser similar al que se muestra a continuación.

Muchas gracias por tu visita, un saludo y cuidaros mucho.

El ejercicio o práctica que se plantea con el lenguaje de programación C es el siguiente:

Escribir un programa que permita visualizar el triangulo de pascal.  En el triángulo de pascal cada número es la suma de los dos números situados encima de él. Solucionar el ejercicio utilizando un arreglo ,matriz, o vector de una única dimensión.

La solución a la práctica o ejercicio que se plantea, se ha de tener en cuenta que no es la única solución posible, y si tenéis algún tipo de aportación o mejora que queráis realizar, enviad las mismas utilizando el formulario de comentarios situado al final de la página.

La solución al algoritmo y práctica planteado es la siguiente:

/*
El ejercicio o práctica que se plantea es el siguiente:
Escribir un programa que permita visualizar el triangulo de pascal.
En el triángulo de pascal cada número es la suma de los dos números
situados encima de él. Solucionar el ejercicio utilizando un arreglo
,matriz, o vector de una única dimensión.
*/
// Inclusión de las librerías a utilizar
#include <stdio.h>
#include <stdlib.h>

// Declaración de las funciones a utilizar
unsigned factorial(unsigned);

// Creación de la función factorial que devuelve
// el resultado del factorial de un numero sin utilizar
// recursividad

unsigned factorial(unsigned numero) {
    int resultado = 0;
    int contador = 0;
    if (numero == 0) {
        resultado=1;
    } else {
        resultado=1;
        for(contador=numero; contador>0; contador--) {
            resultado*=contador;
        }
    }
    return resultado;
}

// Funcion principal
int main()
{
    // Variables a utilizar
    int filas = 0;
    int columnas = 0;
    int contador = 0;
    int posicion = 0;
    int f = 0;
    int c = 0;
    int calculo = 0;

    // Solicitar el numero de filas a visualizar
    printf("No.Filas: ");
    scanf(" %d",&filas);
    // Calculamos el numero de elementos del vector
    // para ello realizamos el sumatorio del numero
    // de filas
    for(contador=filas-1; contador>=0; contador--) {
        columnas+=contador;
    }
    // Creamos el vector donde guardar los valores
    int triangulo[columnas];
    // recorremos el vector realizando el calculo del valor
    // utilizando el numero combinatorio
    for(f=0; f<filas-1; f++) {
        for(c=0; c<=f; c++) {
            // se calcula el valor de la posicion del numero en
            // el vector utilizado el numero combinatorio
           calculo = factorial(f)/(factorial(c)*factorial(f-c));
            // se asigna el valor a la posicion del vector que
            // le corresponde
           triangulo[posicion]=calculo;
           posicion++;
        }
    }

    // Visualizar el triangulo de pascal
    // para que salga correctamente utilizamos
    // un formato de printf que permite indicar las
    // longitudes y espacios en blanco a añadir,
    // utilizando el símbolo asterisco en el patrón de
    // visualización.
    posicion=0;
    for(f=0;f<filas-1;f++) {
        printf("\n%*c",(int) (columnas/2)-f,' ');
        for(c=0;c<=f;c++) {
            printf("%d ",triangulo[posicion]);
            posicion++;
        }
    }

    return 0;
}

Una vez realizada la solución de la práctica planteada y posteriormente a su compilación y ejecución el resultado ha de ser similar al que se muestra a continuación.

Prácticas en C – Triangulo de Pascal

Muchas gracias por tu visita, un saludo y cuidaros mucho.

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

El ejercicio o práctica que se ha de realizar es el siguiente.

Se ha de realizar un ejercicio en el cual se visualicen los números enteros desde un valor 1 hasta un valor N, se ha de calcular el valor de sus cuadrados mediante el método de sumas, e ir visualizando los números que intervienen en la suma así como el resultado final.

Os recuerdo que si tenéis algún tipo de aportación o mejora, utilizad los comentarios situados al final de la pagina para enviarnos un mensaje y así poder incluir vuestras aportaciones.

La práctica se puede plantear de la siguiente forma:

/*
Realizar una práctica o ejercicio muestre los números
enteros desde 1 hasta N y sus cuadrados, calculados
solamente con sumas.
*/

// Definición de librerías
#include <stdio.h>
#include <stdlib.h>

//Función Principal
int main()
{
    // Declaración de variables a utilizar
    int x = 0;
    int n = 0;
    int contador=0;
    int cuadrado = 0;
    int impares=0;
    // Solicitar N numeros
    printf("Cuantos numeros: ");
    scanf(" %d",&n);
    // Crear un bucle que cuente desde 1 hasta el
    // numero de elementos indicados
    for(contador=1; contador<=n; contador++) {
        // Visualizar numero e inicializar las variables en cada
        // iteracion del bucle para realizar los cálculos
        printf("\nNo. %d = ",contador);
        cuadrado=0;
        impares=1;
        x=1;
        // Utilizar un bucle do...while para mostrar
        // el progreso de la suma de los números
        do {
            printf(" %d ",impares);
            // si no es el ultimo numero mostrar el símbolo +
            if(x<contador) printf("+");
            cuadrado+=impares;
            impares+=2;
            x++;
        } while(x<=contador);
        // Visualizar el resultado final del cuadrado calculado
        printf(" = %d ",cuadrado);
    }
    return 0;
}

Una vez compilada la práctica y ejecutado el programa se ha de obtener un resultado similar al que se muestra en la siguiente imagen:

Práctica C – Cuadrado por sumas

Gracias por vuestra visita y un saludo grandisimo.

Todos podemos colaborar, Quédate en casa.

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

Se plantea realizar el siguiente ejercicio o práctica de programación:

Existen ambulancias que recorren la ciudad y cuando se recibe una llamada de emergencia, se informa de la ubicación de la emergencia mediante coordenadas, lo mismo que la ubicación de todas las ambulancias. Se sabe que existen N ambulancias en servicio. Realice un algoritmo que, dada la información necesaria, informe las
coordenadas de la ambulancia más cercana al punto de emergencia.

Una posible solución a la práctica planteada puede ser la siguiente:

/*

Se quiere realizar el siguiente ejercicio:
Existen ambulancias que recorren la ciudad y cuando se recibe 
una llamada de emergencia, se informa de la ubicación de la 
emergencia mediante coordenadas, lo mismo que la ubicación de
todas las ambulancias. Se sabe que existen N ambulancias en servicio.
Realice un algoritmo que, dada la información necesaria, informe las 
coordenadas de la ambulancia más cercana al punto de emergencia.

*/

// Inclusión de las librerías necesarias
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define MAX 10

// Definición de la estructura punto para
// comprobar la ubicación de las ambulancias
typedef struct p {
    float x;
    float y;
} Punto;


int main()
{
    // Definición de variables a utilizar
    // Crear la matriz de ambulancias
    Punto ambulancias[MAX];
    Punto vector;
    // Definir variables auxiliares
    int contador = 0;
    float posicion_x = 0;
    float posicion_y = 0;
    float modulo = 0;
    int posicion_menor = 0;
    float distancia = 0;

    // Establecemos las coordenadas de posición de
    // las ambulancias de forma aleatoria
    // en primer lugar activamos el generador de
    // números aleatorios para que no genere siempre
    // la misma cadena
    srand(time(NULL));
    // recorrer el bucle estableciendo los puntos de
    // coordenadas para cada ambulancia
    for(contador=0; contador<MAX; contador++) {
        // generar un valor x e y aleatorio para la
        // posicion de la ambulancia
        ambulancias[contador].x = rand()%100;
        ambulancias[contador].y = rand()%100;
    }

    // Solicitar llamada de emergencia
    printf("Llamada Emer. Coordenada X: ");
    scanf(" %f",&posicion_x);
    printf("Llamada Emer. Coordenada Y: ");
    scanf(" %f",&posicion_y);

    // Se realiza la búsqueda de la ambulancia más cercana a la vez
    // que se visualizan los datos
    printf("\nCoordenadas Llamada: %6.2f %6.2f",posicion_x,posicion_y);
    printf("\nPosiciones Ambulancias");
    for(contador=0; contador<MAX; contador++) {
        // obtener vector del punto 1 al punto 2
        vector.x = ambulancias[contador].x-posicion_x;
        vector.y = ambulancias[contador].y-posicion_y;
        // calculo de modulo del vector
        modulo = sqrt(pow(vector.x,2)+pow(vector.y,2));
        printf("\n%d. X: %6.2f Y: %6.2f",contador+1,ambulancias[contador].x,ambulancias[contador].y);
        printf(" -  %6.2f",modulo);
        // se obtiene el menor si es la primera iteración del bucle
        // se establece ese primer registro como menor y sino se realiza
        // la comparación
        if(contador==0) {
            posicion_menor = contador;
            distancia = modulo;
        } else {
            if(distancia>modulo) {
                distancia = modulo;
                posicion_menor = contador;
            }
        }
    }

    printf("\n============================================================");
    printf("\nAmbulancia No.%d ,Distancia: %.2f",posicion_menor+1,distancia);
    printf("\n============================================================\n");


    return 0;
}

Una vez compilado y ejecutado el ejercicio planteado, se ha de mostrar un resultado similar al siguiente:

Práctica C – Ambulancia Coordenadas

Gracias por vuestra visita y un saludo, hasta la próxima.

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

El ejercicio o práctica de programación en lenguaje c que se plantea es el siguiente:

Realizar un algoritmo que visualice e indique la cantidad de puntos que se encuentran situados dentro de un circulo
con centro 0,0 en el cuadrante 1. Se amplia el ejercicio o práctica de forma que los puntos sean generados al azar en una matriz de puntos, una vez generados los puntos, calcular cuales están dentro del circulo, visualizar su angulo y el cuadrante al que pertenecen.

En la practica se han utilizado estructuras de datos, bucles, matrices, generación de números aleatorios, condicionales, etc.

Una posible solución al ejercicio puede ser la siguiente:

/*
    El ejercicio o práctica de programación en lenguaje c
    que se plantea es el siguiente:

    Realizar un algoritmo que visualice e indique la cantidad
    de puntos que se encuentran situados dentro de un circulo
    con centro 0,0 en el cuadrante 1.

    Se amplia el ejercicio o práctica de forma que los puntos
    sean generados aleatoriamente en una matriz de puntos, una
    vez generados los puntos, calcular cuales están dentro del
    circulo, visualizar su angulo y el cuadrante al que pertenecen.
*/


// Definición de las librerías a utilizar
#include <stdio.h>
#include <stdlib.h>
// Inclusión de la librería de tiempo para
// el calculo posterior de un numero aleatorio
#include <time.h>
// Inclusión de la librería de matemáticas para
// realizar los cálculos mas cómodamente
#include <math.h>

// Definición de la estructura punto
typedef struct p {
    int x;
    int y;
} Punto;


// Definición del numero máximo de puntos a evaluar
#define MAX 20
#define M_PI 3.14159265358979323846

int main()
{
    // Variables auxiliares a utilizar
    int radio = 0;
    int contador = 0;
    int incremento = 0;
    int vinicio = 0;
    int vfinal = 0;
    float x = 0;
    float y = 0;
    int signo = 0;
    float angulo;
    int cuadrante = 0;
    int cuantos_cuadrante_uno = 0;

    // Creación de la matriz de puntos
    Punto matrizPuntos[MAX];

    // Solicitar el radio del circulo
    printf("Radio: ");
    scanf("%d",&radio);

    // Rellenar la matriz de puntos de forma aleatoria
    // para ello utilizamos la función rand para generar
    // los valores de los puntos, esta funcion esta incluida
    // en la librería estándar
    // se establece el inicio de la creación de los números
    // aleatorios de forma que no se repitan las secuencias
    // para ello se utiliza la función srand indicando un valor
    // cambiante como puede ser la hora actual que se consigue
    // mediante la función time, solo se ha de especificar una
    // vez esta orden.
    srand(time(NULL));
    // se calcula el incremento a aplicar a los puntos a generar
    // de esta forma generaremos puntos dentro y fuera de la
    // circunferencia
    incremento = radio/2;
    // se establece el numero de inicio y final de los valores
    // aleatorios
    vinicio = 0;
    vfinal = radio+incremento;
    // se utiliza un bucle para recorrer la matriz de puntos
    // y asignar un valor aleatorio a cada uno de las coordenadas
    for(contador=0; contador<MAX; contador++) {
        matrizPuntos[contador].x = (rand()%(vinicio+vfinal));
        signo = rand()%2;
        if(signo==0) matrizPuntos[contador].x = -matrizPuntos[contador].x;
        matrizPuntos[contador].y = (rand()%(vinicio+vfinal));
        signo = rand()%2;
        if(signo==0) matrizPuntos[contador].y = -matrizPuntos[contador].y;
    }
    // se visualiza la matriz de puntos utilizando un bucle para
    // recorrer la matriz y se realiza el calculo para comprobar
    // si el punto se encuentra dentro de la circunferencia en caso
    // de encontrarse dentro de ella se visualiza también un mensaje
    for(contador=0; contador<MAX; contador++) {
        printf("\n(%4d,%4d)",matrizPuntos[contador].x,matrizPuntos[contador].y);
        // Comprobar si el punto se encuentra dentro de la circunferencia
        x = matrizPuntos[contador].x;
        y = matrizPuntos[contador].y;
        // la forma más simple de comparación es preguntar si ambos valores
        // x e y son inferiores al tamaño del radio
        if(abs(x)<=radio && abs(y)<=radio){
                // Si el punto esta incluido dentro del circulo
                printf(" Si ");
                // Se calcula su angulo
                angulo = (180*acos(x/radio))/M_PI;
                // Si x es 0 e y negativo se suma 180 grados
                // ya que esta en cuadrante inferior
                if(x==0 && y<0) angulo=angulo+180;
                // Se divide el angulo entre 90 para obtener el cuadrante
                cuadrante = (angulo/90)+1;
                // Si esta en el primer cuadrante se utiliza un contador
                if(cuadrante==1) cuantos_cuadrante_uno++;
                // se visualiza angulo y cuadrante
                printf(" %5.0f - %2d",angulo,cuadrante);
        } else {
            // si no esta incluido simplemente se visualiza no
            printf(" No ");
        }
    }
    // Se visualiza el total de puntos dentro del primer cuadrante
    printf("El No. Total de puntos dentro del cuadrante 1 es : %d",cuantos_cuadrante_uno);
    return 0;
}

Una vez realizada la compilación de la práctica con el compilador de C, y puesto en funcionamiento el programa, el resultado ha de ser similar al que se muestra a continuación.

Prácticas C – Puntos Cuadrante

Gracias por vuestra visita y ser fuertes que de esta salimos seguro!!!

Ah recordad!!!

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

Se quiere realizar el programa correspondiente al siguiente ejercicio o práctica de programación con lenguaje c propuesto.

Utilizando una matriz de datos, que guarde los tres valores correspondientes a los lados de un triangulo, solicitar por pantalla los valores correspondientes para rellenar la matriz, y determinar una vez introducidos los datos cuantos tipos de triángulos equiláteros, isósceles y escalenos hay en la matriz.

Para realizar este ejercicio o práctica de programación, se ha utilizado la definición de una estructura compuesta por tres valores enteros, que representan las medidas de cada uno de los lados del triangulo, a continuación se ha creado una matriz sobre dicha estructura, se han solicitado los datos y se comprueban los valores de cada uno de los lados para determinar de que tipo es el triangulo y visualizarlo, añadiendo también un contador para cada uno de los tipos de triangulo.

Vuelvo a comentaros, perdonad que sea repetitivo, no es la única solución, seguramente habrán otras opciones que si nos las mandáis utilizando los comentarios estaremos encantados de publicarlas haciendo referencia a quien nos la envía.

La posible solución al ejercicio o práctica de programación que se plantea es la siguiente:

/*
    Utilizando una matriz de datos, que guarde los tres valores
    correspondientes a los lados de un triangulo, solicitar por pantalla
    los valores correspondientes para rellenar la matriz, y determinar una
    vez introducidos los datos cuantos tipos de
    triángulos equiláteros, isósceles y escalenos hay en la matriz.
*/

// Inclusión de las librerías
#include <stdio.h>
#include <stdlib.h>

// Definición del numero máximo de triángulos de la matriz
#define MAX 5

// Definición de la estructura para guardar los datos
// definiendo tres valores enteros y dando nombre a la
// estructura "triangulo"
typedef struct t {
    int x;
    int y;
    int z;
} triangulo;


// Funcion principal
int main()
{
    // Definición de variables auxiliares
    int contador=0;
    int a;
    int b;
    int c;
    int contador_equilatero = 0;
    int contador_isosceles = 0;
    int contador_escaleno = 0;
    // Definición de la matriz de triángulos utilizando
    // la estructura como tipo de dato.
    triangulo triangulos[MAX];

    // Solicitar los lados de los triángulos utilizando un bucle
    // y utilizando una sola petición que espera valores separados
    // por comas. Ej: 1,1,1
    for(contador=0;contador<MAX;contador++) {
        printf("Teclee valores X,Y,Z :");
        scanf(" %d,%d,%d",&triangulos[contador].x,&triangulos[contador].y,&triangulos[contador].z);
    }

    // Recorrer la matriz para comprobar cada uno de los triángulos utilizando
    // un bucle FOR, se comprueba el tipo de triangulo y se incrementa el contador
    for(contador=0;contador<MAX;contador++) {
        // Se recogen los valores de la matriz en variables auxiliares por comodidad
        a= triangulos[contador].x;
        b=triangulos[contador].y;
        c=triangulos[contador].z;
        // Se visualizan los valores del triangulo
        printf("\n%d,%d,%d - ",triangulos[contador].x,triangulos[contador].y,triangulos[contador].z);
        // Se comprueban los valores para determinar el tipo con la función if, si condicional
        if(a==b) {
            if(a==c) {
                printf("Equilatero");
                contador_equilatero++;
            } else {
                printf("Isosceles");
                contador_isosceles++;
            }
        } else if(a==c) {
            printf("Isosceles");
            contador_isosceles++;
        } else if(b==c) {
            printf("Isosceles");
            contador_isosceles++;
        } else {
            printf("Escaleno");
            contador_escaleno++;
        }
    }
    printf("\nEquilateros: %d",contador_equilatero);
    printf("\nIsosceles: %d",contador_isosceles);
    printf("\nEscaleno: %d",contador_escaleno);
    return 0;
}

Una vez compilado el programa y puesto en funcionamiento, el resultado ha de ser similar al que se muestra en la siguiente imagen.

Prácticas C – Tipos Triángulos

Un saludo grandisimo y muchas gracias por vuestra visita, espero veros de nuevo y cuidaros mucho.

Ah recordad!!

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

El ejercicio o práctica de programación que se plantea es el siguiente. Realizar la suma del mayor numero y menor numero de un grupo de números positivos guardados en un vector.

Se ha utilizado para solicitar y recorrer posteriormente el vector o matriz bucles de tipo FOR, recordaros que el planteamiento no tiene porque ser el único, si tenéis variantes del mismo y queréis compartirlas, utilizad los comentarios y las publicares, nunca esta de más ver inteligencias alternativas a la de uno, comparad y aprender.

La posible solución a la práctica resuelta con el lenguaje de programación C, es la siguiente:

/*
    Algoritmo que realiza la suma del menor y mayor
    numero encontrado sobre un grupo de números positivos
    los cuales son almacenados en un vector.

*/

// Definir las librerías a utilizar
#include <stdio.h>
#include <stdlib.h>

// Definición de valores
#define MAX 8


// Función principal
int main()
{
    // Declaración de variables del programa
    int vectorNumeros[MAX];
    int contador = 0;
    int mayor = 0;
    int menor = 0;
    // Solicitar mediante un bucle for los valores
    // del vector de números positivos
    for(contador=0; contador<MAX; contador++) {
        printf("Pos Vector: (%d) - Numero:",contador+1);
        scanf(" %d",&vectorNumeros[contador]);
    }

    // Buscar el mayor y menor de los números del vector
    // el valor inicial de ambos números es el primer valor
    // del vector
    mayor = vectorNumeros[0];
    menor = vectorNumeros[0];
    for(contador=0; contador<MAX; contador++) {
        if(mayor<vectorNumeros[contador])
            mayor=vectorNumeros[contador];
        if(menor>vectorNumeros[contador])
            menor=vectorNumeros[contador];
    }
    // Realizar la suma de ambos números y visualizarla
    printf("\nSuma Menor: %d y Mayor: %d = %d",menor,mayor,menor+mayor);

    return 0;
}

Una vez compilado el ejercicio y puesto en marcha el programa, ha de presentar un resultado similar al que se muestra en la siguiente imagen.

Prácticas en C – Mayor y Menor

Muchísimas gracias por vuestra visita, sobre todo cuidaros y ser responsables. Un saludo espero veros pronto.

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

El ejercicio y práctica de programación que se plantea desde aprendoencasa.com es el siguiente.

Se ha de solicitar por consola una serie de números positivos que serán almacenados en una matriz o vector, y seguidamente utilizando bucles, en este caso se ha utilizado el bucle FOR (ya que se conoce el principio y fin del vector), se han de solicitar los números almacenándolos en el vector y posteriormente utilizando otro bucle recorrer el vector y aprovechar el recorrido por el mismo para realizar los cálculos y visualizarlos.

Una posible solución al ejercicio o práctica planteada, puede ser la siguiente. Recordaros que siempre podéis comentar para contrastar opiniones.

/*
    El ejercicio o práctica de programación en C
    que se plantea es el siguiente:
    Encontrar sobre un grupo de números enteros positivos
    la raíz cuadrada, el cuadrado y el cubo de dichos números
    individualmente.

    https://aprendoencasa.com
*/

// Se incluyen las librerías a utilizar, se añade también
// la librería matemática, para simplificar los cálculos a
// realizar.

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

// Definimos valores fijos
#define MAX 5

int main()
{
    // Se crean e inicializan las variables a utilizar
    // Para realizar la solicitud de números se va a utilizar
    // una matriz de números enteros

    int vectorNumeros[MAX];
    int contador = 0;

    // Realizamos la solicitud de los números por consola utilizando
    // un bucle FOR ya que se sabe el principio y final del bucle.

    for( contador = 0; contador<MAX; contador++ ) {
        printf("Numero Positivo (%d): ",contador+1);
        scanf("%d",&vectorNumeros[contador]);
    }

    // Realizamos ahora un bucle que recorra el vector y realice los
    // cálculos de raíz cuadrada, cuadrado y cubo, visualizando
    // los resultados. Para calcular la raíz cuadrada se utiliza
    // la funcion sqrt, para el cuadrado y el cubo se utiliza la función
    // pow, observe que se ha realizado para la visualización de los
    // resultados un casting de tipo float, ya que dependiendo de los valores
    // introducidos se sobrepase el valor máximo de un entero y también se ha
    // indicado en su mascara de visualización que no se visualicen decimales
    printf("\nResultados Vector\n");
    printf("==========================\n");
    for( contador = 0; contador<MAX; contador++ ) {
        printf("Numero: %d ",vectorNumeros[contador]);
        printf("Raiz: %.0f ",(float)sqrt(vectorNumeros[contador]));
        printf("Cuadrado: %.0f ",(float)pow(vectorNumeros[contador],2));
        printf("Cubo: %.0f\n",(float)pow(vectorNumeros[contador],3));
    }


    return 0;
}

Una vez realizada la compilación y ejecución del algoritmo anterior, se ha de visualizar un resultado similar al que se muestra en la siguiente imagen.

Prácticas en C – Raíz, Cuadrado y Cubo

Gracias por vuestra visita y un saludo fuerte para todos animo!!

Ah Recordad!!!

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piénsalo");

}

Calculo de la desviación típica sobre un grupo de números positivos.

El ejercicio o práctica con solución en lenguaje C, que se propone es realizar el calculo de la desviación típica sobre un grupo de números positivos.

La desviación típica es la raíz cuadrada de la varianza. Es decir, la raíz cuadrada de la media de los cuadrados de las puntuaciones de desviación.

Como el calculo se quiere realizar sobre un grupo de números positivos se va a utilizar una matriz o vector para solicitar los datos, comprobando que el valor introducido sea siempre positivo. una vez obtenidos los datos se realizan los cálculos necesarios para calcular la desviación típica.

// Ejercicios y prácticas de programación, Lenguaje C
// La práctica a realizar y solucionar desde www.aprendoencasa.com
// es el algoritmo para calcular la desviación típica sobre un
// grupo de números positivos.

// se incluyen las librerias necesarias
// entre ellas las de matematicas, aunque
// se podrian realizar todas las operaciones
// sin la misma, se añade por comodidad
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX 8
int main()
{
    // Variables a utilizar
    long Vector[MAX];
    int contador = 0;
    long numero = 0;
    float media = 0;
    long suma = 0;
    float destip = 0;
    // Solicitud de la matriz de datos por pantalla
    // realizando la comprobación de valores positivos
    for(contador=0; contador<MAX; contador++) {
        do {
            printf("Teclee numero positivo, posicion Vector(%d) : ",contador);
            scanf("%ld",&numero);
        } while(numero<=0);
        Vector[contador] = numero;
        suma+=numero;
    }

    // Se realiza el calculo de la media aritmetica
    media = suma / MAX;
    // realizamos el calculo de la desviación típica
    // reutilizamos la variable suma para no definir nuevas variables
    suma=0;
    for(contador=0; contador<MAX; contador++) {
        suma+=pow((Vector[contador]-media),2);
    }
    destip = sqrt(suma/MAX);

    // Visualizamos el vector de datos
    printf("\nVector\n");
    for(contador=0; contador<MAX; contador++) {
        printf("%ld, ",Vector[contador]);
    }
    // Visualizamos el resultado
    printf("\nDesviacion Tipica: %.2f\n",destip);


    return 0;
}

El resultado después de compilar y ejecutar el programa, ha de ser similar al que se muestra en la siguiente imagen.

Práctica en C – Desviación Típica

Gracias por vuestra visita y el saludo más amable desde www.aprendoencasa.com

if ( MeQuedoEnCasa == SoyResponsable ) {

  printf("Lo Conseguiremos entre todos");

} else {

 printf("Error 404 - Algo estas haciendo mal, piensalo");

}