Practico 4- Arreglos - Ejercicio 5

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

int CargarArreglo ( int [], int );
int MostrarArreglo ( int[],int );
int SumarArreglo ( int[], int );
void CopiarEnPila (int[],int ,Pila* );
int CargarArregloFloat (float[], int );
float SumarArregloFloat (float[],int );

int main()
{
    float hola[8];
    int validos;
    float arreglosumado;

    //Pila ENERGIZER;
    //inicpila (&ENERGIZER);
    validos=CargarArregloFloat (hola, 8);
    arreglosumado = SumarArregloFloat (hola,validos);
    printf ("\nLa suma del arreglo es %f", arreglosumado);
    //CopiarEnPila (hola,&validos,&ENERGIZER);
    //mostrar (&ENERGIZER);



    return 0;
}


/* 1. Hacer una función que reciba como parámetro un arreglo de números enteros y
permita que el  usuario  ingrese  valores  al  mismo  por  teclado.
  La  función  debe  retornar  la  cantidad  de elementos cargados en el arreglo.*/

int CargarArreglo ( int a[], int dimension)
{
    char respuesta = 's';
    int i = 0;

    while ( i < dimension && respuesta != 'n')
    {
        printf ("\nIngrese un numero: ");
        scanf ("%i",&a[i]);
        printf ("\n Desea continuar?: ");
        fflush(stdin);
        scanf ("%c",&respuesta);
        i++;
    }
    return i;
}

/*2.  Hacer  una  función  que  reciba  como  parámetro  un  arreglo  y
  la  cantidad  de  elementos (válidos) cargados en él y los muestre por pantalla. */

int MostrarArreglo ( int a[],int validos )
{

    int contador = 0;
    while (contador < validos)
    {
        printf  ("\n%i", a[contador]);

        contador++;
    }
    return contador;
}

/* 3.  Hacer  una  función  que  reciba  como  parámetro  un  arreglo
 y  la  cantidad  de  elementos (válidos) cargados en él y calcule la suma de sus elementos. */

int SumarArreglo ( int a[], int validos )
{

    int suma = 0;
    int i;

    for (i=0; i<validos; i++)
    {
        suma = a[i] + suma;
    }

    return suma;
}

/*4.  Hacer  una  función  que  reciba  como  parámetro  un  arreglo,  la  cantidad  de  elementos (válidos)
 cargados en él y una Pila. La función debe copiar los elementos del arreglo en la pila. */


void CopiarEnPila (int a[],int validos,Pila* RECARGABLE)
{
    int i = 0;

    while (a[i]<=validos)
    {
        apilar(RECARGABLE,a[i]);
        i++;
    }
}

/*5. Realizar una función que sume los elementos reales de un arreglo de dimensión 100. */


int CargarArregloFloat ( float a[], int dimension)
{
    char respuesta = 's';
    int i = 0;

    while ( i < dimension && respuesta != 'n')
    {
        printf ("\nIngrese un numero: ");
        scanf ("%f",&a[i]);
        printf ("\n Desea continuar?: ");
        fflush(stdin);
        scanf ("%c",&respuesta);
        i++;
    }
    return i;
}

float SumarArregloFloat ( float a[], int validos )
{

    float resultado = 0;
    int i;

    for (i=0; i<validos; i++)
    {
        resultado = a[i] + resultado;
    }

    return resultado;
}