Practico 4 - Ejercicio 7- en proceso

#include <stdio.h>
#include <stdlib.h>
#include "pila.h"
#include <string.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 BuscarEnArreglo (char[],int ,char );
int CargarArregloChar ( char[], int);
int InsertarChar(char[],int , char );

int main()
{
    char hola[8];
    int validos;
    int resultado;
    int p=0;

    //float arreglosumado;
    //Pila ENERGIZER;
    //inicpila (&ENERGIZER);
    //arreglosumado = SumarArregloFloat (hola,validos);
    //printf ("\nLa suma del arreglo es %f", arreglosumado);
    //CopiarEnPila (hola,&validos,&ENERGIZER);
    //mostrar (&ENERGIZER);
    //resultado = BuscarEnArreglo (hola,3);
    //printf ("Resultado: %i", resultado);

    validos = CargarArregloChar (hola, 8);
    //resultado = BuscarEnArreglo (hola,validos,'o');

   // printf ("Resultado= %i", resultado);
    validos = InsertarChar(hola, validos, 'b');

    printf ("%s", &hola);

    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;
}

/* 6.  Realizar  una  función  que  indique  si  un  elemento  dado  se  encuentra  en  un  arreglo  de caracteres. */


int CargarArregloChar ( char a[], int dimension)
{
    int respuesta = 1;
    int i = 0;

    while ( i < dimension && respuesta == 1)
    {
        printf ("\nIngrese una letra: ");
        fflush(stdin);
        scanf ("%c",&a[i]);
        printf ("\n Desea continuar? 1 = si / 0 = no: ");
        scanf ("%i",&respuesta);
        i++;
    }
    return i;
}

int BuscarEnArreglo (char a[], int cant,char sebusca)
{
    int i=0;
    int endgame=0;

    while (i<cant && a[i]!= sebusca)
        {
        i++;
        }

if (a[i]== sebusca)
    {
    endgame=1;
    }

    return endgame;
}

/*7.  Realizar  una  función  que  inserte  un  carácter  en  un  arreglo  ordenado  alfabéticamente, conservando el orden. */


int InsertarChar(char a[], int canti, char insertadisimo)
{
    int i = canti;
    while(i>=0 && insertadisimo <a[i])
    {
        a[i+1]=a[i];
        i--;
    }
    a[i+1]=insertadisimo;

    return canti + 1;
}