int main()
{
    //parametrizado
    Circulo c1(10.5, 20.0, 1, "Rojo Intenso"),c2, c3;

   c2 = c1--;    // decrementa, si se puede, el diámetro

    c3 = c2++;    // incrementa, si se puede, el diámetro

    Circulo c4 = c3++;

    c4.CambiarColor("Amarillo patito flúo");


    cout << c1 << c2 << c3 << (c4 = c3) << endl;

    return 0;
}

#include "Circulo.h"
#include <string.h>

using namespace std;

Circulo :: Circulo() //por defecto
{
    x=0.0;
    y=0.0;
    diam=0;
    strcpy(Color,"");
}

Circulo::Circulo(float x,float y,unsigned diam,char *Color) //parametrizado
{
    this->x=x;
    this->y=y;
    this->diam=diam;
    this->Color= Color;
}

Circulo::Circulo(const Circulo& obj) //por copia
{
    this->x=obj.x;
    this->y=obj.y;
    this->diam=diam;
    this->Color=Color;
}

#ifndef CIRCULO_H
#define CIRCULO_H
#include <iostream>

using namespace std;

class Circulo
{
    public:
        Circulo();
        Circulo(float x,float y,unsigned diam,char *Color);
        Circulo(const Circulo& obj);
    private:
        float x,y;
        unsigned diam;
        char *Color;

};

#endif // CIRCULO_H

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

#define SIN_MEMORIA 0
#define CLAVE_DUPLICADA 0
#define TODO_BIEN 1
#define FALLO_ABRIR_ARCHIVO 0
#define NO_PUDO_GUARDAR_ARBOL 0
#define FALLO_CREAR_ARCHIVO 0

typedef struct
{
    int num;
}t_info;

typedef struct s_nodo
{   t_info info;
    struct s_nodo *der;
    struct s_nodo *izq;
}t_nodo;

typedef t_nodo* t_arbol;

int menu();
void crearArbol(t_arbol*);
int insertarNodoIterativo(t_arbol*, const t_info*);
int insertarNodoRecursivo(t_arbol*,const t_info*);
int compara(const t_info*,const t_info*);
void preorden(const t_arbol*);
void inorden (const t_arbol*);
void posorden(const t_arbol*);
void mostrar(const t_info*);
void grabarEnArchivo(t_arbol*,FILE*);
int guardarArbol(t_arbol*,FILE*);
int recuperarDeArchivo(t_arbol*,FILE*);
int contarNodos(t_arbol*);
int contarHojas(t_arbol*);
int contarHojasSubarbolDerecho(t_arbol*);
int contarNodosNoHojas(t_arbol*);
int contarNodosconHI(t_arbol*);
int contarHSI(t_arbol*);
int contarPadresSoloCHI(t_arbol*);
int contarNodosMayoresYPares(t_arbol*);
t_nodo* buscarNodo(t_arbol*, const t_info*);
int eliminarHojas(t_arbol*);
void eliminarArbol(t_arbol*);
int eliminarHojasConClave(t_arbol*, const t_info*);
int eliminarSubArbolConClave(t_arbol*, const t_info*);
float promedioArbol(t_arbol*,int*);
int mostrarNoHojas(t_arbol *);


int main()
{
    t_arbol raiz;
    t_info d;
    int opcion;
    t_info clave;
    FILE* pf;
    int sum=0;

     //crearArbol(&raiz);
    while((opcion=menu())!=0)
    {
        switch(opcion)
        {
                case 1:

                        crearArbol(&raiz);
                        printf("Arbol creado correctamente \n");
                        break;
                case 2:

                      printf("Ingresar de forma Iterativa...\n");
                      printf("Ingrese un mumero:\n");
                      scanf("%d",&d.num);
                      if(insertarNodoIterativo(&raiz,&d))
                        printf("Inserto Nodo Correctamente\n");
                      else
                        printf("No se pudo insertar en arbol\n");
                    break;
                case 3:
                       printf("Ingresar de forma Recursiva...\n");
                       printf("Ingrese un mumero:\n");
                       scanf("%d",&d.num);
                       if(insertarNodoRecursivo(&raiz,&d))
                            printf("Inseto Nodo Correctamente\n");
                       else
                         printf("No se pudo insertar en arbol\n");
                    break;
                case 4:
                        printf("Mostrar en preorden...\n");
                        preorden(&raiz);
                        if(raiz==NULL)
                            printf("Arbol Vacio\n");
                        break;

                case 5:
                    printf("Mostrar en inOrden...\n");
                    inorden(&raiz);
                    printf("\n");
                    break;

                case 6:
                    printf("Mostrar en posOrden...\n");
                    posorden(&raiz);
                    break;

                case 7:
                    //if(!(pf=fopen("ArchivoArbol","rb")))
                        if(!(pf=fopen("ArchivoArbol1","wb")))
                            return FALLO_CREAR_ARCHIVO;
                    printf("**************** Guardar el Arbol en Archivo *********************\n");
                    if(guardarArbol(&raiz,pf)==0)
                        printf("No pudo guardar Arbol\n");
                    else
                        printf("Arbol Guardado Correctamente\n");


                        fclose(pf);
                break;

                case 8:
                    crearArbol(&raiz);
                    printf("Recuperar el Arbol de Archivo\n");
                    if(!(pf=fopen("ArchivoArbol1","rb")))
                      return FALLO_ABRIR_ARCHIVO;
                    if(!recuperarDeArchivo(&raiz,pf))
                        printf("No se pudo recuperar datos del arbol\n\n");
                    fclose(pf);
                break;

                case 9:
                    printf("************ CONTAR NODOS ******************\n");
                    printf("Cantidad de nodos en el arbol: %d\t\n\n", contarNodos(&raiz));
                    break;

                case 10:
                    printf("************ CONTAR HOJAS *******************\n");
                    printf("Cantidad de hojas en el arbol: %d\t\n\n", contarHojas(&raiz));
                    break;

                case 11:
                    printf("Hojas del subarbol derecho: %d\t\n\n", contarHojasSubarbolDerecho(&raiz));
                    break;

                case 12:
                    printf("Contar nodos no Hojas\n");
                    printf("Nodos no hojas: %d\t\n\n", contarNodosNoHojas(&raiz));
                    break;

                case 13:
                    printf("***************** Contar nodos con Hijos Izquierda ****************\n");
                    printf("Nodos con hijos a la izquierda: %d\t\n\n", contarNodosconHI(&raiz));
                    break;

                case 14:
                    printf("***************** Contar hijos solo a la izquierda *****************\n");
                    printf("Hijos a la izquierda: %d\t\n\n", contarHSI(&raiz));
                    break;

                case 15:
                    printf("********** Padres con hijos solo a la izquierda *********************\n");
                    printf("Padres con hijos solo a la izquierda: %d\t\n\n", contarPadresSoloCHI(&raiz));
                    break;

                case 16:
                    printf("************* Nodos Pares y Mayores a 50 ****************************\n");
                    printf("Nodos pares y mayores a 50: %d\t\n\n", contarNodosMayoresYPares(&raiz));
                    break;

                case 17:
                    printf("******** Buscar por una clave dada y retornar direccion **************\n");
                    printf("Ingrese la clave de busqueda: ");
                    scanf("%d",&d);
                    printf("La direccion de la clave %d es %p\n", d,buscarNodo(&raiz,&d));

                case 18:
                    printf("************* Eliminar las hojas **********************************\n");
                    printf("Hojas eliminadas: %d\t\n", eliminarHojas(&raiz));
                    break;

                case 19:
                    printf("******************** Eliminar Arbol ********************************\n");
                    eliminarArbol(&raiz);
                    break;

                case 20:
                    printf("*********** Eliminar hojas a partir de una clave *******************\n");
                    printf("Ingrese la clave: ");
                    scanf("%d", & d);
                    printf("Se eliminaron %d hojas\t\n", eliminarHojasConClave(&raiz,&d));
                    break;

                case 21:
                    printf("************ Eliminar Subarbol a partir de una clave *****************\n");
                    printf("Ingrese la clave: ");
                    scanf("%d", & d);
                    printf("Se eliminaron %d nodos del subArbol desde la clave %d", eliminarSubArbolConClave(&raiz,&d), d);
                    break;

                case 22:
                    printf("***************** Promedio del Arbol *******************************)");
                    printf("el promedio del Arbol es: %f", (float)sum/promedioArbol(&raiz,&sum));
                    break;
                case 23:
                    printf("***************** Mostrar No Hojas *******************************)");
                    printf("Mostrar no nodos en el arbol: %d\t\n\n", mostrarNoHojas(&raiz));
                    break;
        }

    }
   //fclose(pf);
return 1;
}
////////////////////////////////////////
int menu(void)
{
    int opcion;
    do{
        printf("1 -  Crear Arbol \n");
        printf("2 -  Insertar Nodo Iterativo \n");
        printf("3 -  Insertar Nodo Recursivo \n");
        printf("4 -  Recorrido PREORDEN \n");
        printf("5 -  Recorrido INORDEN \n");
        printf("6 -  Recorrido POSORDEN \n");
        printf("7 -  Guardar el Arbol a un Archivo \n");
        printf("8 -  Recuperar el Arbol desde un Archivo \n");
        printf("9 -  Contar Nodos\n");
        printf("10-  Contar Hojas\n");
        printf("11-  Contar Hojas sub Arbol Derecho\n");
        printf("12-  Contar Nodos no Hojas\n");
        printf("13-  Contar Nodos con Hijos a la izquierda\n");
        printf("14-  Contar hijos solo a la izquierda\n");
        printf("15-  Contar Padres con Hijos solo a la izquierda\n");
        printf("16-  Contar nodos pares y mayores a 50\n");
        printf("17-  Buscar por una clave dada\n");
        printf("18-  Eliminar las hojas\n");
        printf("19-  Eliminar Arbol\n");
        printf("20-  Eliminar hojas a partir de una clave\n");
        printf("21-  Eliminar un SubArbol a partir de una clave\n");
        printf("22-  Promedio del Arbol\n");
        printf("23-  Mostrar no hojas\n");

        printf("0-  Salir \n");
        scanf("%d",&opcion);

    }while(opcion<0&&opcion>22);
    //system("cls");
}
//////////////////////////////////////////////////
void crearArbol(t_arbol*p)
{
    *p=NULL;
}
//////////////////////////////////
int insertarNodoIterativo(t_arbol* p, const t_info *d)
{int cmp;
    while(*p)
    {
        if((cmp=compara(d,&(*p)->info))==0)
           return CLAVE_DUPLICADA;
         if(cmp<0)
            p=&(*p)->izq;
         else
            p=&(*p)->der;

    }
    ///poner en nodo
    *p=(t_nodo*) malloc(sizeof(t_nodo));
    if(!(*p))
        return SIN_MEMORIA;
    (*p)->info=*d;
    (*p)->izq=(*p)->der=NULL;
    return TODO_BIEN;
}
///////////////////////////////////////
int insertarNodoRecursivo(t_arbol* p, const t_info*d)
{int cmp;
    if(*p)
    {
       if((cmp=compara(d,&(*p)->info))==0)
           return CLAVE_DUPLICADA;
           if(cmp<0)
                insertarNodoRecursivo(&(*p)->izq,d);
           else
                insertarNodoRecursivo(&(*p)->der,d);
    }
    else
    {
           //poner en nodo
        *p=(t_nodo*) malloc(sizeof(t_nodo));
        if(!(*p))
            return SIN_MEMORIA;
        (*p)->info=*d;
        (*p)->izq=(*p)->der=NULL;
        return TODO_BIEN;
    }

}
///////////////////////////////////
int compara(const t_info* d,const t_info* p )
{
    if(d->num < p->num)
        return -1;
    if(d->num > p->num)
        return 1;
    return 0;
}
/////////////////////////////////////
void preorden(const t_arbol *p)
{
    if(*p)
    {
        mostrar(&(*p)->info);
        preorden(&(*p)->izq);
        preorden(&(*p)->der);
    }
}
///////////////////////////////
void inorden(const t_arbol*p)
{
    if(*p)
    {
        inorden(&(*p)->izq);
        mostrar(&(*p)->info);
        inorden(&(*p)->der);
    }
}
//////////////////////////////////////
void posorden(const t_arbol*p)
{
    if(*p)
    {
        posorden(&(*p)->izq);
        posorden(&(*p)->der);
        mostrar(&(*p)->info);
    }
}
//////////////////////////////
void mostrar(const t_info* p)
{
    //mostrar(&(*p)->izq);
    printf("%d\t",p->num);
    printf("\n");
    //mostrar(&(*p)->der);
}

///////////////////////////////////////////////
void grabarenArchivo(t_arbol* p ,FILE* pf)
{
    fwrite(&(*p)->info.num,sizeof(t_info),1,pf);
}

////////////////////////////////////////////////////
int guardarArbol(t_arbol* p, FILE* pf)
{
    //printf("Grabo correctamente\n");
    if(*p)
    {
        grabarenArchivo(p,pf);
        guardarArbol(&(*p)->izq,pf);
        guardarArbol(&(*p)->der,pf);
        return 1;
    }
    return 0;
}

//////////////////////////////////////////////////////////////////
int recuperarDeArchivo(t_arbol* p, FILE* pf)
{
    t_info aux;
    fread(&aux,sizeof(t_info),1,pf);
    while(!feof(pf))
    {
       if(insertarNodoIterativo(p,&aux))
            fread(&aux,sizeof(t_info),1,pf);
        else
            return 0;
    }
    return 1;
}

///////////////////////////////////////////////////////////////////////

int contarNodos(t_arbol* p)
{
    if(*p)
        return 1+ contarNodos(&(*p)->izq) + contarNodos(&(*p)->der);
    return 0;
}
/*
int contarHojas(t_arbol* p)
{
    if(*p)
    {
        if((*p)->izq==NULL && (*p)->der==NULL)
            return 1;
        return contarHojas(&(*p)->izq)+ contarHojas(&(*p)->der);
    }
    return 0;
}
*/

int contarHojas(t_arbol *p)
{
    if(!*p)
        return 0;
    return (((*p)->izq==NULL)&&((*p)->der==NULL))?1:0+contarHojas(&(*p)->izq == NULL)+contarHojas(&(*p)->der);
}
///////////////////////////////////////////////////////////////////////

int contarHojasSubarbolDerecho(t_arbol* p)
{
    if(*p)
        return contarHojas(&(*p)->der);
}

int contarNodosNoHojas(t_arbol* p)
{
    if(!(*p))
        return 0;
    if((*p)->izq ||(*p)->der)
        return 1+contarNodosNoHojas(&(*p)->izq)+contarNodosNoHojas(&(*p)->der);
    return 0;
}

int contarNodosconHI(t_arbol* p)
{
    if(!(*p))
        return 0;
    if((*p)->izq)
        return contarNodosconHI(&(*p)->izq)+contarNodosconHI(&(*p)->der)+1;
    return contarNodosconHI(&(*p)->der);
}

int contarHSI(t_arbol* p)///Hijos a la izquierda y no tienen hijos a la derecha
{
    if(!(*p))
        return 0;
    return contarHSI(&(*p)->izq)+contarHSI(&(*p)->der)+(((*p)->izq) && !(*p)->der)?1:0;
}

int contarPadresSoloCHI(t_arbol* p)
{
    if(!(*p))
        return 0;
    return contarPadresSoloCHI(&(*p)->izq)+contarPadresSoloCHI(&(*p)->der)+((*p)->izq && !(*p)->der)?1:0;
}

int contarNodosMayoresYPares(t_arbol* p)
{
    if(*p)
    {
        return contarNodosMayoresYPares(&(*p)->izq) + contarNodosMayoresYPares(&(*p)->der) + (((*p)->info.num)>50 && (((*p)->info.num)%2==0)?1:0);
    }
    return 0;
}

t_nodo* buscarNodo(t_arbol* p, const t_info* d)
{
    int cmp;
    if(*p)
    {
        if((cmp=compara(d,&(*p)->info))==0)
            return *p;
        if(cmp<0)
            return buscarNodo(&(*p)->izq,d);
        else
            return buscarNodo(&(*p)->der,d);
    }
    return NULL;
}

int eliminarHojas(t_arbol* p)
{
    if(*p)
    {
        if(!(*p)->izq && !(*p)->der)//if((*p)->izq == (*p)->der)
        {
            free(*p);
            *p=NULL;
            return 1;
        }
        return eliminarHojas(&(*p)->izq)+eliminarHojas(&(*p)->der);
    }
}
void eliminarArbol(t_arbol* p)
{
    if(*p)
    {
        eliminarArbol(&(*p)->izq);
        eliminarArbol(&(*p)->der);
        free(*p);
        *p=NULL;
    }
}

int eliminarHojasConClave(t_arbol* p, const t_info* d)
{
    int cmp;
    if(*p)
    {
        cmp=compara(d,&(*p)->info);
        if(cmp==0)
        {
            return eliminarHojas(&(*p)->izq)+eliminarHojas(&(*p)->der);
        }
        if(cmp<0)
            return eliminarHojasConClave(&(*p)->izq,d);
        else
            return eliminarHojasConClave(&(*p)->der,d);
    }
    return 0;
}

int eliminarSubArbolConClave(t_arbol* p, const t_info* d)
{
    t_nodo* nodo;
    if(nodo=buscarNodo(p,d))
    {
       eliminarArbol(&(*nodo).izq);
       eliminarArbol(&(*nodo).der);
       ///eliminarArbol(nodo);
       return 1;
    }
     return 0;
}

/*float promedioArbol(t_arbol* p)
{
    int cont=0;

    int acum=0;
    if(*p)
    {
       cont=sumaracumulararbol(p,&acum);
       return (float) acum/cont;
    }
    return 0;
    *p==NULL;
}

int sumaracumulararbol(t_arbol* p,int* acum)
{
    if(*p)
    {
        printf("%d\n",(*p)->info.num);
        (*acum)+=(*p)->info.num;
        return 1 + sumaracumulararbol(&(*p)->izq,acum)+sumaracumulararbol(&(*p)->der,acum);

        printf("%d: ",acum);

    }
    return 0;
}
*/

float promedioArbol(t_arbol* p,int* sum)
{
    if(*p)
    {
        return promedioArbol(&(*p)->izq,sum)+((*p)->izq?1:0);
            if((*p)->izq)
                *sum+=(*p)->info.num;

        return promedioArbol(&(*p)->der,sum)+((*p)->der?1:0);
            if((*p)->der)
                *sum+=(*p)->info.num;
    }
    return 0;
}

int mostrarNoHojas(t_arbol *p)
{
    int aux=0;
    if(*p==NULL)
        return;
    if((*p)->izq != NULL || (*p)->der !=  NULL)
    {
        printf("%d",(*p)->info.num);
        aux++;
    }
    aux += mostrarNoHojas(&((*p)->izq));
    aux += mostrarNoHojas(&((*p)->der));
    return aux;
}
/*
int eliminarHojas(t_arbol *p)
{
    if(*p)
        return 0;
    if(!(*p)->izq && !(*p)->der )
    {
        free(*p);
        *p=NULL;
        return 1;
    }
    else
    {
      return   eliminarHojas(&(*p)->izq) + //elimina y cuenta
        eliminarHojas(&(*p)->der);
    }
}
*/
/*
void eliminarArbol(t_arbol *p)
int eliminarArbol(t_arbol *p) //para contar
{
    int aux=0;
    if(!*p)

        return;
      (eliminarArbol(&(*p)->izq)+eliminarArbol(&(*p)->der)+1);
     free(*p);

}
*/
/*

int eliminarArbol(t_arbol *p) //para contar
{
    int aux=0;
    if(!*p)

        return 0;
      aux+=eliminarArbol(&(*p)->izq);
      aux+=eliminarArbol(&(*p)->der);
     free(*p);
     *p=NULL;
     return aux;

}
*/

/*
int altura(t_arbol*p)
{
    int hd,hi;
    if(!*0)
        return 0; //0 nivel , 1 altura
    hd=altura(&(*p)->der);
    hi=altura(&(*p)->izq);
    return hd>hi?hd+1:hi+1;0
}
*/

#include <stdio.h>
#define TAM 10
#define MSG 1

typedef struct
{
   int codReceta;
   int nroRegIngr[30]; //vector de ingredientes
   int cantIngr[30];  //vector de cantidad de ingredientes
   int cantRegIngr;
}t_receta;

typedef struct  //estructura de ingredientes
{
    char nroRegIngr;
    char nomIngr[16];
    int  stock;
    float precio;
}t_ingrediente;

int main()
{
    FILE *rece;
    FILE *pingre;
    if(!abrirArchivo(&rece,"recetas.bin","rb",MSG))
        return 1;
    if(!abrirArchivo(&pingre,"ingredientes.bin","rb",MSG))
    {
        fclose(pingre);
        return 2;
    }

    if(rece)
    {
        int conta=1;
        while (!feof(rece))
        {
            ///procesar recetas

        }
    }
    else
    {
        puts("imposible abrir archivo");
    }

    return 0;
}



void CrearArchivo()
{
    FILE *prec=fopen("recetas.bin","wb");
    FILE *pingre=fopen("ingredientes.bin","wb");
    t_receta re []={{1,3,4,4 },
                    {2,4,5,5 }};

    t_receta re2[]={{1,"harina",4.0 },
                    {2,"huevo",4.0 },
                    };


    if(prec!=NULL )
    {
        fwrite(re, sizeof(re),1,prec);
        fclose(prec);
    }

    if(pingre!=NULL)
    {
        fwrite(re, sizeof(re2),1,pingre);
        fclose(pingre);
    }
}

#include <stdio.h>
#include <stdlib.h>
#include "dinamica.h"
#define MSG 1

void crearArchivo();
int abrirArchivo(FILE **, const char *, const char *, int);
void mostrarArchivo(FILE*);


int main()
{
    FILE *fpBin,
         *fpFem;
    t_info reg;
    t_pila pila;

    crearArchivo(fpBin);
    crearPila(&pila);
    if(!abrirArchivo(&fpBin, "Datos.bin", "rb", MSG))
        return 1;
    printf("\n \n \t \t \t ARCHIVO ORIGINAL \n");
    mostrarArchivo(fpBin);
    rewind(fpBin);
    fread(&reg, sizeof(t_info), 1, fpBin);
    while(!feof(fpBin))
    {
        if(reg.sex=='F' && !pilaLLena(&pila))
        {
            apilar(&pila, &reg);
            printf("%s \n", reg.ape);
        }
        fread(&reg, sizeof(t_info), 1, fpBin);
    }
    fclose(fpBin);

    if(!abrirArchivo(&fpFem, "Femeninas", "w+b", MSG))
        return 1;
    while(!pilaVacia(&pila))
    {
        sacarDePila(&pila, &reg);
        printf("%s \n", reg.ape);
        fwrite(&reg, sizeof(t_info), 1, fpFem);
    }
    rewind(fpFem);
    printf("\n \n \t \t \t ARCHIVO FEMENINO \n");
    mostrarArchivo(fpFem);
    fclose(fpFem);
    return 0;
}

//////funciones
void crearArchivo(void)
{
    FILE *fp = fopen("Datos.bin", "wb");
    t_info reg[] = {{111, "Palacio", "Rocio", 'F'},
        {222, "Sa", "Lia", 'F'},
        {333, "Perez", "Roberto", 'M'},
        {444, "Sanchez", "Lara", 'F'},
        {555, "Castillo", "Luis", 'M'}
    };

    if(fp!=NULL)
        fwrite(&reg, sizeof(t_info), 5, fp);
    fclose(fp);
}
////
int abrirArchivo(FILE **fp, const char *nombre, const char * modo, int msg)
{
    *fp = fopen("Datos.bin", "rb");
    if(*fp==NULL && msg)
    {
        printf("error abriendo archivo \n");
        return 0;
    }
    return 1;
}
/////
void mostrarArchivo(FILE*fp)
{
    t_info reg;
    printf("DNI \t Apellido \t Nombre \t Sexo \n");
    fread(&reg, sizeof(reg), 1, fp);
    while(!feof(fp))
    {
        printf("%d \t %s \t %s \t \t%c \n", reg.dni, reg.ape, reg.nombre, reg.sex);
        fread(&reg, sizeof(reg), 1, fp);
    }
}
////

#ifndef DINAMICA_H_INCLUDED
#define DINAMICA_H_INCLUDED

typedef struct
{
    int dni;
    char ape[30],
         nombre[30],
         sex;
} t_info;

typedef struct s_nodo
{
    t_info info;
    struct s_nodo *sig;
} t_nodo;

typedef t_nodo* t_pila;

void crearPila(t_pila *);
int apilar(t_pila *, const t_info *);
int verTope(const t_pila *, t_info *);
int sacarDePila(t_pila *, t_info *);
int pilaLLena(const t_pila *);
int pilaVacia(const t_pila *);
void vaciarPila(t_pila *);

/////FUNCIONES
void crearPila(t_pila *p)
{
    *p = NULL;
}
/////
int apilar(t_pila *p, const t_info *d)
{
    t_nodo * nue= (t_nodo*)malloc(sizeof(t_nodo));
    if(nue==NULL)
        return 0;
    nue->info=*d;
    nue->sig=*p;
    *p=nue;
    return 1;
}
/////
int pilaLLena(const t_pila *p)
{
    t_nodo *aux = (t_nodo*)malloc(sizeof(t_nodo));
    free(aux);
    return aux==NULL;
}
/////
int pilaVacia(const t_pila *p)
{
    return *p==NULL;
}
/////
int verTope(const t_pila *p, t_info *d)
{
    if(*p==NULL)
        return 0;
    *d = (*p)->info;
    return 1;
}
/////
int sacarDePila(t_pila *p, t_info *d)
{
    t_nodo *aux;
    if(*p==NULL)
        return 0;
    aux=*p;
    *d =aux->info;
    *p=aux->sig;
    free(aux);
    return 1;
}
/////
void vaciarPila (t_pila *p)
{
    t_nodo *aux;
    while(*p)
    {
        aux=*p;
        *p=aux->sig;
        free(aux);
    }
}

#endif // DINAMICA_H_INCLUDED

fseek(pf,29,0)

fseek(pf,51,1)

fseek(pf,60,2)

#‎include‬ <stdio.h>
#include <stdlib.h>
‪#‎define‬ MSG 1

int abrir_archivo (FILE**, char *, char *, int);
void mostrarReg(vect);

int main(void)
{
int i;
int vect;
FILE *archi;
archi=fopen("archalea.dat","w+b");
if(!archi)
{
puts("imposible abrir archivo");
}
else
{
 printf("90 numeros aleatorios del 0 al 99\n\n");
 for(i=0; i<89; i++)
 {
    vect=rand() % 1000;
   fwrite(&vect,sizeof(vect),1,archi);
 }
fclose(archi);

archi=fopen("archalea.dat","r+b");
if(archi)
{
int conta=0;
while (!feof(archi))
{

printf("\n posicion= %d Numero : %d", conta+1,vect);
conta++;
fread(&vect, sizeof(vect),1, archi);
//acá tengo que poner los fseek?
}
}
else
{
puts("imposible abrir archivo");
}

}
close(archi);
printf("\n");
return 0;
}

printf ("\n La cadena 5 se repite %d veces en la cadena 4",cantrepeticiones(cad4,cad5));

La cadena 5 se repite 1 veces en la cadena 4"

La cadena 5 se repite 0 veces en la cadena 4

#include <stdio.h>
#include <stdlib.h>
#define aMayusc(X)((X)>='a'&&(X)<='z'?(X)-32:(X))

int cantrepeticiones (char*,char*);

int main()
{
    char cad1[]= "ananana";
    char cad2[]= "ana";
    char cad3[]= "an";
    printf ("\n");
    char cad4[]= "mariamariamariamariana";
    char cad5[]= "maria jose";
    char cad6[]= "maria";
    puts(cad1);
    puts(cad2);
    puts(cad3);
    puts(cad4);
    puts(cad5);
    puts(cad6);
    printf ("\n La cadena 2 se repite %d veces en la cadena 1",cantrepeticiones(cad1,cad2));
    printf ("\n La cadena 3 se repite %d veces en la cadena 1",cantrepeticiones(cad1,cad3));
    printf ("\n La cadena 5 se repite %d veces en la cadena 4",cantrepeticiones(cad4,cad5));
    printf ("\n La cadena 6 se repite %d veces en la cadena 4",cantrepeticiones(cad4,cad6));
    printf ("\n");
    return 0;
}

int cantrepeticiones(char* c1, char* c2)
{
    int repeticiones=0;
    char* coindicencia=c1;  //Para guardar la posicion donde encuentra coincidencia con el primer caracter de la cadena a buscar
    char* inicio=c2; // Para poder volver al inicio de la cadena a buscar, en caso de no encontrarla completa
    while (*c1)
    {
        if (aMayusc(*c1)==aMayusc(*c2))
        {
            coindicencia=c1; //Guardo la posicion de la primera coincidencia
            while (*c1 && *c2 && aMayusc(*c1)==aMayusc(*c2))
            {
                c1++;
                c2++;
            }
            if (!*c2)
                repeticiones+=1;
            c1=coindicencia; // Vuelvo a la posicion de la primera coincidencia de caracteres
            c2=inicio; //Vuelvo al inicio del a cadena a buscar, por que el puntero quedo en el \0 o en la posicion donde no hubo coincidencia
        }
        c1++;
    }
    //printf("\n %d",repeticiones);
    return repeticiones;
}

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

#define esBlanco(x)((x)==' '||(x)=='\t')
#define aMayusc(x)((x)>='a'&&(x)<='z'?(x)-32:(x))
#define aMinusc(x)((x)>='A'&&(x)<='Z'?(x)+32:(x))

char* normalizar (char *);
char* normalizar2 (char *);
char* normalizar3 (char *);
char* normalizar4 (char *);

int main()
{
    char cad1[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
char cad11[100]={"\t                UN\teJEmPlo   aDeCUAdo  "};
char cad12[100]={"\t                UN EJEMPLO   ADECUADO  "};
    char cad2[100]={"   "};
    char cad3[100]={"\tUufFFc Jf \t\t  "};
char cad31[100]={"\tUUUUUfff JfeY78u \t\t  "};
    printf("\"%s\"\n",normalizar(cad1));
printf("\"%s\"\n",normalizar(cad11));
printf("\"%s\"\n",normalizar(cad12));
    printf("\"%s\"\n",normalizar(cad2));
    printf("\"%s\"\n",normalizar(cad3));
printf("\"%s\"\n",normalizar(cad31));
printf("\n ----------------------------------------------------------------------------\n");
char cad4[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
    char cad5[100]={"   "};
    char cad6[100]={"\tUufFFc Jf \t\t  "};
printf("\"%s\"\n",normalizar2(cad4));
    printf("\"%s\"\n",normalizar2(cad5));
    printf("\"%s\"\n",normalizar2(cad6));
    printf("\n ----------------------------------------------------------------------------\n");
    char cad7[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
    char cad8[100]={"   "};
    char cad9[100]={"\tUufFFc Jf \t\t  "};
    printf("\"%s\"\n",normalizar3(cad7));
    printf("\"%s\"\n",normalizar3(cad8));
    printf("\"%s\"\n",normalizar3(cad9));
    printf("\n ----------------------------------------------------------------------------\n");
    char cad101[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
    char cad111[100]={"   "};
    char cad121[100]={"\tUufFFc Jf \t\t  "};
    printf("\"%s\"\n",normalizar4(cad101));
    printf("\"%s\"\n",normalizar4(cad111));
    printf("\"%s\"\n",normalizar4(cad121));
    printf("\n");
    return 0;
}

char * normalizar (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl)
        {
            *pe=aMayusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMinusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}

char * normalizar2 (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl)
        {
            *pe=aMinusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMinusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}


char * normalizar3 (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl)
        {
            *pe=aMayusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMayusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}

char * normalizar4 (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        int bande=0;
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl && bande==1)
        {
            *pe=aMayusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMinusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
        //bande++;
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}

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

#define fil 2
#define col 2

int menu();
int * cargar_mat (int[fil][col],int* );
void mostrar_DP (int [fil][col]);
void mostrar_DS (int [fil][col]);
void mostrar_TS (int [fil][col]);
void mostrar_TR (int [fil][col]);

int main()
{
    int opc,mat[fil][col],cantElem=0;
    cargar_mat(mat,&cantElem);
    printf("\t escoja una opcion:");
    opc=menu();
    while(opc!=0)
    {
        switch(opc)
        {
        case 1:
        {
            mostrar_DP(mat);
            printf("\n");
            //printf("elementos:%d\n",cantElem);
        }
        break;
        case 2:
        {
            mostrar_DS(mat);
            printf("\n");
        }
        break;
        case 3:
        {
            mostrar_TS(mat);
            printf("\n");
        }
        case 4:
        {
            mostrar_TR(mat);
            printf("\n");
        }
        default:
        {

        } break;
        }
        printf("\t escoja una opcion:\n");
        opc=menu();
    }
    printf("\n");
    return 0;
}

int * cargar_mat (int mat[fil][col],int* cantE)
{
    int i,j;
    for(i=0; i<fil; i++)
    {
        for(j=0; j<col; j++)
        {
            printf("ingrese un numero: ");
            scanf("%d",&mat[i][j]);
            if(mat[i][j]==0)
                return  cantE;
            else
                (*cantE)++;
        }
    }
}


int menu()
{
    int opc;
    printf("\n");
    printf("\n1_ver diagonal principal\n2_ver diagonal secundaria\n3_triangulo superior\n4_traza\n0_salir\n");
    scanf("%d",&opc);
    printf("\n");
    return opc;
}

void mostrar_DP (int m[fil][col])
{
    int i;
    for(i=0; i<fil; i++)
        printf("%d\n",m[i][i]);
}


void mostrar_DS (int m[fil][col])
{
    int i;
    for(i=0; i<fil; i++)
        printf("%d\n",m[i][(col-1)-i]);
}

void mostrar_TS (int m[fil][col])
{
    int i;
    for(i=0; i<fil; i++)
        printf("%d\n",m[i][i]);
}

void mostrar_TR (int m[fil][col])
{
    int i;
    int acu=0;
    for(i=0; i<fil; i++)
    {
        acu+=m[i][i];
        printf("%d\n",acu);
    }

}

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

double exponencial(int,double);
int factorial(int);
long int potencia(int,int);
int vector(int[]);

void main(void)
{
    int num;
    double tol;
    printf("Ingrese un numero entero: ");
    scanf("%d",&num);
    printf("Ingrese la tolerancia: ");
    scanf("%lf",&tol);
    printf("e elevado a %d es: %ld \n", num, exponencial(num,tol));
}
///////////////////////////////////////////////////
int factorial(int num)
{
    int f=1,i;
    for(i=1;i<=num;i++)
       f*=i;
    return f;
}
////////////////////////////////////////////////////
long int potencia(int x, int y)
{
  int i;
  long int pot=1;
  for(i=0;i<y;i++)
        pot*=x;
  printf("%ld elevado a %d es:  %d\n",x,y,pot);
  return pot;
}
/////////////////////////////////////////////////
double exponencial(int x, double t)
{
    double exp=0,tot;
    int i=0;
    do{
        tot=(double) potencia(x,i)/factorial(i);
        exp+=tot;
        ///printf("\n%d\t%f\n\t",i,exp);
        i++;
    }while(t<tot);
return exp;
}