diff --git a/PRIMITIVAS DE LISTAS/lista_doblemente_enlazada.c b/PRIMITIVAS DE LISTAS/lista_doblemente_enlazada.c new file mode 100644 index 0000000..88cf49b --- /dev/null +++ b/PRIMITIVAS DE LISTAS/lista_doblemente_enlazada.c @@ -0,0 +1,236 @@ +#include "lista_doblemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int insertar_en_lista_ordenada_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(!(cmp=comparar((void*)&act->dato,(void*)d))) + return DUPLICADO; + if(cmp>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + act->dato=*d; + act->ant=ant; + act->sig=sig; + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + *l=act; + return OK; +} + +int insertar_en_lista_ordenada_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(comparar((void*)&act->dato,(void*)d)>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + act->dato=*d; + act->ant=ant; + act->sig=sig; + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + *l=act; + return OK; +} + +int eliminar_de_lista_ordenada_por_clave(t_lista *l,t_dato *d,void *clave,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant; + t_nodo *sig; + if(!act) + return LISTA_VACIA; + while(comparar((void*)&act->dato,clave)<0) + act=act->sig; + while(comparar((void*)&act->dato,clave)>0) + act=act->ant; + if(comparar((void*)&act->dato,clave)) + return NO_ENCONTRADO; + *d=act->dato; + ant=act->ant; + sig=act->sig; + if(ant) + { + ant->sig=act->sig; + *l=ant; + } + if(sig) + { + sig->ant=act->ant; + *l=sig; + } + if(!ant&&!sig) + *l=NULL; + free(act); + return OK; +} + +int eliminar_primero_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + while((*l)->ant) + l=&(*l)->ant; + aux=*l; + l=&(*l)->sig; + (*l)->ant=NULL; + *d=aux->dato; + free(aux); + return OK; +} + +int eliminar_ultimo_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + aux=*l; + l=&(*l)->ant; + (*l)->sig=NULL; + *d=aux->dato; + free(aux); + return OK; +} + +int ver_nodo_actual_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + *d=(*l)->dato; + return OK; +} + +int ver_primero_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->ant) + l=&(*l)->ant; + *d=(*l)->dato; + return OK; +} + +int ver_ultimo_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + *d=(*l)->dato; + return OK; +} + +void mostrar_lista_orden_ascendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->ant) + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + while((*l)->sig) + { + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + } +} + +void mostrar_lista_orden_descendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->sig) + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + while((*l)->ant) + { + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + } +} + +int contar_nodos_de_lista(const t_lista *l) +{ + int cont=0; + while((*l)->ant) + l=&(*l)->ant; + if(*l) + cont++; + while((*l)->sig) + { + l=&(*l)->sig; + cont++; + } + return cont; +} + +void vaciar_lista(t_lista *l) +{ + t_nodo *aux; + while((*l)->ant) + l=&(*l)->ant; + while((*l)->sig) + { + aux=*l; + l=&(*l)->sig; + free(aux); + } + *l=NULL; +} diff --git a/PRIMITIVAS DE LISTAS/lista_doblemente_enlazada.h b/PRIMITIVAS DE LISTAS/lista_doblemente_enlazada.h new file mode 100644 index 0000000..b1b87c4 --- /dev/null +++ b/PRIMITIVAS DE LISTAS/lista_doblemente_enlazada.h @@ -0,0 +1,40 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *ant; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int insertar_en_lista_ordenada_sin_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenada_con_duplicado(t_lista*,const t_dato*,t_cmp); +int eliminar_de_lista_ordenada_por_clave(t_lista*,t_dato*,void*,t_cmp); +int eliminar_primero_de_lista(t_lista*,t_dato*); +int eliminar_ultimo_de_lista(t_lista*,t_dato*); +int ver_nodo_actual_de_lista(const t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +int ver_ultimo_de_lista(const t_lista*,t_dato*); +void mostrar_lista_orden_ascendente(const t_lista*,t_mst); +void mostrar_lista_orden_descendente(const t_lista*,t_mst); +int contar_nodos_de_lista(const t_lista*); +void vaciar_lista(t_lista*); diff --git a/PRIMITIVAS DE LISTAS/lista_simplemente_enlazada.c b/PRIMITIVAS DE LISTAS/lista_simplemente_enlazada.c new file mode 100644 index 0000000..e2823de --- /dev/null +++ b/PRIMITIVAS DE LISTAS/lista_simplemente_enlazada.c @@ -0,0 +1,225 @@ +#include +#include + +#include "lista_simplemente_enlazada.h" + +void crear_lista(t_lista *l) + { + *l=NULL; + } + +void vaciar_lista(t_lista *l) + { + t_nodo *aux; + while(*l) + { + aux=*l; + *l=aux->sig; + free(aux); + } + } + +int lista_llena(const t_lista *l) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int lista_vacia(const t_lista *l) + { + return *l==NULL; + } + +int poner_en_lista_primero(t_lista *l,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int poner_en_lista_ultimo(t_lista *l,const t_dato *d) + { + while(*l) + l=&(*l)->sig; + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato=*d; + (*l)->sig=NULL; + return OK; + } + +int sacar_de_lista_primero(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + t_nodo *aux=*l; + *d=aux->dato; + *l=aux->sig; + free(aux); + return OK; + } + +int sacar_de_lista_ultimo(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + while(!(*l)->sig) + l=&(*l)->sig; + t_nodo *aux=*l; + *d=aux->dato; + *l=NULL; + free(aux); + return OK; + } + +int insertar_en_lista_por_posicion(t_lista *l,const t_dato *d,int *pos) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + while(*l&&*pos>1) + { + l=&(*l)->sig; + (*pos)--; + } + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int insertar_en_lista_ordenado_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d)<=0)) + l=&(*l)->sig; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int insertar_en_lista_ordenado_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar(&(*l)->dato,d)<0)) + l=&(*l)->sig; + if(*l&&!cmp) + return DUPLICADO; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +/* +ESTA FUNCIÓN SOLO TIENE SENTIDO SI SE IMPLEMENTA CON UN DATO QUE CONTENGA LOS CAMPOS CLAVE Y CANTIDAD DE REPETICIONES + +int insertar_si_no_existe_clave(t_lista *l,const t_dato *d,int clave) + { + while(*l&&(*l)->dato.clave!=clave) + l=&(*l)->sig; + if(*l) + { + ((*l)->dato.cant_rep)++; + return CLAVE_DUPLICADA; + } + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato.clave=clave; + (*l)->dato.cant_rep=0; + (*l)->sig=NULL; + return OK; + } +*/ + +int buscar_en_lista_ordenada(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d))<0) + l=&(*l)->sig; + if(*l&&!cmp) + return ENCONTRADO; + return NO_ENCONTRADO; + } + +int buscar_en_lista_desordenada(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d))!=0) + l=&(*l)->sig; + if(*l&&!cmp) + return ENCONTRADO; + return NO_ENCONTRADO; + } + +int eliminar_por_clave_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) + { + while(*l&&(comparar((void*)&(*l)->dato,clave)!=0)) + l=&(*l)->sig; + if(!*l) + return NO_ENCONTRADO; + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; + } + +int eliminar_por_clave_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,clave))<0) + l=&(*l)->sig; + if(*l&&!cmp) + { + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; + } + return NO_ENCONTRADO; + } + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) + { + int cmp; + t_nodo *aux; + while(*l&&(cmp=comparar((void*)&(*l)->dato,clave))<=0) + { + if(!cmp) + { + aux=*l; + *l=(*l)->sig; + free(aux); + } + l=&(*l)->sig; + } + } + +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) + { + t_nodo *aux; + while(*l) + { + if(!comparar((void*)&(*l)->dato,clave)) + { + aux=*l; + *l=(*l)->sig; + free(aux); + } + l=&(*l)->sig; + } + } diff --git a/PRIMITIVAS DE LISTAS/lista_simplemente_enlazada.h b/PRIMITIVAS DE LISTAS/lista_simplemente_enlazada.h new file mode 100644 index 0000000..2f3f9c5 --- /dev/null +++ b/PRIMITIVAS DE LISTAS/lista_simplemente_enlazada.h @@ -0,0 +1,48 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 +#define DUPLICADO 0 +#define CLAVE_DUPLICADA 1 +#define ENCONTRADO 1 +#define NO_ENCONTRADO 0 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +void vaciar_lista(t_lista*); + +int lista_llena(const t_lista*); +int lista_vacia(const t_lista*); + +int poner_en_lista_primero(t_lista*,const t_dato*); +int poner_en_lista_ultimo(t_lista*,const t_dato*); + +int sacar_de_lista_primero(t_lista*,t_dato*); +int sacar_de_lista_ultimo(t_lista*,t_dato*); + +int insertar_en_lista_por_posicion(t_lista*,const t_dato*,int*); +int insertar_en_lista_ordenado_con_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenado_sin_duplicado(t_lista*,const t_dato*,t_cmp); + +/* +int insertar_si_no_existe_clave(t_lista*,const t_dato*,int); +*/ + +int buscar_en_lista_ordenada(t_lista*,const t_dato*,t_cmp); +int buscar_en_lista_desordenada(t_lista*,const t_dato*,t_cmp); + +int eliminar_por_clave_en_lista_desordenada(t_lista*,void*,t_cmp); +int eliminar_por_clave_en_lista_ordenada(t_lista*,void*,t_cmp); + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista*,void*,t_cmp); +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista*,void*,t_cmp); diff --git a/PRIMITIVAS DE LISTAS/primitivas_lista_circular.c b/PRIMITIVAS DE LISTAS/primitivas_lista_circular.c new file mode 100644 index 0000000..1b7e527 --- /dev/null +++ b/PRIMITIVAS DE LISTAS/primitivas_lista_circular.c @@ -0,0 +1,77 @@ +#include "primitivas_lista_circular.h" + +#include +#include + +void crear_lista(t_lista *l) + { + *l=NULL; + } + +int lista_vacia(const t_lista *l) + { + return *l==NULL; + } + +int lista_llena(const t_lista *l) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int poner_en_lista(t_lista *l,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*l) + { + *l=nue; + nue->sig=nue; + } + else + { + nue->sig=(*l)->sig; + (*l)->sig=nue; + } + return OK; + } + +int sacar_de_lista(t_lista *l,t_dato *d) + { + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + aux=(*l)->sig; + *d=aux->dato; + if(*l==aux) + *l=NULL; + else + (*l)->sig=aux->sig; + free(aux); + return OK; + } + +int ver_primero_de_lista(const t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + *d=(*l)->dato; + return OK; + } + +void vaciar_lista(t_lista *l) + { + t_nodo *aux,*pri=*l; + *l=(*l)->sig; + while(*l&&*l!=pri) + { + aux=*l; + *l=aux->sig; + free(aux); + } + free(*l); + *l=NULL; + } diff --git a/PRIMITIVAS DE LISTAS/primitivas_lista_circular.h b/PRIMITIVAS DE LISTAS/primitivas_lista_circular.h new file mode 100644 index 0000000..aa145bd --- /dev/null +++ b/PRIMITIVAS DE LISTAS/primitivas_lista_circular.h @@ -0,0 +1,21 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int poner_en_lista(t_lista*,const t_dato*); +int sacar_de_lista(t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +void vaciar_lista(t_lista*); diff --git a/PRIMITIVAS DE PILA Y COLA/primitivas_cola_circular.c b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_circular.c new file mode 100644 index 0000000..323f6b8 --- /dev/null +++ b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_circular.c @@ -0,0 +1,83 @@ +#include "primitivas_cola_circular.h" + +#include +#include + +void crear_cola(t_lista *c) + { + *c=NULL; + } + +int cola_vacia(const t_lista *c) + { + return *c==NULL; + } + +int cola_llena(const t_lista *c) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int acolar(t_lista *c,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*c) + nue->sig=nue; + else + { + nue->sig=(*c)->sig; + (*c)->sig=nue; + } + *c=nue; + return OK; + } + +int desacolar(t_lista *c,t_dato *d) + { + t_nodo *aux; + if(!*c) + return COLA_VACIA; + aux=(*c)->sig; + *d=aux->dato; + if(*c==aux) + *c=NULL; + else + (*c)->sig=aux->sig; + free(aux); + return OK; + } + +int ver_primero_en_cola(const t_lista *c,t_dato *d) + { + if(!*c) + return COLA_VACIA; + *d=(*c)->sig->dato; + return OK; + } + +int ver_ultimo_en_cola(const t_lista *c,t_dato *d) + { + if(!*c) + return COLA_VACIA; + *d=(*c)->dato; + return OK; + } + +void vaciar_cola(t_lista *c) + { + t_nodo *aux,*ult=*c; + *c=(*c)->sig; + while(*c&&*c!=ult) + { + aux=*c; + *c=aux->sig; + free(aux); + } + free(*c); + *c=NULL; + } diff --git a/PRIMITIVAS DE PILA Y COLA/primitivas_cola_circular.h b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_circular.h new file mode 100644 index 0000000..cacddbc --- /dev/null +++ b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_circular.h @@ -0,0 +1,22 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +void crear_cola(t_lista*); +int cola_vacia(const t_lista*); +int cola_llena(const t_lista*); +int acolar(t_lista*,const t_dato*); +int desacolar(t_lista*,t_dato*); +int ver_primero_en_cola(const t_lista*,t_dato*); +int ver_ultimo_en_cola(const t_lista*,t_dato*); +void vaciar_cola(t_lista*); diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_cola_din\303\241mica.c" "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_din\303\241mica.c" new file mode 100644 index 0000000..c8a0a09 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_din\303\241mica.c" @@ -0,0 +1,79 @@ +#include "primitivas_cola_dinámica.h" + +//no sé por qué si no incluyo las bibliotecas tira error +#include +#include + +void crear_cola(t_cola *c) + { + c->pri=NULL; + c->ult=NULL; + } + +int cola_llena(const t_cola *c) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int acolar(t_cola *c,const t_dato *d) + { + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=NULL; + if(c->ult==NULL) + c->pri=nuevo; + else + c->ult->sig=nuevo; + c->ult=nuevo; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->pri==NULL; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + t_nodo *aux=c->pri; + *d=aux->dato;//*d=c->prim->dato; + c->pri=aux->sig;//c->pri=c->pri->sig; + if(c->pri==NULL) + c->ult=NULL; + free(aux); + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + *d=c->pri->dato; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + *d=c->ult->dato; + return OK; + } + +void vaciar_cola(t_cola *c) + { + t_nodo *aux; + while(c->pri!=NULL) + { + aux=c->pri; + c->pri=aux->sig; + free(aux); + } + c->ult=NULL; + } diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_cola_din\303\241mica.h" "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_din\303\241mica.h" new file mode 100644 index 0000000..35dfbee --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_din\303\241mica.h" @@ -0,0 +1,26 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef struct + { + t_nodo *pri; + t_nodo *ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_cola_est\303\241tica.c" "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_est\303\241tica.c" new file mode 100644 index 0000000..111cbe5 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_est\303\241tica.c" @@ -0,0 +1,63 @@ +#include "primitivas_cola_estática.h" + +void crear_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } + +int cola_llena(const t_cola *c) + { + return (c->ult+1)%TAM==c->pri&&c->ult!=-1; + } + +int acolar(t_cola *c,const t_dato *d) + { + if((c->ult+1)%TAM==c->pri&&c->ult!=-1) + return COLA_LLENA; + c->ult=(c->ult+1)%TAM; + c->cola[c->ult]=*d; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->ult==-1; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + if(c->pri==c->ult) + { + c->pri=0; + c->ult=-1; + } + else + c->pri=(c->pri+1)%TAM; + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->ult]; + return OK; + } + +void vaciar_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_cola_est\303\241tica.h" "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_est\303\241tica.h" new file mode 100644 index 0000000..54c94d6 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_cola_est\303\241tica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define COLA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct + { + t_dato cola[TAM]; + int pri; + int ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git a/PRIMITIVAS DE PILA Y COLA/primitivas_pila_circular.c b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_circular.c new file mode 100644 index 0000000..f020c42 --- /dev/null +++ b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_circular.c @@ -0,0 +1,72 @@ +#include "primitivas_pila_circular.h" + +#include +#include + +void crear_pila(t_lista *p) + { + *p=NULL; + } + +int pila_vacia(const t_lista *p) + { + return *p==NULL; + } + +int pila_llena(const t_lista *p) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int apilar(t_lista *p,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*p) + *p=nue; + else + nue->sig=(*p)->sig; + (*p)->sig=nue; + return OK; + } + +int desapilar(t_lista *p,t_dato *d) + { + t_nodo *aux; + if(!*p) + return PILA_VACIA; + aux=(*p)->sig; + *d=aux->dato; + if(*p==aux) + *p=NULL; + else + (*p)->sig=aux->sig; + free(aux); + return OK; + } + +int ver_tope(const t_lista *p,t_dato *d) + { + if(!*p) + return PILA_VACIA; + *d=(*p)->sig->dato; + return OK; + } + +void vaciar_pila(t_lista *p) + { + t_nodo *aux,*pri=*p; + *p=(*p)->sig; + while(*p&&*p!=pri) + { + aux=*p; + *p=aux->sig; + free(aux); + } + free(*p); + *p=NULL; + } diff --git a/PRIMITIVAS DE PILA Y COLA/primitivas_pila_circular.h b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_circular.h new file mode 100644 index 0000000..5e04673 --- /dev/null +++ b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_circular.h @@ -0,0 +1,21 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define PILA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +void crear_pila(t_lista*); +int pila_vacia(const t_lista*); +int pila_llena(const t_lista*); +int apilar(t_lista*,const t_dato*); +int desapilar(t_lista*,t_dato*); +int ver_tope(const t_lista*,t_dato*); +void vaciar_pila(t_lista*); diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_pila_din\303\241mica.c" "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..0d475e8 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_pila_din\303\241mica.h" "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..90e4155 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,22 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); + diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_pila_est\303\241tica.c" "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..c1da8f4 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,48 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) + { + p->tope=0; + } + +int pila_llena(const t_pila *p) + { + return p->tope==TAM; + } + +int apilar(t_pila *p,const t_dato *d) + { + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return p->tope==0; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; + } + +void vaciar_pila(t_pila *p) + { + p->tope=0; + } + diff --git "a/PRIMITIVAS DE PILA Y COLA/primitivas_pila_est\303\241tica.h" "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..b227de3 --- /dev/null +++ "b/PRIMITIVAS DE PILA Y COLA/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 1 +#define OK 1 + +typedef struct + { + t_dato pila[TAM]; + int tope;//primera libre + }t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/PRIMITIVAS DE \303\201RBOL/primitivas_pila_din\303\241mica.c" "b/PRIMITIVAS DE \303\201RBOL/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..b2dede4 --- /dev/null +++ "b/PRIMITIVAS DE \303\201RBOL/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo_pila)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo_pila *nuevo=(t_nodo_pila*)malloc(sizeof(t_nodo_pila)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo_pila *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo_pila *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/PRIMITIVAS DE \303\201RBOL/primitivas_pila_din\303\241mica.h" "b/PRIMITIVAS DE \303\201RBOL/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..de93910 --- /dev/null +++ "b/PRIMITIVAS DE \303\201RBOL/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo_pila + { + t_dato dato; + struct s_nodo_pila *sig; + }t_nodo_pila; + +typedef t_nodo_pila* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/PRIMITIVAS DE \303\201RBOL/primitivas_\303\241rbol.c" "b/PRIMITIVAS DE \303\201RBOL/primitivas_\303\241rbol.c" new file mode 100644 index 0000000..f737049 --- /dev/null +++ "b/PRIMITIVAS DE \303\201RBOL/primitivas_\303\241rbol.c" @@ -0,0 +1,1037 @@ +#include "primitivas_árbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + free(*a); + *a=NULL; + } +} + +int arbol_vacio(const t_arbol *a) +{ + return *a==NULL; +} + +int arbol_lleno(const t_arbol *a) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +void recorrer_arbol_inorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_inorden_recursiva(&(*a)->izq,mostrar); + mostrar(&(*a)->dato); + recorrer_arbol_inorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_preorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + recorrer_arbol_preorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_preorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_posorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_posorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_posorden_recursiva(&(*a)->der,mostrar); + mostrar(&(*a)->dato); + } +} + +void recorrer_arbol_inorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_preorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_posorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +int insertar_en_arbol_recursiva(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + if(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + return insertar_en_arbol_recursiva(&(*a)->izq,d,comparar); + if(comparar((void*)&(*a)->dato,(void*)d)<0) + return insertar_en_arbol_recursiva(&(*a)->der,d,comparar); + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int buscar_en_arbol_recursiva(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + return buscar_en_arbol_recursiva(&(*a)->izq,d,comparar); + else + return buscar_en_arbol_recursiva(&(*a)->der,d,comparar); + } + return NO_ENCONTRADO; +} + +int buscar_en_arbol_iterativa(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NO_ENCONTRADO; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo **padre=a; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return NULL; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(t_arbol *a,t_dato *d,t_cmp comparar,t_nodo **padre) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return padre; + *padre=*a; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_iterativa(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo **padre=a; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return (padre!=a)?padre:NULL; + padre=a; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NULL; +} + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->izq,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->der,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + } +} + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->izq,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->der,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + } +} + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + fread(&dato,sizeof(t_dato),1,pf); + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_pila pila; + crear_pila(&pila); + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + if(!apilar(&pila,&dato)) + return 0; + fread(&dato,sizeof(t_dato),1,pf); + } + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + } + return OK; +} + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_pila pila; + crear_pila(&pila); + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + if(!apilar(&pila,&dato)) + return 0; + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + } + return OK; +} + +int contar_nodos(const t_arbol *a) +{ + if(*a) + return contar_nodos(&(*a)->izq)+contar_nodos(&(*a)->der)+1; + return 0; +} + +int contar_hojas(const t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + return 1; + return contar_hojas(&(*a)->izq)+contar_hojas(&(*a)->der); + } + return 0; +} + +int contar_no_hojas(const t_arbol *a) +{ + if(*a) + if((*a)->izq||(*a)->der) + return contar_no_hojas(&(*a)->izq)+contar_no_hojas(&(*a)->der)+1; + return 0; +} + +int contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + return contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq)+1; + return contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq)+contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + return contar_nodos_con_hijos_solo_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_solo_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + return contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + return contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + return contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_de_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel) + return contar_nodos_de_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_de_un_nivel(&(*a)->der,nivel-1); + return 1; + } + return 0; +} + +int contar_nodos_hasta_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + if(nivel) + return contar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_hasta_un_nivel(&(*a)->der,nivel-1)+1; + return 0; +} + +int contar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel) + return contar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1)+1; + return 1; + } + return 0; +} + +int contar_nodos_desde_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel>=0) + return contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel(&(*a)->der,nivel-1); + return contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel(&(*a)->der,nivel-1)+1; + } + return 0; +} + +int contar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel>=1) + return contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1); + return contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1)+1; + } + return 0; +} + +void mostrar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + mostrar_nodos(&(*a)->izq,mostrar); + mostrar_nodos(&(*a)->der,mostrar); + } +} + +void mostrar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + mostrar(&(*a)->dato); + mostrar_hojas(&(*a)->izq,mostrar); + mostrar_hojas(&(*a)->der,mostrar); + } +} + +void mostrar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + mostrar(&(*a)->dato); + mostrar_no_hojas(&(*a)->izq,mostrar); + mostrar_no_hojas(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + { + mostrar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + } + else + mostrar(&(*a)->dato); + } +} + +void mostrar_nodos_hasta_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + { + mostrar(&(*a)->dato); + mostrar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_hasta_un_nivel(&(*a)->der,nivel-1,mostrar); + } + } +} + +void mostrar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + if(nivel) + { + mostrar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + } + } +} + +void mostrar_nodos_desde_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel<0) + mostrar(&(*a)->dato); + mostrar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar); + } +} + +void mostrar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel<=0) + mostrar(&(*a)->dato); + mostrar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + } +} + +int mostrar_y_contar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos(&(*a)->izq,mostrar)+mostrar_y_contar_nodos(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + { + mostrar(&(*a)->dato); + return 1; + } + return mostrar_y_contar_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_hojas(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + if((*a)->izq||(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_no_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_no_hojas(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } + return 0; +} + + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + return mostrar_y_contar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return 1; + } + return 0; +} + +int mostrar_y_contar_nodos_hasta_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + if(nivel) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_hasta_un_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + if(nivel) + return mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + return 1; + } + return 0; +} + +int mostrar_y_contar_nodos_desde_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=0) + return mostrar_y_contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=1) + return mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +void talar_arbol(t_arbol *a) +{ + *a=NULL; +} + +void podar_hojas(t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + { + free(*a); + *a=NULL; + } + else + { + podar_hojas(&(*a)->izq); + podar_hojas(&(*a)->der); + } + } +} + +void podar_hasta_nivel(t_arbol *a,int nivel) +{ + if(*a) + { + podar_hasta_nivel(&(*a)->izq,nivel-1); + podar_hasta_nivel(&(*a)->der,nivel-1); + if(nivel<0) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_nivel_inclusive(t_arbol *a,int nivel) +{ + if(*a) + { + podar_hasta_nivel_inclusive(&(*a)->izq,nivel-1); + podar_hasta_nivel_inclusive(&(*a)->der,nivel-1); + if(!nivel) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_altura(t_arbol *a,int altura) +{ + if(*a) + { + podar_hasta_altura(&(*a)->izq,altura-1); + podar_hasta_altura(&(*a)->der,altura-1); + if(!altura) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_altura_inclusive(t_arbol *a,int altura) +{ + if(*a) + { + podar_hasta_altura_inclusive(&(*a)->izq,altura-1); + podar_hasta_altura_inclusive(&(*a)->der,altura-1); + if(altura<=1) + { + free(*a); + *a=NULL; + } + } +} + +int calcular_nivel(const t_arbol *a) +{ + if(*a) + { + int niv_izq=calcular_nivel(&(*a)->izq); + int niv_der=calcular_nivel(&(*a)->der); + return (niv_izq>=niv_der)?niv_izq+1:niv_der+1; + } + return -1; +} + +int calcular_altura(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (alt_izq>=alt_der)?alt_izq+1:alt_der+1; + } + return 0; +} + +int arbol_semibalanceado(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (ABS(alt_izq-alt_der)>1)?0:arbol_semibalanceado(&(*a)->izq)&&arbol_semibalanceado(&(*a)->der); + } + return 1; +} + +int arbol_balanceado(const t_arbol *a) +{ + int h=calcular_altura(a); + return arbol_balanceado_interna(a,h); +} + +int arbol_balanceado_interna(const t_arbol *a,int altura) +{ + if(*a) + return arbol_balanceado_interna(&(*a)->izq,altura-1)&&arbol_balanceado_interna(&(*a)->der,altura-1); + return altura<=1; +} + +int arbol_completo(const t_arbol *a) +{ + int h=calcular_altura(a); + return arbol_completo_interno(a,h); +} + +int arbol_completo_interno(const t_arbol *a,int altura) +{ + if(*a) + return arbol_completo_interno(&(*a)->izq,altura-1)&&arbol_completo_interno(&(*a)->der,altura-1); + return altura==0; +} + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(t_arbol *a,FILE *pf,t_cmp comparar) +{ + fseek(pf,0L,SEEK_END); + return cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,1,ftell(pf)/sizeof(t_dato),comparar); +} + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(t_arbol *a,FILE *pf,int pri,int ult,t_cmp comparar) +{ + t_dato dato; + if(pri<=ult) + { + int medio=(pri+ult)/2; + fseek(pf,(medio-1)*sizeof(t_dato),SEEK_SET); + fread(&dato,sizeof(t_dato),1,pf); + if(!feof(pf)) + { + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,pri,medio-1,comparar); + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,medio+1,ult,comparar); + } + } + return OK; +} + +int hoja(const t_arbol *a) +{ + return *a&&!(*a)->izq&&!(*a)->der; +} + +t_nodo **buscar_nodo_menor(t_arbol *a) +{ + if(!*a) + return NULL; + while((*a)->izq) + a=&(*a)->izq; + return a; +} + +t_nodo **buscar_nodo_mayor(t_arbol *a) +{ + if(!*a) + return NULL; + while((*a)->der) + a=&(*a)->der; + return a; +} + +int eliminar_nodo_y_acomodar_ramas_iterativa(t_arbol *a,t_dato *d,t_cmp comparar) +{ + t_arbol *sub_arbol; + a=buscar_en_arbol_y_retornar_direccion_padre_iterativa(a,d,comparar); + if(!a) + return NO_ENCONTRADO; + while((*a)->izq||(*a)->der) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + sub_arbol=(alt_izq<=alt_der)?buscar_nodo_menor(&(*a)->izq):buscar_nodo_mayor(&(*a)->der); + (*a)->dato=(*sub_arbol)->dato; + a=sub_arbol; + } + free(*a); + *a=NULL; + return OK; +} + +int eliminar_nodo_y_acomodar_ramas_recursiva(t_arbol *a,t_dato *d,t_cmp comparar) +{ + a=buscar_en_arbol_y_retornar_direccion_padre_iterativa(a,d,comparar); + if(!a) + return NO_ENCONTRADO; + return eliminar_nodo_y_acomodar_ramas_recursiva_interna(a,d); +} + +int eliminar_nodo_y_acomodar_ramas_recursiva_interna(t_arbol *a,t_dato *d) +{ + if((*a)->izq||(*a)->der) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + t_arbol *sub_arbol=(alt_izq<=alt_der)?buscar_nodo_menor(&(*a)->izq):buscar_nodo_mayor(&(*a)->der); + (*a)->dato=(*sub_arbol)->dato; + a=sub_arbol; + return eliminar_nodo_y_acomodar_ramas_recursiva_interna(a,d); + } + free(*a); + *a=NULL; + return OK; +} + +void arbol_grafico(const t_arbol *a,t_mst mostrar) +{ + arbol_grafico_interna(a,mostrar,0); +} + +void arbol_grafico_interna(const t_arbol *a,t_mst mostrar,int nivel) +{ + if(*a) + { + if((*a)->der) + arbol_grafico_interna(&(*a)->der,mostrar,nivel+1); + + tab(nivel); + mostrar((void*)&(*a)->dato); + printf("\n\n"); + + if((*a)->izq) + arbol_grafico_interna(&(*a)->izq,mostrar,nivel+1); + } +} + +void tab(int x) +{ + int i; + for(i=0;i +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +#define ABS(x) ((x)>0)?(x):(-(x)) + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *izq; + struct s_nodo *der; +}t_nodo; + +typedef t_nodo* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol*); +void vaciar_arbol(t_arbol*); + +int arbol_vacio(const t_arbol*); +int arbol_lleno(const t_arbol*); + +void recorrer_arbol_inorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_preorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_posorden_recursiva(const t_arbol*,t_mst); + +void recorrer_arbol_inorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_preorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_posorden_iterativa(const t_arbol*,t_mst); + +int insertar_en_arbol_recursiva(t_arbol*,const t_dato*,t_cmp); +int insertar_en_arbol_iterativa(t_arbol*,const t_dato*,t_cmp); + +int buscar_en_arbol_recursiva(t_arbol*,t_dato*,t_cmp); +int buscar_en_arbol_iterativa(t_arbol*,t_dato*,t_cmp); + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva(t_arbol*,t_dato*,t_cmp); +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(t_arbol*,t_dato*,t_cmp,t_nodo**); +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_iterativa(t_arbol*,t_dato*,t_cmp); + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol*,FILE*); + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol*,FILE*); + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); + +int contar_nodos(const t_arbol*); +int contar_hojas(const t_arbol*); +int contar_no_hojas(const t_arbol*); + +int contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*); +int contar_nodos_con_hijos_solo_por_derecha(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*); + +int contar_nodos_de_un_nivel(const t_arbol*,int); +int contar_nodos_hasta_un_nivel(const t_arbol*,int); +int contar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int); +int contar_nodos_desde_un_nivel(const t_arbol*,int); +int contar_nodos_desde_un_nivel_inclusive(const t_arbol*,int); + +void mostrar_nodos(const t_arbol*,t_mst); +void mostrar_hojas(const t_arbol*,t_mst); +void mostrar_no_hojas(const t_arbol*,t_mst); + +void mostrar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +void mostrar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_hasta_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int,t_mst); +void mostrar_nodos_desde_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_desde_un_nivel_inclusive(const t_arbol*,int,t_mst); + +int mostrar_y_contar_nodos(const t_arbol*,t_mst); +int mostrar_y_contar_hojas(const t_arbol*,t_mst); +int mostrar_y_contar_no_hojas(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_hasta_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_desde_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_desde_un_nivel_inclusive(const t_arbol*,int,t_mst); + +void talar_arbol(t_arbol*); + +void podar_hojas(t_arbol*); +void podar_hasta_nivel(t_arbol*,int); +void podar_hasta_nivel_inclusive(t_arbol*,int); +void podar_hasta_altura(t_arbol*,int); +void podar_hasta_altura_inclusive(t_arbol*,int); + +int calcular_nivel(const t_arbol*); +int calcular_altura(const t_arbol*); + +int arbol_semibalanceado(const t_arbol*); + +int arbol_balanceado(const t_arbol*); +int arbol_balanceado_interna(const t_arbol*,int); + +int arbol_completo(const t_arbol*); +int arbol_completo_interno(const t_arbol*,int); + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(t_arbol*,FILE*,int,int,t_cmp); + +int hoja(const t_arbol*); + +t_nodo **buscar_nodo_menor(t_arbol*); +t_nodo **buscar_nodo_mayor(t_arbol*); + +int eliminar_nodo_y_acomodar_ramas_iterativa(t_arbol*,t_dato*,t_cmp); +int eliminar_nodo_y_acomodar_ramas_recursiva(t_arbol*,t_dato*,t_cmp); +int eliminar_nodo_y_acomodar_ramas_recursiva_interna(t_arbol*,t_dato*); + +void arbol_grafico(const t_arbol*,t_mst); +void arbol_grafico_interna(const t_arbol*,t_mst,int); +void tab(int); diff --git "a/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con cola/TDA_\303\255ndice_est\303\241tico.c" "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con cola/TDA_\303\255ndice_est\303\241tico.c" new file mode 100644 index 0000000..2b9cc18 --- /dev/null +++ "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con cola/TDA_\303\255ndice_est\303\241tico.c" @@ -0,0 +1,159 @@ +#include "TDA_índice_estático.h" + +#include +#include + +void ind_crear(t_indice *ind) + { + ind->tope=0; + ind->hay_cola=0; + } + +int ind_insertar(t_indice *ind,const t_reg_indice *reg_ind) + { + if(ind->tope==TAM) + return INDICE_LLENO; + if(ind->tope!=0) + { + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(ind->registro[pos].dni==reg_ind->dni) + return DUPLICADO; + t_reg_indice aux1,aux2; + aux1=ind->registro[pos]; + ind->registro[pos]=*reg_ind; + pos++; + while(postope) + { + aux2=ind->registro[pos]; + ind->registro[pos]=aux1; + aux1=aux2; + pos++; + } + ind->registro[pos]=aux1; + } + else + ind->registro[ind->tope]=*reg_ind; + ind->tope++; + return OK; + } + +int ind_eliminar(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(pos==ind->tope||ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + while(postope) + { + ind->registro[pos]=ind->registro[pos+1]; + pos++; + } + ind->tope--; + return OK; + } + +int ind_buscar(const t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(postope&&ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + *reg_ind=ind->registro[pos]; + return OK; + } + +int ind_cargar(t_indice *ind,const char *path) + { + FILE *pf; + pf=fopen(path,"rb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + while(!feof(pf)) + { + pos++; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + } + fclose(pf); + ind->tope=pos; + return OK; + } + +int ind_grabar(const t_indice *ind,const char *path) + { + if(ind->tope==0) + return INDICE_VACIO; + FILE *pf; + pf=fopen(path,"wb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + while(postope) + { + fwrite(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + pos++; + } + fclose(pf); + return OK; + } + +void ind_vaciar(t_indice *ind) + { + ind->tope=0; + ind->hay_cola=0; + } + +int ind_primero(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + if(ind->hay_cola==1) + vaciar_cola(&ind->cola); + crear_cola(&ind->cola); + ind->hay_cola=1; + int i=0; + while(itope) + { + if(cola_llena(&ind->cola)) + return COLA_LLENA; + acolar(&ind->cola,(t_dato*)&ind->registro[i]); + i++; + } + desacolar(&ind->cola,(t_dato*)reg_ind); + return OK; + } + +int ind_siguiente(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + if(ind->hay_cola==0) + return COLA_VACIA; + desacolar(&ind->cola,(t_dato*)reg_ind); + if(cola_vacia(&ind->cola)) + ind->hay_cola=0; + return OK; + } + +int ind_fin(t_indice *ind) + { + if(ind->tope==0) + return INDICE_VACIO; + if(ind->hay_cola==1) + return COLA_LLENA; + return OK; + } + +void ind_liberar(t_indice *indice) + { + ///Esta primitiva no aplica a la implementación estática del TDA índice + } diff --git "a/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con cola/TDA_\303\255ndice_est\303\241tico.h" "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con cola/TDA_\303\255ndice_est\303\241tico.h" new file mode 100644 index 0000000..a98d2fb --- /dev/null +++ "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con cola/TDA_\303\255ndice_est\303\241tico.h" @@ -0,0 +1,29 @@ +#include "registro.h" +#include "primitivas_cola_estática.h" + +#define INDICE_VACIO 0 +#define INDICE_LLENO 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define ARCHIVO_CORRUPTO 0 +#define OK 1 + +typedef struct + { + t_cola cola; + unsigned hay_cola; + t_reg_indice registro[TAM]; + unsigned tope;//primera posición libre + }t_indice; + +void ind_crear(t_indice*); +int ind_insertar(t_indice*,const t_reg_indice*); +int ind_eliminar(t_indice*,t_reg_indice*); +int ind_buscar(const t_indice*,t_reg_indice*); +int ind_cargar(t_indice*,const char*); +int ind_grabar(const t_indice*,const char*); +void ind_vaciar(t_indice*); +int ind_primero(t_indice*,t_reg_indice*); +int ind_siguiente(t_indice*,t_reg_indice*); +int ind_fin(t_indice*); +void ind_liberar(t_indice*); diff --git "a/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con variable global/TDA_\303\255ndice_est\303\241tico.c" "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con variable global/TDA_\303\255ndice_est\303\241tico.c" new file mode 100644 index 0000000..336c3ff --- /dev/null +++ "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con variable global/TDA_\303\255ndice_est\303\241tico.c" @@ -0,0 +1,150 @@ +#include "TDA_índice_estático.h" + +#include +#include + +unsigned indicador=TAM; + +void ind_crear(t_indice *ind) + { + ind->tope=0; + } + +int ind_insertar(t_indice *ind,const t_reg_indice *reg_ind) + { + if(ind->tope==TAM) + return INDICE_LLENO; + if(ind->tope!=0) + { + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(ind->registro[pos].dni==reg_ind->dni) + return DUPLICADO; + t_reg_indice aux1,aux2; + aux1=ind->registro[pos]; + ind->registro[pos]=*reg_ind; + pos++; + while(postope) + { + aux2=ind->registro[pos]; + ind->registro[pos]=aux1; + aux1=aux2; + pos++; + } + ind->registro[pos]=aux1; + } + else + ind->registro[ind->tope]=*reg_ind; + ind->tope++; + return OK; + } + +int ind_eliminar(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(pos==ind->tope||ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + while(postope) + { + ind->registro[pos]=ind->registro[pos+1]; + pos++; + } + ind->tope--; + return OK; + } + +int ind_buscar(const t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(postope&&ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + *reg_ind=ind->registro[pos]; + return OK; + } + +int ind_cargar(t_indice *ind,const char *path) + { + FILE *pf; + pf=fopen(path,"rb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + while(!feof(pf)) + { + pos++; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + } + fclose(pf); + ind->tope=pos; + return OK; + } + +int ind_grabar(const t_indice *ind,const char *path) + { + if(ind->tope==0) + return INDICE_VACIO; + FILE *pf; + pf=fopen(path,"wb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + while(postope) + { + fwrite(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + pos++; + } + fclose(pf); + return OK; + } + +void ind_vaciar(t_indice *ind) + { + ind->tope=0; + } + +int ind_primero(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + extern unsigned indicador; + indicador=0; + *reg_ind=ind->registro[indicador]; + return OK; + } + +int ind_siguiente(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + extern unsigned indicador; + if(indicador==TAM) + return NO_ENCONTRADO; + if(indicador+1==ind->tope) + return NO_ENCONTRADO; + indicador++; + *reg_ind=ind->registro[indicador]; + return OK; + } + +int ind_fin(t_indice *ind) + { + extern unsigned indicador; + if(indicador+1==ind->tope) + return OK; + return NO_ENCONTRADO; + } + +void ind_liberar(t_indice *indice) + { + ///Esta primitiva no aplica a la implementación estática del TDA índice + } diff --git "a/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con variable global/TDA_\303\255ndice_est\303\241tico.h" "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con variable global/TDA_\303\255ndice_est\303\241tico.h" new file mode 100644 index 0000000..e63f43a --- /dev/null +++ "b/PRIMITIVAS DE \303\215NDICE/\303\255ndice_est\303\241tico_con variable global/TDA_\303\255ndice_est\303\241tico.h" @@ -0,0 +1,26 @@ +#include "registro.h" + +#define INDICE_VACIO 0 +#define INDICE_LLENO 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define ARCHIVO_CORRUPTO 0 +#define OK 1 + +typedef struct + { + t_reg_indice registro[TAM]; + unsigned tope;//primera posición libre + }t_indice; + +void ind_crear(t_indice*); +int ind_insertar(t_indice*,const t_reg_indice*); +int ind_eliminar(t_indice*,t_reg_indice*); +int ind_buscar(const t_indice*,t_reg_indice*); +int ind_cargar(t_indice*,const char*); +int ind_grabar(const t_indice*,const char*); +void ind_vaciar(t_indice*); +int ind_primero(t_indice*,t_reg_indice*); +int ind_siguiente(t_indice*,t_reg_indice*); +int ind_fin(t_indice*); +void ind_liberar(t_indice*); diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.cbp" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.cbp" new file mode 100644 index 0000000..a0a9231 --- /dev/null +++ "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.layout" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.layout" new file mode 100644 index 0000000..4c916dc --- /dev/null +++ "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/bin/Debug/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.exe" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/bin/Debug/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.exe" new file mode 100644 index 0000000..08c261c Binary files /dev/null and "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/bin/Debug/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato.exe" differ diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/functions.c" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/functions.c" new file mode 100644 index 0000000..39ce2c7 --- /dev/null +++ "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/functions.c" @@ -0,0 +1,20 @@ +#include "header.h" + +void nueva_linea(FILE *pf,int n) + { + int i,j; + char caracter; + for(i=0;i +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) +#define ES_LETRA(x) ((x)>='A'&&(x)<='Z')||((x)>='a'&&(x)<='z') + +void nueva_linea(FILE*,int); + diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/main.c" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/main.c" new file mode 100644 index 0000000..182bc22 --- /dev/null +++ "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/main.c" @@ -0,0 +1,44 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n \t AGREGAR LÍNEAS DE VARIAS PALABRAS A UN ARCHIVO TXT \a\a"); + printf("\n\n Se agregará a un archivo de texto, líneas de entre 1 y 10 \n palabras, cantidad que irá indicando usted mismo."); + + FILE *pf; + pf=fopen("palabras.txt","at"); + if(!pf) + { + printf("\n\n Error al leer el fichero de texto \n\n Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + int n,bandera; + do + { + bandera=0; + do + { + printf("\n\n Indique cantidad de palabras para la fila: [1;10] ó 0 para finalizar: \t"); + if(bandera==1) + printf("\n\t El número ingresado no es válido. Ingrese uno nuevo: \n\n\a \a\a"); + scanf("%d",&n); + bandera=1; + } + while(!DATO_VALIDO(n,0,10)); + if(n!=0) + nueva_linea(pf,n); + } + while(n!=0); + + printf("\n\n Se ha modificado exitosamente el archivo \"palabras.txt\""); + + fclose(pf); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } + diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/obj/Debug/functions.o" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/obj/Debug/functions.o" new file mode 100644 index 0000000..f16e149 Binary files /dev/null and "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/obj/Debug/functions.o" differ diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/obj/Debug/main.o" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/obj/Debug/main.o" new file mode 100644 index 0000000..7b60a0c Binary files /dev/null and "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/obj/Debug/main.o" differ diff --git "a/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/palabras.txt" "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/palabras.txt" new file mode 100644 index 0000000..bce3496 --- /dev/null +++ "b/agregar l\303\255neas de varias palabras a un archivo de texto de ese formato/palabras.txt" @@ -0,0 +1,140 @@ +RIGMCZ EPIIOD ISWIOJ SYHDPT +FJJWRC EYYITU NGFAFM FATAOD SLLMYB LZNAAB LSCZMV THOWCJ +JPCGHC WPYINB QPCKZN XFIUZW ESYUNN CSFUWJ YBQJQA +XOKVTI OXGBTH DVKAIQ EWNYGK ODPJIT NMGCKY ZZHHHI ZUYWEV BOEZKN +TMIIPG DHAFUQ OXVJXH APPXJD WKLWCP +DAHNYP ULYXYW KOQUJB QFXIJW OHLCNM ATAUME +BZVBUI TAJMRH DZTNVP +SGUBHV GDCWIT +AVNFEC GKJMAG QDJDLR RUOPPT +RJASVL RVOCBP FRSIHH JKKYKS TJKLKP +AUWIQG BGUYSL GUHWWG PUISHI QTCIFW GNHQQT HMYCPU AYROJU +XDKJKV WJXAQH SBXNAL IOUKBY FWTGXD ISQSMH WSBPWR +TTNYMB HRPAAO KMZGIT SAVUKZ +IWWJZR +FRSPAN KWGOEJ ZWHSBC EELFUF IHCSIS +HSUMJD WCSZEE SIPOFD HLYUCJ ZMVJLG RWWDIR +AJWNCW WVABSY CYHKGT NSGXYH OFZRCT WMQXAD GDCOJL YZQULY +JMVKZM OZVRQM ZVLRBG HLNJCV ZXMADI BFMJQV ELQEXQ +GOETNC MAQWGZ SRYVJZ PSYKYI SWPSBN DDOPYP MLIYYR FILXIW EYANCF +PXFQQZ QQTGUJ OPZEHI JFVGZD YMQDXJ +TORUBH CPBCUZ NKAFIG +JDUCMK RQWYRS GHTJZR BZSYWQ ETFXRT +JEUCNL UZKLWA +CSMIRK +WSYEVW WAMKNG PLCYTA HXFAJN +KPLATK KMSWRR VPVZZD SJZWFL EEDYRY RGZFFS +ZEZRKX YUDJQN SCONMO MWJWHT RKSMBR YFYFUV LHVCWZ UIFPFE +BUYLZB JWKQKZ AZUSJH TKZLQN ERUBTD +WBMEQG LYQTCK KLIACJ MYOYJI ZJBPBA SVEOAH OOCYJU +ODUEFM YGRDUZ ZQEVYW XFKMXL CSQLWT TFEMLU CBIKDO KFCAYM LZMEZQ +ZDIAAR LKJTKW SQJJUT VTLYZT NYNZII +PGSOLH RLDQAL LQSZQI OCGCMB LZLQTO OEKJTW LPXYSA IUQJNU +TFZHNT GUZSZB SHBEBW MTRIRQ STEVPM OYRPAM +PYSMLO YCQMGL SWXNMR +JQLLFZ CAADJO +AFUQDZ +UZHMJQ MBHPWI DENTRN PSVPUR +WKYALU NPGTWT +JWPLZV VBMNYL LUESKD EQISYI KKADVU +GMHWLY EEAGHS KPGUNC EQFRXK +OETFXL IULEXK +HJIHXF OZNMJT TNDUPR +TNDDTO DEOBTX QFMJSW CLSWTU MCKQHY +MLQLCY NWIIEK +HUSFDA DBTFEW JEIICD IIMMCR PWFCTJ LZKAZV +GYCMFG XHZAWG ZXRRQS YGCSUI +EEGBGX OOZSIX AWXUKR DGFQTQ UZCCWJ JYCRUG RLPIGO +HUKCYB MHROIN QUVISB EPDQUE AZVMTK FTMXKC KBCEUK ROZYHZ +UGJXEN CFTXLQ VCCDWH HYVALJ UPQGZL +WLEOSP UCQHGX WNXSOQ IKUPCD +YVVFSM RDLYFM +QRYHSI +PUVQZA FBPAXE OQDGGN +WDUOUL GNGMFE +GCMLPJ LTIQAV VGDAOI MRGNSH QQIMXQ +EXMHLR VRXPRI KKGDMY DEWANL AXKSXM AZLKDN +EBEALW XBWYMY PSHBUX KPCWUA PWJKAV QFVQON VDPYRK ZTLKLA RUEQKC +XKDYNI MXMSGW AMNVVW GHIQMI GFIXUH JLNRGP JISDVR JWNKWK +OIJWRL PYHSVD +DTDUSD ECYZHL BINZRZ CEAHYU IQKYOJ +DVKNHC WFBBQH KBRILF +RIGMCZ EPIIOD ISWIOJ SYHDPT +FJJWRC +EYYITU NGFAFM +FATAOD SLLMYB LZNAAB LSCZMV THOWCJ +JPCGHC WPYINB QPCKZN +XFIUZW ESYUNN +CSFUWJ YBQJQA XOKVTI OXGBTH DVKAIQ EWNYGK +ODPJIT NMGCKY ZZHHHI ZUYWEV BOEZKN +TMIIPG DHAFUQ OXVJXH APPXJD +WKLWCP DAHNYP +ULYXYW +KOQUJB QFXIJW OHLCNM ATAUME +BZVBUI TAJMRH DZTNVP SGUBHV GDCWIT +AVNFEC GKJMAG QDJDLR RUOPPT RJASVL RVOCBP FRSIHH JKKYKS +TJKLKP AUWIQG BGUYSL GUHWWG PUISHI QTCIFW +GNHQQT HMYCPU AYROJU +XDKJKV WJXAQH +SBXNAL IOUKBY FWTGXD ISQSMH WSBPWR TTNYMB HRPAAO KMZGIT SAVUKZ +IWWJZR FRSPAN KWGOEJ ZWHSBC EELFUF IHCSIS HSUMJD +WCSZEE SIPOFD HLYUCJ ZMVJLG RWWDIR AJWNCW WVABSY CYHKGT +NSGXYH OFZRCT WMQXAD GDCOJL YZQULY +JMVKZM OZVRQM ZVLRBG HLNJCV ZXMADI BFMJQV ELQEXQ GOETNC MAQWGZ +SRYVJZ PSYKYI SWPSBN DDOPYP MLIYYR FILXIW +EYANCF PXFQQZ QQTGUJ OPZEHI JFVGZD YMQDXJ TORUBH CPBCUZ NKAFIG +JDUCMK RQWYRS GHTJZR BZSYWQ ETFXRT JEUCNL UZKLWA CSMIRK +WSYEVW WAMKNG PLCYTA HXFAJN KPLATK KMSWRR VPVZZD +SJZWFL EEDYRY RGZFFS ZEZRKX +YUDJQN SCONMO MWJWHT RKSMBR YFYFUV +LHVCWZ UIFPFE BUYLZB JWKQKZ AZUSJH TKZLQN ERUBTD WBMEQG +LYQTCK KLIACJ MYOYJI ZJBPBA SVEOAH OOCYJU ODUEFM YGRDUZ ZQEVYW +XFKMXL CSQLWT TFEMLU CBIKDO KFCAYM LZMEZQ ZDIAAR LKJTKW +SQJJUT VTLYZT NYNZII PGSOLH RLDQAL LQSZQI OCGCMB +LZLQTO OEKJTW LPXYSA IUQJNU +TFZHNT GUZSZB SHBEBW MTRIRQ STEVPM OYRPAM PYSMLO YCQMGL +SWXNMR JQLLFZ CAADJO AFUQDZ UZHMJQ MBHPWI +DENTRN PSVPUR WKYALU NPGTWT JWPLZV +VBMNYL +LUESKD +EQISYI KKADVU GMHWLY EEAGHS KPGUNC EQFRXK OETFXL IULEXK HJIHXF OZNMJT +TNDUPR TNDDTO DEOBTX QFMJSW CLSWTU MCKQHY MLQLCY NWIIEK HUSFDA DBTFEW +JEIICD IIMMCR PWFCTJ LZKAZV GYCMFG XHZAWG ZXRRQS YGCSUI EEGBGX OOZSIX +AWXUKR DGFQTQ UZCCWJ JYCRUG RLPIGO HUKCYB MHROIN QUVISB EPDQUE AZVMTK +FTMXKC KBCEUK ROZYHZ UGJXEN CFTXLQ VCCDWH HYVALJ +UPQGZL WLEOSP UCQHGX WNXSOQ +IKUPCD YVVFSM +RDLYFM QRYHSI PUVQZA FBPAXE OQDGGN +WDUOUL GNGMFE GCMLPJ LTIQAV VGDAOI MRGNSH +QQIMXQ EXMHLR VRXPRI KKGDMY DEWANL AXKSXM AZLKDN EBEALW +XBWYMY PSHBUX KPCWUA PWJKAV QFVQON VDPYRK ZTLKLA +RUEQKC XKDYNI MXMSGW AMNVVW GHIQMI GFIXUH JLNRGP JISDVR JWNKWK +OIJWRL PYHSVD DTDUSD ECYZHL BINZRZ +CEAHYU IQKYOJ DVKNHC WFBBQH +KBRILF LXKQEC MPQSAQ +UYHXVA QKNMNG QJHPEV UZKPRM PFMYFK ZCUTHX +ZRIXUJ UXDKGI +UNCWJH +SCKROK MEWJCF CQXWPM HYWQXA +INANGE YHMEYR JLEQNX PCHXDR WGMGLZ DXKFUP +ZUOEZD LOEQOK FYZIQF GVMPKD MPVLKC +DZGEKI EYJHTD XNQIBK BLYIHQ ZRUPHA YSPBDF TZOLBW OCUJRR +PLKIPH UMJUMM +ZXRKDP NPHGFZ JNQOVK MRSBUY IPWQYN BEDKUZ ZTUAGQ JOCMAL +LHLGBZ LGQYVM EPVQFW DOBCEA WUMLEY ZJEWIY ACOEKS +BZNWEA SOKBOY ZDSZJK ARMQKG WXPQJK HNVMYG CVIIDK UIAKVH EPTUHT +OJKUJJ CZRSEO ZUGXMY AYYLEW IPRKAM LOSVVF +OBOOWH VAZVFY IWISTT +HPKIWX VDDRSC +HYMIIC +AEOGDW BQOVMW UOVOOA OBVELX SDXBUY +UJMPZE QYRMTZ CWIFAR YVEULP WDFRZV MJQMPU LRUVPT ICLAOO EWYLEO +LRBQSW XXJTFB WFTXTZ CVNVZA QGHZBG WOJWBO UDYJZV ZRAUID +DEWOGT ORPPQB UDZRVS XVKTRI RGQZHT MTXFVY ZFNQZJ +AJRMGM DHCDBM NLWDGE ZALXCO YOPTXO +GDOJMW MUASSR FAROPF +KNLRIA BLVYSA +TSFJCE +JKIDMK JJXEZV IBVZGX PWJRVG +XUGSZZ BYWVEL MDUEIX FWTTZL WAEMSW BYTBJY PDBDIB HZRBKY +UUOEOG diff --git a/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.cbp b/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.cbp new file mode 100644 index 0000000..f404669 --- /dev/null +++ b/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.depend b/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.depend new file mode 100644 index 0000000..a133e8d --- /dev/null +++ b/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474747832 source:d:\unlam\programaciÓn\fabian 2\analizando cadenas de un archivo txt\functions.c + "header.h" + +1474593639 d:\unlam\programaciÓn\fabian 2\analizando cadenas de un archivo txt\header.h + + + + + +1474747848 source:d:\unlam\programaciÓn\fabian 2\analizando cadenas de un archivo txt\main.c + "header.h" + diff --git a/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.layout b/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.layout new file mode 100644 index 0000000..8be6174 --- /dev/null +++ b/analizando cadenas de un archivo txt/analizando cadenas de un archivo txt.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/analizando cadenas de un archivo txt/bin/Debug/analizando cadenas de un archivo txt.exe b/analizando cadenas de un archivo txt/bin/Debug/analizando cadenas de un archivo txt.exe new file mode 100644 index 0000000..71ed4d7 Binary files /dev/null and b/analizando cadenas de un archivo txt/bin/Debug/analizando cadenas de un archivo txt.exe differ diff --git a/analizando cadenas de un archivo txt/functions.c b/analizando cadenas de un archivo txt/functions.c new file mode 100644 index 0000000..c4cbf07 --- /dev/null +++ b/analizando cadenas de un archivo txt/functions.c @@ -0,0 +1,125 @@ +#include "header.h" + +char *leer_cadena(FILE *pf) + { + char s[6]; + fflush(stdin); + fscanf(pf,"%6s",s); + return s; + } + +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +int es_uniletra(char *s) + { + if(str_len(s)==1) + return 1; + else + return 0; + } + +int es_de_cant_par_de_letras(char *s) + { + if(str_len(s)%2==0) + return 1; + else + return 0; + } + +int empieza_con_n(char *s,char c) + { + if(*s==c) + return 1; + else + return 0; + } + +int empieza_con_prefijo(char *s,char *prefijo) + { + while(*prefijo) + { + if(*s!=*prefijo) + return 0; + s++; + prefijo++; + } + return 1; + } + +int tiene_mas_de_3_vocales(char *s) + { + int cont=0; + while(*s) + { + if(ES_VOCAL(*s)) + cont++; + s++; + } + return (cont>3)?1:0; + } + +int empieza_y_termina_con_vocal(char *s) + { + if(!ES_VOCAL(A_MAYUSCULA(*s))) + return 0; + while(*s) + s++; + s--; + return (!ES_VOCAL(A_MAYUSCULA(*s)))?0:1; + } + +int contiene_digitos(char *s) + { + while(*s) + { + if(ES_DIGITO(*s)) + return 1; + s++; + } + return 0; + } + +int tiene_solo_numeros(char *s) + { + while(*s) + { + if(!ES_DIGITO(*s)) + return 0; + s++; + } + return 1; + } + +int es_palindromo(char *s1) + { + while(ES_BLANCO(*s1)||ES_SIGNO(*s1)) + s1++; + int i,longitud=str_len(s1),punto_medio=longitud/2; + char *s2=s1+longitud-1; + for(i=0;i<=punto_medio;i++) + if(*s1++!=*s2--) + return 0; + return 1; + } diff --git a/analizando cadenas de un archivo txt/header.h b/analizando cadenas de un archivo txt/header.h new file mode 100644 index 0000000..abe9ebc --- /dev/null +++ b/analizando cadenas de un archivo txt/header.h @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) +#define ES_VOCAL(x) ((x)=='A'||(x)=='E'||(x)=='I'||(x)=='O'||(x)=='U'||(x)=='a'||(x)=='e'||(x)=='i'||(x)=='o'||(x)=='u') +#define ES_DIGITO(x) (((x)>='0'&&(x)<='9')) +#define ES_BLANCO(x) ((x)==' ') +#define ES_SIGNO(x) ((x)=='+'||(x)=='-') + +char *leer_cadena(FILE*); +char *str_cpy(char*,const char*); +size_t str_len(const char*); +int es_uniletra(char*); +int es_de_cant_par_de_letras(char*); +int empieza_con_n(char*,char); +int empieza_con_prefijo(char*,char*); +int tiene_mas_de_3_vocales(char*); +int empieza_y_termina_con_vocal(char*); +int contiene_digitos(char*); +int tiene_solo_numeros(char*); +int es_palindromo(char*); diff --git a/analizando cadenas de un archivo txt/main.c b/analizando cadenas de un archivo txt/main.c new file mode 100644 index 0000000..1d8cd24 --- /dev/null +++ b/analizando cadenas de un archivo txt/main.c @@ -0,0 +1,75 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n \t ANALIZANDO PALABRAS EN UN TXT DE PALABRAS \a\a"); + + FILE *pf; + pf=fopen("palabras.txt","rt"); + if(!pf) + { + printf("\n\n Error al leer el fichero de texto \n\n Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + int cuenta_uniletras=0,cuenta_cant_par_letras=0,cuenta_empiezan_con_n=0,cuenta_comienzan_con_prefijo=0; + int cuenta_con_mas_de_tres_vocales=0,cuenta_empiezan_y_terminan_con_vocal=0,cuenta_contienen_digitos=0; + int cuenta_solo_formados_por_digitos=0,cuenta_palindromos=0; + + printf("\n\n Ingrese un prefijo (que se usará luego) (no más de 3 caracteres): \t"); + char prefijo[3]; + fflush(stdin); + gets(prefijo); + + printf("\n\n Ingrese un caracter (que se usará luego): \t"); + char caracter; + fflush(stdin); + scanf("%c",&caracter); + + char cadena[6]; + + while(!feof(pf)) + { + str_cpy(cadena,leer_cadena(pf)); + + if(es_uniletra(cadena)) + cuenta_uniletras++; + if(es_de_cant_par_de_letras(cadena)) + cuenta_cant_par_letras++; + if(empieza_con_n(cadena,caracter)) + cuenta_empiezan_con_n++; + if(empieza_con_prefijo(cadena,prefijo)) + cuenta_comienzan_con_prefijo++; + if(tiene_mas_de_3_vocales(cadena)) + cuenta_con_mas_de_tres_vocales++; + if(empieza_y_termina_con_vocal(cadena)) + cuenta_empiezan_y_terminan_con_vocal++; + if(contiene_digitos(cadena)) + cuenta_contienen_digitos++; + if(tiene_solo_numeros(cadena)) + cuenta_solo_formados_por_digitos++; + if(es_palindromo(cadena)) + cuenta_palindromos++; + } + + printf("\n\n RESULTADOS DEL ANÁLISIS DE LAS CADENAS \n"); + + printf("\n Formadas por solo una letra: \t %d",cuenta_uniletras); + printf("\n Formadas por una cantidad par de letras: \t %d",cuenta_cant_par_letras); + printf("\n Comienzan con el caracter %c: \t %d",caracter,cuenta_empiezan_con_n); + printf("\n Comienzan con el prefijo %s: \t %d",prefijo,cuenta_comienzan_con_prefijo); + printf("\n Tienen más de tres vocales: \t %d",cuenta_con_mas_de_tres_vocales); + printf("\n Comienzan y terminan con vocal: \t %d",cuenta_empiezan_y_terminan_con_vocal); + printf("\n Contienen algún dígito: \t %d",cuenta_contienen_digitos); + printf("\n Solo formadas por dígitos: \t %d",cuenta_solo_formados_por_digitos); + printf("\n Palíndromos: \t %d",cuenta_palindromos); + + fclose(pf); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + diff --git a/analizando cadenas de un archivo txt/obj/Debug/functions.o b/analizando cadenas de un archivo txt/obj/Debug/functions.o new file mode 100644 index 0000000..833bda3 Binary files /dev/null and b/analizando cadenas de un archivo txt/obj/Debug/functions.o differ diff --git a/analizando cadenas de un archivo txt/obj/Debug/main.o b/analizando cadenas de un archivo txt/obj/Debug/main.o new file mode 100644 index 0000000..5c79841 Binary files /dev/null and b/analizando cadenas de un archivo txt/obj/Debug/main.o differ diff --git a/analizando cadenas de un archivo txt/palabras.txt b/analizando cadenas de un archivo txt/palabras.txt new file mode 100644 index 0000000..bce3496 --- /dev/null +++ b/analizando cadenas de un archivo txt/palabras.txt @@ -0,0 +1,140 @@ +RIGMCZ EPIIOD ISWIOJ SYHDPT +FJJWRC EYYITU NGFAFM FATAOD SLLMYB LZNAAB LSCZMV THOWCJ +JPCGHC WPYINB QPCKZN XFIUZW ESYUNN CSFUWJ YBQJQA +XOKVTI OXGBTH DVKAIQ EWNYGK ODPJIT NMGCKY ZZHHHI ZUYWEV BOEZKN +TMIIPG DHAFUQ OXVJXH APPXJD WKLWCP +DAHNYP ULYXYW KOQUJB QFXIJW OHLCNM ATAUME +BZVBUI TAJMRH DZTNVP +SGUBHV GDCWIT +AVNFEC GKJMAG QDJDLR RUOPPT +RJASVL RVOCBP FRSIHH JKKYKS TJKLKP +AUWIQG BGUYSL GUHWWG PUISHI QTCIFW GNHQQT HMYCPU AYROJU +XDKJKV WJXAQH SBXNAL IOUKBY FWTGXD ISQSMH WSBPWR +TTNYMB HRPAAO KMZGIT SAVUKZ +IWWJZR +FRSPAN KWGOEJ ZWHSBC EELFUF IHCSIS +HSUMJD WCSZEE SIPOFD HLYUCJ ZMVJLG RWWDIR +AJWNCW WVABSY CYHKGT NSGXYH OFZRCT WMQXAD GDCOJL YZQULY +JMVKZM OZVRQM ZVLRBG HLNJCV ZXMADI BFMJQV ELQEXQ +GOETNC MAQWGZ SRYVJZ PSYKYI SWPSBN DDOPYP MLIYYR FILXIW EYANCF +PXFQQZ QQTGUJ OPZEHI JFVGZD YMQDXJ +TORUBH CPBCUZ NKAFIG +JDUCMK RQWYRS GHTJZR BZSYWQ ETFXRT +JEUCNL UZKLWA +CSMIRK +WSYEVW WAMKNG PLCYTA HXFAJN +KPLATK KMSWRR VPVZZD SJZWFL EEDYRY RGZFFS +ZEZRKX YUDJQN SCONMO MWJWHT RKSMBR YFYFUV LHVCWZ UIFPFE +BUYLZB JWKQKZ AZUSJH TKZLQN ERUBTD +WBMEQG LYQTCK KLIACJ MYOYJI ZJBPBA SVEOAH OOCYJU +ODUEFM YGRDUZ ZQEVYW XFKMXL CSQLWT TFEMLU CBIKDO KFCAYM LZMEZQ +ZDIAAR LKJTKW SQJJUT VTLYZT NYNZII +PGSOLH RLDQAL LQSZQI OCGCMB LZLQTO OEKJTW LPXYSA IUQJNU +TFZHNT GUZSZB SHBEBW MTRIRQ STEVPM OYRPAM +PYSMLO YCQMGL SWXNMR +JQLLFZ CAADJO +AFUQDZ +UZHMJQ MBHPWI DENTRN PSVPUR +WKYALU NPGTWT +JWPLZV VBMNYL LUESKD EQISYI KKADVU +GMHWLY EEAGHS KPGUNC EQFRXK +OETFXL IULEXK +HJIHXF OZNMJT TNDUPR +TNDDTO DEOBTX QFMJSW CLSWTU MCKQHY +MLQLCY NWIIEK +HUSFDA DBTFEW JEIICD IIMMCR PWFCTJ LZKAZV +GYCMFG XHZAWG ZXRRQS YGCSUI +EEGBGX OOZSIX AWXUKR DGFQTQ UZCCWJ JYCRUG RLPIGO +HUKCYB MHROIN QUVISB EPDQUE AZVMTK FTMXKC KBCEUK ROZYHZ +UGJXEN CFTXLQ VCCDWH HYVALJ UPQGZL +WLEOSP UCQHGX WNXSOQ IKUPCD +YVVFSM RDLYFM +QRYHSI +PUVQZA FBPAXE OQDGGN +WDUOUL GNGMFE +GCMLPJ LTIQAV VGDAOI MRGNSH QQIMXQ +EXMHLR VRXPRI KKGDMY DEWANL AXKSXM AZLKDN +EBEALW XBWYMY PSHBUX KPCWUA PWJKAV QFVQON VDPYRK ZTLKLA RUEQKC +XKDYNI MXMSGW AMNVVW GHIQMI GFIXUH JLNRGP JISDVR JWNKWK +OIJWRL PYHSVD +DTDUSD ECYZHL BINZRZ CEAHYU IQKYOJ +DVKNHC WFBBQH KBRILF +RIGMCZ EPIIOD ISWIOJ SYHDPT +FJJWRC +EYYITU NGFAFM +FATAOD SLLMYB LZNAAB LSCZMV THOWCJ +JPCGHC WPYINB QPCKZN +XFIUZW ESYUNN +CSFUWJ YBQJQA XOKVTI OXGBTH DVKAIQ EWNYGK +ODPJIT NMGCKY ZZHHHI ZUYWEV BOEZKN +TMIIPG DHAFUQ OXVJXH APPXJD +WKLWCP DAHNYP +ULYXYW +KOQUJB QFXIJW OHLCNM ATAUME +BZVBUI TAJMRH DZTNVP SGUBHV GDCWIT +AVNFEC GKJMAG QDJDLR RUOPPT RJASVL RVOCBP FRSIHH JKKYKS +TJKLKP AUWIQG BGUYSL GUHWWG PUISHI QTCIFW +GNHQQT HMYCPU AYROJU +XDKJKV WJXAQH +SBXNAL IOUKBY FWTGXD ISQSMH WSBPWR TTNYMB HRPAAO KMZGIT SAVUKZ +IWWJZR FRSPAN KWGOEJ ZWHSBC EELFUF IHCSIS HSUMJD +WCSZEE SIPOFD HLYUCJ ZMVJLG RWWDIR AJWNCW WVABSY CYHKGT +NSGXYH OFZRCT WMQXAD GDCOJL YZQULY +JMVKZM OZVRQM ZVLRBG HLNJCV ZXMADI BFMJQV ELQEXQ GOETNC MAQWGZ +SRYVJZ PSYKYI SWPSBN DDOPYP MLIYYR FILXIW +EYANCF PXFQQZ QQTGUJ OPZEHI JFVGZD YMQDXJ TORUBH CPBCUZ NKAFIG +JDUCMK RQWYRS GHTJZR BZSYWQ ETFXRT JEUCNL UZKLWA CSMIRK +WSYEVW WAMKNG PLCYTA HXFAJN KPLATK KMSWRR VPVZZD +SJZWFL EEDYRY RGZFFS ZEZRKX +YUDJQN SCONMO MWJWHT RKSMBR YFYFUV +LHVCWZ UIFPFE BUYLZB JWKQKZ AZUSJH TKZLQN ERUBTD WBMEQG +LYQTCK KLIACJ MYOYJI ZJBPBA SVEOAH OOCYJU ODUEFM YGRDUZ ZQEVYW +XFKMXL CSQLWT TFEMLU CBIKDO KFCAYM LZMEZQ ZDIAAR LKJTKW +SQJJUT VTLYZT NYNZII PGSOLH RLDQAL LQSZQI OCGCMB +LZLQTO OEKJTW LPXYSA IUQJNU +TFZHNT GUZSZB SHBEBW MTRIRQ STEVPM OYRPAM PYSMLO YCQMGL +SWXNMR JQLLFZ CAADJO AFUQDZ UZHMJQ MBHPWI +DENTRN PSVPUR WKYALU NPGTWT JWPLZV +VBMNYL +LUESKD +EQISYI KKADVU GMHWLY EEAGHS KPGUNC EQFRXK OETFXL IULEXK HJIHXF OZNMJT +TNDUPR TNDDTO DEOBTX QFMJSW CLSWTU MCKQHY MLQLCY NWIIEK HUSFDA DBTFEW +JEIICD IIMMCR PWFCTJ LZKAZV GYCMFG XHZAWG ZXRRQS YGCSUI EEGBGX OOZSIX +AWXUKR DGFQTQ UZCCWJ JYCRUG RLPIGO HUKCYB MHROIN QUVISB EPDQUE AZVMTK +FTMXKC KBCEUK ROZYHZ UGJXEN CFTXLQ VCCDWH HYVALJ +UPQGZL WLEOSP UCQHGX WNXSOQ +IKUPCD YVVFSM +RDLYFM QRYHSI PUVQZA FBPAXE OQDGGN +WDUOUL GNGMFE GCMLPJ LTIQAV VGDAOI MRGNSH +QQIMXQ EXMHLR VRXPRI KKGDMY DEWANL AXKSXM AZLKDN EBEALW +XBWYMY PSHBUX KPCWUA PWJKAV QFVQON VDPYRK ZTLKLA +RUEQKC XKDYNI MXMSGW AMNVVW GHIQMI GFIXUH JLNRGP JISDVR JWNKWK +OIJWRL PYHSVD DTDUSD ECYZHL BINZRZ +CEAHYU IQKYOJ DVKNHC WFBBQH +KBRILF LXKQEC MPQSAQ +UYHXVA QKNMNG QJHPEV UZKPRM PFMYFK ZCUTHX +ZRIXUJ UXDKGI +UNCWJH +SCKROK MEWJCF CQXWPM HYWQXA +INANGE YHMEYR JLEQNX PCHXDR WGMGLZ DXKFUP +ZUOEZD LOEQOK FYZIQF GVMPKD MPVLKC +DZGEKI EYJHTD XNQIBK BLYIHQ ZRUPHA YSPBDF TZOLBW OCUJRR +PLKIPH UMJUMM +ZXRKDP NPHGFZ JNQOVK MRSBUY IPWQYN BEDKUZ ZTUAGQ JOCMAL +LHLGBZ LGQYVM EPVQFW DOBCEA WUMLEY ZJEWIY ACOEKS +BZNWEA SOKBOY ZDSZJK ARMQKG WXPQJK HNVMYG CVIIDK UIAKVH EPTUHT +OJKUJJ CZRSEO ZUGXMY AYYLEW IPRKAM LOSVVF +OBOOWH VAZVFY IWISTT +HPKIWX VDDRSC +HYMIIC +AEOGDW BQOVMW UOVOOA OBVELX SDXBUY +UJMPZE QYRMTZ CWIFAR YVEULP WDFRZV MJQMPU LRUVPT ICLAOO EWYLEO +LRBQSW XXJTFB WFTXTZ CVNVZA QGHZBG WOJWBO UDYJZV ZRAUID +DEWOGT ORPPQB UDZRVS XVKTRI RGQZHT MTXFVY ZFNQZJ +AJRMGM DHCDBM NLWDGE ZALXCO YOPTXO +GDOJMW MUASSR FAROPF +KNLRIA BLVYSA +TSFJCE +JKIDMK JJXEZV IBVZGX PWJRVG +XUGSZZ BYWVEL MDUEIX FWTTZL WAEMSW BYTBJY PDBDIB HZRBKY +UUOEOG diff --git a/aproximar coseno/aproximar coseno.cbp b/aproximar coseno/aproximar coseno.cbp new file mode 100644 index 0000000..fa00150 --- /dev/null +++ b/aproximar coseno/aproximar coseno.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/aproximar coseno/aproximar coseno.depend b/aproximar coseno/aproximar coseno.depend new file mode 100644 index 0000000..1c9db01 --- /dev/null +++ b/aproximar coseno/aproximar coseno.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1471560800 source:d:\unlam\programaciÓn\fabian 2da\aproximar coseno\funciones.c + "encabezados.h" + +1471560105 d:\unlam\programaciÓn\fabian 2da\aproximar coseno\encabezados.h + + + + + +1471560891 source:d:\unlam\programaciÓn\fabian 2da\aproximar coseno\main.c + "encabezados.h" + diff --git a/aproximar coseno/aproximar coseno.layout b/aproximar coseno/aproximar coseno.layout new file mode 100644 index 0000000..01f50f7 --- /dev/null +++ b/aproximar coseno/aproximar coseno.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/aproximar coseno/bin/Debug/aproximar coseno.exe b/aproximar coseno/bin/Debug/aproximar coseno.exe new file mode 100644 index 0000000..975f6e5 Binary files /dev/null and b/aproximar coseno/bin/Debug/aproximar coseno.exe differ diff --git a/aproximar coseno/encabezados.h b/aproximar coseno/encabezados.h new file mode 100644 index 0000000..f574c6f --- /dev/null +++ b/aproximar coseno/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +#include +float coseno(float,float); diff --git a/aproximar coseno/funciones.c b/aproximar coseno/funciones.c new file mode 100644 index 0000000..5433b61 --- /dev/null +++ b/aproximar coseno/funciones.c @@ -0,0 +1,17 @@ +#include "encabezados.h" +float coseno(float x,float tol) + { + int i,signo; + float cos,ult;//ult=último término + i=1; + cos=ult=1;//primer término + signo=-1;//comienzo con signo negativo porque el segundo término es negativo + while(fabs(ult)>tol)//deja de ciclar cuando el módulo del último término no sea mayor que la tolerancia + {//fabs calcula el módulo de un flotante + ult=ult*x*x/i/(i+1);//calculo un nuevo término + cos+=(signo*ult); + signo*=-1;//cambio de signo + i+=2;//los exponentes se incrementan de a dos + } + return cos; + } diff --git a/aproximar coseno/main.c b/aproximar coseno/main.c new file mode 100644 index 0000000..b5347d7 --- /dev/null +++ b/aproximar coseno/main.c @@ -0,0 +1,20 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + float x,tol,cos; + printf("\n\t\t FUNCIÓN COSENO \n"); + printf("\n Aproximación mediante el polinomio de Taylor \n"); + printf("\n Ingrese un número real para calcular su coseno: \n\n\t\t"); + scanf("%f",&x); + do + { + printf("\n Ingrese la tolerancia de error permitida: \n\n\t\t"); + scanf("%f",&tol); + } + while(tol<=0); + cos=coseno(x,tol); + printf("\n El coseno de %f es %f \n\n",x,cos); + getch(); + return 0; + } diff --git a/aproximar coseno/obj/Debug/funciones.o b/aproximar coseno/obj/Debug/funciones.o new file mode 100644 index 0000000..359f018 Binary files /dev/null and b/aproximar coseno/obj/Debug/funciones.o differ diff --git a/aproximar coseno/obj/Debug/main.o b/aproximar coseno/obj/Debug/main.o new file mode 100644 index 0000000..368ef9d Binary files /dev/null and b/aproximar coseno/obj/Debug/main.o differ diff --git a/aproximar exponencial optimizada/aproximar exponencial optimizada.cbp b/aproximar exponencial optimizada/aproximar exponencial optimizada.cbp new file mode 100644 index 0000000..acd930a --- /dev/null +++ b/aproximar exponencial optimizada/aproximar exponencial optimizada.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/aproximar exponencial optimizada/aproximar exponencial optimizada.depend b/aproximar exponencial optimizada/aproximar exponencial optimizada.depend new file mode 100644 index 0000000..16bc7d1 --- /dev/null +++ b/aproximar exponencial optimizada/aproximar exponencial optimizada.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471558486 source:d:\unlam\programaciÓn\fabian 2da\aproximar exponencial optimizada\funciones.c + "encabezados.h" + +1471550744 d:\unlam\programaciÓn\fabian 2da\aproximar exponencial optimizada\encabezados.h + + + + +1471550817 source:d:\unlam\programaciÓn\fabian 2da\aproximar exponencial optimizada\main.c + "encabezados.h" + diff --git a/aproximar exponencial optimizada/aproximar exponencial optimizada.layout b/aproximar exponencial optimizada/aproximar exponencial optimizada.layout new file mode 100644 index 0000000..d229682 --- /dev/null +++ b/aproximar exponencial optimizada/aproximar exponencial optimizada.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/aproximar exponencial optimizada/bin/Debug/aproximar exponencial optimizada.exe b/aproximar exponencial optimizada/bin/Debug/aproximar exponencial optimizada.exe new file mode 100644 index 0000000..ae138ff Binary files /dev/null and b/aproximar exponencial optimizada/bin/Debug/aproximar exponencial optimizada.exe differ diff --git a/aproximar exponencial optimizada/encabezados.h b/aproximar exponencial optimizada/encabezados.h new file mode 100644 index 0000000..95c3423 --- /dev/null +++ b/aproximar exponencial optimizada/encabezados.h @@ -0,0 +1,4 @@ +#include +#include +#include +float exponencial(int,float); diff --git a/aproximar exponencial optimizada/funciones.c b/aproximar exponencial optimizada/funciones.c new file mode 100644 index 0000000..415abad --- /dev/null +++ b/aproximar exponencial optimizada/funciones.c @@ -0,0 +1,15 @@ +#include "encabezados.h" +float exponencial(int x,float tol) + { + int i; + float f,ult;//ult=último término + f=ult=1; + i=1; + while(ult>=tol)//deja de ciclar cuando un término sea menor que la tolerancia + { + ult=ult*x/i;//me ahorro calcular potencias y factoriales + f+=ult; + i++; + } + return f; + } diff --git a/aproximar exponencial optimizada/main.c b/aproximar exponencial optimizada/main.c new file mode 100644 index 0000000..32c83d7 --- /dev/null +++ b/aproximar exponencial optimizada/main.c @@ -0,0 +1,21 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x; + float tol,exp; + printf("\n\t\t FUNCIÓN EXPONENCIAL \n\n"); + printf("\n Aproximación mediante el polinomio de Taylor \n"); + printf("\n Ingrese un número entero para calcular su exponencial: \n\n\t\t"); + scanf("%d",&x); + do + { + printf("\n Ingrese la tolerancia de error permitida: \n\n\t\t"); + scanf("%f",&tol); + } + while(tol<=0);//no es lógico que sea negativa y cero tampoco porque no habría error y estoy aproximando + exp=exponencial(x,tol); + printf("\n La exponencial de %d es %f \n\n",x,exp); + getch(); + return 0; + } diff --git a/aproximar exponencial optimizada/obj/Debug/funciones.o b/aproximar exponencial optimizada/obj/Debug/funciones.o new file mode 100644 index 0000000..1288957 Binary files /dev/null and b/aproximar exponencial optimizada/obj/Debug/funciones.o differ diff --git a/aproximar exponencial optimizada/obj/Debug/main.o b/aproximar exponencial optimizada/obj/Debug/main.o new file mode 100644 index 0000000..f6717ca Binary files /dev/null and b/aproximar exponencial optimizada/obj/Debug/main.o differ diff --git a/aproximar exponencial/aproximar exponencial.cbp b/aproximar exponencial/aproximar exponencial.cbp new file mode 100644 index 0000000..3146a5b --- /dev/null +++ b/aproximar exponencial/aproximar exponencial.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/aproximar exponencial/aproximar exponencial.depend b/aproximar exponencial/aproximar exponencial.depend new file mode 100644 index 0000000..151e8e2 --- /dev/null +++ b/aproximar exponencial/aproximar exponencial.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471558414 source:d:\unlam\programaciÓn\fabian 2da\aproximar exponencial\funciones.c + "encabezados.h" + +1471547828 d:\unlam\programaciÓn\fabian 2da\aproximar exponencial\encabezados.h + + + + +1471560187 source:d:\unlam\programaciÓn\fabian 2da\aproximar exponencial\main.c + "encabezados.h" + diff --git a/aproximar exponencial/aproximar exponencial.layout b/aproximar exponencial/aproximar exponencial.layout new file mode 100644 index 0000000..91a67d9 --- /dev/null +++ b/aproximar exponencial/aproximar exponencial.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/aproximar exponencial/bin/Debug/aproximar exponencial.exe b/aproximar exponencial/bin/Debug/aproximar exponencial.exe new file mode 100644 index 0000000..46445a9 Binary files /dev/null and b/aproximar exponencial/bin/Debug/aproximar exponencial.exe differ diff --git a/aproximar exponencial/encabezados.h b/aproximar exponencial/encabezados.h new file mode 100644 index 0000000..db66b9d --- /dev/null +++ b/aproximar exponencial/encabezados.h @@ -0,0 +1,6 @@ +#include +#include +#include +int factorial(int); +int potencia(int,int); +float exponencial(int,float); diff --git a/aproximar exponencial/funciones.c b/aproximar exponencial/funciones.c new file mode 100644 index 0000000..5a7f63a --- /dev/null +++ b/aproximar exponencial/funciones.c @@ -0,0 +1,30 @@ +#include "encabezados.h" +int factorial(int n) + { + if(n<=1) + return 1; + else + return n*factorial(n-1); + } +int potencia(int b,int e) + { + int p,i; + p=1; + for(i=1;i<=e;i++) + p*=b; + return p; + } +float exponencial(int x,float tol) + { + int i; + float f,ult;//ult=último término + i=0; + f=0; + while(i==0||ult>=tol)//deja de ciclar cuando un término sea menor que la tolerancia + { + ult=(float)potencia(x,i)/factorial(i); + f+=ult; + i++; + } + return f; + } diff --git a/aproximar exponencial/main.c b/aproximar exponencial/main.c new file mode 100644 index 0000000..32c83d7 --- /dev/null +++ b/aproximar exponencial/main.c @@ -0,0 +1,21 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x; + float tol,exp; + printf("\n\t\t FUNCIÓN EXPONENCIAL \n\n"); + printf("\n Aproximación mediante el polinomio de Taylor \n"); + printf("\n Ingrese un número entero para calcular su exponencial: \n\n\t\t"); + scanf("%d",&x); + do + { + printf("\n Ingrese la tolerancia de error permitida: \n\n\t\t"); + scanf("%f",&tol); + } + while(tol<=0);//no es lógico que sea negativa y cero tampoco porque no habría error y estoy aproximando + exp=exponencial(x,tol); + printf("\n La exponencial de %d es %f \n\n",x,exp); + getch(); + return 0; + } diff --git a/aproximar exponencial/obj/Debug/funciones.o b/aproximar exponencial/obj/Debug/funciones.o new file mode 100644 index 0000000..9f38961 Binary files /dev/null and b/aproximar exponencial/obj/Debug/funciones.o differ diff --git a/aproximar exponencial/obj/Debug/main.o b/aproximar exponencial/obj/Debug/main.o new file mode 100644 index 0000000..1f39d7f Binary files /dev/null and b/aproximar exponencial/obj/Debug/main.o differ diff --git "a/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.cbp" "b/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.cbp" new file mode 100644 index 0000000..85815c2 --- /dev/null +++ "b/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.depend" "b/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.depend" new file mode 100644 index 0000000..8ee927a --- /dev/null +++ "b/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1471558636 source:d:\unlam\programaciÓn\fabian 2da\aproximar raíz cuadrada\main.c + "encabezados.h" + +1472315455 d:\unlam\programaciÓn\fabian 2da\aproximar raíz cuadrada\encabezados.h + + + + + +1472315601 source:d:\unlam\programaciÓn\fabian 2da\aproximar raíz cuadrada\funciones.c + "encabezados.h" + diff --git "a/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.layout" "b/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.layout" new file mode 100644 index 0000000..ab6984f --- /dev/null +++ "b/aproximar ra\303\255z cuadrada/aproximar ra\303\255z cuadrada.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/aproximar ra\303\255z cuadrada/bin/Debug/aproximar ra\303\255z cuadrada.exe" "b/aproximar ra\303\255z cuadrada/bin/Debug/aproximar ra\303\255z cuadrada.exe" new file mode 100644 index 0000000..475817b Binary files /dev/null and "b/aproximar ra\303\255z cuadrada/bin/Debug/aproximar ra\303\255z cuadrada.exe" differ diff --git "a/aproximar ra\303\255z cuadrada/encabezados.h" "b/aproximar ra\303\255z cuadrada/encabezados.h" new file mode 100644 index 0000000..86ecdd3 --- /dev/null +++ "b/aproximar ra\303\255z cuadrada/encabezados.h" @@ -0,0 +1,5 @@ +#include +#include +#include +#include +float raiz(float,float); diff --git "a/aproximar ra\303\255z cuadrada/funciones.c" "b/aproximar ra\303\255z cuadrada/funciones.c" new file mode 100644 index 0000000..868a417 --- /dev/null +++ "b/aproximar ra\303\255z cuadrada/funciones.c" @@ -0,0 +1,13 @@ +#include "encabezados.h" +float raiz(float x,float tol) + { + float t_ant,t_act; + t_act=1;//primer término de la serie + do + { + t_ant=t_act; + t_act=(t_ant+x/t_ant)/2; + } + while(fabs(t_act-t_ant)>=tol);//dejo de ciclar cuando el módulo de la diferencia entre dos términos sucesivos sea menor que la tolerancia + return t_act; + } diff --git "a/aproximar ra\303\255z cuadrada/main.c" "b/aproximar ra\303\255z cuadrada/main.c" new file mode 100644 index 0000000..b390ca2 --- /dev/null +++ "b/aproximar ra\303\255z cuadrada/main.c" @@ -0,0 +1,23 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + float x,tol,r; + printf("\n\t\t RAÍZ CUADRADA \n"); + do + { + printf("\n Ingrese un número positivo para aproximar su raíz cuadrada: \n\n\t\t"); + scanf("%f",&x); + } + while(x<=0);//no se puede calcular raíces de negativos a menos que se trabaje con complejos--->>>>>>no es el caso + do + { + printf("\n Ingrese la tolerancia de error permitida: \n\n\t\t"); + scanf("%f",&tol); + } + while(tol<=0);//no tiene sentido que sea negativa ni cero porque no habría error y estoy aproximando + r=raiz(x,tol); + printf("\n La raíz cuadrada de %f es %f \n\n",x,r); + getch(); + return 0; + } diff --git "a/aproximar ra\303\255z cuadrada/obj/Debug/funciones.o" "b/aproximar ra\303\255z cuadrada/obj/Debug/funciones.o" new file mode 100644 index 0000000..e3e0a95 Binary files /dev/null and "b/aproximar ra\303\255z cuadrada/obj/Debug/funciones.o" differ diff --git "a/aproximar ra\303\255z cuadrada/obj/Debug/main.o" "b/aproximar ra\303\255z cuadrada/obj/Debug/main.o" new file mode 100644 index 0000000..f117df3 Binary files /dev/null and "b/aproximar ra\303\255z cuadrada/obj/Debug/main.o" differ diff --git a/aproximar seno/aproximar seno.cbp b/aproximar seno/aproximar seno.cbp new file mode 100644 index 0000000..ae95359 --- /dev/null +++ b/aproximar seno/aproximar seno.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/aproximar seno/aproximar seno.depend b/aproximar seno/aproximar seno.depend new file mode 100644 index 0000000..348a34e --- /dev/null +++ b/aproximar seno/aproximar seno.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1471559973 source:d:\unlam\programaciÓn\fabian 2da\aproximar seno\funciones.c + "encabezados.h" + +1471559960 d:\unlam\programaciÓn\fabian 2da\aproximar seno\encabezados.h + + + + + +1471557355 source:d:\unlam\programaciÓn\fabian 2da\aproximar seno\main.c + "encabezados.h" + diff --git a/aproximar seno/aproximar seno.layout b/aproximar seno/aproximar seno.layout new file mode 100644 index 0000000..6e17d72 --- /dev/null +++ b/aproximar seno/aproximar seno.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/aproximar seno/bin/Debug/aproximar seno.exe b/aproximar seno/bin/Debug/aproximar seno.exe new file mode 100644 index 0000000..bbc9d30 Binary files /dev/null and b/aproximar seno/bin/Debug/aproximar seno.exe differ diff --git a/aproximar seno/encabezados.h b/aproximar seno/encabezados.h new file mode 100644 index 0000000..5f63e3d --- /dev/null +++ b/aproximar seno/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +#include +float seno(float,float); diff --git a/aproximar seno/funciones.c b/aproximar seno/funciones.c new file mode 100644 index 0000000..9061334 --- /dev/null +++ b/aproximar seno/funciones.c @@ -0,0 +1,17 @@ +#include "encabezados.h" +float seno(float x,float tol) + { + int i,signo; + float sen,ult;//ult=(último término) + i=2; + sen=ult=x;//primer término + signo=-1;//comienzo con signo negativo porque el segundo término es negativo + while(fabs(ult)>tol)//deja de ciclar cuando el módulo del último término no sea mayor que la tolerancia + {//fabs calcula el módulo de un flotante + ult=ult*x*x/i/(i+1);//calculo un nuevo término + sen+=(signo*ult); + signo*=-1;//cambio de signo; + i+=2;//los exponentes se incrementan de a dos + } + return(sen); + } diff --git a/aproximar seno/main.c b/aproximar seno/main.c new file mode 100644 index 0000000..35f750e --- /dev/null +++ b/aproximar seno/main.c @@ -0,0 +1,20 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + float x,tol,sen; + printf("\n\t\t FUNCIÓN SENO \n"); + printf("\n Aproximación mediante el polinomio de Taylor \n"); + printf("\n Ingrese un número real para calcular su seno: \n\n\t\t"); + scanf("%f",&x); + do + { + printf("\n Ingrese la tolerancia de error permitida: \n\n\t\t"); + scanf("%f",&tol); + } + while(tol<=0); + sen=seno(x,tol); + printf("\n El seno de %f es %f \n\n",x,sen); + getch(); + return 0; + } diff --git a/aproximar seno/obj/Debug/funciones.o b/aproximar seno/obj/Debug/funciones.o new file mode 100644 index 0000000..e4970d7 Binary files /dev/null and b/aproximar seno/obj/Debug/funciones.o differ diff --git a/aproximar seno/obj/Debug/main.o b/aproximar seno/obj/Debug/main.o new file mode 100644 index 0000000..51ceda2 Binary files /dev/null and b/aproximar seno/obj/Debug/main.o differ diff --git "a/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.cbp" "b/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.cbp" new file mode 100644 index 0000000..695309a --- /dev/null +++ "b/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.depend" "b/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.depend" new file mode 100644 index 0000000..409fff7 --- /dev/null +++ "b/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474584988 source:d:\unlam\programaciÓn\fabian 2\archivo de texto con líneas de varias palabras\funcions.c + "header.h" + +1474585542 d:\unlam\programaciÓn\fabian 2\archivo de texto con líneas de varias palabras\header.h + + + + + +1474585825 source:d:\unlam\programaciÓn\fabian 2\archivo de texto con líneas de varias palabras\main.c + "header.h" + diff --git "a/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.layout" "b/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.layout" new file mode 100644 index 0000000..b470d62 --- /dev/null +++ "b/archivo de texto con l\303\255neas de varias palabras/archivo de texto con l\303\255neas de varias palabras.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/archivo de texto con l\303\255neas de varias palabras/bin/Debug/archivo de texto con l\303\255neas de varias palabras.exe" "b/archivo de texto con l\303\255neas de varias palabras/bin/Debug/archivo de texto con l\303\255neas de varias palabras.exe" new file mode 100644 index 0000000..c50c637 Binary files /dev/null and "b/archivo de texto con l\303\255neas de varias palabras/bin/Debug/archivo de texto con l\303\255neas de varias palabras.exe" differ diff --git "a/archivo de texto con l\303\255neas de varias palabras/funcions.c" "b/archivo de texto con l\303\255neas de varias palabras/funcions.c" new file mode 100644 index 0000000..c329dfd --- /dev/null +++ "b/archivo de texto con l\303\255neas de varias palabras/funcions.c" @@ -0,0 +1,19 @@ +#include "header.h" + +void nueva_linea(FILE *pf,int n) + { + int i,j; + char caracter; + for(i=0;i +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) +#define ES_LETRA(x) ((x)>='A'&&(x)<='Z')||((x)>='a'&&(x)<='z') + + +void nueva_linea(FILE*,int); + diff --git "a/archivo de texto con l\303\255neas de varias palabras/main.c" "b/archivo de texto con l\303\255neas de varias palabras/main.c" new file mode 100644 index 0000000..e7110fd --- /dev/null +++ "b/archivo de texto con l\303\255neas de varias palabras/main.c" @@ -0,0 +1,43 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n \t GENERACIÓN DE ARCHIVO CON LÍNEAS DE VARIAS PALABRAS \a\a"); + printf("\n\n Se generará un archivo de texto con líneas de entre 1 y 10 \n palabras, cantidad que irá indicando usted mismo."); + + FILE *pf; + pf=fopen("palabras.txt","wt"); + if(!pf) + { + printf("\n\n Error al crear el fichero de texto \n\n Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + int n,bandera; + do + { + bandera=0; + do + { + printf("\n\n Indique cantidad de palabras para la fila: [1;10] ó 0 para finalizar: \t"); + if(bandera==1) + printf("\n\t El número ingresado no es válido. Ingrese uno nuevo: \n\n\a \a\a"); + scanf("%d",&n); + bandera=1; + } + while(!DATO_VALIDO(n,0,10)); + if(n!=0) + nueva_linea(pf,n); + } + while(n!=0); + + printf("\n\n Se ha generado exitosamente el archivo \"palabras.txt\""); + + fclose(pf); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git "a/archivo de texto con l\303\255neas de varias palabras/obj/Debug/funcions.o" "b/archivo de texto con l\303\255neas de varias palabras/obj/Debug/funcions.o" new file mode 100644 index 0000000..1ed12c2 Binary files /dev/null and "b/archivo de texto con l\303\255neas de varias palabras/obj/Debug/funcions.o" differ diff --git "a/archivo de texto con l\303\255neas de varias palabras/obj/Debug/main.o" "b/archivo de texto con l\303\255neas de varias palabras/obj/Debug/main.o" new file mode 100644 index 0000000..2fa3ac5 Binary files /dev/null and "b/archivo de texto con l\303\255neas de varias palabras/obj/Debug/main.o" differ diff --git "a/archivo de texto con l\303\255neas de varias palabras/palabras.txt" "b/archivo de texto con l\303\255neas de varias palabras/palabras.txt" new file mode 100644 index 0000000..7b7c4af --- /dev/null +++ "b/archivo de texto con l\303\255neas de varias palabras/palabras.txt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diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.cbp" "b/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.cbp" new file mode 100644 index 0000000..fbbdd08 --- /dev/null +++ "b/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.depend" "b/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.depend" new file mode 100644 index 0000000..c6839e9 --- /dev/null +++ "b/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474563439 source:d:\unlam\programaciÓn\fabian 2\archivo txt con números pseudo aleatorios\functions.c + "header.h" + +1474562663 d:\unlam\programaciÓn\fabian 2\archivo txt con números pseudo aleatorios\header.h + + + + + +1474563533 source:d:\unlam\programaciÓn\fabian 2\archivo txt con números pseudo aleatorios\main.c + "header.h" + diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.layout" "b/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.layout" new file mode 100644 index 0000000..3470463 --- /dev/null +++ "b/archivo txt con n\303\272meros pseudo aleatorios/archivo txt con n\303\272meros pseudo aleatorios.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/bin/Debug/archivo txt con n\303\272meros pseudo aleatorios.exe" "b/archivo txt con n\303\272meros pseudo aleatorios/bin/Debug/archivo txt con n\303\272meros pseudo aleatorios.exe" new file mode 100644 index 0000000..21165b9 Binary files /dev/null and "b/archivo txt con n\303\272meros pseudo aleatorios/bin/Debug/archivo txt con n\303\272meros pseudo aleatorios.exe" differ diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/datos.txt" "b/archivo txt con n\303\272meros pseudo aleatorios/datos.txt" new file mode 100644 index 0000000..c5a88bd --- /dev/null +++ "b/archivo txt con n\303\272meros pseudo aleatorios/datos.txt" @@ -0,0 +1,63 @@ + 41 18467 6334 26500 + 19169 15724 11478 29358 26962 24464 + 5705 28145 23281 16827 9961 491 2995 + 11942 4827 5436 + 32391 14604 3902 153 292 + 12382 + 17421 18716 + 19718 19895 5447 21726 + 14771 11538 1869 19912 25667 26299 17035 + 9894 28703 23811 31322 30333 + 17673 4664 15141 + 7711 28253 + 6868 25547 27644 32662 32757 20037 + 12859 8723 9741 27529 778 + 12316 3035 22190 1842 288 30106 9040 + 8942 19264 22648 27446 + 23805 15890 6729 24370 15350 + 15006 31101 + 24393 3548 19629 + 12623 24084 19954 18756 + 11840 + 4966 7376 + 13931 26308 16944 32439 24626 + 11323 5537 21538 16118 2082 22929 + 16541 4833 31115 4639 + 29658 22704 9930 13977 2306 31673 22386 + 5021 + 28745 26924 19072 6270 5829 26777 15573 + 5097 + 16512 23986 13290 9161 18636 22355 24767 + 23655 + 15574 4031 12052 27350 1150 16941 21724 + 13966 3430 + 31107 30191 18007 11337 + 15457 12287 27753 + 10383 14945 + 8909 + 32209 9758 24221 18588 6422 24946 27506 + 13030 16413 + 29168 900 32591 18762 1655 + 17410 6359 27624 20537 + 21548 6483 27595 4041 3602 24350 10291 + 30836 9374 11020 + 4596 24021 + 27348 + 23199 19668 24484 8281 4734 53 1999 + 26418 27938 6900 3788 18127 + 467 3728 14893 24648 + 22483 17807 + 2421 14310 6617 + 22813 9514 + 14309 + 7616 18935 17451 20600 + 5249 16519 31556 22798 30303 6224 11008 + 5844 32609 14989 + 32702 3195 + 20485 3093 14343 30523 1587 29314 9503 + 7448 + 25200 13458 6618 20580 19796 + 14798 15281 19589 20798 + 28009 27157 + 20472 + 23622 18538 12292 6038 24179 18190 29657 diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/functions.c" "b/archivo txt con n\303\272meros pseudo aleatorios/functions.c" new file mode 100644 index 0000000..b4c3725 --- /dev/null +++ "b/archivo txt con n\303\272meros pseudo aleatorios/functions.c" @@ -0,0 +1,9 @@ +#include "header.h" + +void nueva_linea(FILE *pf,int n) + { + int i; + for(i=0;i +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void nueva_linea(FILE*,int); diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/main.c" "b/archivo txt con n\303\272meros pseudo aleatorios/main.c" new file mode 100644 index 0000000..08506ad --- /dev/null +++ "b/archivo txt con n\303\272meros pseudo aleatorios/main.c" @@ -0,0 +1,57 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n \t GENERACIÓN DE ARCHIVO CON NÚMEROS PSEUDO ALEATORIOS \a\a"); + printf("\n\n Se generará un archivo de texto con líneas de entre 1 y 7 números \n enteros cortos pseudo aleatorios, cantidad que irá indicando usted mismo."); + printf("\n Se le exigirá que al menos ingrese una vez 1 y una vez 7."); + printf("\n Los demás números variarán a su gusto... \n\n"); + + FILE *pf; + pf=fopen("datos.txt","wt"); + if(!pf) + { + printf("\n\n Error al crear el fichero de texto \n\n Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n Comience con el ingreso de números enteros del rango [1;7] ó 0 para finalizar"); + printf("\n\n No se le permitirá finalizar el proceso mientras no ingrese \n al menos una vez el número 1 y una vez el número 7. \n"); + + int n=1,bandera,bandera1=0,bandera7=0; + do + { + if(n==0) + printf("\n\t No tiene permitido terminar el proceso... \n \a\a"); + bandera=0; + do + { + if(bandera==1) + printf("\n\t El número ingresado no es válido... \n \a\a"); + printf("\n Ingrese un número entero: \t"); + scanf("%d",&n); + bandera=1; + } + while(!DATO_VALIDO(n,0,7)); + + if(n!=0) + { + nueva_linea(pf,n); + if(n==1) + bandera1=1; + if(n==7) + bandera7=1; + } + } + while(!(n==0&&bandera1==1&&bandera7==1)); + + printf("\n\n Se ha generado exitosamente el archivo \"datos.txt\""); + + fclose(pf); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/obj/Debug/functions.o" "b/archivo txt con n\303\272meros pseudo aleatorios/obj/Debug/functions.o" new file mode 100644 index 0000000..4ed3005 Binary files /dev/null and "b/archivo txt con n\303\272meros pseudo aleatorios/obj/Debug/functions.o" differ diff --git "a/archivo txt con n\303\272meros pseudo aleatorios/obj/Debug/main.o" "b/archivo txt con n\303\272meros pseudo aleatorios/obj/Debug/main.o" new file mode 100644 index 0000000..30437c0 Binary files /dev/null and "b/archivo txt con n\303\272meros pseudo aleatorios/obj/Debug/main.o" differ diff --git "a/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.cbp" "b/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.cbp" new file mode 100644 index 0000000..89f1342 --- /dev/null +++ "b/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.depend" "b/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.depend" new file mode 100644 index 0000000..f395aea --- /dev/null +++ "b/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473706977 source:d:\unlam\programaciÓn\fabian 2\archivos_función para abrir un archivo\functions.c + "header.h" + +1473706436 d:\unlam\programaciÓn\fabian 2\archivos_función para abrir un archivo\header.h + + + + + +1473707703 source:d:\unlam\programaciÓn\fabian 2\archivos_función para abrir un archivo\main.c + "header.h" + diff --git "a/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.layout" "b/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.layout" new file mode 100644 index 0000000..3e9dfa8 --- /dev/null +++ "b/archivos_funci\303\263n para abrir un archivo/archivos_funci\303\263n para abrir un archivo.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/archivos_funci\303\263n para abrir un archivo/bin/Debug/archivos_funci\303\263n para abrir un archivo.exe" "b/archivos_funci\303\263n para abrir un archivo/bin/Debug/archivos_funci\303\263n para abrir un archivo.exe" new file mode 100644 index 0000000..c552f3d Binary files /dev/null and "b/archivos_funci\303\263n para abrir un archivo/bin/Debug/archivos_funci\303\263n para abrir un archivo.exe" differ diff --git "a/archivos_funci\303\263n para abrir un archivo/fichero.dat" "b/archivos_funci\303\263n para abrir un archivo/fichero.dat" new file mode 100644 index 0000000..e69de29 diff --git "a/archivos_funci\303\263n para abrir un archivo/functions.c" "b/archivos_funci\303\263n para abrir un archivo/functions.c" new file mode 100644 index 0000000..f93fa07 --- /dev/null +++ "b/archivos_funci\303\263n para abrir un archivo/functions.c" @@ -0,0 +1,12 @@ +#include "header.h" +int abrir_archivo(FILE **pf,const char *ruta,const char *modo_tipo,int mensaje) + { + *pf=fopen(ruta,modo_tipo); + if(!*pf) + if(mensaje) + { + printf("\n\n No se pudo abrir el archivo %s con el modo_tipo %s \n\n\a\a",ruta,modo_tipo); + return 0; + } + return 1; + } diff --git "a/archivos_funci\303\263n para abrir un archivo/header.h" "b/archivos_funci\303\263n para abrir un archivo/header.h" new file mode 100644 index 0000000..f63cdc8 --- /dev/null +++ "b/archivos_funci\303\263n para abrir un archivo/header.h" @@ -0,0 +1,7 @@ +#include +#include +#include +#include +#define CON_MENSAJE 0 +#define SIN_MENSAJE 1 +int abrir_archivo(FILE**,const char*,const char*,int); diff --git "a/archivos_funci\303\263n para abrir un archivo/main.c" "b/archivos_funci\303\263n para abrir un archivo/main.c" new file mode 100644 index 0000000..53779c4 --- /dev/null +++ "b/archivos_funci\303\263n para abrir un archivo/main.c" @@ -0,0 +1,14 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + FILE *pf; + printf("\n\n FUNCIÓN PARA ABRIR UN ARCHIVO \n"); + if(!abrir_archivo(&pf,"fichero.dat","rb",CON_MENSAJE)) + exit(EXIT_FAILURE); + printf("\n\n El archivo fue abierto exitosamente \n\n"); + fclose(pf); + printf("\n\n Fin del programa \n\n"); + getch(); + return 0; + } diff --git "a/archivos_funci\303\263n para abrir un archivo/obj/Debug/functions.o" "b/archivos_funci\303\263n para abrir un archivo/obj/Debug/functions.o" new file mode 100644 index 0000000..b9f65bc Binary files /dev/null and "b/archivos_funci\303\263n para abrir un archivo/obj/Debug/functions.o" differ diff --git "a/archivos_funci\303\263n para abrir un archivo/obj/Debug/main.o" "b/archivos_funci\303\263n para abrir un archivo/obj/Debug/main.o" new file mode 100644 index 0000000..bcf7f7d Binary files /dev/null and "b/archivos_funci\303\263n para abrir un archivo/obj/Debug/main.o" differ diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array de flotantes.txt" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array de flotantes.txt" new file mode 100644 index 0000000..67e93c1 --- /dev/null +++ "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array de flotantes.txt" @@ -0,0 +1,25 @@ +23.264540 +2.659650 +1.268489 +1.849400 +0.187500 +8.194950 +6.185480 +8.264900 +4.945950 +9.849490 +7.164590 +7.266500 +1.214000 +0.149000 +0.299200 +0.294900 +1.154900 +8.484900 +5.000000 +4.000010 +6.216546 +3.265900 +5.659000 +0.194900 +1.595900 diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.cbp" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.cbp" new file mode 100644 index 0000000..af3f1c3 --- /dev/null +++ "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.depend" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.depend" new file mode 100644 index 0000000..71a6497 --- /dev/null +++ "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473887411 source:d:\unlam\programaciÓn\fabian 2\array float_mínimo, promedio pos pares, orden inverso y grabar en fichero\functions.c + "header.h" + +1473887446 d:\unlam\programaciÓn\fabian 2\array float_mínimo, promedio pos pares, orden inverso y grabar en fichero\header.h + + + + + +1473619861 source:d:\unlam\programaciÓn\fabian 2\array float_mínimo, promedio pos pares, orden inverso y grabar en fichero\main.c + "header.h" + diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.layout" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.layout" new file mode 100644 index 0000000..e5f95dd --- /dev/null +++ "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array_de_flotantes.dat" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array_de_flotantes.dat" new file mode 100644 index 0000000..cef5fdc Binary files /dev/null and "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/array_de_flotantes.dat" differ diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/bin/Debug/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.exe" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/bin/Debug/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.exe" new file mode 100644 index 0000000..6b1133f Binary files /dev/null and "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/bin/Debug/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero.exe" differ diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/functions.c" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/functions.c" new file mode 100644 index 0000000..35d1498 --- /dev/null +++ "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/functions.c" @@ -0,0 +1,113 @@ +#include "header.h" +int cargar_array_float(float *v,int ce) + { + int band,n,i; + printf("\n\n Proceda a la carga del vector. Usted cuenta con %d posiciones \n",ce); + printf("\n\n Ingrese la cantidad de elementos que desea cargar: \t "); + band=0; + do + { + if(band==1) + printf("\n\n El número ingresado es incorrecto. Reingréselo: \t"); + scanf("%d",&n); + band=1; + } + while(!DATO_VALIDO(n,0,ce)); + for(i=1;i<=n;i++) + { + printf("\n Ingrese el flotante número %d :\t",i); + scanf("%f",v); + v++; + } + printf("\n\n La carga del array ha finalizado \n"); + return n; + } +void mostrar_array_float(float *v,int ce) + { + int i; + for(i=1;i<=ce;i++) + { + printf("\n Elemento número %d: \t %.4f",i,*v); + v++; + } + } +int menu(void) + { + int band,op; + printf("\n\n --------------------MENU-------------------- \n"); + printf("\n\n Seleccione alguna de las siguientes opciones \n"); + printf("\n 1- Buscar el mínimo elemento"); + printf("\n 2- Calcular el promedio de los valores de las posiciones pares"); + printf("\n 3- Mostrarlo en orden inverso"); + printf("\n 4- Salir"); + printf("\n\n \t\t\t\t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n\n La opción ingresada es incorrecta!!! Ingrese una opción: \t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,4)); + printf("\n\n -------------------------------------------- \n"); + return op; + } +void minimo(float *v,int ce) + { + float *min=v,*fin=v+ce; + v++; + while(v=1;i--) + { + printf("\n Elemento número %d: \t %.4f",i,*v); + v--; + } + } +void grabar_en_archivo_binario(float *v,int ce,FILE *pf) + { + int i; + t_registro reg; + for(i=0;i +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +typedef struct + { + float num; + }t_registro; + +int cargar_array_float(float*,int); +void mostrar_array_float(float*,int); +int menu(void); +void minimo(float*,int); +void promedio_valores_posiciones_pares(float*,int); +void mostrar_orden_inverso(float*,int); +void grabar_en_archivo_binario(float*,int,FILE*); +void grabar_en_archivo_de_texto(float*,int,FILE*); diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/main.c" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/main.c" new file mode 100644 index 0000000..2e589ea --- /dev/null +++ "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/main.c" @@ -0,0 +1,68 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int band,op,cant,ocupados; + printf("\n\n ARRAY DE FLOAT \n"); + printf("\n\n Usted debe cargar un array de números flotantes \n"); + printf("\n Para ello, se le solicita que ingrese la cantidad máxima \n de elementos a ingresar en el array: \t"); + band=0; + do + { + if(band==1) + printf("\n\n El número ingresado no es lógico. Ingrese un nuevo número: \t\a\a"); + scanf("%d",&cant); + band=1; + } + while(cant<=0); + float v[cant]; + ocupados=cargar_array_float(v,cant); + if(ocupados==0) + { + printf("\n\n El array está vacío \n No tiene sentido continuar con la ejecución del programa \n\n\a\a"); + printf("\n\n Programa evacuado \n\n"); + exit(1); + } + printf("\n El vector ingresado tiene %d posiciones ocupadas \n",ocupados); + printf("\n Sus elementos son: \n\n"); + mostrar_array_float(v,ocupados); + op=menu(); + while(op!=4) + { + switch(op) + { + case 1: minimo(v,ocupados); + break; + case 2: promedio_valores_posiciones_pares(v,ocupados); + break; + case 3: mostrar_orden_inverso(v,ocupados); + break; + } + op=menu(); + } + printf("\n\n Menú abortado \n\n"); + FILE *pf; + pf=fopen("array_de_flotantes.dat","wb"); + if(!pf) + { + printf("\n\n No se pudo grabar el array en un archivo binario \n\n\a\a"); + printf("\n\n Programa evacuado \n\n"); + exit(EXIT_FAILURE); + } + grabar_en_archivo_binario(v,ocupados,pf); + fclose(pf); + printf("\n Se ha grabado el array en el archivo binario \"array_de_flotantes.dat\""); + pf=fopen("array de flotantes.txt","wt"); + if(!pf) + { + printf("\n\n No se pudo grabar el array en un archivo de texto \n\n\a\a"); + printf("\n\n Programa evacuado \n\n"); + exit(EXIT_FAILURE); + } + grabar_en_archivo_de_texto(v,ocupados,pf); + fclose(pf); + printf("\n Se ha grabado el array en el archivo de texto \"array_de_flotantes.txt\""); + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/obj/Debug/functions.o" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/obj/Debug/functions.o" new file mode 100644 index 0000000..42ddad9 Binary files /dev/null and "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/obj/Debug/functions.o" differ diff --git "a/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/obj/Debug/main.o" "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/obj/Debug/main.o" new file mode 100644 index 0000000..1a24eca Binary files /dev/null and "b/array float_m\303\255nimo, promedio pos pares, orden inverso y grabar en fichero/obj/Debug/main.o" differ diff --git a/atexit/atexit.cbp b/atexit/atexit.cbp new file mode 100644 index 0000000..f8a0b49 --- /dev/null +++ b/atexit/atexit.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/atexit/atexit.depend b/atexit/atexit.depend new file mode 100644 index 0000000..34ff044 --- /dev/null +++ b/atexit/atexit.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474501085 source:d:\unlam\programaciÓn\fabian 2\atexit\functions.c + "header.h" + +1474501051 d:\unlam\programaciÓn\fabian 2\atexit\header.h + + + + + +1474501003 source:d:\unlam\programaciÓn\fabian 2\atexit\main.c + "header.h" + diff --git a/atexit/atexit.layout b/atexit/atexit.layout new file mode 100644 index 0000000..cf0558d --- /dev/null +++ b/atexit/atexit.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/atexit/bin/Debug/atexit.exe b/atexit/bin/Debug/atexit.exe new file mode 100644 index 0000000..1a1e426 Binary files /dev/null and b/atexit/bin/Debug/atexit.exe differ diff --git a/atexit/functions.c b/atexit/functions.c new file mode 100644 index 0000000..6b5f01e --- /dev/null +++ b/atexit/functions.c @@ -0,0 +1,6 @@ +#include "header.h" + +void antes_de_salir(void) + { + puts("\n\n\a\a\t\t Nos vamos... chau chau... \n\n"); + } diff --git a/atexit/header.h b/atexit/header.h new file mode 100644 index 0000000..7a0ff74 --- /dev/null +++ b/atexit/header.h @@ -0,0 +1,6 @@ +#include +#include +#include +#include + +void antes_de_salir(void); diff --git a/atexit/main.c b/atexit/main.c new file mode 100644 index 0000000..d67d9c4 --- /dev/null +++ b/atexit/main.c @@ -0,0 +1,11 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n FUNCIÓN ATEXIT \n"); + printf("\n Esta función de stdlib.h sirve para ejecutar una función void sin parámetros \n que se le manda por parámetro, antes de cerrar la ejecución del programa.. \n\n"); + atexit(antes_de_salir); + getch(); + return 0; + } diff --git a/atexit/obj/Debug/functions.o b/atexit/obj/Debug/functions.o new file mode 100644 index 0000000..7416a48 Binary files /dev/null and b/atexit/obj/Debug/functions.o differ diff --git a/atexit/obj/Debug/main.o b/atexit/obj/Debug/main.o new file mode 100644 index 0000000..9e38cca Binary files /dev/null and b/atexit/obj/Debug/main.o differ diff --git a/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.cbp b/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.cbp new file mode 100644 index 0000000..8a4294a --- /dev/null +++ b/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.depend b/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.depend new file mode 100644 index 0000000..b8845a8 --- /dev/null +++ b/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.depend @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1482797380 source:d:\unlam\programaciÓn\fabian\barajar y repartir cartas de la baraja inglesa\main.c + + + + diff --git a/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.layout b/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.layout new file mode 100644 index 0000000..7624cf1 --- /dev/null +++ b/barajar y repartir cartas de la baraja inglesa/barajar y repartir cartas de la baraja inglesa.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/barajar y repartir cartas de la baraja inglesa/bin/Debug/barajar y repartir cartas de la baraja inglesa.exe b/barajar y repartir cartas de la baraja inglesa/bin/Debug/barajar y repartir cartas de la baraja inglesa.exe new file mode 100644 index 0000000..713aefc Binary files /dev/null and b/barajar y repartir cartas de la baraja inglesa/bin/Debug/barajar y repartir cartas de la baraja inglesa.exe differ diff --git a/barajar y repartir cartas de la baraja inglesa/main.c b/barajar y repartir cartas de la baraja inglesa/main.c new file mode 100644 index 0000000..9fe278a --- /dev/null +++ b/barajar y repartir cartas de la baraja inglesa/main.c @@ -0,0 +1,88 @@ +/* Programa para barajar y repartir cartas */ +#include +#include +#include +#include + +/* prototipos */ +void baraja( int wMazo[][ 13 ] ); +void reparte( const int wMazo[][ 13 ], const char *wCara[],const char *wPalo[] ); + +int main() +{ + /* inicializa el arreglo palo */ + const char *palo[ 4 ] = { "Corazones", "Diamantes", "Treboles", "Espadas" }; + + /* inicializa el arreglo cara */ + const char *cara[ 13 ] = { "As", "Dos", "Tres", "Cuatro","Cinco", "Seis", "Siete", "Ocho","Nueve", "Diez", "Joto", "Quina", "Rey" }; + + /* inicializa el arreglo mazo */ + int mazo[ 4 ][ 13 ] = { 0 }; + + printf("\n\n \t\t Baraja inglesa \n\n"); + + srand( time( 0 ) ); /* semilla del generador de números aleatorios */ + + baraja( mazo ); + reparte( mazo, cara, palo ); + + getch(); + return 0; /* indica terminación exitosa */ +} /* fin de main */ + +/* baraja las cartas del mazo */ +void baraja( int wMazo[][ 13 ] ) +{ + int fila; /* número de fila */ + int columna; /* número de columna */ + int carta; /* contador */ + + /* elige aleatoriamente un espacio para cada una de las 52 cartas */ + for ( carta = 1; carta <= 52; carta++ ) + { + + /* elije una nueva ubicación al azar hasta que encuentra un espacio vacío */ + do + { + fila = rand() % 4; + columna = rand() % 13; + } + while( wMazo[ fila ][ columna ] != 0 ); /* fin de do...while */ + + /* coloca el número de carta en el espacio vacío del mazo */ + wMazo[ fila ][ columna ] = carta; + } /* fin de for */ + +} /* fin de la función baraja */ + +/* reparte las cartas del mazo */ +void reparte( const int wMazo[][ 13 ], const char *wCara[],const char *wPalo[] ) +{ + int carta; /* contador de cartas */ + int fila; /* contador de filas */ + int columna; /* contador de columnas */ + + /* reparte cada una de las 52 cartas */ + for ( carta = 1; carta <= 52; carta++ ) + { + + /* realiza el ciclo a través de las filas de wMazo */ + for ( fila = 0; fila <= 3; fila++ ) + { + + /* realiza el ciclo a través de las columnas de wMazo en la fila actual */ + for ( columna = 0; columna <= 12; columna++ ) + { + + /* si el espacio contiene la carta actual, despliega la carta */ + if ( wMazo[ fila ][ columna ] == carta ) + { + printf( "%6s de %-9s%c", wCara[ columna ], wPalo[ fila ],carta % 2 == 0 ? '\n' : '\t' ); + } /* fin de if */ + } /* fin de for */ + + } /* fin de for */ + + } /* fin de for */ + +} /* fin de la función reparte */ diff --git a/barajar y repartir cartas de la baraja inglesa/obj/Debug/main.o b/barajar y repartir cartas de la baraja inglesa/obj/Debug/main.o new file mode 100644 index 0000000..12d637a Binary files /dev/null and b/barajar y repartir cartas de la baraja inglesa/obj/Debug/main.o differ diff --git a/bsearch/bin/Debug/bsearch.exe b/bsearch/bin/Debug/bsearch.exe new file mode 100644 index 0000000..2e47ea4 Binary files /dev/null and b/bsearch/bin/Debug/bsearch.exe differ diff --git a/bsearch/bsearch.cbp b/bsearch/bsearch.cbp new file mode 100644 index 0000000..abd90ff --- /dev/null +++ b/bsearch/bsearch.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/bsearch/bsearch.depend b/bsearch/bsearch.depend new file mode 100644 index 0000000..3320c41 --- /dev/null +++ b/bsearch/bsearch.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474502716 source:d:\unlam\programaciÓn\fabian 2\bsearch\functions.c + "header.h" + +1474502765 d:\unlam\programaciÓn\fabian 2\bsearch\header.h + + + + + +1474503159 source:d:\unlam\programaciÓn\fabian 2\bsearch\main.c + "header.h" + diff --git a/bsearch/bsearch.layout b/bsearch/bsearch.layout new file mode 100644 index 0000000..a668008 --- /dev/null +++ b/bsearch/bsearch.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/bsearch/functions.c b/bsearch/functions.c new file mode 100644 index 0000000..5d21d77 --- /dev/null +++ b/bsearch/functions.c @@ -0,0 +1,7 @@ +#include "header.h" + +int comparar_int(const void *arg1,const void *arg2) + { + int *e1=(int*)arg1,*e2=(int*)arg2; + return *e1-*e2; + } diff --git a/bsearch/header.h b/bsearch/header.h new file mode 100644 index 0000000..45cbbdb --- /dev/null +++ b/bsearch/header.h @@ -0,0 +1,6 @@ +#include +#include +#include +#include + +int comparar_int(const void*,const void*); diff --git a/bsearch/main.c b/bsearch/main.c new file mode 100644 index 0000000..1985097 --- /dev/null +++ b/bsearch/main.c @@ -0,0 +1,24 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n BSEARCH \n"); + int lista[5]={6,4,8,9,2}; + printf("\n\n Esta función de stdlib.h sirve para encontrar un elemento \n en un array de cualquier tipo. \n Espera que se le envíe por parámetro una función de comparación \n\n"); + puts("\n Especifique un número a encontrar dentro de un array de entero \n (o un número negativo para salir):" ); + int num,*elementoPtr; + scanf("%d",&num); + while(num>=0) + { + if((elementoPtr=bsearch(&num,lista,5,sizeof(int),comparar_int))!=NULL) + printf( "\n\n Encontrado: \t %d\n",*elementoPtr); + else + printf( "\n\n No encontrado: \t %d\n",num); + puts("\n Especifique un número a encontrar dentro de un array de entero \n (o un número negativo para salir):" ); + scanf("%d",&num); + } + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/bsearch/obj/Debug/functions.o b/bsearch/obj/Debug/functions.o new file mode 100644 index 0000000..a7e7e0a Binary files /dev/null and b/bsearch/obj/Debug/functions.o differ diff --git a/bsearch/obj/Debug/main.o b/bsearch/obj/Debug/main.o new file mode 100644 index 0000000..0b291bf Binary files /dev/null and b/bsearch/obj/Debug/main.o differ diff --git a/buscar cadena en un archivo txt con palabras/bin/Debug/buscar cadena en un archivo txt con palabras.exe b/buscar cadena en un archivo txt con palabras/bin/Debug/buscar cadena en un archivo txt con palabras.exe new file mode 100644 index 0000000..05c75c9 Binary files /dev/null and b/buscar cadena en un archivo txt con palabras/bin/Debug/buscar cadena en un archivo txt con palabras.exe differ diff --git a/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.cbp b/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.cbp new file mode 100644 index 0000000..510801a --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.depend b/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.depend new file mode 100644 index 0000000..bf4dc0d --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474589183 source:d:\unlam\programaciÓn\fabian 2\buscar cadena en un archivo txt con palabras\functions.c + "header.h" + +1474588143 d:\unlam\programaciÓn\fabian 2\buscar cadena en un archivo txt con palabras\header.h + + + + + +1474589000 source:d:\unlam\programaciÓn\fabian 2\buscar cadena en un archivo txt con palabras\main.c + "header.h" + diff --git a/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.layout b/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.layout new file mode 100644 index 0000000..8303fe7 --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/buscar cadena en un archivo txt con palabras.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/buscar cadena en un archivo txt con palabras/functions.c b/buscar cadena en un archivo txt con palabras/functions.c new file mode 100644 index 0000000..cb7b6f5 --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/functions.c @@ -0,0 +1,77 @@ +#include "header.h" + +void busqueda_de_palabra(FILE *pf,char *subcadena) + { + char cadena[6]; + rewind(pf); + while(!feof(pf)) + { + str_cpy(cadena,leer_cadena(pf)); + if(str_str(cadena,subcadena)!=NULL) + { + printf("\n %c La subcadena %s fue encontrada en la cadena %s \n del archivo \n\n",16,subcadena,cadena); + //getch(); + } + } + } + +char *leer_cadena(FILE *pf) + { + char s[6]; + fflush(stdin); + fscanf(pf,"%6s",s); + return s; + } + +char *str_upr(char *s1) + { + char *s2=s1; + while(*s1) + { + *s1=A_MAYUSCULA(*s1); + s1++; + } + return s2; + } + +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +int str_ncmp(const char *s1,const char *s2,size_t cant) + { + while(*s1==*s2&&*s1&&*s2&&--cant) + { + s1++; + s2++; + } + return *s1-*s2; + } + +char *str_str(const char *s1,const char *s2) + { + size_t tam=str_len(s2); + while(*s1&&str_ncmp(s1,s2,tam)) + s1++; + return (*s1)?s1:NULL; + } diff --git a/buscar cadena en un archivo txt con palabras/header.h b/buscar cadena en un archivo txt con palabras/header.h new file mode 100644 index 0000000..8464a68 --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/header.h @@ -0,0 +1,13 @@ +#include +#include +#include +#include +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +void busqueda_de_palabra(FILE*,char*); +char *leer_cadena(FILE*); +char *str_upr(char*); +char *str_cpy(char*,const char*); +size_t str_len(const char*); +int str_ncmp(const char*,const char*,size_t); +char *str_str(const char*,const char*); diff --git a/buscar cadena en un archivo txt con palabras/main.c b/buscar cadena en un archivo txt con palabras/main.c new file mode 100644 index 0000000..08229c4 --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/main.c @@ -0,0 +1,37 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n \t BUSCAR PALABRA EN UN TXT DE PALABRAS \a\a"); + + FILE *pf; + pf=fopen("palabras.txt","rt"); + if(!pf) + { + printf("\n\n Error al leer el fichero de texto \n\n Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n Ingrese una cadena (de hasta 6 caracteres, \n (el archivo tiene palabras de esa longitud) \n para ser buscada en el archivo de texto \"palabras.txt\" \n\n\t"); + printf("\n Si la cadena no está en mayúscula, será convertida, \n ya que las palabras del archivo están en mayúscula \n\n\t\t"); + char cadena[6]; + gets(cadena); + printf("\n Cadena a buscar: %s \n",cadena); + printf("\n\n Si la cadena es subcadena del archivo se le informará \n"); + printf("\n Comienzo de los resultados de la búsqueda \n\n"); + busqueda_de_palabra(pf,str_upr(cadena)); + + printf("\n\n \t\t\t\t\t Fin de los resultados de la búsqueda \n"); + getch(); + printf("\n\n Se ha cerrado el archivo \"palabras.txt\" utilizado \"palabras.txt\""); + fclose(pf); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + + diff --git a/buscar cadena en un archivo txt con palabras/obj/Debug/functions.o b/buscar cadena en un archivo txt con palabras/obj/Debug/functions.o new file mode 100644 index 0000000..f5a4da6 Binary files /dev/null and b/buscar cadena en un archivo txt con palabras/obj/Debug/functions.o differ diff --git a/buscar cadena en un archivo txt con palabras/obj/Debug/main.o b/buscar cadena en un archivo txt con palabras/obj/Debug/main.o new file mode 100644 index 0000000..bc1ab94 Binary files /dev/null and b/buscar cadena en un archivo txt con palabras/obj/Debug/main.o differ diff --git a/buscar cadena en un archivo txt con palabras/palabras.txt b/buscar cadena en un archivo txt con palabras/palabras.txt new file mode 100644 index 0000000..bce3496 --- /dev/null +++ b/buscar cadena en un archivo txt con palabras/palabras.txt @@ -0,0 +1,140 @@ +RIGMCZ EPIIOD ISWIOJ SYHDPT +FJJWRC EYYITU NGFAFM FATAOD SLLMYB LZNAAB LSCZMV THOWCJ +JPCGHC WPYINB QPCKZN XFIUZW ESYUNN CSFUWJ YBQJQA +XOKVTI OXGBTH DVKAIQ EWNYGK ODPJIT NMGCKY ZZHHHI ZUYWEV BOEZKN +TMIIPG DHAFUQ OXVJXH APPXJD WKLWCP +DAHNYP ULYXYW KOQUJB QFXIJW OHLCNM ATAUME +BZVBUI TAJMRH DZTNVP +SGUBHV GDCWIT +AVNFEC GKJMAG QDJDLR RUOPPT +RJASVL RVOCBP FRSIHH JKKYKS TJKLKP +AUWIQG BGUYSL GUHWWG PUISHI QTCIFW GNHQQT HMYCPU AYROJU +XDKJKV WJXAQH SBXNAL IOUKBY FWTGXD ISQSMH WSBPWR +TTNYMB HRPAAO KMZGIT SAVUKZ +IWWJZR +FRSPAN KWGOEJ ZWHSBC EELFUF IHCSIS +HSUMJD WCSZEE SIPOFD HLYUCJ ZMVJLG RWWDIR +AJWNCW WVABSY CYHKGT NSGXYH OFZRCT WMQXAD GDCOJL YZQULY +JMVKZM OZVRQM ZVLRBG HLNJCV ZXMADI BFMJQV ELQEXQ +GOETNC MAQWGZ SRYVJZ PSYKYI SWPSBN DDOPYP MLIYYR FILXIW EYANCF +PXFQQZ QQTGUJ OPZEHI JFVGZD YMQDXJ +TORUBH CPBCUZ NKAFIG +JDUCMK RQWYRS GHTJZR BZSYWQ ETFXRT +JEUCNL UZKLWA +CSMIRK +WSYEVW WAMKNG PLCYTA HXFAJN +KPLATK KMSWRR VPVZZD SJZWFL EEDYRY RGZFFS +ZEZRKX YUDJQN SCONMO MWJWHT RKSMBR YFYFUV LHVCWZ UIFPFE +BUYLZB JWKQKZ AZUSJH TKZLQN ERUBTD +WBMEQG LYQTCK KLIACJ MYOYJI ZJBPBA SVEOAH OOCYJU +ODUEFM YGRDUZ ZQEVYW XFKMXL CSQLWT TFEMLU CBIKDO KFCAYM LZMEZQ +ZDIAAR LKJTKW SQJJUT VTLYZT NYNZII +PGSOLH RLDQAL LQSZQI OCGCMB LZLQTO OEKJTW LPXYSA IUQJNU +TFZHNT GUZSZB SHBEBW MTRIRQ STEVPM OYRPAM +PYSMLO YCQMGL SWXNMR +JQLLFZ CAADJO +AFUQDZ +UZHMJQ MBHPWI DENTRN PSVPUR +WKYALU NPGTWT +JWPLZV VBMNYL LUESKD EQISYI KKADVU +GMHWLY EEAGHS KPGUNC EQFRXK +OETFXL IULEXK +HJIHXF OZNMJT TNDUPR +TNDDTO DEOBTX QFMJSW CLSWTU MCKQHY +MLQLCY NWIIEK +HUSFDA DBTFEW JEIICD IIMMCR PWFCTJ LZKAZV +GYCMFG XHZAWG ZXRRQS YGCSUI +EEGBGX OOZSIX AWXUKR DGFQTQ UZCCWJ JYCRUG RLPIGO +HUKCYB MHROIN QUVISB EPDQUE AZVMTK FTMXKC KBCEUK ROZYHZ +UGJXEN CFTXLQ VCCDWH HYVALJ UPQGZL +WLEOSP UCQHGX WNXSOQ IKUPCD +YVVFSM RDLYFM +QRYHSI +PUVQZA FBPAXE OQDGGN +WDUOUL GNGMFE +GCMLPJ LTIQAV VGDAOI MRGNSH QQIMXQ +EXMHLR VRXPRI KKGDMY DEWANL AXKSXM AZLKDN +EBEALW XBWYMY PSHBUX KPCWUA PWJKAV QFVQON VDPYRK ZTLKLA RUEQKC +XKDYNI MXMSGW AMNVVW GHIQMI GFIXUH JLNRGP JISDVR JWNKWK +OIJWRL PYHSVD +DTDUSD ECYZHL BINZRZ CEAHYU IQKYOJ +DVKNHC WFBBQH KBRILF +RIGMCZ EPIIOD ISWIOJ SYHDPT +FJJWRC +EYYITU NGFAFM +FATAOD SLLMYB LZNAAB LSCZMV THOWCJ +JPCGHC WPYINB QPCKZN +XFIUZW ESYUNN +CSFUWJ YBQJQA XOKVTI OXGBTH DVKAIQ EWNYGK +ODPJIT NMGCKY ZZHHHI ZUYWEV BOEZKN +TMIIPG DHAFUQ OXVJXH APPXJD +WKLWCP DAHNYP +ULYXYW +KOQUJB QFXIJW OHLCNM ATAUME +BZVBUI TAJMRH DZTNVP SGUBHV GDCWIT +AVNFEC GKJMAG QDJDLR RUOPPT RJASVL RVOCBP FRSIHH JKKYKS +TJKLKP AUWIQG BGUYSL GUHWWG PUISHI QTCIFW +GNHQQT HMYCPU AYROJU +XDKJKV WJXAQH +SBXNAL IOUKBY FWTGXD ISQSMH WSBPWR TTNYMB HRPAAO KMZGIT SAVUKZ +IWWJZR FRSPAN KWGOEJ ZWHSBC EELFUF IHCSIS HSUMJD +WCSZEE SIPOFD HLYUCJ ZMVJLG RWWDIR AJWNCW WVABSY CYHKGT +NSGXYH OFZRCT WMQXAD GDCOJL YZQULY +JMVKZM OZVRQM ZVLRBG HLNJCV ZXMADI BFMJQV ELQEXQ GOETNC MAQWGZ +SRYVJZ PSYKYI SWPSBN DDOPYP MLIYYR FILXIW +EYANCF PXFQQZ QQTGUJ OPZEHI JFVGZD YMQDXJ TORUBH CPBCUZ NKAFIG +JDUCMK RQWYRS GHTJZR BZSYWQ ETFXRT JEUCNL UZKLWA CSMIRK +WSYEVW WAMKNG PLCYTA HXFAJN KPLATK KMSWRR VPVZZD +SJZWFL EEDYRY RGZFFS ZEZRKX +YUDJQN SCONMO MWJWHT RKSMBR YFYFUV +LHVCWZ UIFPFE BUYLZB JWKQKZ AZUSJH TKZLQN ERUBTD WBMEQG +LYQTCK KLIACJ MYOYJI ZJBPBA SVEOAH OOCYJU ODUEFM YGRDUZ ZQEVYW +XFKMXL CSQLWT TFEMLU CBIKDO KFCAYM LZMEZQ ZDIAAR LKJTKW +SQJJUT VTLYZT NYNZII PGSOLH RLDQAL LQSZQI OCGCMB +LZLQTO OEKJTW LPXYSA IUQJNU +TFZHNT GUZSZB SHBEBW MTRIRQ STEVPM OYRPAM PYSMLO YCQMGL +SWXNMR JQLLFZ CAADJO AFUQDZ UZHMJQ MBHPWI +DENTRN PSVPUR WKYALU NPGTWT JWPLZV +VBMNYL +LUESKD +EQISYI KKADVU GMHWLY EEAGHS KPGUNC EQFRXK OETFXL IULEXK HJIHXF OZNMJT +TNDUPR TNDDTO DEOBTX QFMJSW CLSWTU MCKQHY MLQLCY NWIIEK HUSFDA DBTFEW +JEIICD IIMMCR PWFCTJ LZKAZV GYCMFG XHZAWG ZXRRQS YGCSUI EEGBGX OOZSIX +AWXUKR DGFQTQ UZCCWJ JYCRUG RLPIGO HUKCYB MHROIN QUVISB EPDQUE AZVMTK +FTMXKC KBCEUK ROZYHZ UGJXEN CFTXLQ VCCDWH HYVALJ +UPQGZL WLEOSP UCQHGX WNXSOQ +IKUPCD YVVFSM +RDLYFM QRYHSI PUVQZA FBPAXE OQDGGN +WDUOUL GNGMFE GCMLPJ LTIQAV VGDAOI MRGNSH +QQIMXQ EXMHLR VRXPRI KKGDMY DEWANL AXKSXM AZLKDN EBEALW +XBWYMY PSHBUX KPCWUA PWJKAV QFVQON VDPYRK ZTLKLA +RUEQKC XKDYNI MXMSGW AMNVVW GHIQMI GFIXUH JLNRGP JISDVR JWNKWK +OIJWRL PYHSVD DTDUSD ECYZHL BINZRZ +CEAHYU IQKYOJ DVKNHC WFBBQH +KBRILF LXKQEC MPQSAQ +UYHXVA QKNMNG QJHPEV UZKPRM PFMYFK ZCUTHX +ZRIXUJ UXDKGI +UNCWJH +SCKROK MEWJCF CQXWPM HYWQXA +INANGE YHMEYR JLEQNX PCHXDR WGMGLZ DXKFUP +ZUOEZD LOEQOK FYZIQF GVMPKD MPVLKC +DZGEKI EYJHTD XNQIBK BLYIHQ ZRUPHA YSPBDF TZOLBW OCUJRR +PLKIPH UMJUMM +ZXRKDP NPHGFZ JNQOVK MRSBUY IPWQYN BEDKUZ ZTUAGQ JOCMAL +LHLGBZ LGQYVM EPVQFW DOBCEA WUMLEY ZJEWIY ACOEKS +BZNWEA SOKBOY ZDSZJK ARMQKG WXPQJK HNVMYG CVIIDK UIAKVH EPTUHT +OJKUJJ CZRSEO ZUGXMY AYYLEW IPRKAM LOSVVF +OBOOWH VAZVFY IWISTT +HPKIWX VDDRSC +HYMIIC +AEOGDW BQOVMW UOVOOA OBVELX SDXBUY +UJMPZE QYRMTZ CWIFAR YVEULP WDFRZV MJQMPU LRUVPT ICLAOO EWYLEO +LRBQSW XXJTFB WFTXTZ CVNVZA QGHZBG WOJWBO UDYJZV ZRAUID +DEWOGT ORPPQB UDZRVS XVKTRI RGQZHT MTXFVY ZFNQZJ +AJRMGM DHCDBM NLWDGE ZALXCO YOPTXO +GDOJMW MUASSR FAROPF +KNLRIA BLVYSA +TSFJCE +JKIDMK JJXEZV IBVZGX PWJRVG +XUGSZZ BYWVEL MDUEIX FWTTZL WAEMSW BYTBJY PDBDIB HZRBKY +UUOEOG diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/bin/Debug/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.exe" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/bin/Debug/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.exe" new file mode 100644 index 0000000..854401c Binary files /dev/null and "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/bin/Debug/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.exe" differ diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.cbp" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.cbp" new file mode 100644 index 0000000..57f07e5 --- /dev/null +++ "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.depend" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.depend" new file mode 100644 index 0000000..3d77132 --- /dev/null +++ "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.depend" @@ -0,0 +1,14 @@ +# depslib dependency file v1.0 +1474576171 source:d:\unlam\programaciÓn\fabian 2\cadena que representa número, capicúa, múltiplo\functions.c + "header.h" + +1474576038 d:\unlam\programaciÓn\fabian 2\cadena que representa número, capicúa, múltiplo\header.h + + + + + + +1474575896 source:d:\unlam\programaciÓn\fabian 2\cadena que representa número, capicúa, múltiplo\main.c + "header.h" + diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.layout" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.layout" new file mode 100644 index 0000000..90e7087 --- /dev/null +++ "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/functions.c" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/functions.c" new file mode 100644 index 0000000..04c2c1f --- /dev/null +++ "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/functions.c" @@ -0,0 +1,122 @@ +#include "header.h" + +int mi_atoi(char *s) + { + int i=0,signo=1; + if(!s) + return 0; + if(!ES_DIGITO(*s)) + { + while(*s==' ') + s++; + if(*s=='-') + { + signo=-1; + s++; + } + else + if(*s=='+') + s++; + } + while(ES_DIGITO(*s)) + { + i*=10; + i+=(*s-'0'); + s++; + } + return i*signo; + } + +int es_numero(char *s) + { + if(!s) + return 0; + if(!ES_DIGITO(*s)) + { + while(ES_BLANCO(*s)) + s++; + if(ES_SIGNO(*s)) + { + s++; + } + else + if(!ES_DIGITO(*s)) + return 0; + } + while(ES_DIGITO(*s)) + { + s++; + } + return *s?0:1; + } + +int es_capicua(char *s1) + { + while(ES_BLANCO(*s1)||ES_SIGNO(*s1)) + s1++; + int i,longitud=str_len(s1),punto_medio=longitud/2; + char *s2=s1+longitud-1; + for(i=0;i<=punto_medio;i++) + if(*s1++!=*s2--) + return 0; + return 1; + } + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +int es_multiplo_de_5(char *s) + { + while(*s) + s++; + s--; + return (*s=='5'||(*s=='0'))?1:0; + } + +int es_multiplo_de_6(char *s) + { + while(*s) + s++; + s--; + if(*s!='0'&&(*s!='2')&&(*s!='4')&&(*s!='6')&&(*s!='8')) + return 0; + int acum=0; + while(ES_DIGITO(*s)) + { + acum=acum+A_NUMERO(*s); + s--; + } + return acum%3==0?1:0; + } + +int es_multiplo_de_11(char *s) + { + int signo=1,acum=0; + while(!ES_DIGITO(*s)) + s++; + while(*s) + { + acum+=signo*A_NUMERO(*s); + signo*=-1; + s++; + } + return (acum==0||acum%11==0)?1:0; + } + +int es_mayor(char *s1,char *s2) + { + return (mi_atoi(s1)>mi_atoi(s2))?1:0; + } + +int es_del_intervalo_de_los_short_int(char *s) + { + return DATO_VALIDO(mi_atoi(s),SHRT_MIN,SHRT_MAX)?1:0;//SHRT_MIN=-32768&&SHRT_MAX=32767 + } diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/header.h" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/header.h" new file mode 100644 index 0000000..d2a37fb --- /dev/null +++ "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/header.h" @@ -0,0 +1,22 @@ +#include +#include +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) +#define ES_DIGITO(x) (((x)>='0'&&(x)<='9')) +#define ES_BLANCO(x) ((x)==' ') +#define ES_SIGNO(x) ((x)=='+'||(x)=='-') +#define A_NUMERO(x) ((x)-48) +#define MAYOR(x,y) ((x)>(y)?(x):(y)) + +int mi_atoi(char*); +int es_numero(char*); +size_t str_len(const char*); +int es_capicua(char*); +int es_multiplo_de_5(char*); +int es_multiplo_de_6(char*); +int es_multiplo_de_11(char*); +int es_mayor(char*,char*); +int es_del_intervalo_de_los_short_int(char*); diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/main.c" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/main.c" new file mode 100644 index 0000000..82c3b4a --- /dev/null +++ "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/main.c" @@ -0,0 +1,27 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n Cadena que representa un número entero \n"); + printf("\n Ingrese un cadena de caracteres cualquiera (menos de 50 caracteres): \n\n\t"); + + char cadena[50]; + fflush(stdin); + gets(cadena); + printf("\n\n ¿La cadena \"%s\" representa un número entero? \t %s \n",cadena,es_numero(cadena)?"SI":"NO"); + + if(es_numero(cadena)) + { + printf("\n Es capicúa? \t %s \n",es_capicua(cadena)?"SI":"NO"); + printf("\n Es múltiplo de 5? \t %s \n",es_multiplo_de_5(cadena)?"SI":"NO"); + printf("\n Es múltiplo de 6? \t %s \n",es_multiplo_de_6(cadena)?"SI":"NO"); + printf("\n Es múltiplo de 11? \t %s \n",es_multiplo_de_11(cadena)?"SI":"NO"); + printf("\n Es mayor que %s? \t %s \n","100",es_mayor(cadena,"100")?"SI":"NO"); + printf("\n Es del intervalo de los short int? \t %s \n",es_del_intervalo_de_los_short_int(cadena)?"SI":"NO"); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/obj/Debug/functions.o" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/obj/Debug/functions.o" new file mode 100644 index 0000000..23bacfa Binary files /dev/null and "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/obj/Debug/functions.o" differ diff --git "a/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/obj/Debug/main.o" "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/obj/Debug/main.o" new file mode 100644 index 0000000..2f66b8a Binary files /dev/null and "b/cadena que representa n\303\272mero, capic\303\272a, m\303\272ltiplo/obj/Debug/main.o" differ diff --git a/cadenas_simulacro de memccpy/bin/Debug/cadenas_simulacro de memccpy.exe b/cadenas_simulacro de memccpy/bin/Debug/cadenas_simulacro de memccpy.exe new file mode 100644 index 0000000..91b5f00 Binary files /dev/null and b/cadenas_simulacro de memccpy/bin/Debug/cadenas_simulacro de memccpy.exe differ diff --git a/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.cbp b/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.cbp new file mode 100644 index 0000000..31c6258 --- /dev/null +++ b/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.depend b/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.depend new file mode 100644 index 0000000..3bc9d73 --- /dev/null +++ b/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473357160 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memccpy\functions.c + "header.h" + +1473357102 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memccpy\header.h + + + + +1473357051 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memccpy\main.c + "header.h" + diff --git a/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.layout b/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.layout new file mode 100644 index 0000000..223f129 --- /dev/null +++ b/cadenas_simulacro de memccpy/cadenas_simulacro de memccpy.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memccpy/functions.c b/cadenas_simulacro de memccpy/functions.c new file mode 100644 index 0000000..41ff03c --- /dev/null +++ b/cadenas_simulacro de memccpy/functions.c @@ -0,0 +1,16 @@ +#include "header.h" +void *mem_ccpy(void *destino,const void *origen,int c,size_t cant) + { + int marca=0; + while(cant--&&!marca) + { + *(char*)destino=*(char *)origen; + if(*(char*)destino==(char)c) + marca++; + else + (char*)destino++; + (char*)origen++; + } + *(char*)destino='\0'; + return (*(char*)destino==(char)c&&marca)?(char*)destino+1:NULL; + } diff --git a/cadenas_simulacro de memccpy/header.h b/cadenas_simulacro de memccpy/header.h new file mode 100644 index 0000000..1ccd054 --- /dev/null +++ b/cadenas_simulacro de memccpy/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +void *mem_ccpy(void*,const void*,int,size_t); diff --git a/cadenas_simulacro de memccpy/main.c b/cadenas_simulacro de memccpy/main.c new file mode 100644 index 0000000..fb9fe57 --- /dev/null +++ b/cadenas_simulacro de memccpy/main.c @@ -0,0 +1,28 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + char car; + unsigned n; + printf("\n\n COPIAR CADENAS EN UNA CIERTA CANTIDAD DE BYTES DE OTRA \n O HASTA COPIAR CIERTO CARACTER \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de bytes que desea copiar: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + printf("\n\n Ingrese el caracter de corte: \n\n\t"); + fflush(stdin); + scanf("%c",&car); + mem_ccpy(cadena1,cadena2,car,n); + printf("\n Las cadenas fueron copiadas \n"); + printf("\n Cadena 1: \t %s \n Cadena 2: \t %s \n\n",cadena1,cadena2); + getch(); + return 0; + } + diff --git a/cadenas_simulacro de memccpy/obj/Debug/functions.o b/cadenas_simulacro de memccpy/obj/Debug/functions.o new file mode 100644 index 0000000..4184b23 Binary files /dev/null and b/cadenas_simulacro de memccpy/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memccpy/obj/Debug/main.o b/cadenas_simulacro de memccpy/obj/Debug/main.o new file mode 100644 index 0000000..d0330ef Binary files /dev/null and b/cadenas_simulacro de memccpy/obj/Debug/main.o differ diff --git a/cadenas_simulacro de memchr/bin/Debug/cadenas_simulacro de memchr.exe b/cadenas_simulacro de memchr/bin/Debug/cadenas_simulacro de memchr.exe new file mode 100644 index 0000000..018eef3 Binary files /dev/null and b/cadenas_simulacro de memchr/bin/Debug/cadenas_simulacro de memchr.exe differ diff --git a/cadenas_simulacro de memchr/cadenas_simulacro de memchr.cbp b/cadenas_simulacro de memchr/cadenas_simulacro de memchr.cbp new file mode 100644 index 0000000..a138d2e --- /dev/null +++ b/cadenas_simulacro de memchr/cadenas_simulacro de memchr.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de memchr/cadenas_simulacro de memchr.depend b/cadenas_simulacro de memchr/cadenas_simulacro de memchr.depend new file mode 100644 index 0000000..f62e9b3 --- /dev/null +++ b/cadenas_simulacro de memchr/cadenas_simulacro de memchr.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473360714 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memchr\functions.c + "header.h" + +1473360714 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memchr\header.h + + + + +1473355020 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memchr\main.c + "header.h" + diff --git a/cadenas_simulacro de memchr/cadenas_simulacro de memchr.layout b/cadenas_simulacro de memchr/cadenas_simulacro de memchr.layout new file mode 100644 index 0000000..80af6ad --- /dev/null +++ b/cadenas_simulacro de memchr/cadenas_simulacro de memchr.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memchr/functions.c b/cadenas_simulacro de memchr/functions.c new file mode 100644 index 0000000..f3c23d2 --- /dev/null +++ b/cadenas_simulacro de memchr/functions.c @@ -0,0 +1,10 @@ +#include "header.h" +void *mem_chr(const void *s,int c,size_t n) + { + while(n&&*(char*)s!=(char)c) + { + n--; + (char*)s++; + } + return n?s:NULL; + } diff --git a/cadenas_simulacro de memchr/header.h b/cadenas_simulacro de memchr/header.h new file mode 100644 index 0000000..726229d --- /dev/null +++ b/cadenas_simulacro de memchr/header.h @@ -0,0 +1,4 @@ +#include +#include +#include +void *mem_chr(const void*,int,size_t); diff --git a/cadenas_simulacro de memchr/main.c b/cadenas_simulacro de memchr/main.c new file mode 100644 index 0000000..63361ca --- /dev/null +++ b/cadenas_simulacro de memchr/main.c @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char car; + unsigned n; + printf("\n\n PRIMERA OCURRENCIA DE UN CARACTER \n EN CIERTA CANTIDAD DE BYTES DE UNA CADENA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese un caracter para buscar su primera ocurrencia: \n\n\t"); + fflush(stdin); + scanf("%c",&car); + printf("\n\n Ingrese la cantidad de bytes en las que desea buscar: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + if(mem_chr(cadena1,car,n)!=NULL) + printf("\n Cadena a partir de la primera ocurrencia de %c: \n\n\t %s \n\n",car,(char*)mem_chr(cadena1,car,n)); + else + printf("\n No se ha encontrado la ocurrencia del caracter %c \n\n",car); + getch(); + return 0; + } diff --git a/cadenas_simulacro de memchr/obj/Debug/functions.o b/cadenas_simulacro de memchr/obj/Debug/functions.o new file mode 100644 index 0000000..03c7500 Binary files /dev/null and b/cadenas_simulacro de memchr/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memchr/obj/Debug/main.o b/cadenas_simulacro de memchr/obj/Debug/main.o new file mode 100644 index 0000000..333748a Binary files /dev/null and b/cadenas_simulacro de memchr/obj/Debug/main.o differ diff --git a/cadenas_simulacro de memcmp/bin/Debug/cadenas_simulacro de memcmp.exe b/cadenas_simulacro de memcmp/bin/Debug/cadenas_simulacro de memcmp.exe new file mode 100644 index 0000000..7027a7a Binary files /dev/null and b/cadenas_simulacro de memcmp/bin/Debug/cadenas_simulacro de memcmp.exe differ diff --git a/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.cbp b/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.cbp new file mode 100644 index 0000000..ae3791e --- /dev/null +++ b/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.depend b/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.depend new file mode 100644 index 0000000..fb23d66 --- /dev/null +++ b/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473358331 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memcmp\functions.c + "header.h" + +1473357966 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memcmp\header.h + + + + +1473358171 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memcmp\main.c + "header.h" + diff --git a/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.layout b/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.layout new file mode 100644 index 0000000..abbb44d --- /dev/null +++ b/cadenas_simulacro de memcmp/cadenas_simulacro de memcmp.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memcmp/functions.c b/cadenas_simulacro de memcmp/functions.c new file mode 100644 index 0000000..81b64d2 --- /dev/null +++ b/cadenas_simulacro de memcmp/functions.c @@ -0,0 +1,12 @@ +#include "header.h" +int mem_cmp(const void *s1,const void *s2,size_t n) + { + if(!n) + return 0; + while(--n&&*(char*)s1==*(char*)s2) + { + (char*)++s1; + (char*)++s2; + } + return *(unsigned char *)s1-*(unsigned char *)s2; + } diff --git a/cadenas_simulacro de memcmp/header.h b/cadenas_simulacro de memcmp/header.h new file mode 100644 index 0000000..7ad3ec7 --- /dev/null +++ b/cadenas_simulacro de memcmp/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +int mem_cmp(const void*,const void*,size_t); diff --git a/cadenas_simulacro de memcmp/main.c b/cadenas_simulacro de memcmp/main.c new file mode 100644 index 0000000..bc005f7 --- /dev/null +++ b/cadenas_simulacro de memcmp/main.c @@ -0,0 +1,28 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + size_t n; + printf("\n\n COMPARAR CADENAS HASTA CIERTA CANTIDAD DE BYTES \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de bytes que desea comparar: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + if(mem_cmp(cadena1,cadena2,n)>0) + printf("\n La primera cadena es mayor a la segunda \n\n"); + else + if(mem_cmp(cadena1,cadena2,n)<0) + printf("\n La primera cadena es menor a la segunda \n\n"); + else + printf("\n Las cadenas son iguales \n\n"); + getch(); + return 0; + } + diff --git a/cadenas_simulacro de memcmp/obj/Debug/functions.o b/cadenas_simulacro de memcmp/obj/Debug/functions.o new file mode 100644 index 0000000..4022779 Binary files /dev/null and b/cadenas_simulacro de memcmp/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memcmp/obj/Debug/main.o b/cadenas_simulacro de memcmp/obj/Debug/main.o new file mode 100644 index 0000000..e90546c Binary files /dev/null and b/cadenas_simulacro de memcmp/obj/Debug/main.o differ diff --git a/cadenas_simulacro de memcpy/bin/Debug/cadenas_simulacro de memcpy.exe b/cadenas_simulacro de memcpy/bin/Debug/cadenas_simulacro de memcpy.exe new file mode 100644 index 0000000..115bd0f Binary files /dev/null and b/cadenas_simulacro de memcpy/bin/Debug/cadenas_simulacro de memcpy.exe differ diff --git a/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.cbp b/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.cbp new file mode 100644 index 0000000..f223767 --- /dev/null +++ b/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.depend b/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.depend new file mode 100644 index 0000000..96c85b2 --- /dev/null +++ b/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.depend @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1473356038 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memcpy\functions.c + "header.h" + +1473359310 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memcpy\header.h + + + + diff --git a/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.layout b/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.layout new file mode 100644 index 0000000..036d36a --- /dev/null +++ b/cadenas_simulacro de memcpy/cadenas_simulacro de memcpy.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memcpy/functions.c b/cadenas_simulacro de memcpy/functions.c new file mode 100644 index 0000000..d418ec2 --- /dev/null +++ b/cadenas_simulacro de memcpy/functions.c @@ -0,0 +1,13 @@ +#include "header.h" +void *mem_cpy(void *destino,const void *origen,size_t n) + { + void *s=destino; + while(n--) + { + *(char*)destino=*(char *)origen; + destino++; + origen++; + } + *(char*)destino='\0'; + return s; + } diff --git a/cadenas_simulacro de memcpy/header.h b/cadenas_simulacro de memcpy/header.h new file mode 100644 index 0000000..8990451 --- /dev/null +++ b/cadenas_simulacro de memcpy/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +void *mem_cpy(void*,const void*,size_t); diff --git a/cadenas_simulacro de memcpy/main.c b/cadenas_simulacro de memcpy/main.c new file mode 100644 index 0000000..5847205 --- /dev/null +++ b/cadenas_simulacro de memcpy/main.c @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + unsigned n; + printf("\n\n COPIAR CADENAS EN UNA CIERTA CANTIDAD DE BYTES DE OTRA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de bytes que desea copiar: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + mem_cpy(cadena1,cadena2,n); + printf("\n Las cadenas fueron copiadas \n"); + printf("\n Cadena 1: \t %s \n Cadena 2: \t %s \n\n",cadena1,cadena2); + getch(); + return 0; + } + diff --git a/cadenas_simulacro de memcpy/obj/Debug/functions.o b/cadenas_simulacro de memcpy/obj/Debug/functions.o new file mode 100644 index 0000000..4b3d426 Binary files /dev/null and b/cadenas_simulacro de memcpy/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memcpy/obj/Debug/main.o b/cadenas_simulacro de memcpy/obj/Debug/main.o new file mode 100644 index 0000000..0b27e2f Binary files /dev/null and b/cadenas_simulacro de memcpy/obj/Debug/main.o differ diff --git a/cadenas_simulacro de memicmp/bin/Debug/cadenas_simulacro de memicmp.exe b/cadenas_simulacro de memicmp/bin/Debug/cadenas_simulacro de memicmp.exe new file mode 100644 index 0000000..2046b18 Binary files /dev/null and b/cadenas_simulacro de memicmp/bin/Debug/cadenas_simulacro de memicmp.exe differ diff --git a/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.cbp b/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.cbp new file mode 100644 index 0000000..140ba99 --- /dev/null +++ b/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.depend b/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.depend new file mode 100644 index 0000000..625ae75 --- /dev/null +++ b/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473358770 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memicmp\functions.c + "header.h" + +1474474478 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memicmp\header.h + + + + +1474474451 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memicmp\main.c + "header.h" + diff --git a/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.layout b/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.layout new file mode 100644 index 0000000..7bf256b --- /dev/null +++ b/cadenas_simulacro de memicmp/cadenas_simulacro de memicmp.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memicmp/functions.c b/cadenas_simulacro de memicmp/functions.c new file mode 100644 index 0000000..875f4a7 --- /dev/null +++ b/cadenas_simulacro de memicmp/functions.c @@ -0,0 +1,13 @@ +#include "header.h" +int mem_icmp(const void *s1,const void *s2,size_t n) + { + if(!n) + return 0; + while(--n&&A_MAYUSCULA(*(char*)s1)==A_MAYUSCULA(*(char*)s2)) + { + (char*)++s1; + (char*)++s2; + } + return A_MAYUSCULA(*(unsigned char *)s1)-A_MAYUSCULA(*(unsigned char *)s2); + } + diff --git a/cadenas_simulacro de memicmp/header.h b/cadenas_simulacro de memicmp/header.h new file mode 100644 index 0000000..50b93a2 --- /dev/null +++ b/cadenas_simulacro de memicmp/header.h @@ -0,0 +1,7 @@ +#include +#include +#include +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +int mem_icmp(const void*,const void*,size_t); + diff --git a/cadenas_simulacro de memicmp/main.c b/cadenas_simulacro de memicmp/main.c new file mode 100644 index 0000000..d57aa7e --- /dev/null +++ b/cadenas_simulacro de memicmp/main.c @@ -0,0 +1,29 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + size_t n; + printf("\n\n COMPARAR CADENAS HASTA CIERTA CANTIDAD DE BYTES \n (sin diferenciar mayúsculas y minúsculas) \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de bytes que desea comparar: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + if(mem_icmp(cadena1,cadena2,n)>0) + printf("\n La primera cadena es mayor a la segunda \n\n"); + else + if(mem_icmp(cadena1,cadena2,n)<0) + printf("\n La primera cadena es menor a la segunda \n\n"); + else + printf("\n Las cadenas son iguales \n\n"); + getch(); + return 0; + } + + diff --git a/cadenas_simulacro de memicmp/obj/Debug/functions.o b/cadenas_simulacro de memicmp/obj/Debug/functions.o new file mode 100644 index 0000000..0e71f7d Binary files /dev/null and b/cadenas_simulacro de memicmp/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memicmp/obj/Debug/main.o b/cadenas_simulacro de memicmp/obj/Debug/main.o new file mode 100644 index 0000000..ef2580a Binary files /dev/null and b/cadenas_simulacro de memicmp/obj/Debug/main.o differ diff --git a/cadenas_simulacro de memmove/bin/Debug/cadenas_simulacro de memmove.exe b/cadenas_simulacro de memmove/bin/Debug/cadenas_simulacro de memmove.exe new file mode 100644 index 0000000..752ebac Binary files /dev/null and b/cadenas_simulacro de memmove/bin/Debug/cadenas_simulacro de memmove.exe differ diff --git a/cadenas_simulacro de memmove/cadenas_simulacro de memmove.cbp b/cadenas_simulacro de memmove/cadenas_simulacro de memmove.cbp new file mode 100644 index 0000000..4f82dc7 --- /dev/null +++ b/cadenas_simulacro de memmove/cadenas_simulacro de memmove.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de memmove/cadenas_simulacro de memmove.depend b/cadenas_simulacro de memmove/cadenas_simulacro de memmove.depend new file mode 100644 index 0000000..7290619 --- /dev/null +++ b/cadenas_simulacro de memmove/cadenas_simulacro de memmove.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473360256 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memmove\functions.c + "header.h" + +1473359368 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memmove\header.h + + + + +1473359444 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memmove\main.c + "header.h" + diff --git a/cadenas_simulacro de memmove/cadenas_simulacro de memmove.layout b/cadenas_simulacro de memmove/cadenas_simulacro de memmove.layout new file mode 100644 index 0000000..3bb8e1a --- /dev/null +++ b/cadenas_simulacro de memmove/cadenas_simulacro de memmove.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memmove/functions.c b/cadenas_simulacro de memmove/functions.c new file mode 100644 index 0000000..ead7806 --- /dev/null +++ b/cadenas_simulacro de memmove/functions.c @@ -0,0 +1,25 @@ +#include "header.h" +void *mem_move(void *destino,const void *origen,size_t n) + { + void *s=destino; + if(origen>=destino) + while(n--) + { + *(char*)destino=*(char *)origen; + (char*)destino++; + (char*)origen++; + } + else + { + (char*)destino+(n-1); + (char*)origen+(n-1); + while(n--) + { + *(char*)destino=*(char *)origen; + (char*)destino--; + (char*)origen--; + } + } + *(char*)destino='\0'; + return s; + } diff --git a/cadenas_simulacro de memmove/header.h b/cadenas_simulacro de memmove/header.h new file mode 100644 index 0000000..5bc37d7 --- /dev/null +++ b/cadenas_simulacro de memmove/header.h @@ -0,0 +1,6 @@ +#include +#include +#include + +void *mem_move(void*,const void*,size_t); + diff --git a/cadenas_simulacro de memmove/main.c b/cadenas_simulacro de memmove/main.c new file mode 100644 index 0000000..e7c997f --- /dev/null +++ b/cadenas_simulacro de memmove/main.c @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + unsigned n; + printf("\n\n MOVER CADENA EN UNA CIERTA CANTIDAD DE BYTES EN OTRA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de bytes que desea mover: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + mem_move(cadena1,cadena2,n); + printf("\n Una cadena fue movida dentro de la otra \n"); + printf("\n Cadena 1: \t %s \n Cadena 2: \t %s \n\n",cadena1,cadena2); + getch(); + return 0; + } + diff --git a/cadenas_simulacro de memmove/obj/Debug/functions.o b/cadenas_simulacro de memmove/obj/Debug/functions.o new file mode 100644 index 0000000..8fe68b2 Binary files /dev/null and b/cadenas_simulacro de memmove/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memmove/obj/Debug/main.o b/cadenas_simulacro de memmove/obj/Debug/main.o new file mode 100644 index 0000000..0ea10c5 Binary files /dev/null and b/cadenas_simulacro de memmove/obj/Debug/main.o differ diff --git a/cadenas_simulacro de memset/bin/Debug/cadenas_simulacro de memset.exe b/cadenas_simulacro de memset/bin/Debug/cadenas_simulacro de memset.exe new file mode 100644 index 0000000..1c95449 Binary files /dev/null and b/cadenas_simulacro de memset/bin/Debug/cadenas_simulacro de memset.exe differ diff --git a/cadenas_simulacro de memset/cadenas_simulacro de memset.cbp b/cadenas_simulacro de memset/cadenas_simulacro de memset.cbp new file mode 100644 index 0000000..6604686 --- /dev/null +++ b/cadenas_simulacro de memset/cadenas_simulacro de memset.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de memset/cadenas_simulacro de memset.depend b/cadenas_simulacro de memset/cadenas_simulacro de memset.depend new file mode 100644 index 0000000..d5fb371 --- /dev/null +++ b/cadenas_simulacro de memset/cadenas_simulacro de memset.depend @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1473361207 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memset\functions.c + "header.h" + +1473360995 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de memset\header.h + + + + diff --git a/cadenas_simulacro de memset/cadenas_simulacro de memset.layout b/cadenas_simulacro de memset/cadenas_simulacro de memset.layout new file mode 100644 index 0000000..ec945ea --- /dev/null +++ b/cadenas_simulacro de memset/cadenas_simulacro de memset.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de memset/functions.c b/cadenas_simulacro de memset/functions.c new file mode 100644 index 0000000..20b60f0 --- /dev/null +++ b/cadenas_simulacro de memset/functions.c @@ -0,0 +1,11 @@ +#include "header.h" +void *mem_set(void *s1,int c,size_t n) + { + void *s2=s1; + while(n--) + { + *(char *)s1=(char)c; + (char*)s1++; + } + return s2; + } diff --git a/cadenas_simulacro de memset/header.h b/cadenas_simulacro de memset/header.h new file mode 100644 index 0000000..137a6b1 --- /dev/null +++ b/cadenas_simulacro de memset/header.h @@ -0,0 +1,6 @@ +#include +#include +#include + +void *mem_set(void*,int,size_t); + diff --git a/cadenas_simulacro de memset/main.c b/cadenas_simulacro de memset/main.c new file mode 100644 index 0000000..545af83 --- /dev/null +++ b/cadenas_simulacro de memset/main.c @@ -0,0 +1,25 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[30]; + char car; + unsigned n; + printf("\n\n SETEAR UN CARACTER A UNA CADENA EN UNA CIERTA CANTIDAD DE BYTES \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena); + printf("\n Ingrese un caracter para setearlo a la cadena: \n\n\t"); + fflush(stdin); + scanf("%c",&car); + printf("\n\n Ingrese la cantidad de bytes que desea setear: \n\n\t"); + fflush(stdin); + scanf("%d",&n); + mem_set(cadena,car,n); + printf("\n La cadena fue seteada exitosamente \n"); + printf("\n Cadena : \t %s \n\n",cadena); + getch(); + return 0; + } + + diff --git a/cadenas_simulacro de memset/obj/Debug/functions.o b/cadenas_simulacro de memset/obj/Debug/functions.o new file mode 100644 index 0000000..d0cd59d Binary files /dev/null and b/cadenas_simulacro de memset/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de memset/obj/Debug/main.o b/cadenas_simulacro de memset/obj/Debug/main.o new file mode 100644 index 0000000..ca42519 Binary files /dev/null and b/cadenas_simulacro de memset/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strcat/bin/Debug/cadenas_simulacro de strcat.exe b/cadenas_simulacro de strcat/bin/Debug/cadenas_simulacro de strcat.exe new file mode 100644 index 0000000..9b03f84 Binary files /dev/null and b/cadenas_simulacro de strcat/bin/Debug/cadenas_simulacro de strcat.exe differ diff --git a/cadenas_simulacro de strcat/cadenas_simulacro de strcat.cbp b/cadenas_simulacro de strcat/cadenas_simulacro de strcat.cbp new file mode 100644 index 0000000..d892517 --- /dev/null +++ b/cadenas_simulacro de strcat/cadenas_simulacro de strcat.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strcat/cadenas_simulacro de strcat.depend b/cadenas_simulacro de strcat/cadenas_simulacro de strcat.depend new file mode 100644 index 0000000..a73d216 --- /dev/null +++ b/cadenas_simulacro de strcat/cadenas_simulacro de strcat.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473280772 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcat\functions.c + "header.h" + +1473281696 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcat\header.h + + + + +1473280781 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcat\main.c + "header.h" + diff --git a/cadenas_simulacro de strcat/cadenas_simulacro de strcat.layout b/cadenas_simulacro de strcat/cadenas_simulacro de strcat.layout new file mode 100644 index 0000000..a1c532b --- /dev/null +++ b/cadenas_simulacro de strcat/cadenas_simulacro de strcat.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strcat/functions.c b/cadenas_simulacro de strcat/functions.c new file mode 100644 index 0000000..c70e226 --- /dev/null +++ b/cadenas_simulacro de strcat/functions.c @@ -0,0 +1,15 @@ +#include "header.h" +char *str_cat(char *destino,const char *origen) + { + char *s=destino; + while(*destino) + destino++; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } diff --git a/cadenas_simulacro de strcat/header.h b/cadenas_simulacro de strcat/header.h new file mode 100644 index 0000000..11c4dbb --- /dev/null +++ b/cadenas_simulacro de strcat/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +char *str_cat(char*,const char*); diff --git a/cadenas_simulacro de strcat/main.c b/cadenas_simulacro de strcat/main.c new file mode 100644 index 0000000..2e366aa --- /dev/null +++ b/cadenas_simulacro de strcat/main.c @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n CONCATENAR CADENAS \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Cadenas concatenadas: %s \n\n",str_cat(cadena1,cadena2)); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strcat/obj/Debug/functions.o b/cadenas_simulacro de strcat/obj/Debug/functions.o new file mode 100644 index 0000000..c486566 Binary files /dev/null and b/cadenas_simulacro de strcat/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strcat/obj/Debug/main.o b/cadenas_simulacro de strcat/obj/Debug/main.o new file mode 100644 index 0000000..e71ecf4 Binary files /dev/null and b/cadenas_simulacro de strcat/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strchr/bin/Debug/cadenas_simulacro de strchr.exe b/cadenas_simulacro de strchr/bin/Debug/cadenas_simulacro de strchr.exe new file mode 100644 index 0000000..a1f87bb Binary files /dev/null and b/cadenas_simulacro de strchr/bin/Debug/cadenas_simulacro de strchr.exe differ diff --git a/cadenas_simulacro de strchr/cadenas_simulacro de strchr.cbp b/cadenas_simulacro de strchr/cadenas_simulacro de strchr.cbp new file mode 100644 index 0000000..8d383e8 --- /dev/null +++ b/cadenas_simulacro de strchr/cadenas_simulacro de strchr.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strchr/cadenas_simulacro de strchr.depend b/cadenas_simulacro de strchr/cadenas_simulacro de strchr.depend new file mode 100644 index 0000000..8ae62a2 --- /dev/null +++ b/cadenas_simulacro de strchr/cadenas_simulacro de strchr.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473286570 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strchr\functions.c + "header.h" + +1473286538 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strchr\header.h + + + + +1473286524 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strchr\main.c + "header.h" + diff --git a/cadenas_simulacro de strchr/cadenas_simulacro de strchr.layout b/cadenas_simulacro de strchr/cadenas_simulacro de strchr.layout new file mode 100644 index 0000000..367176d --- /dev/null +++ b/cadenas_simulacro de strchr/cadenas_simulacro de strchr.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strchr/functions.c b/cadenas_simulacro de strchr/functions.c new file mode 100644 index 0000000..349e619 --- /dev/null +++ b/cadenas_simulacro de strchr/functions.c @@ -0,0 +1,8 @@ +#include "header.h" +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } + diff --git a/cadenas_simulacro de strchr/header.h b/cadenas_simulacro de strchr/header.h new file mode 100644 index 0000000..9aa1fea --- /dev/null +++ b/cadenas_simulacro de strchr/header.h @@ -0,0 +1,4 @@ +#include +#include +#include +char *str_chr(char*,int); diff --git a/cadenas_simulacro de strchr/main.c b/cadenas_simulacro de strchr/main.c new file mode 100644 index 0000000..8f443bf --- /dev/null +++ b/cadenas_simulacro de strchr/main.c @@ -0,0 +1,20 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char car; + printf("\n\n PRIMERA OCURRENCIA DE UN CARACTER EN UNA CADENA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese un caracter para buscar su primera ocurrencia: \n\n\t"); + fflush(stdin); + scanf("%c",&car); + if(str_chr(cadena1,car)!=NULL) + printf("\n Cadena a partir de la primera ocurrencia de %c: \n\n\t %s \n\n",car,strchr(cadena1,car)); + else + printf("\n No se ha encontrado la ocurrencia del caracter %c \n\n",car); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strchr/obj/Debug/functions.o b/cadenas_simulacro de strchr/obj/Debug/functions.o new file mode 100644 index 0000000..9702a41 Binary files /dev/null and b/cadenas_simulacro de strchr/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strchr/obj/Debug/main.o b/cadenas_simulacro de strchr/obj/Debug/main.o new file mode 100644 index 0000000..5c2f602 Binary files /dev/null and b/cadenas_simulacro de strchr/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strcmp/bin/Debug/cadenas_simulacro de strcmp.exe b/cadenas_simulacro de strcmp/bin/Debug/cadenas_simulacro de strcmp.exe new file mode 100644 index 0000000..cb6c41c Binary files /dev/null and b/cadenas_simulacro de strcmp/bin/Debug/cadenas_simulacro de strcmp.exe differ diff --git a/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.cbp b/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.cbp new file mode 100644 index 0000000..90087df --- /dev/null +++ b/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.depend b/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.depend new file mode 100644 index 0000000..e8b94db --- /dev/null +++ b/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473282634 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcmp\functions.c + "header.h" + +1473282690 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcmp\header.h + + + + +1473282703 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcmp\main.c + "header.h" + diff --git a/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.layout b/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.layout new file mode 100644 index 0000000..7fbca60 --- /dev/null +++ b/cadenas_simulacro de strcmp/cadenas_simulacro de strcmp.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strcmp/functions.c b/cadenas_simulacro de strcmp/functions.c new file mode 100644 index 0000000..68123bd --- /dev/null +++ b/cadenas_simulacro de strcmp/functions.c @@ -0,0 +1,10 @@ +#include "header.h" +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } diff --git a/cadenas_simulacro de strcmp/header.h b/cadenas_simulacro de strcmp/header.h new file mode 100644 index 0000000..26818db --- /dev/null +++ b/cadenas_simulacro de strcmp/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +int str_cmp(const char*,const char*); diff --git a/cadenas_simulacro de strcmp/main.c b/cadenas_simulacro de strcmp/main.c new file mode 100644 index 0000000..2f3fdb5 --- /dev/null +++ b/cadenas_simulacro de strcmp/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n COMPARAR CADENAS \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + if(str_cmp(cadena1,cadena2)>0) + printf("\n La primera cadena es mayor a la segunda \n\n"); + else + if(str_cmp(cadena1,cadena2)<0) + printf("\n La primera cadena es menor a la segunda \n\n"); + else + printf("\n Las cadenas son iguales \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strcmp/obj/Debug/functions.o b/cadenas_simulacro de strcmp/obj/Debug/functions.o new file mode 100644 index 0000000..415e8f6 Binary files /dev/null and b/cadenas_simulacro de strcmp/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strcmp/obj/Debug/main.o b/cadenas_simulacro de strcmp/obj/Debug/main.o new file mode 100644 index 0000000..08e76d2 Binary files /dev/null and b/cadenas_simulacro de strcmp/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strcmpi/bin/Debug/cadenas_simulacro de strcmpi.exe b/cadenas_simulacro de strcmpi/bin/Debug/cadenas_simulacro de strcmpi.exe new file mode 100644 index 0000000..b23c69a Binary files /dev/null and b/cadenas_simulacro de strcmpi/bin/Debug/cadenas_simulacro de strcmpi.exe differ diff --git a/cadenas_simulacro de strcmpi/cadenas_simulacro de strcmpi.cbp b/cadenas_simulacro de strcmpi/cadenas_simulacro de strcmpi.cbp new file mode 100644 index 0000000..700fe7d --- /dev/null +++ b/cadenas_simulacro de strcmpi/cadenas_simulacro de strcmpi.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strcmpi/cadenas_simulacro de strcmpi.layout b/cadenas_simulacro de strcmpi/cadenas_simulacro de strcmpi.layout new file mode 100644 index 0000000..a76677f --- /dev/null +++ b/cadenas_simulacro de strcmpi/cadenas_simulacro de strcmpi.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strcmpi/functions.c b/cadenas_simulacro de strcmpi/functions.c new file mode 100644 index 0000000..4fbd2f7 --- /dev/null +++ b/cadenas_simulacro de strcmpi/functions.c @@ -0,0 +1,10 @@ +#include "header.h" +int str_icmp(const char *s1,const char *s2) + { + while(A_MAYUSCULA(*s1)==A_MAYUSCULA(*s2)&&*s1&&*s2) + { + s1++; + s2++; + } + return A_MAYUSCULA(*s1)-A_MAYUSCULA(*s2); + } diff --git a/cadenas_simulacro de strcmpi/header.h b/cadenas_simulacro de strcmpi/header.h new file mode 100644 index 0000000..47336f3 --- /dev/null +++ b/cadenas_simulacro de strcmpi/header.h @@ -0,0 +1,5 @@ +#include +#include +#include +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) +#define str_cmpi(s1,s2) str_icmp(s1,s2) diff --git a/cadenas_simulacro de strcmpi/main.c b/cadenas_simulacro de strcmpi/main.c new file mode 100644 index 0000000..a180d59 --- /dev/null +++ b/cadenas_simulacro de strcmpi/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n COMPARAR CADENAS (sin diferenciar mayúsculas y minúsculas) \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + if(str_cmpi(cadena1,cadena2)>0) + printf("\n La primera cadena es mayor a la segunda \n\n"); + else + if(str_cmpi(cadena1,cadena2)<0) + printf("\n La primera cadena es menor a la segunda \n\n"); + else + printf("\n Las cadenas son iguales \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strcmpi/obj/Debug/functions.o b/cadenas_simulacro de strcmpi/obj/Debug/functions.o new file mode 100644 index 0000000..99a9c9a Binary files /dev/null and b/cadenas_simulacro de strcmpi/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strcmpi/obj/Debug/main.o b/cadenas_simulacro de strcmpi/obj/Debug/main.o new file mode 100644 index 0000000..bf0e820 Binary files /dev/null and b/cadenas_simulacro de strcmpi/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strcpy/bin/Debug/cadenas_simulacro de strcpy.exe b/cadenas_simulacro de strcpy/bin/Debug/cadenas_simulacro de strcpy.exe new file mode 100644 index 0000000..845cd17 Binary files /dev/null and b/cadenas_simulacro de strcpy/bin/Debug/cadenas_simulacro de strcpy.exe differ diff --git a/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.cbp b/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.cbp new file mode 100644 index 0000000..fd61358 --- /dev/null +++ b/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.depend b/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.depend new file mode 100644 index 0000000..8802568 --- /dev/null +++ b/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473278784 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcpy\functions.c + "header.h" + +1473355888 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcpy\header.h + + + + +1473281598 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcpy\main.c + "header.h" + diff --git a/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.layout b/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.layout new file mode 100644 index 0000000..3f3f006 --- /dev/null +++ b/cadenas_simulacro de strcpy/cadenas_simulacro de strcpy.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strcpy/functions.c b/cadenas_simulacro de strcpy/functions.c new file mode 100644 index 0000000..6c32b88 --- /dev/null +++ b/cadenas_simulacro de strcpy/functions.c @@ -0,0 +1,13 @@ +#include "header.h" +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } diff --git a/cadenas_simulacro de strcpy/header.h b/cadenas_simulacro de strcpy/header.h new file mode 100644 index 0000000..ac6975d --- /dev/null +++ b/cadenas_simulacro de strcpy/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +char *str_cpy(char*,const char*); diff --git a/cadenas_simulacro de strcpy/main.c b/cadenas_simulacro de strcpy/main.c new file mode 100644 index 0000000..59384de --- /dev/null +++ b/cadenas_simulacro de strcpy/main.c @@ -0,0 +1,19 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n COMPIAR CADENAS \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + str_cpy(cadena1,cadena2); + printf("\n Las cadenas fueron copiadas \n"); + printf("\n Cadena 1: \t %s \n Cadena 2: \t %s \n\n",cadena1,cadena2); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strcpy/obj/Debug/functions.o b/cadenas_simulacro de strcpy/obj/Debug/functions.o new file mode 100644 index 0000000..c1dd80b Binary files /dev/null and b/cadenas_simulacro de strcpy/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strcpy/obj/Debug/main.o b/cadenas_simulacro de strcpy/obj/Debug/main.o new file mode 100644 index 0000000..fcbe909 Binary files /dev/null and b/cadenas_simulacro de strcpy/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strcspn/bin/Debug/cadenas_simulacro de strcspn.exe b/cadenas_simulacro de strcspn/bin/Debug/cadenas_simulacro de strcspn.exe new file mode 100644 index 0000000..d5ffbe2 Binary files /dev/null and b/cadenas_simulacro de strcspn/bin/Debug/cadenas_simulacro de strcspn.exe differ diff --git a/cadenas_simulacro de strcspn/cadenas_simulacro de strcspn.cbp b/cadenas_simulacro de strcspn/cadenas_simulacro de strcspn.cbp new file mode 100644 index 0000000..818beab --- /dev/null +++ b/cadenas_simulacro de strcspn/cadenas_simulacro de strcspn.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strcspn/cadenas_simulacro de strcspn.depend b/cadenas_simulacro de strcspn/cadenas_simulacro de strcspn.depend new file mode 100644 index 0000000..a4f1308 --- /dev/null +++ b/cadenas_simulacro de strcspn/cadenas_simulacro de strcspn.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473289787 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcspn\functions.c + "header.h" + +1473289760 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcspn\header.h + + + + +1473289902 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strcspn\main.c + "header.h" + diff --git a/cadenas_simulacro de strcspn/functions.c b/cadenas_simulacro de strcspn/functions.c new file mode 100644 index 0000000..ec6f187 --- /dev/null +++ b/cadenas_simulacro de strcspn/functions.c @@ -0,0 +1,17 @@ +#include "header.h" +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } +size_t str_cspn(const char *s1,const char *s2) + { + size_t cant=0; + while(*s1&&!str_chr(s2,*s1)) + { + cant++; + s1++; + } + return cant; + } diff --git a/cadenas_simulacro de strcspn/header.h b/cadenas_simulacro de strcspn/header.h new file mode 100644 index 0000000..9f55579 --- /dev/null +++ b/cadenas_simulacro de strcspn/header.h @@ -0,0 +1,7 @@ +#include +#include +#include + +char *str_chr(char*,int); +size_t str_cspn(const char*,const char*); + diff --git a/cadenas_simulacro de strcspn/main.c b/cadenas_simulacro de strcspn/main.c new file mode 100644 index 0000000..f602771 --- /dev/null +++ b/cadenas_simulacro de strcspn/main.c @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n CANTIDAD DE CARACTERES DE UNA CADENA QUE PERTENECEN ENTERAMENTE A LA OTRA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n La cantidad de caracteres de la primera cadena en que está enteramente \n algún caracter de la segunda cadena es de %d \n\n",str_cspn(cadena1,cadena2)); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strcspn/obj/Debug/functions.o b/cadenas_simulacro de strcspn/obj/Debug/functions.o new file mode 100644 index 0000000..5673d94 Binary files /dev/null and b/cadenas_simulacro de strcspn/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strcspn/obj/Debug/main.o b/cadenas_simulacro de strcspn/obj/Debug/main.o new file mode 100644 index 0000000..6f92315 Binary files /dev/null and b/cadenas_simulacro de strcspn/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strdup/bin/Debug/cadenas_simulacro de strdup.exe b/cadenas_simulacro de strdup/bin/Debug/cadenas_simulacro de strdup.exe new file mode 100644 index 0000000..149754b Binary files /dev/null and b/cadenas_simulacro de strdup/bin/Debug/cadenas_simulacro de strdup.exe differ diff --git a/cadenas_simulacro de strdup/cadenas_simulacro de strdup.cbp b/cadenas_simulacro de strdup/cadenas_simulacro de strdup.cbp new file mode 100644 index 0000000..ec99e63 --- /dev/null +++ b/cadenas_simulacro de strdup/cadenas_simulacro de strdup.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strdup/cadenas_simulacro de strdup.depend b/cadenas_simulacro de strdup/cadenas_simulacro de strdup.depend new file mode 100644 index 0000000..d3da9dd --- /dev/null +++ b/cadenas_simulacro de strdup/cadenas_simulacro de strdup.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473296927 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strdup\functions.c + "header.h" + +1473297106 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strdup\header.h + + + + + +1473297075 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strdup\main.c + "header.h" + diff --git a/cadenas_simulacro de strdup/cadenas_simulacro de strdup.layout b/cadenas_simulacro de strdup/cadenas_simulacro de strdup.layout new file mode 100644 index 0000000..527c5f2 --- /dev/null +++ b/cadenas_simulacro de strdup/cadenas_simulacro de strdup.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strdup/functions.c b/cadenas_simulacro de strdup/functions.c new file mode 100644 index 0000000..d66d7b1 --- /dev/null +++ b/cadenas_simulacro de strdup/functions.c @@ -0,0 +1,30 @@ +#include "header.h" +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } +char *str_dup(const char *s1) + { + char *s2=(char *)malloc(str_len(s1)+1); + if(s2) + str_cpy(s2,s1); + return s2; + } diff --git a/cadenas_simulacro de strdup/header.h b/cadenas_simulacro de strdup/header.h new file mode 100644 index 0000000..215263b --- /dev/null +++ b/cadenas_simulacro de strdup/header.h @@ -0,0 +1,7 @@ +#include +#include +#include +#include +size_t str_len(const char*); +char *str_cpy(char*,const char*); +char *str_dup(const char*); diff --git a/cadenas_simulacro de strdup/main.c b/cadenas_simulacro de strdup/main.c new file mode 100644 index 0000000..ed82d00 --- /dev/null +++ b/cadenas_simulacro de strdup/main.c @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[20]; + char *copia; + printf("\n\n DUPLICAR CADENA \n"); + printf("\n Ingrese una cadena de caracteres (menos de 20 caracteres):\n\n\t"); + fflush(stdin); + gets(cadena); + if(copia=str_dup(cadena)) + printf("\n Se ha duplicado la cadena --->>> copia: %s \n\n",copia); + else + printf("\n No se ha generado la cadena \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strdup/obj/Debug/functions.o b/cadenas_simulacro de strdup/obj/Debug/functions.o new file mode 100644 index 0000000..006cfdf Binary files /dev/null and b/cadenas_simulacro de strdup/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strdup/obj/Debug/main.o b/cadenas_simulacro de strdup/obj/Debug/main.o new file mode 100644 index 0000000..4f39e1a Binary files /dev/null and b/cadenas_simulacro de strdup/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strerror/bin/Debug/cadenas_simulacro de strerror.exe b/cadenas_simulacro de strerror/bin/Debug/cadenas_simulacro de strerror.exe new file mode 100644 index 0000000..34b5978 Binary files /dev/null and b/cadenas_simulacro de strerror/bin/Debug/cadenas_simulacro de strerror.exe differ diff --git a/cadenas_simulacro de strerror/cadenas_simulacro de strerror.cbp b/cadenas_simulacro de strerror/cadenas_simulacro de strerror.cbp new file mode 100644 index 0000000..21d58ba --- /dev/null +++ b/cadenas_simulacro de strerror/cadenas_simulacro de strerror.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strerror/cadenas_simulacro de strerror.layout b/cadenas_simulacro de strerror/cadenas_simulacro de strerror.layout new file mode 100644 index 0000000..98f54f8 --- /dev/null +++ b/cadenas_simulacro de strerror/cadenas_simulacro de strerror.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strerror/functions.c b/cadenas_simulacro de strerror/functions.c new file mode 100644 index 0000000..2eef120 --- /dev/null +++ b/cadenas_simulacro de strerror/functions.c @@ -0,0 +1,8 @@ +#include "header.h" +char *str_error(int errnum) + { + static char msg_error[40]; + sprintf(msg_error,"%.*s\n",sizeof(msg_error)-2,errnum>=0&&errnum +#include +#include +#include +char* str_error(int); + diff --git a/cadenas_simulacro de strerror/main.c b/cadenas_simulacro de strerror/main.c new file mode 100644 index 0000000..56d46bd --- /dev/null +++ b/cadenas_simulacro de strerror/main.c @@ -0,0 +1,12 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int errnum; + printf("\n\n MENSAJES DE ERROR \n\n"); + for(errnum=0;errnum<44;errnum++) + printf("\n ERROR %d = %s\n",errnum,str_error(errnum)); + printf("\n ERRORES en adelante ídem error 43 \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strerror/obj/Debug/functions.o b/cadenas_simulacro de strerror/obj/Debug/functions.o new file mode 100644 index 0000000..556c17f Binary files /dev/null and b/cadenas_simulacro de strerror/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strerror/obj/Debug/main.o b/cadenas_simulacro de strerror/obj/Debug/main.o new file mode 100644 index 0000000..b43952a Binary files /dev/null and b/cadenas_simulacro de strerror/obj/Debug/main.o differ diff --git a/cadenas_simulacro de stricmp/bin/Debug/cadenas_simulacro de stricmp.exe b/cadenas_simulacro de stricmp/bin/Debug/cadenas_simulacro de stricmp.exe new file mode 100644 index 0000000..9a6bddc Binary files /dev/null and b/cadenas_simulacro de stricmp/bin/Debug/cadenas_simulacro de stricmp.exe differ diff --git a/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.cbp b/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.cbp new file mode 100644 index 0000000..30ec286 --- /dev/null +++ b/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.depend b/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.depend new file mode 100644 index 0000000..e4d5fad --- /dev/null +++ b/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473283949 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de stricmp\main.c + "header.h" + +1473284064 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de stricmp\header.h + + + + +1473283988 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de stricmp\functions.c + "header.h" + diff --git a/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.layout b/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.layout new file mode 100644 index 0000000..9f0b324 --- /dev/null +++ b/cadenas_simulacro de stricmp/cadenas_simulacro de stricmp.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de stricmp/functions.c b/cadenas_simulacro de stricmp/functions.c new file mode 100644 index 0000000..4fbd2f7 --- /dev/null +++ b/cadenas_simulacro de stricmp/functions.c @@ -0,0 +1,10 @@ +#include "header.h" +int str_icmp(const char *s1,const char *s2) + { + while(A_MAYUSCULA(*s1)==A_MAYUSCULA(*s2)&&*s1&&*s2) + { + s1++; + s2++; + } + return A_MAYUSCULA(*s1)-A_MAYUSCULA(*s2); + } diff --git a/cadenas_simulacro de stricmp/header.h b/cadenas_simulacro de stricmp/header.h new file mode 100644 index 0000000..90dccc9 --- /dev/null +++ b/cadenas_simulacro de stricmp/header.h @@ -0,0 +1,6 @@ +#include +#include +#include +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +int str_icmp(const char*,const char*); diff --git a/cadenas_simulacro de stricmp/main.c b/cadenas_simulacro de stricmp/main.c new file mode 100644 index 0000000..5c0215f --- /dev/null +++ b/cadenas_simulacro de stricmp/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n COMPARAR CADENAS (sin diferenciar mayúsculas y minúsculas) \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + if(str_icmp(cadena1,cadena2)>0) + printf("\n La primera cadena es mayor a la segunda \n\n"); + else + if(str_icmp(cadena1,cadena2)<0) + printf("\n La primera cadena es menor a la segunda \n\n"); + else + printf("\n Las cadenas son iguales \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de stricmp/obj/Debug/functions.o b/cadenas_simulacro de stricmp/obj/Debug/functions.o new file mode 100644 index 0000000..bdb6c08 Binary files /dev/null and b/cadenas_simulacro de stricmp/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de stricmp/obj/Debug/main.o b/cadenas_simulacro de stricmp/obj/Debug/main.o new file mode 100644 index 0000000..664131e Binary files /dev/null and b/cadenas_simulacro de stricmp/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strlen/bin/Debug/cadenas_simulacro de strlen.exe b/cadenas_simulacro de strlen/bin/Debug/cadenas_simulacro de strlen.exe new file mode 100644 index 0000000..3791387 Binary files /dev/null and b/cadenas_simulacro de strlen/bin/Debug/cadenas_simulacro de strlen.exe differ diff --git a/cadenas_simulacro de strlen/cadenas_simulacro de strlen.cbp b/cadenas_simulacro de strlen/cadenas_simulacro de strlen.cbp new file mode 100644 index 0000000..4e49c28 --- /dev/null +++ b/cadenas_simulacro de strlen/cadenas_simulacro de strlen.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strlen/cadenas_simulacro de strlen.depend b/cadenas_simulacro de strlen/cadenas_simulacro de strlen.depend new file mode 100644 index 0000000..4cb1007 --- /dev/null +++ b/cadenas_simulacro de strlen/cadenas_simulacro de strlen.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473278341 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strlen\functions.c + "header.h" + +1473278283 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strlen\header.h + + + + +1473278415 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strlen\main.c + "header.h" + diff --git a/cadenas_simulacro de strlen/cadenas_simulacro de strlen.layout b/cadenas_simulacro de strlen/cadenas_simulacro de strlen.layout new file mode 100644 index 0000000..07a9356 --- /dev/null +++ b/cadenas_simulacro de strlen/cadenas_simulacro de strlen.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strlen/functions.c b/cadenas_simulacro de strlen/functions.c new file mode 100644 index 0000000..a204337 --- /dev/null +++ b/cadenas_simulacro de strlen/functions.c @@ -0,0 +1,11 @@ +#include "header.h" +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } diff --git a/cadenas_simulacro de strlen/header.h b/cadenas_simulacro de strlen/header.h new file mode 100644 index 0000000..5435b8a --- /dev/null +++ b/cadenas_simulacro de strlen/header.h @@ -0,0 +1,4 @@ +#include +#include +#include +size_t str_len(const char*); diff --git a/cadenas_simulacro de strlen/main.c b/cadenas_simulacro de strlen/main.c new file mode 100644 index 0000000..e5cae0e --- /dev/null +++ b/cadenas_simulacro de strlen/main.c @@ -0,0 +1,13 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[30]; + printf("\n\n LONGITUD DE UNA CADENA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena); + printf("\n\n La longitud de la cadena \"%s\" es %d \n",cadena,str_len(cadena)); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strlen/obj/Debug/functions.o b/cadenas_simulacro de strlen/obj/Debug/functions.o new file mode 100644 index 0000000..25e0102 Binary files /dev/null and b/cadenas_simulacro de strlen/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strlen/obj/Debug/main.o b/cadenas_simulacro de strlen/obj/Debug/main.o new file mode 100644 index 0000000..42f7d6b Binary files /dev/null and b/cadenas_simulacro de strlen/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strlwr/bin/Debug/cadenas_simulacro de strlwr.exe b/cadenas_simulacro de strlwr/bin/Debug/cadenas_simulacro de strlwr.exe new file mode 100644 index 0000000..b52b5ff Binary files /dev/null and b/cadenas_simulacro de strlwr/bin/Debug/cadenas_simulacro de strlwr.exe differ diff --git a/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.cbp b/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.cbp new file mode 100644 index 0000000..7822577 --- /dev/null +++ b/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.depend b/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.depend new file mode 100644 index 0000000..696e59c --- /dev/null +++ b/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473291045 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strlwr\functions.c + "header.h" + +1473291057 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strlwr\header.h + + + + +1473290974 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strlwr\main.c + "header.h" + diff --git a/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.layout b/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.layout new file mode 100644 index 0000000..87a846d --- /dev/null +++ b/cadenas_simulacro de strlwr/cadenas_simulacro de strlwr.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strlwr/functions.c b/cadenas_simulacro de strlwr/functions.c new file mode 100644 index 0000000..b5d11b8 --- /dev/null +++ b/cadenas_simulacro de strlwr/functions.c @@ -0,0 +1,12 @@ +#include "header.h" +char *str_lwr(char *s1) + { + char *s2=s1; + while(*s1) + { + *s1=A_MINUSCULA(*s1); + s1++; + } + return s2; + } + diff --git a/cadenas_simulacro de strlwr/header.h b/cadenas_simulacro de strlwr/header.h new file mode 100644 index 0000000..5259c33 --- /dev/null +++ b/cadenas_simulacro de strlwr/header.h @@ -0,0 +1,6 @@ +#include +#include +#include +#define A_MINUSCULA(x) (((x)>='A'&&(x)<='Z')?((x)+32):(x)) +char *str_lwr(char*); + diff --git a/cadenas_simulacro de strlwr/main.c b/cadenas_simulacro de strlwr/main.c new file mode 100644 index 0000000..f3b6c68 --- /dev/null +++ b/cadenas_simulacro de strlwr/main.c @@ -0,0 +1,14 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + printf("\n\n CADENA A MINÚSCULA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + str_lwr(cadena1); + printf("\n Cadena en minúscula: \t %s \n\n",cadena1); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strlwr/obj/Debug/functions.o b/cadenas_simulacro de strlwr/obj/Debug/functions.o new file mode 100644 index 0000000..4a77365 Binary files /dev/null and b/cadenas_simulacro de strlwr/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strlwr/obj/Debug/main.o b/cadenas_simulacro de strlwr/obj/Debug/main.o new file mode 100644 index 0000000..cbcb8ab Binary files /dev/null and b/cadenas_simulacro de strlwr/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strncat/bin/Debug/cadenas_simulacro de strncat.exe b/cadenas_simulacro de strncat/bin/Debug/cadenas_simulacro de strncat.exe new file mode 100644 index 0000000..ae9c013 Binary files /dev/null and b/cadenas_simulacro de strncat/bin/Debug/cadenas_simulacro de strncat.exe differ diff --git a/cadenas_simulacro de strncat/cadenas_simulacro de strncat.cbp b/cadenas_simulacro de strncat/cadenas_simulacro de strncat.cbp new file mode 100644 index 0000000..52f33f0 --- /dev/null +++ b/cadenas_simulacro de strncat/cadenas_simulacro de strncat.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strncat/cadenas_simulacro de strncat.depend b/cadenas_simulacro de strncat/cadenas_simulacro de strncat.depend new file mode 100644 index 0000000..94a36b1 --- /dev/null +++ b/cadenas_simulacro de strncat/cadenas_simulacro de strncat.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473281265 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncat\main.c + "header.h" + +1473281734 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncat\header.h + + + + +1473281406 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncat\functions.c + "header.h" + diff --git a/cadenas_simulacro de strncat/cadenas_simulacro de strncat.layout b/cadenas_simulacro de strncat/cadenas_simulacro de strncat.layout new file mode 100644 index 0000000..b9f7f6a --- /dev/null +++ b/cadenas_simulacro de strncat/cadenas_simulacro de strncat.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strncat/functions.c b/cadenas_simulacro de strncat/functions.c new file mode 100644 index 0000000..0f65db2 --- /dev/null +++ b/cadenas_simulacro de strncat/functions.c @@ -0,0 +1,16 @@ +#include "header.h" +char* str_ncat(char *destino,const char *origen,size_t cant) + { + char *s=destino; + while(*destino) + destino++; + while(*origen&&cant--) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } + diff --git a/cadenas_simulacro de strncat/header.h b/cadenas_simulacro de strncat/header.h new file mode 100644 index 0000000..40c61ba --- /dev/null +++ b/cadenas_simulacro de strncat/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +char *str_ncat(char*,const char*,size_t); diff --git a/cadenas_simulacro de strncat/main.c b/cadenas_simulacro de strncat/main.c new file mode 100644 index 0000000..db93389 --- /dev/null +++ b/cadenas_simulacro de strncat/main.c @@ -0,0 +1,20 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + size_t x; + char cadena1[30]; + char cadena2[30]; + printf("\n\n CONCATENAR N CARACTERES DE UNA CADENA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de caracteres que desea copiar: \n\n\t"); + scanf("%d",&x); + printf("\n\n Cadenas concatenadas: %s \n\n",str_ncat(cadena1,cadena2,x)); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strncat/obj/Debug/functions.o b/cadenas_simulacro de strncat/obj/Debug/functions.o new file mode 100644 index 0000000..ffe7737 Binary files /dev/null and b/cadenas_simulacro de strncat/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strncat/obj/Debug/main.o b/cadenas_simulacro de strncat/obj/Debug/main.o new file mode 100644 index 0000000..de7c396 Binary files /dev/null and b/cadenas_simulacro de strncat/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strncmp/bin/Debug/cadenas_simulacro de strncmp.exe b/cadenas_simulacro de strncmp/bin/Debug/cadenas_simulacro de strncmp.exe new file mode 100644 index 0000000..6cdab27 Binary files /dev/null and b/cadenas_simulacro de strncmp/bin/Debug/cadenas_simulacro de strncmp.exe differ diff --git a/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.cbp b/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.cbp new file mode 100644 index 0000000..839aa1d --- /dev/null +++ b/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.depend b/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.depend new file mode 100644 index 0000000..5ece974 --- /dev/null +++ b/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473283415 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncmp\functions.c + "header.h" + +1473283351 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncmp\header.h + + + + +1473283182 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncmp\main.c + "header.h" + diff --git a/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.layout b/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.layout new file mode 100644 index 0000000..003cd25 --- /dev/null +++ b/cadenas_simulacro de strncmp/cadenas_simulacro de strncmp.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strncmp/functions.c b/cadenas_simulacro de strncmp/functions.c new file mode 100644 index 0000000..62e6ccb --- /dev/null +++ b/cadenas_simulacro de strncmp/functions.c @@ -0,0 +1,11 @@ +#include "header.h" +int str_ncmp(const char *s1,const char *s2,size_t cant) + { + while(*s1==*s2&&*s1&&*s2&&--cant) + { + s1++; + s2++; + } + return *s1-*s2; + } + diff --git a/cadenas_simulacro de strncmp/header.h b/cadenas_simulacro de strncmp/header.h new file mode 100644 index 0000000..9898960 --- /dev/null +++ b/cadenas_simulacro de strncmp/header.h @@ -0,0 +1,5 @@ +#include +#include +#include +int str_ncmp(const char*,const char*,size_t); + diff --git a/cadenas_simulacro de strncmp/main.c b/cadenas_simulacro de strncmp/main.c new file mode 100644 index 0000000..641d9f4 --- /dev/null +++ b/cadenas_simulacro de strncmp/main.c @@ -0,0 +1,26 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + size_t x; + char cadena1[30]; + char cadena2[30]; + printf("\n\n COMPARAR CADENAS HASTA N CARACTERES \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de caracteres que desea comparar: \n\n\t"); + scanf("%d",&x); + if(str_ncmp(cadena1,cadena2,x)>0) + printf("\n La primera cadena es mayor a la segunda \n\n"); + else + if(str_ncmp(cadena1,cadena2,x)<0) + printf("\n La primera cadena es menor a la segunda \n\n"); + else + printf("\n Las cadenas son iguales \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strncmp/obj/Debug/functions.o b/cadenas_simulacro de strncmp/obj/Debug/functions.o new file mode 100644 index 0000000..78a6275 Binary files /dev/null and b/cadenas_simulacro de strncmp/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strncmp/obj/Debug/main.o b/cadenas_simulacro de strncmp/obj/Debug/main.o new file mode 100644 index 0000000..f767199 Binary files /dev/null and b/cadenas_simulacro de strncmp/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strncpy/bin/Debug/cadenas_simulacro de strncpy.exe b/cadenas_simulacro de strncpy/bin/Debug/cadenas_simulacro de strncpy.exe new file mode 100644 index 0000000..0b826b2 Binary files /dev/null and b/cadenas_simulacro de strncpy/bin/Debug/cadenas_simulacro de strncpy.exe differ diff --git a/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.cbp b/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.cbp new file mode 100644 index 0000000..9775fd7 --- /dev/null +++ b/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.depend b/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.depend new file mode 100644 index 0000000..b4666b0 --- /dev/null +++ b/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473279966 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncpy\main.c + "header.h" + +1473279631 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncpy\header.h + + + + +1473280091 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strncpy\functions.c + "header.h" + diff --git a/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.layout b/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.layout new file mode 100644 index 0000000..1554560 --- /dev/null +++ b/cadenas_simulacro de strncpy/cadenas_simulacro de strncpy.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strncpy/functions.c b/cadenas_simulacro de strncpy/functions.c new file mode 100644 index 0000000..3f2511f --- /dev/null +++ b/cadenas_simulacro de strncpy/functions.c @@ -0,0 +1,16 @@ +#include "header.h" +char *str_ncpy(char *destino,const char *origen,size_t cant) + { + char *s=destino; + while(*origen&&cant) + { + *destino=*origen; + destino++; + origen++; + cant--; + } + while(cant--) + *destino++='\0'; + *destino='\0'; + return s; + } diff --git a/cadenas_simulacro de strncpy/header.h b/cadenas_simulacro de strncpy/header.h new file mode 100644 index 0000000..53aa903 --- /dev/null +++ b/cadenas_simulacro de strncpy/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +char *str_ncpy(char*,const char*,size_t); diff --git a/cadenas_simulacro de strncpy/main.c b/cadenas_simulacro de strncpy/main.c new file mode 100644 index 0000000..128602a --- /dev/null +++ b/cadenas_simulacro de strncpy/main.c @@ -0,0 +1,22 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + size_t x; + char cadena1[30]; + char cadena2[30]; + printf("\n\n COPIAR N CARACTERES DE UNA CADENA A OTRA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n Ingrese la cantidad de caracteres que desea copiar \n desde la cadena 2 hacia la cadena 1: \n\n\t"); + scanf("%d",&x); + str_ncpy(cadena1,cadena2,x); + printf("\n Las cadenas fueron copiadas \n"); + printf("\n Cadena 1: \t %s \n Cadena 2: \t %s \n\n",cadena1,cadena2); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strncpy/obj/Debug/functions.o b/cadenas_simulacro de strncpy/obj/Debug/functions.o new file mode 100644 index 0000000..682ebc5 Binary files /dev/null and b/cadenas_simulacro de strncpy/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strncpy/obj/Debug/main.o b/cadenas_simulacro de strncpy/obj/Debug/main.o new file mode 100644 index 0000000..49b98c5 Binary files /dev/null and b/cadenas_simulacro de strncpy/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strpbrk/bin/Debug/cadenas_simulacro de strpbrk.exe b/cadenas_simulacro de strpbrk/bin/Debug/cadenas_simulacro de strpbrk.exe new file mode 100644 index 0000000..816a103 Binary files /dev/null and b/cadenas_simulacro de strpbrk/bin/Debug/cadenas_simulacro de strpbrk.exe differ diff --git a/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.cbp b/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.cbp new file mode 100644 index 0000000..d8af866 --- /dev/null +++ b/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.depend b/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.depend new file mode 100644 index 0000000..c64ee70 --- /dev/null +++ b/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.depend @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1473292805 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strpbrk\main.c + "header.h" + +1473292749 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strpbrk\header.h + + + + diff --git a/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.layout b/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.layout new file mode 100644 index 0000000..08c0ba3 --- /dev/null +++ b/cadenas_simulacro de strpbrk/cadenas_simulacro de strpbrk.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strpbrk/functions.c b/cadenas_simulacro de strpbrk/functions.c new file mode 100644 index 0000000..0fdebb0 --- /dev/null +++ b/cadenas_simulacro de strpbrk/functions.c @@ -0,0 +1,13 @@ +#include "header.h" +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } +char* str_pbrk(const char *s1,const char *s2) + { + while(*s1&&!str_chr(s2,*s1)) + s1++; + return (*s1)?(char*)s1:NULL; + } diff --git a/cadenas_simulacro de strpbrk/header.h b/cadenas_simulacro de strpbrk/header.h new file mode 100644 index 0000000..fceb5d6 --- /dev/null +++ b/cadenas_simulacro de strpbrk/header.h @@ -0,0 +1,5 @@ +#include +#include +#include +char *str_chr(char*,int); +char *str_pbrk(const char*,const char*); diff --git a/cadenas_simulacro de strpbrk/main.c b/cadenas_simulacro de strpbrk/main.c new file mode 100644 index 0000000..1cf7dc8 --- /dev/null +++ b/cadenas_simulacro de strpbrk/main.c @@ -0,0 +1,20 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n PRIMERA OCURRENCIA DE CUALQUIER CARACTER \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + if(str_pbrk(cadena1,cadena2)!=NULL) + printf("\n Primera cadena a partir de la primera ocurrencia \n de un caracter de la segunda cadena: \n\n\t %s \n\n",str_pbrk(cadena1,cadena2)); + else + printf("\n No se ha encontrado la ocurrencia de ningún caracter \n de la segunda cadena \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strpbrk/obj/Debug/functions.o b/cadenas_simulacro de strpbrk/obj/Debug/functions.o new file mode 100644 index 0000000..b4f4aed Binary files /dev/null and b/cadenas_simulacro de strpbrk/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strpbrk/obj/Debug/main.o b/cadenas_simulacro de strpbrk/obj/Debug/main.o new file mode 100644 index 0000000..7a10ba4 Binary files /dev/null and b/cadenas_simulacro de strpbrk/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strrchr/bin/Debug/cadenas_simulacro de strrchr.exe b/cadenas_simulacro de strrchr/bin/Debug/cadenas_simulacro de strrchr.exe new file mode 100644 index 0000000..4f268c8 Binary files /dev/null and b/cadenas_simulacro de strrchr/bin/Debug/cadenas_simulacro de strrchr.exe differ diff --git a/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.cbp b/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.cbp new file mode 100644 index 0000000..7dea985 --- /dev/null +++ b/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.depend b/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.depend new file mode 100644 index 0000000..d8045e3 --- /dev/null +++ b/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473287562 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strrchr\functions.c + "header.h" + +1473287021 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strrchr\header.h + + + + +1473287393 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strrchr\main.c + "header.h" + diff --git a/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.layout b/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.layout new file mode 100644 index 0000000..81b1038 --- /dev/null +++ b/cadenas_simulacro de strrchr/cadenas_simulacro de strrchr.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strrchr/functions.c b/cadenas_simulacro de strrchr/functions.c new file mode 100644 index 0000000..3d0649d --- /dev/null +++ b/cadenas_simulacro de strrchr/functions.c @@ -0,0 +1,10 @@ +#include "header.h" +char *str_rchr(char *s,int c) + { + char *inicio=s; + while(*s) + s++; + while(s>inicio&&*s!=c) + s--; + return (*s==c)?s:NULL; + } diff --git a/cadenas_simulacro de strrchr/header.h b/cadenas_simulacro de strrchr/header.h new file mode 100644 index 0000000..d55600f --- /dev/null +++ b/cadenas_simulacro de strrchr/header.h @@ -0,0 +1,5 @@ +#include +#include +#include + +char *str_rchr(char*,int); diff --git a/cadenas_simulacro de strrchr/main.c b/cadenas_simulacro de strrchr/main.c new file mode 100644 index 0000000..08cd218 --- /dev/null +++ b/cadenas_simulacro de strrchr/main.c @@ -0,0 +1,20 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char car; + printf("\n\n ÚLTIMA OCURRENCIA DE UN CARACTER \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese un caracter para buscar su primera ocurrencia: \n\n\t"); + fflush(stdin); + scanf("%c",&car); + if(str_rchr(cadena1,car)!=NULL) + printf("\n Cadena a partir de la última ocurrencia de %c: \n\n\t %s \n\n",car,strrchr(cadena1,car)); + else + printf("\n No se ha encontrado la ocurrencia del caracter %c \n\n",car); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strrchr/obj/Debug/functions.o b/cadenas_simulacro de strrchr/obj/Debug/functions.o new file mode 100644 index 0000000..5c25702 Binary files /dev/null and b/cadenas_simulacro de strrchr/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strrchr/obj/Debug/main.o b/cadenas_simulacro de strrchr/obj/Debug/main.o new file mode 100644 index 0000000..cd546ef Binary files /dev/null and b/cadenas_simulacro de strrchr/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strspn/bin/Debug/cadenas_simulacro de strspn.exe b/cadenas_simulacro de strspn/bin/Debug/cadenas_simulacro de strspn.exe new file mode 100644 index 0000000..3251826 Binary files /dev/null and b/cadenas_simulacro de strspn/bin/Debug/cadenas_simulacro de strspn.exe differ diff --git a/cadenas_simulacro de strspn/cadenas_simulacro de strspn.cbp b/cadenas_simulacro de strspn/cadenas_simulacro de strspn.cbp new file mode 100644 index 0000000..8d0e236 --- /dev/null +++ b/cadenas_simulacro de strspn/cadenas_simulacro de strspn.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strspn/cadenas_simulacro de strspn.depend b/cadenas_simulacro de strspn/cadenas_simulacro de strspn.depend new file mode 100644 index 0000000..01bf3dc --- /dev/null +++ b/cadenas_simulacro de strspn/cadenas_simulacro de strspn.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473289556 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strspn\functions.c + "header.h" + +1473289378 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strspn\header.h + + + + +1473289876 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strspn\main.c + "header.h" + diff --git a/cadenas_simulacro de strspn/cadenas_simulacro de strspn.layout b/cadenas_simulacro de strspn/cadenas_simulacro de strspn.layout new file mode 100644 index 0000000..374caa6 --- /dev/null +++ b/cadenas_simulacro de strspn/cadenas_simulacro de strspn.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strspn/functions.c b/cadenas_simulacro de strspn/functions.c new file mode 100644 index 0000000..6417c66 --- /dev/null +++ b/cadenas_simulacro de strspn/functions.c @@ -0,0 +1,17 @@ +#include "header.h" +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } +size_t str_spn(const char *s1,const char *s2) + { + size_t cant=0; + while(*s1&&str_chr(s2,*s1)) + { + cant++; + s1++; + } + return cant; + } diff --git a/cadenas_simulacro de strspn/header.h b/cadenas_simulacro de strspn/header.h new file mode 100644 index 0000000..ddc11ac --- /dev/null +++ b/cadenas_simulacro de strspn/header.h @@ -0,0 +1,6 @@ +#include +#include +#include + +char *str_chr(char*,int); +size_t str_spn(const char*,const char*); diff --git a/cadenas_simulacro de strspn/main.c b/cadenas_simulacro de strspn/main.c new file mode 100644 index 0000000..70c1157 --- /dev/null +++ b/cadenas_simulacro de strspn/main.c @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { +setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n CANTIDAD DE CARACTERES DE UNA CADENA QUE NO PERTENECEN A LA OTRA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + printf("\n\n La cantidad de caracteres de la primera cadena en que no está \n algún caracter de la segunda cadena es de %d \n\n",str_spn(cadena1,cadena2)); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strspn/obj/Debug/functions.o b/cadenas_simulacro de strspn/obj/Debug/functions.o new file mode 100644 index 0000000..1d0747a Binary files /dev/null and b/cadenas_simulacro de strspn/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strspn/obj/Debug/main.o b/cadenas_simulacro de strspn/obj/Debug/main.o new file mode 100644 index 0000000..a0c363b Binary files /dev/null and b/cadenas_simulacro de strspn/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strstr/bin/Debug/cadenas_simulacro de strstr.exe b/cadenas_simulacro de strstr/bin/Debug/cadenas_simulacro de strstr.exe new file mode 100644 index 0000000..86cdcc6 Binary files /dev/null and b/cadenas_simulacro de strstr/bin/Debug/cadenas_simulacro de strstr.exe differ diff --git a/cadenas_simulacro de strstr/cadenas_simulacro de strstr.cbp b/cadenas_simulacro de strstr/cadenas_simulacro de strstr.cbp new file mode 100644 index 0000000..f6ab688 --- /dev/null +++ b/cadenas_simulacro de strstr/cadenas_simulacro de strstr.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strstr/cadenas_simulacro de strstr.depend b/cadenas_simulacro de strstr/cadenas_simulacro de strstr.depend new file mode 100644 index 0000000..305199b --- /dev/null +++ b/cadenas_simulacro de strstr/cadenas_simulacro de strstr.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473288349 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strstr\functions.c + "header.h" + +1473288231 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strstr\header.h + + + + +1473288483 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strstr\main.c + "header.h" + diff --git a/cadenas_simulacro de strstr/cadenas_simulacro de strstr.layout b/cadenas_simulacro de strstr/cadenas_simulacro de strstr.layout new file mode 100644 index 0000000..edf56b8 --- /dev/null +++ b/cadenas_simulacro de strstr/cadenas_simulacro de strstr.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strstr/functions.c b/cadenas_simulacro de strstr/functions.c new file mode 100644 index 0000000..ef1b248 --- /dev/null +++ b/cadenas_simulacro de strstr/functions.c @@ -0,0 +1,27 @@ +#include "header.h" +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } +int str_ncmp(const char *s1,const char *s2,size_t cant) + { + while(*s1==*s2&&*s1&&*s2&&--cant) + { + s1++; + s2++; + } + return *s1-*s2; + } +char *str_str(const char *s1,const char *s2) + { + size_t tam=str_len(s2); + while(*s1&&str_ncmp(s1,s2,tam)) + s1++; + return (*s1)?s1:NULL; + } diff --git a/cadenas_simulacro de strstr/header.h b/cadenas_simulacro de strstr/header.h new file mode 100644 index 0000000..2a81f08 --- /dev/null +++ b/cadenas_simulacro de strstr/header.h @@ -0,0 +1,6 @@ +#include +#include +#include +size_t str_len(const char*); +int str_ncmp(const char*,const char*,size_t); +char *str_str(const char*,const char*); diff --git a/cadenas_simulacro de strstr/main.c b/cadenas_simulacro de strstr/main.c new file mode 100644 index 0000000..90c9b6a --- /dev/null +++ b/cadenas_simulacro de strstr/main.c @@ -0,0 +1,20 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + char cadena2[30]; + printf("\n\n PRIMERA OCURRENCIA DE UNA SUBCADENA EN UNA CADENA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + printf("\n Ingrese otra cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena2); + if(str_str(cadena1,cadena2)!=NULL) + printf("\n Primera cadena a partir de la primera ocurrencia \n de una subcadena en otra cadena: \n\n\t %s \n\n",str_str(cadena1,cadena2)); + else + printf("\n No se ha encontrado la ocurrencia de ningún caracter \n de la segunda cadena \n\n"); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strstr/obj/Debug/functions.o b/cadenas_simulacro de strstr/obj/Debug/functions.o new file mode 100644 index 0000000..9ed5bdb Binary files /dev/null and b/cadenas_simulacro de strstr/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strstr/obj/Debug/main.o b/cadenas_simulacro de strstr/obj/Debug/main.o new file mode 100644 index 0000000..b2cacb5 Binary files /dev/null and b/cadenas_simulacro de strstr/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strtok/bin/Debug/cadenas_simulacro de strtok.exe b/cadenas_simulacro de strtok/bin/Debug/cadenas_simulacro de strtok.exe new file mode 100644 index 0000000..b3a9f01 Binary files /dev/null and b/cadenas_simulacro de strtok/bin/Debug/cadenas_simulacro de strtok.exe differ diff --git a/cadenas_simulacro de strtok/cadenas_simulacro de strtok.cbp b/cadenas_simulacro de strtok/cadenas_simulacro de strtok.cbp new file mode 100644 index 0000000..3648f54 --- /dev/null +++ b/cadenas_simulacro de strtok/cadenas_simulacro de strtok.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cadenas_simulacro de strtok/cadenas_simulacro de strtok.depend b/cadenas_simulacro de strtok/cadenas_simulacro de strtok.depend new file mode 100644 index 0000000..46714b5 --- /dev/null +++ b/cadenas_simulacro de strtok/cadenas_simulacro de strtok.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473295359 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strtok\functions.c + "header.h" + +1473294345 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strtok\header.h + + + + +1473295251 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strtok\main.c + "header.h" + diff --git a/cadenas_simulacro de strtok/cadenas_simulacro de strtok.layout b/cadenas_simulacro de strtok/cadenas_simulacro de strtok.layout new file mode 100644 index 0000000..8d44321 --- /dev/null +++ b/cadenas_simulacro de strtok/cadenas_simulacro de strtok.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strtok/functions.c b/cadenas_simulacro de strtok/functions.c new file mode 100644 index 0000000..821f9e9 --- /dev/null +++ b/cadenas_simulacro de strtok/functions.c @@ -0,0 +1,22 @@ +#include "header.h" +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } +char *str_tok(char *s, const char *sep) + { + static char *sig; + char *aux; + if(s) + sig=s; + while(*sig&&str_chr(sep,*sig)) + sig++; + aux=sig; + while(*sig&&!strchr(sep,*sig)) + sig++; + if(*sig) + *sig++='\0'; + return (*aux)?aux:NULL; + } diff --git a/cadenas_simulacro de strtok/header.h b/cadenas_simulacro de strtok/header.h new file mode 100644 index 0000000..046718f --- /dev/null +++ b/cadenas_simulacro de strtok/header.h @@ -0,0 +1,6 @@ +#include +#include +#include + +char *str_chr(char*,int); +char *str_tok(char*,const char*); diff --git a/cadenas_simulacro de strtok/main.c b/cadenas_simulacro de strtok/main.c new file mode 100644 index 0000000..3105d9f --- /dev/null +++ b/cadenas_simulacro de strtok/main.c @@ -0,0 +1,18 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cad[100]; + char separador[4]=" \n\t"; + char *ptr; + printf("\n\n QUEBRAR UNA CADENA DE CARACTERES \n"); + printf("\n Ingrese una oración (menos de 100 caracteres): \n\n\t"); + gets(cad); + ptr=str_tok(cad,separador); // Primera llamada => Primer token + printf("\n\n Cadena quebrada: \n\n"); + printf("%s\n",ptr); + while((ptr=str_tok(NULL,separador))!=NULL ) // Posteriores llamadas + printf("%s\n",ptr); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strtok/obj/Debug/functions.o b/cadenas_simulacro de strtok/obj/Debug/functions.o new file mode 100644 index 0000000..70ff47d Binary files /dev/null and b/cadenas_simulacro de strtok/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strtok/obj/Debug/main.o b/cadenas_simulacro de strtok/obj/Debug/main.o new file mode 100644 index 0000000..71d4983 Binary files /dev/null and b/cadenas_simulacro de strtok/obj/Debug/main.o differ diff --git a/cadenas_simulacro de strupr/bin/Debug/cadenas_simulacro de strupr.exe b/cadenas_simulacro de strupr/bin/Debug/cadenas_simulacro de strupr.exe new file mode 100644 index 0000000..10ec7e0 Binary files /dev/null and b/cadenas_simulacro de strupr/bin/Debug/cadenas_simulacro de strupr.exe differ diff --git a/cadenas_simulacro de strupr/cadenas_simulacro de strupr.cbp b/cadenas_simulacro de strupr/cadenas_simulacro de strupr.cbp new file mode 100644 index 0000000..bcac1c3 --- /dev/null +++ b/cadenas_simulacro de strupr/cadenas_simulacro de strupr.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/cadenas_simulacro de strupr/cadenas_simulacro de strupr.depend b/cadenas_simulacro de strupr/cadenas_simulacro de strupr.depend new file mode 100644 index 0000000..e3b0ac5 --- /dev/null +++ b/cadenas_simulacro de strupr/cadenas_simulacro de strupr.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473290798 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strupr\functions.c + "header.h" + +1473290745 d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strupr\header.h + + + + +1473290804 source:d:\unlam\programaciÓn\fabian 2\cadenas_simulacro de strupr\main.c + "header.h" + diff --git a/cadenas_simulacro de strupr/cadenas_simulacro de strupr.layout b/cadenas_simulacro de strupr/cadenas_simulacro de strupr.layout new file mode 100644 index 0000000..960c4f7 --- /dev/null +++ b/cadenas_simulacro de strupr/cadenas_simulacro de strupr.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cadenas_simulacro de strupr/functions.c b/cadenas_simulacro de strupr/functions.c new file mode 100644 index 0000000..665aec3 --- /dev/null +++ b/cadenas_simulacro de strupr/functions.c @@ -0,0 +1,12 @@ +#include "header.h" +char *str_upr(char *s1) + { + char *s2=s1; + while(*s1) + { + *s1=A_MAYUSCULA(*s1); + s1++; + } + return s2; + } + diff --git a/cadenas_simulacro de strupr/header.h b/cadenas_simulacro de strupr/header.h new file mode 100644 index 0000000..1f5b9ef --- /dev/null +++ b/cadenas_simulacro de strupr/header.h @@ -0,0 +1,5 @@ +#include +#include +#include +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) +char *str_upr(char*); diff --git a/cadenas_simulacro de strupr/main.c b/cadenas_simulacro de strupr/main.c new file mode 100644 index 0000000..610bc9c --- /dev/null +++ b/cadenas_simulacro de strupr/main.c @@ -0,0 +1,14 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena1[30]; + printf("\n\n CADENA A MAYÚSCULA \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena1); + str_upr(cadena1); + printf("\n Cadena en mayúscula: \t %s \n\n",cadena1); + getch(); + return 0; + } diff --git a/cadenas_simulacro de strupr/obj/Debug/functions.o b/cadenas_simulacro de strupr/obj/Debug/functions.o new file mode 100644 index 0000000..44e3698 Binary files /dev/null and b/cadenas_simulacro de strupr/obj/Debug/functions.o differ diff --git a/cadenas_simulacro de strupr/obj/Debug/main.o b/cadenas_simulacro de strupr/obj/Debug/main.o new file mode 100644 index 0000000..a6d37d3 Binary files /dev/null and b/cadenas_simulacro de strupr/obj/Debug/main.o differ diff --git a/calculadora de operandos binarios/bin/Debug/calculadora de operandos binarios.exe b/calculadora de operandos binarios/bin/Debug/calculadora de operandos binarios.exe new file mode 100644 index 0000000..85495e6 Binary files /dev/null and b/calculadora de operandos binarios/bin/Debug/calculadora de operandos binarios.exe differ diff --git a/calculadora de operandos binarios/calculadora de operandos binarios.cbp b/calculadora de operandos binarios/calculadora de operandos binarios.cbp new file mode 100644 index 0000000..3968043 --- /dev/null +++ b/calculadora de operandos binarios/calculadora de operandos binarios.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/calculadora de operandos binarios/calculadora de operandos binarios.depend b/calculadora de operandos binarios/calculadora de operandos binarios.depend new file mode 100644 index 0000000..722065b --- /dev/null +++ b/calculadora de operandos binarios/calculadora de operandos binarios.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1471475245 source:d:\unlam\programaciÓn\fabian 2da\calculadora de operandos binarios\funciones.c + "encabezados.h" + +1471474779 d:\unlam\programaciÓn\fabian 2da\calculadora de operandos binarios\encabezados.h + + + + + +1471474906 source:d:\unlam\programaciÓn\fabian 2da\calculadora de operandos binarios\main.c + "encabezados.h" + diff --git a/calculadora de operandos binarios/calculadora de operandos binarios.layout b/calculadora de operandos binarios/calculadora de operandos binarios.layout new file mode 100644 index 0000000..8f89a0e --- /dev/null +++ b/calculadora de operandos binarios/calculadora de operandos binarios.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/calculadora de operandos binarios/encabezados.h b/calculadora de operandos binarios/encabezados.h new file mode 100644 index 0000000..c68c473 --- /dev/null +++ b/calculadora de operandos binarios/encabezados.h @@ -0,0 +1,11 @@ +#include +#include +#include +#include +char menu(); +int validaopcion(char); +float ingresa_flotante(); +void sumar(); +void restar(); +void multiplicar(); +void dividir(); diff --git a/calculadora de operandos binarios/funciones.c b/calculadora de operandos binarios/funciones.c new file mode 100644 index 0000000..6242212 --- /dev/null +++ b/calculadora de operandos binarios/funciones.c @@ -0,0 +1,81 @@ +#include "encabezados.h" +char menu() + { + char op; + int band; + band=0;//bandera para saber si se ingresa un dato erróneo + printf("\n\n\t MENÚ \n\n"); + printf("\n %c Seleccione una de las siguientes opciones: \n",16); + printf("\n\t s: sumar"); + printf("\n\t r: restar"); + printf("\n\t m: multiplicar"); + printf("\n\t d: dividir"); + printf("\n\t q: salir"); + do + { + if(band==1)//enciendo bandera si ya se ha ingresado una opción + printf("\n La opción ingresada es inválida. \n\t\t Ingrese una nueva opción:"); + printf("\n\t\t\t Opción: \t\t"); + fflush(stdin); + scanf("%c",&op); + op=tolower(op);//para no tener problemas con las mayúsculas + band=1;//ya hubo ingreso + } + while(!validaopcion(op)); + return op; + } +int validaopcion(char op) + { + if(op=='s'||op=='r'||op=='m'||op=='d'||op=='q') + return 1; + else + return 0; + } +float ingresa_flotante() + { + float x; + printf("\n Ingrese número flotante: \t\t"); + scanf("%f",&x); + return x; + } +void sumar() + { + float num1,num2,y; + num1=ingresa_flotante(); + num2=ingresa_flotante(); + y=num1+num2; + printf("\n\n La suma es: \t %.2f \n",y); + } +void restar() + { + float num1,num2,y; + num1=ingresa_flotante(); + num2=ingresa_flotante(); + y=num1-num2; + printf("\n\n La resta es: \t %.2f \n",y); + } +void multiplicar() + { + float num1,num2,y; + num1=ingresa_flotante(); + num2=ingresa_flotante(); + y=num1*num2; + printf("\n\n La multiplicación es: \t %.2f \n",y); + } +void dividir() + { + float num1,num2,y; + int band; + band=0; + num1=ingresa_flotante(); + do + { + if(band==1) + printf("\n No se puede dividir por cero. Reelija una opción: \t"); + num2=ingresa_flotante(); + band=1; + } + while(num2==0); + y=num1/num2; + printf("\n\n La división es: \t %.2f \n",y); + } diff --git a/calculadora de operandos binarios/main.c b/calculadora de operandos binarios/main.c new file mode 100644 index 0000000..c555e87 --- /dev/null +++ b/calculadora de operandos binarios/main.c @@ -0,0 +1,28 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char op; + printf("\n\t\t *************************************"); + printf("\n\t\t * CALCULADORA DE OPERANDOS BINARIOS *"); + printf("\n\t\t *************************************"); + op=menu(); + while(op!='q') + { + switch(op) + { + case 's':sumar(); + break; + case 'r':restar(); + break; + case 'm':multiplicar(); + break; + case 'd':dividir(); + break; + } + op=menu(); + } + printf("\n\n\n\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/calculadora de operandos binarios/obj/Debug/funciones.o b/calculadora de operandos binarios/obj/Debug/funciones.o new file mode 100644 index 0000000..513d462 Binary files /dev/null and b/calculadora de operandos binarios/obj/Debug/funciones.o differ diff --git a/calculadora de operandos binarios/obj/Debug/main.o b/calculadora de operandos binarios/obj/Debug/main.o new file mode 100644 index 0000000..f93daa5 Binary files /dev/null and b/calculadora de operandos binarios/obj/Debug/main.o differ diff --git a/calificaciones de los alumnos/bin/Debug/calificaciones de los alumnos.exe b/calificaciones de los alumnos/bin/Debug/calificaciones de los alumnos.exe new file mode 100644 index 0000000..6fd1b6b Binary files /dev/null and b/calificaciones de los alumnos/bin/Debug/calificaciones de los alumnos.exe differ diff --git a/calificaciones de los alumnos/calificaciones de los alumnos.cbp b/calificaciones de los alumnos/calificaciones de los alumnos.cbp new file mode 100644 index 0000000..ce583ad --- /dev/null +++ b/calificaciones de los alumnos/calificaciones de los alumnos.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/calificaciones de los alumnos/calificaciones de los alumnos.depend b/calificaciones de los alumnos/calificaciones de los alumnos.depend new file mode 100644 index 0000000..29487cf --- /dev/null +++ b/calificaciones de los alumnos/calificaciones de los alumnos.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474154896 source:d:\unlam\programaciÓn\fabian 2\calificaciones de los alumnos\main.c + "header.h" + +1474155839 d:\unlam\programaciÓn\fabian 2\calificaciones de los alumnos\header.h + + + + + +1474157843 source:d:\unlam\programaciÓn\fabian 2\calificaciones de los alumnos\functions.c + "header.h" + diff --git a/calificaciones de los alumnos/calificaciones de los alumnos.layout b/calificaciones de los alumnos/calificaciones de los alumnos.layout new file mode 100644 index 0000000..acf92fc --- /dev/null +++ b/calificaciones de los alumnos/calificaciones de los alumnos.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/calificaciones de los alumnos/calificaciones de los alumnos.txt b/calificaciones de los alumnos/calificaciones de los alumnos.txt new file mode 100644 index 0000000..72953a3 --- /dev/null +++ b/calificaciones de los alumnos/calificaciones de los alumnos.txt @@ -0,0 +1,15 @@ +12 12345678901234567890123456789012345 12345 12345 12345 12345 12345 12345 12345 + Apellido/s, Nombre/s P. 1 P. 2 P. 3 P. 4 P. 5 P. 6 - Prome + =================================== ===== ===== ===== ===== ===== ===== ===== + + 1 Sa, Lia 5.50 6.00 7.50 10.00 8.00 4.40 - 6.90 + 2 Sarmiento, Domingo Faustino 10.00 10.00 10.00 10.00 10.00 10.00 - 10.00 + 3 Martinez Del Campo, Maria de los An 6.00 8.00 7.50 8.00 8.50 5.00 - 7.17 + + PROMEDIOS POR EVALUACIÓN Y PROMEDIO GENERAL DEL CURSO + ===================================================== + + P. 1 P. 2 P. 3 P. 4 P. 5 P. 6 - Gral. + ===== ===== ===== ===== ===== ===== ===== + + 7.17 8.00 8.33 9.33 8.83 6.47 - 8.02 diff --git a/calificaciones de los alumnos/functions.c b/calificaciones de los alumnos/functions.c new file mode 100644 index 0000000..fea21e8 --- /dev/null +++ b/calificaciones de los alumnos/functions.c @@ -0,0 +1,160 @@ +#include "header.h" + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +char *str_ncpy(char *destino,const char *origen,size_t cant) + { + char *s=destino; + while(*origen&&cant) + { + *destino=*origen; + destino++; + origen++; + cant--; + } + while(cant--) + *destino++='\0'; + *destino='\0'; + return s; + } + +int cargar_matrices_de_datos(char mat_apyn[][TOPE],int reg,int tope,float mat_notas[][COL],int fil,int col) + { + int bandera,op,j,i=0; + char cadena[tope]; + do + { + printf("\n\n REGISTRO %d \n",i+1); + + printf("\n\n Ingrese apellido/s y nombre/s del alumno \n (en formato \"Apellido1 Apellido 2 ... etc, Nombre1 Nombre 2 ... etc\") \n (cuenta con %d caracteres): \n\n\t",tope-1); + bandera=0; + do + { + if(bandera==1) + printf("\n\n El campo solicitado está vacío. Reingréselo: \n\n\t\a\a"); + fflush(stdin); + gets(cadena); + bandera=1; + } + while(str_len(cadena)==0); + str_ncpy((char*)&mat_apyn[i],cadena,tope-1); + + for(j=0;j +#include +#include +#include + +#define REG 99 +#define TOPE 36 +#define FIL 100 +#define COL 7 + +#define VERDADERO 1 +#define FALSO 0 + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +size_t str_len(const char*); +char *str_ncpy(char*,const char*,size_t); +int cargar_matrices_de_datos(char[][TOPE],int,int,float[][COL],int,int); +void mostrar_matrices_de_datos(char[][TOPE],int,int,float[][COL],int,int,int); +void promedios_de_alumnos(float[][COL],int,int,int); +void calcular_promedio_de_alumno(float[],int,int); +void promedios_por_evaluacion_y_general(float[][COL],int,int,int); +int exportar_a_archivo_de_texto(char[][TOPE],int,int,float[][COL],int,int,int); diff --git a/calificaciones de los alumnos/main.c b/calificaciones de los alumnos/main.c new file mode 100644 index 0000000..636709e --- /dev/null +++ b/calificaciones de los alumnos/main.c @@ -0,0 +1,45 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 17"); + + char mat_apyn[REG][TOPE]; + float mat_notas[FIL][COL]; + int cant_reg; + + printf("\n\t\t *********************************"); + printf("\n\t\t * CALIFICACIONES DE LOS ALUMNOS *"); + printf("\n\t\t *********************************"); + + printf("\n\n\a\a En este programa, usted podrá ingresar los datos de sus alumnos,"); + printf("\n apellido/s, nombre/s y calificaciones obtenidas en cada una de las"); + printf("\n 6 evaluaciones que se han tomado, pudiendo finalmente calcular:"); + printf("\n los promedios por alumno, por evaluación y general del curso."); + printf("\n\n Al finalizar se exportarán los datos a un archivo de texto \n"); + getch(); + + printf("\n\n CARGA DE LOS REGISTROS \n\n"); + cant_reg=cargar_matrices_de_datos(mat_apyn,REG,TOPE,mat_notas,FIL,COL); + getch(); + + printf("\n\n\n MATRICES DE DATOS \n\n"); + mostrar_matrices_de_datos(mat_apyn,REG,TOPE,mat_notas,FIL,COL,cant_reg); + getch(); + + promedios_de_alumnos(mat_notas,FIL,COL,cant_reg); + promedios_por_evaluacion_y_general(mat_notas,FIL,COL,cant_reg); + printf("\n\n Se han calculado exitosamente los promedios por alumno, \n por evaluación y general del alumno \n"); + getch(); + + if(exportar_a_archivo_de_texto(mat_apyn,REG,TOPE,mat_notas,FIL,COL,cant_reg)) + printf("\n\n Se han exportado los registros exitosamente \n al archivo de texto \"calificaciones de los alumnos.txt\" \n\n"); + else + printf("\n\n No se han podido exportar los registros a un archivo de texto \n\n"); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git a/calificaciones de los alumnos/obj/Debug/functions.o b/calificaciones de los alumnos/obj/Debug/functions.o new file mode 100644 index 0000000..29c20a7 Binary files /dev/null and b/calificaciones de los alumnos/obj/Debug/functions.o differ diff --git a/calificaciones de los alumnos/obj/Debug/main.o b/calificaciones de los alumnos/obj/Debug/main.o new file mode 100644 index 0000000..d4975f4 Binary files /dev/null and b/calificaciones de los alumnos/obj/Debug/main.o differ diff --git a/cara o seca_lanzamiento de moneda/bin/Debug/cara o seca_lanzamiento de moneda.exe b/cara o seca_lanzamiento de moneda/bin/Debug/cara o seca_lanzamiento de moneda.exe new file mode 100644 index 0000000..b6470ce Binary files /dev/null and b/cara o seca_lanzamiento de moneda/bin/Debug/cara o seca_lanzamiento de moneda.exe differ diff --git a/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.cbp b/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.cbp new file mode 100644 index 0000000..09b4d7e --- /dev/null +++ b/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.depend b/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.depend new file mode 100644 index 0000000..72462bb --- /dev/null +++ b/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.depend @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1482793633 source:d:\unlam\programaciÓn\fabian\cara o seca_lanzamiento de moneda\main.c + + + + diff --git a/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.layout b/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.layout new file mode 100644 index 0000000..8774044 --- /dev/null +++ b/cara o seca_lanzamiento de moneda/cara o seca_lanzamiento de moneda.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/cara o seca_lanzamiento de moneda/main.c b/cara o seca_lanzamiento de moneda/main.c new file mode 100644 index 0000000..b20c3c8 --- /dev/null +++ b/cara o seca_lanzamiento de moneda/main.c @@ -0,0 +1,27 @@ +#include +#include +#include + +int main() +{ + int i,caras,secas; + caras=secas=0; + + enum estados{CARA,SECA}; + + printf("\n\n CARA O SECA \n"); + + printf("\n Se arroja una moneda 100 veces y los resultados son: \n"); + + srand(time(NULL)); + for(i=0;i<100;i++) + { + if(rand()%2==CARA) + caras++; + else + secas++; + } + + printf("\n CARAS: %d \t SECAS: %d \n",caras,secas); + return 0; +} diff --git a/cara o seca_lanzamiento de moneda/obj/Debug/main.o b/cara o seca_lanzamiento de moneda/obj/Debug/main.o new file mode 100644 index 0000000..349dddf Binary files /dev/null and b/cara o seca_lanzamiento de moneda/obj/Debug/main.o differ diff --git "a/cargar vector a partir de primera posici\303\263n libre/bin/Debug/cargar vector a partir de primera posici\303\263n libre.exe" "b/cargar vector a partir de primera posici\303\263n libre/bin/Debug/cargar vector a partir de primera posici\303\263n libre.exe" new file mode 100644 index 0000000..c77acb6 Binary files /dev/null and "b/cargar vector a partir de primera posici\303\263n libre/bin/Debug/cargar vector a partir de primera posici\303\263n libre.exe" differ diff --git "a/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.cbp" "b/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.cbp" new file mode 100644 index 0000000..1275cdb --- /dev/null +++ "b/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.depend" "b/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.depend" new file mode 100644 index 0000000..a4dc165 --- /dev/null +++ "b/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472188485 source:d:\unlam\programaciÓn\fabian 2da\cargar vector a partir de primera posición libre\functions.c + "header.h" + +1472187771 d:\unlam\programaciÓn\fabian 2da\cargar vector a partir de primera posición libre\header.h + + + + +1472187810 source:d:\unlam\programaciÓn\fabian 2da\cargar vector a partir de primera posición libre\main.c + "header.h" + diff --git "a/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.layout" "b/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.layout" new file mode 100644 index 0000000..dc04325 --- /dev/null +++ "b/cargar vector a partir de primera posici\303\263n libre/cargar vector a partir de primera posici\303\263n libre.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/cargar vector a partir de primera posici\303\263n libre/functions.c" "b/cargar vector a partir de primera posici\303\263n libre/functions.c" new file mode 100644 index 0000000..be58f47 --- /dev/null +++ "b/cargar vector a partir de primera posici\303\263n libre/functions.c" @@ -0,0 +1,70 @@ +#include "header.h" +int valida_dato(int x,int li,int ls) + { + return (x>=li&&x<=ls)?1:0; + } +int menu(void) + { + int i,op,band=0; + printf("\n\n\t\t --->>> MENÚ \n"); + printf("\n\t 1- Cargar vector"); + printf("\n\t 2- Mostrar vector"); + printf("\n\t 3- Salir"); + printf("\n\t\t\t Opción: \t"); + do + { + if(band==1) + printf("\n\n La opción ingresada no es válida. Elija una de las opciones enumeradas: \n\n Opción: \t\t\t\t"); + scanf("%d",&op); + band=1; + } + while(!valida_dato(op,1,3)); + return op; + } +int cargar_vector(int *v,int tam,int ce) + { + int i,op,band=0; + v+=ce; + printf("\n Proceda a la carga del vector"); + printf("\n Usted cuenta con %d posiciones en total\n",tam); + for(i=ce;i +#include +#include +#define TOPE 1000 +int valida_dato(int,int,int); +int menu(void); +int cargar_vector(int*,int,int); +void mostrar_vector(int*,int,int); diff --git "a/cargar vector a partir de primera posici\303\263n libre/main.c" "b/cargar vector a partir de primera posici\303\263n libre/main.c" new file mode 100644 index 0000000..286b048 --- /dev/null +++ "b/cargar vector a partir de primera posici\303\263n libre/main.c" @@ -0,0 +1,22 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int op,v[TOPE],ce=0; + printf("\n\n CARGAR Y MOSTRAR VECTOR \n"); + op=menu(); + while(op!=3) + { + switch(op) + { + case 1: ce=cargar_vector(v,TOPE,ce); + break; + case 2: mostrar_vector(v,TOPE,ce); + break; + } + op=menu(); + } + printf("\n\n\t\t\t\t\t Fin del programa.. \a\a\n\n"); + getch(); + return 0; + } diff --git "a/cargar vector a partir de primera posici\303\263n libre/obj/Debug/functions.o" "b/cargar vector a partir de primera posici\303\263n libre/obj/Debug/functions.o" new file mode 100644 index 0000000..3d08ebe Binary files /dev/null and "b/cargar vector a partir de primera posici\303\263n libre/obj/Debug/functions.o" differ diff --git "a/cargar vector a partir de primera posici\303\263n libre/obj/Debug/main.o" "b/cargar vector a partir de primera posici\303\263n libre/obj/Debug/main.o" new file mode 100644 index 0000000..f8429dd Binary files /dev/null and "b/cargar vector a partir de primera posici\303\263n libre/obj/Debug/main.o" differ diff --git "a/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/bin/Debug/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).exe" "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/bin/Debug/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).exe" new file mode 100644 index 0000000..99ade4c Binary files /dev/null and "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/bin/Debug/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).exe" differ diff --git "a/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).cbp" "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).cbp" new file mode 100644 index 0000000..1752faa --- /dev/null +++ "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).depend" "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).depend" new file mode 100644 index 0000000..148f1b4 --- /dev/null +++ "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1471400681 source:d:\unlam\programaciÓn\fabian 2da cursada\clase 01 (modificadores de tipo, máscaras y juego con char)\main.c + + + + diff --git "a/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).layout" "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).layout" new file mode 100644 index 0000000..f31d75d --- /dev/null +++ "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/clase 01 (modificadores de tipo, m\303\241scaras y juego con char).layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/main.c" "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/main.c" new file mode 100644 index 0000000..5740490 --- /dev/null +++ "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/main.c" @@ -0,0 +1,50 @@ +#include +#include +#include +void main() + { + setlocale(LC_CTYPE,"Spanish"); + + //el espacio reservado para una variable de un determinado tipo depende de la arquitectura de la computadora + int x=2;//entero común + short int sx=4;//usa la mitad de espacio en memoria + long int lx=2;//usa el doble de espacio en memoria + unsigned int ux=8;//el rango del entero se traslada a partir del cero para que se aproveche para positivos + + printf("\n\n MODIFICADORES DE TIPO Y MÁSCARAS \n"); + //las mascaras se anteceden por porcentaje y son las que indican la interpretacion de cada uno de los datos + printf("\n Entero: %d \t Tamaño: %d \t Octal: %o \t Hexadecimal: %x",x,sizeof(x),x,x); + printf("\n Short: %d \t Tamaño: %d \t Octal: %o \t Hexadecimal: %x",sx,sizeof(sx),sx,sx); + printf("\n Long: %d \t Tamaño: %d \t Octal: %o \t Hexadecimal: %x",lx,sizeof(lx),lx,lx); + printf("\n Unsigned: %d \t Tamaño: %d \t Octal: %o \t Hexadecimal: %x",ux,sizeof(ux),ux,ux); + + char c1,c2,c3,c4; + //c1="a"; da warning porque no se puede guardar un string en un char---->>>>> reemplazo por la siguiente sentencia + //las comillas simples indica un caracter, y las dobles un string + c1='a';//caracter + c2='A';//caracter + c3='3';//caracter + c4=3;//número-------->>>> su ascii es un corazón + + printf("\n\n JUEGOS CON CHAR \n"); + //los ca¿har guardan números enteros------>>>>>>>>>>> entonces pueden ser manipulados matemáticamente + printf("\n Número \t\t Valor en Ascii \t\t Hexadecimal \n"); + printf("\n %d \t\t\t %c \t\t\t\t %x",c1,c1,c1); + printf("\n %d \t\t\t %c \t\t\t\t %x",c2,c2,c2); + printf("\n %d \t\t\t %c \t\t\t\t %x",c3,c3,c3); + printf("\n %d \t\t\t %c \t\t\t\t %x",c4,c4,c4); + + int r; + printf("\n\n Sumando dos char \n"); + r=c3+c4;//sumo dos char + printf("\n c3=%d \t c4=%d \t Suma: x=c3+c4=%d",c3,c4,r); + + int s; + printf("\n\n CONVERTIR CARACTER A NÚMERO \n"); + //s=c3-48; se debe restar 48 porque en el 48 comienzan a almacenarse los números + s=c3-'0';// para no recordar el número 48, lo que se hace es restar el número ascii en que se almacena el cero-->>>>> ojo! no es el caracter nulo + printf("\n c3=%d \t Convertido a: %d",c3,s); + + printf("\n\n"); + getch(); + } diff --git "a/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/obj/Debug/main.o" "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/obj/Debug/main.o" new file mode 100644 index 0000000..ebeef45 Binary files /dev/null and "b/clase 01 (modificadores de tipo, m\303\241scaras y juego con char)/obj/Debug/main.o" differ diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/bin/Debug/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).exe" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/bin/Debug/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).exe" new file mode 100644 index 0000000..c1c0d45 Binary files /dev/null and "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/bin/Debug/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).exe" differ diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/bin/Debug/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario.exe" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/bin/Debug/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario.exe" new file mode 100644 index 0000000..c8a72ae Binary files /dev/null and "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/bin/Debug/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario.exe" differ diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).cbp" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).cbp" new file mode 100644 index 0000000..6e60771 --- /dev/null +++ "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).depend" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).depend" new file mode 100644 index 0000000..1cd86cb --- /dev/null +++ "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1471731128 source:d:\unlam\programaciÓn\fabian 2da\clase 02 (conversión automática de tipo, casteo, pre y pos incremento, y operador ternario)\main.c + + + + diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).layout" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).layout" new file mode 100644 index 0000000..1dd431f --- /dev/null +++ "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario).layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/main.c" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/main.c" new file mode 100644 index 0000000..d914e99 --- /dev/null +++ "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/main.c" @@ -0,0 +1,37 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x=5,y=2,r; + float z; + //la división entre dos números enteros siempre da un número entero + //realizando esta división queda + r=x/y;//2 + z=x/y;//2.00 + printf("\n división de enteros: r=%d \t z=%.2f \n",r,z); + z=(float)x/y;//realizando este casteo sí va a quedar almacenado 2.5 porque se está convirtiendo el tipo + printf("\n con casteo: \t z=%.2f \n",z); + //------------------------------------------------------------------------------------------------------ + x=2.5; + printf("\n conversión automática de tipo:\t x=%d",x);// conversión automática de tipo-------->>>>>2 + printf("\n visualización con máscara: \t x=%f",x);//------->>>>2.5 esto quiere decir que en algún lado en memoria quedaron almacenados los decimales + //------------------------------------------------------------------------------------------------------ + x=5; + y=5; + int r1,r2; + r1=++x;//preincremento: primero incrementa, luego asigna + r2=y++;//posincremento: primero asigna y luego incrementa + printf("\n\n preincremento y posincremento"); + printf("\n esto queda almacenado: x=%d \t y=%d \t r1=%d \t r2=%d \n",x,y,r1,r2);; + //------------------------------------------------------------------------------------------------------- + x=5; + y=3; + printf("\n operador ternario");//puede meterse dentro de cualquier instrucción + //x>y?printf("\n x>y"):printf("\n xy?x:y);//me ahorro una impresión en oantalla + getch(); + return 0; + } diff --git "a/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/obj/Debug/main.o" "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/obj/Debug/main.o" new file mode 100644 index 0000000..8a368cd Binary files /dev/null and "b/clase 02 (conversi\303\263n autom\303\241tica de tipo, casteo, pre y pos incremento, y operador ternario)/obj/Debug/main.o" differ diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/bin/Debug/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).exe" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/bin/Debug/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).exe" new file mode 100644 index 0000000..82bf6eb Binary files /dev/null and "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/bin/Debug/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).exe" differ diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).cbp" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).cbp" new file mode 100644 index 0000000..1ac5ebb --- /dev/null +++ "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).depend" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).depend" new file mode 100644 index 0000000..6090666 --- /dev/null +++ "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471731926 source:d:\unlam\programaciÓn\fabian 2da\clase 02 (estructuras, campos, uso del typedef y como parámetro de funciones)\funciones.c + "header.h" + +1471732568 d:\unlam\programaciÓn\fabian 2da\clase 02 (estructuras, campos, uso del typedef y como parámetro de funciones)\header.h + + + + +1471732774 source:d:\unlam\programaciÓn\fabian 2da\clase 02 (estructuras, campos, uso del typedef y como parámetro de funciones)\main.c + "header.h" + diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).layout" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).layout" new file mode 100644 index 0000000..424af6a --- /dev/null +++ "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones).layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/funciones.c" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/funciones.c" new file mode 100644 index 0000000..caaf050 --- /dev/null +++ "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/funciones.c" @@ -0,0 +1,13 @@ +#include "header.h" //las comillas dobles lo que hacen es buscar el archivo en la ruta del proyecto que se está codificando +void mostrarAl(t_alumno alum)//las estructuras pueden mandarse como parametros de funciones + { + printf("\n Dni: %d \t Promedio: %.2f \n",alum.dni,alum.prom); + } +/* +bien podría haber hecho ésta función para el tipo s_alumno + +void mostrarAl(s_alumno alum) + { + printf("\n Dni: %d \t Promedio: %.2f \n",alum.dni,alum.prom); + } +*/ diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/header.h" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/header.h" new file mode 100644 index 0000000..a99fb21 --- /dev/null +++ "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/header.h" @@ -0,0 +1,19 @@ +#include +#include +#include//las comillas angulares o corchetes triangulares lo que hacen es buscar esa biblioteca + // en la ruta donde está instalado el compilador +struct s_alumno//nombre con s y guión bajo por convención + { + int dni; + //char nomb[20]; + float prom; + };// acá no estoy reservando memoria + //-------->>>>> solo defino un conjunto de variables que se almacenan de forma contigua en la memoria +typedef struct + { + int dni; + //char nomb[20]; + float prom; + }t_alumno;// el typedef redefine una estructura como un tipo--------> tampoco reservo memoria + // nombre con t y guión bajo por convención +void mostrarAl(t_alumno al1); diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/main.c" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/main.c" new file mode 100644 index 0000000..8b448d8 --- /dev/null +++ "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/main.c" @@ -0,0 +1,21 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + struct s_alumno al1; + al1.dni=11111111; + printf("\n estructura con struct \n"); + printf("\n alumno 1 \n \t dni: \t %d \n\t promedio: \t",al1.dni); + scanf("%f",&al1.prom); + t_alumno al2; + //al2=al1;esto no se puede hacer ya que no son del mismo tipo + // es conveniente trabajar con typedef; + //pero si se puede hacer lo siguiente, ya que los tipos de campo sí son los mismos + al2.dni=al1.dni; + al2.prom=al1.prom; + printf("\n estructura con typedef \n"); + printf("\n alumno 2"); + mostrarAl(al2); + getch(); + return 0; + } diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/obj/Debug/funciones.o" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/obj/Debug/funciones.o" new file mode 100644 index 0000000..2413081 Binary files /dev/null and "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/obj/Debug/funciones.o" differ diff --git "a/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/obj/Debug/main.o" "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/obj/Debug/main.o" new file mode 100644 index 0000000..592e2cb Binary files /dev/null and "b/clase 02 (estructuras, campos, uso del typedef y como par\303\241metro de funciones)/obj/Debug/main.o" differ diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/bin/Debug/clase 02 (fechas, separador de string fecha con barras y algunas funciones).exe b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/bin/Debug/clase 02 (fechas, separador de string fecha con barras y algunas funciones).exe new file mode 100644 index 0000000..f82bc6a Binary files /dev/null and b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/bin/Debug/clase 02 (fechas, separador de string fecha con barras y algunas funciones).exe differ diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).cbp b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).cbp new file mode 100644 index 0000000..fc4abe3 --- /dev/null +++ b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).depend b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).depend new file mode 100644 index 0000000..2e3fbec --- /dev/null +++ b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471738279 source:d:\unlam\programaciÓn\fabian 2da\clase 02 (fechas, separador de string fecha con barras y algunas funciones)\funciones.c + "header.h" + +1471737657 d:\unlam\programaciÓn\fabian 2da\clase 02 (fechas, separador de string fecha con barras y algunas funciones)\header.h + + + + +1471738562 source:d:\unlam\programaciÓn\fabian 2da\clase 02 (fechas, separador de string fecha con barras y algunas funciones)\main.c + "header.h" + diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).layout b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).layout new file mode 100644 index 0000000..44880d3 --- /dev/null +++ b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/clase 02 (fechas, separador de string fecha con barras y algunas funciones).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/funciones.c b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/funciones.c new file mode 100644 index 0000000..9447c0b --- /dev/null +++ b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/funciones.c @@ -0,0 +1,150 @@ +#include "header.h" +void mostrar_fecha(t_fecha f) + { + printf("\n Fecha: %d/%d/%d \n",f.d,f.m,f.a); + } +int fecha_valida(t_fecha f) + { + if(f.a>=1600&&f.m>=1&&f.m<=12&&f.d>=1&&f.d<=cant_dias_mes(f.m,f.a)) + return 1; + else + return 0; + } +//el año debe ser mayor a 1600 por ser el inicio del calendario gregoriano +int cant_dias_mes(int m,int a) + { + if(m==4||m==6||m==9||m==11) + return 30; + else + if(m==2) + return 28+bisiesto(a); + else + return 31; + } +/* +otras opciones.. +usando un vector: + +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + if(m==2&&bisiesto(a)) + return 29; + return dias[m-1]; + } + +optimizando con operadores ternarios: + +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + //o bien: return (m==2)?28+(bisiesto(a)?1:0):dias[m-1]; + } +*/ +int bisiesto(int a) + { + if((a%4==0&&a%100!=0)||a%400==0) + return 1; + else + return 0; + } +//un año es bisiesto si es múltiplo de 4 pero no de 100, o múltiplo de 400 +/* +otra opción..... +int bisiesto(int a) + { + return (a%4==0&&a%100!=0)||a%400==0); + } +*/ +//--------------------------------------------------------------más funciones---------------------------------- +t_fecha incrementar_un_dia(t_fecha f) + { + if(f.d==cant_dias_mes(f.m,f.a)) + { + f.d=1; + if(f.m==12) + { + f.m=1; + f.a++; + } + else + f.m++; + } + else + f.d++; + return f; + } +/* + es prácticamente lo mismo: + +t_fecha incrementar_un_dia(t_fecha f) + { + if(f.d==cant_dias_mes(f.m,f.a)) + f.d=1; + f.m++; + if(f.m>12) + { + f.m==1; + f.a++; + } + return f; + } +*/ +t_fecha sumar_dias_a_fecha(t_fecha f,int cant) +{ + f.d+=cant; + while(f.d>cant_dias_mes(f.m,f.a)) + { + f.d-=cant_dias_mes(f.m,f.a); + f.m++; + if(f.m>12) + { + f.m==1; + f.a++; + } + } + return f; +} +//esa es la mejor alternativa, pero ver la siguiente: +/* +idéntica a la anterior solo que en esta estoy guardando el retorno de la función cant_dias_mes en una variable + +t_fecha sumar_dias_a_fecha(t_fecha f,int cant) + { + int diasM; + f.d+=cant; + while(f.d>(diasM=cant_dias_mes(f.m,f.a))) + { + f.m++; + f.d-=diasM; + if(f.m>12) + { + f.m=1; + f.a++; + } + } + return f; + } + +otra opción es ir restando los días que quiero sumar si exceden los que me quedan en el mes e ir aumentando el mes, controlando si se pasa o no del año + +t_fecha sumar_dias_a_fecha(t_fecha f,int cant) + { + while(f.d+cant>cant_dias_mes(f.m,f.a)) + { + cant-=(cantDiaMes(f.m,f.a)-f.d+1); + f.d=1; + if(f.m==12) + { + f.m=1; + f.a++; + } + else + f.m++; + } + f.d+=cant; + return f; + } +*/ +//agregar luego a este proyecto las funciones de restar dias a una fecha y de scar la diferencia entre dos fechas diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/header.h b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/header.h new file mode 100644 index 0000000..f64f5be --- /dev/null +++ b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/header.h @@ -0,0 +1,15 @@ +#include +#include +#include +typedef struct + { + int d, + m, + a; + }t_fecha; +void mostrar_fecha(t_fecha); +int fecha_valida(t_fecha); +int cant_dias_mes(int,int); +int bisiesto(int); +t_fecha incrementar_un_dia(t_fecha); +t_fecha sumar_dias_a_fecha(t_fecha,int); diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/main.c b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/main.c new file mode 100644 index 0000000..2f677a1 --- /dev/null +++ b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/main.c @@ -0,0 +1,33 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + t_fecha f1; + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + scanf("%d/%d/%d",&f1.d,&f1.m,&f1.a); + mostrar_fecha(f1); + // para comentar automáticamente: ctrl+shift+c + //para revertirlo: ctrl+shift+x +// if(fecha_valida(f1)) +// puts("\n La fecha es válida \n"); +// else +// { +// puts("\n La fecha no es válida \n"); +// exit(0);//evacúo por lo que debe seguir asiéndose en este programa +// } + printf("\n La fecha %s válida \n",fecha_valida(f1)?"es":"no es");//ternario y concatenación es la forna más óptima + fecha_valida(f1)?:exit(0); + t_fecha f2=incrementar_un_dia(f1); + printf("\n La fecha siguiente a la ingresada es: %d/%d/%d \n",f2.d,f2.m,f2.a); + printf("\n Ingrese una cantidad de días para sumarlos a la fecha ingresada: \t"); + int dias; + do + { + scanf("%d",&dias); + } + while(dias<0); + printf("\n La nueva fecha es: \n"); + mostrar_fecha(sumar_dias_a_fecha(f1,dias)); + getch(); + return 0; + } diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/obj/Debug/funciones.o b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/obj/Debug/funciones.o new file mode 100644 index 0000000..01468a5 Binary files /dev/null and b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/obj/Debug/funciones.o differ diff --git a/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/obj/Debug/main.o b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/obj/Debug/main.o new file mode 100644 index 0000000..43187aa Binary files /dev/null and b/clase 02 (fechas, separador de string fecha con barras y algunas funciones)/obj/Debug/main.o differ diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/bin/Debug/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).exe" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/bin/Debug/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).exe" new file mode 100644 index 0000000..698cc06 Binary files /dev/null and "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/bin/Debug/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).exe" differ diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).cbp" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).cbp" new file mode 100644 index 0000000..6365f6c --- /dev/null +++ "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).depend" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).depend" new file mode 100644 index 0000000..fe79953 --- /dev/null +++ "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1472003377 source:d:\unlam\programaciÓn\fabian 2da\clase 03 (array unidimensional,vector,declaración e inicialización)\main.c + + + + diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).layout" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).layout" new file mode 100644 index 0000000..a4303f7 --- /dev/null +++ "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n).layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/funciones.c" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/funciones.c" new file mode 100644 index 0000000..f5bec35 --- /dev/null +++ "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/funciones.c" @@ -0,0 +1 @@ +#include "header.h" diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/header.h" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/header.h" new file mode 100644 index 0000000..f601f56 --- /dev/null +++ "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/header.h" @@ -0,0 +1,4 @@ +#include +#include +#include + diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/main.c" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/main.c" new file mode 100644 index 0000000..557e56f --- /dev/null +++ "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/main.c" @@ -0,0 +1,80 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x[10]; + int i; + x[23]=3;//C deja que se guarde el valor pero está sobreescribiendo en memoria y podría llegar a borrar algo importante + //x[23]={3};//da error ya que no coinciden las dimensiones del tamaño y del vector y la declaración del mismo + int v1[5]={1,55,3,4,5};//reserva y asigna memoria para las 5 variables + int v2[]={1,9,3,4,5};//inicializado-->>>el complilador reserva el espacio mínimo necesario para almacenar esas variables + //int v3[5]={1,2,,4,5};//error:--->>>si empiezo a dar valores, tengo que hacerlo para todas las posiciones + int v4[5]={11,12,13,14,15,60,70};// C no hace control de overflow.. el 60 y el 70 no los almacena.. + //en este caso, el compilador de Borland tira error porque no sabe si descartar los valores que no caben... + //... en esa dimensión, o si guardarlos en las posiciones necesarias + //por eso da error, y que lo decida el programador + //en cambio el compilador de CodeBlocks no da error ni warning, y te lo acepta.. guarda hasta donde se lo indicaste + //y el resto lo descarta.. no se hace responsable de los errores del programador + //*******>>>>> el compilador asigna memoria de manera inversa.. desde lo último que fue declarado hasta lo primero + //por eso, cuando nosotros mostramos posiciones de vectores que no son válidas nos está mostrando lo que continuá, que será + //contenido de cualquier otra variable, en este caso vectores + //por ejemplo, la primera posición afuera de v2 es la primera posición adentro de v1 + //también, la primera posición afuera de v4 es la primera posición adentro de v2 + // además, la primera posición antes del vector 2, es la última posición adentro del vector 4 + int v5[5]={};//rellena todo con cero + int v6[5]={1,'b',3,'d'};//en la segunda y la cuarta posición guarda los ascii de los caracteres declarados y.. + //.. la quinta posición la rellena con cero + int v7[5]={1,2};//guarda el 1 y el 2 en las dos primeras posiciones, y el resto rellena con cero + //int v21[];//error!!!--->>> falta el tamaño + v2[5] = 88;//por prueba nomás + printf("\n VECTORES \n"); + printf("\n\n vector x \n"); + for(i=0;i<23;i++) + { + printf("%d \t", x[i]); + } + printf("\n tamaño del vector x: %d",sizeof(x)); + printf("\n contenido en posición no válida de x: %d",x[23]); + printf("\n\n vector v1 \n"); + for(i=0;i<5;i++) + { + printf("%d \t", v1[i]); + } + printf("\n tamaño del vector v1: %d",sizeof(v1)); + printf("\n\n vector v2 \n"); + for(i=0;i<5;i++) + { + printf("%d \t", v2[i]); + } + printf("\n tamaño del vector v2: %d",sizeof(v2)); + printf("\n\n vector v4 \n"); + for(i=0;i<7;i++) + { + printf("%d \t", v4[i]); + } + printf("\n tamaño del vector v4: %d",sizeof(v4));//reservó 20 bytes, 4 para cada una de las 5 variables + printf("\n\n vector v5 \n"); + for(i=0;i<5;i++) + { + printf("%d \t", v5[i]); + } + printf("\n tamaño del vector v5: %d",sizeof(v5)); + printf("\n\n vector v6 \n"); + for(i=0;i<5;i++) + { + printf("%d \t", v6[i]); + } + printf("\n tamaño del vector v6: %d",sizeof(v6)); + printf("\n\n vector v7 \n"); + for(i=0;i<5;i++) + { + printf("%d \t", v7[i]); + } + printf("\n tamaño del vector v7: %d \n\n",sizeof(v7)); + //printf("\n %d",v4[5]); + //printf("\n %d",v4[6]); + getch(); + return 0; + } diff --git "a/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/obj/Debug/main.o" "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/obj/Debug/main.o" new file mode 100644 index 0000000..17b6ba8 Binary files /dev/null and "b/clase 03 (array unidimensional,vector,declaraci\303\263n e inicializaci\303\263n)/obj/Debug/main.o" differ diff --git "a/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/bin/Debug/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).exe" "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/bin/Debug/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).exe" new file mode 100644 index 0000000..4cf2cf5 Binary files /dev/null and "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/bin/Debug/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).exe" differ diff --git "a/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).cbp" "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).cbp" new file mode 100644 index 0000000..81187d5 --- /dev/null +++ "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).layout" "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).layout" new file mode 100644 index 0000000..469a884 --- /dev/null +++ "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles).layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/main.c" "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/main.c" new file mode 100644 index 0000000..d981053 --- /dev/null +++ "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/main.c" @@ -0,0 +1,45 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n PUNTEROS y PUNTERO A PUNTERO \n"); + //un PUNTERO es una variable que guarda una dirección de memoria + //declaración de punteros: tipo_de_dato *nombre_de_la_variable + //el asterisco acompaña al nombre de la variable, no al tipo de dato + + int *px,x,*py,y;//acá tenemos dos variables y dos punteros + //float *pz,z;//variable flotante y puntero a variable puntero + + int **paux;//puntero a puntero + //un PUNTERO A PUNTERO es una variable que guarda la dirección de una variable que guarda la dirección de otra variable + + x = 3; + y = 8; + py = &y;//apunto el puntero + px = &x;//apunto el puntero + y = *px;//asigno el contenido del puntero a la variable + py = px;//hago que ambos punteros aounten a la misma dirección de memoria + paux = &px;//guardo la dirección de un puntero en otro + + //ver 3 desde todos los lugares posibles y ver la dirección de x desde todos los lugares posibles.. + //además, definir una variable que me guarde la dirección del puntero px + printf("\n Contenido de la variable x visto desde todas los lugares posibles \n"); + printf("\n Variable x: \t %d",x); + printf("\n Contenido de puntero a x: \t %d",*px); + printf("\n Variable y: \t %d ",y); + printf("\n Contenido de puntero a y: \t %d",*py); + printf("\n Contenido del contenido del puntero al puntero de x: \t %d\n",**paux); + + printf("\n Dirección de la variable x desde todos los lugares posibles \n"); + printf("\n Dirección de variable x: \t %p",&x); + printf("\n Puntero a x: \t %p",px); + printf("\n Puntero a y: \t %p",py); + printf("\n Contenido del puntero al puntero de x: \t %p\n",*paux); + //la máscara para las direcciones de memoria de los punteros es %p + //la máscara %x para hexadecimal tira warning + + getch(); + return 0; + } diff --git "a/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/obj/Debug/main.o" "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/obj/Debug/main.o" new file mode 100644 index 0000000..008280e Binary files /dev/null and "b/clase 03 (punteros, ver contenido y direcci\303\263n de todas las formas posibles)/obj/Debug/main.o" differ diff --git a/clase 04 (cargar vector forma renata)/bin/Debug/clase 04 (cargar vector forma renata).exe b/clase 04 (cargar vector forma renata)/bin/Debug/clase 04 (cargar vector forma renata).exe new file mode 100644 index 0000000..b0a9d65 Binary files /dev/null and b/clase 04 (cargar vector forma renata)/bin/Debug/clase 04 (cargar vector forma renata).exe differ diff --git a/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).cbp b/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).cbp new file mode 100644 index 0000000..387ccf0 --- /dev/null +++ b/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).depend b/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).depend new file mode 100644 index 0000000..22c47be --- /dev/null +++ b/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472321069 source:d:\unlam\programaciÓn\fabian 2\clase 04 (cargar vector forma renata)\functions.c + "header.h" + +1472320605 d:\unlam\programaciÓn\fabian 2\clase 04 (cargar vector forma renata)\header.h + + + + +1472321032 source:d:\unlam\programaciÓn\fabian 2\clase 04 (cargar vector forma renata)\main.c + "header.h" + diff --git a/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).layout b/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).layout new file mode 100644 index 0000000..bb4179d --- /dev/null +++ b/clase 04 (cargar vector forma renata)/clase 04 (cargar vector forma renata).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 04 (cargar vector forma renata)/functions.c b/clase 04 (cargar vector forma renata)/functions.c new file mode 100644 index 0000000..2b09543 --- /dev/null +++ b/clase 04 (cargar vector forma renata)/functions.c @@ -0,0 +1,20 @@ +#include "header.h" +int cargar_vector(int *v,int tam,int *ce) + { + unsigned cant; + int *ult; + printf("\n Ingrese cantidad de elementos a cargar:\t"); + fflush(stdin); + scanf("%d",&cant); + if((*ce+cant)>tam) + return 0;//no cargué + ult=v+*ce+cant;//me voy a la última posición a la que puedo cargar + for(v=v+*ce;v +#include +#include +#define TAM 1000 +int cargar_vector(int *v,int tam,int *ce); diff --git a/clase 04 (cargar vector forma renata)/main.c b/clase 04 (cargar vector forma renata)/main.c new file mode 100644 index 0000000..f0d8e5d --- /dev/null +++ b/clase 04 (cargar vector forma renata)/main.c @@ -0,0 +1,13 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int v[TAM],ce=0; + printf("\n\n CARGAR VECTOR \n"); + if(cargar_vector(v,TAM,&ce)) + printf("\n Se cargaron nuevos elementos; el vector ahora tiene %d elementos \n\n",ce); + else + printf("\n No se cargaron elementos \n\n"); + getch(); + return 0; + } diff --git a/clase 04 (cargar vector forma renata)/obj/Debug/functions.o b/clase 04 (cargar vector forma renata)/obj/Debug/functions.o new file mode 100644 index 0000000..8fd8efc Binary files /dev/null and b/clase 04 (cargar vector forma renata)/obj/Debug/functions.o differ diff --git a/clase 04 (cargar vector forma renata)/obj/Debug/main.o b/clase 04 (cargar vector forma renata)/obj/Debug/main.o new file mode 100644 index 0000000..f34f944 Binary files /dev/null and b/clase 04 (cargar vector forma renata)/obj/Debug/main.o differ diff --git "a/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n).cbp" "b/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n).cbp" new file mode 100644 index 0000000..c0d28aa --- /dev/null +++ "b/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n).cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n).layout" "b/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n).layout" new file mode 100644 index 0000000..3c7cd90 --- /dev/null +++ "b/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n).layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/main.c" "b/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/main.c" new file mode 100644 index 0000000..49c1ace --- /dev/null +++ "b/clase 05 (array bidimensional, matriz, declaraci\303\263n e inicializaci\303\263n)/main.c" @@ -0,0 +1,30 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n MATRICES \n"); + //las matrices se almacenan de forma contigua en la memoria, como si fuese un vector + //de hecho, se las interpreta como un vector de punteros + int mat[3][2];//de esta manera se reserva memoria + mat[0][0]=1;//así se le da un valor a la matriz en esa posición + int mat1[3][2]={1,2,3,4,5,6};//tira warning: faltan las llaves delimitadoras de las columnas + int mat2[3][2]={{1,2},{3,4},{5,6}};//esta es la forma ideal para inicializar las matrices + int mat3[3][]={1,2,3,4,5,6};//error: no sabe cuando termina cada fila--->>>>>> necesita las columnas + int mat4[3][]={{1,2},{3,4},{5,6}};//ídem caso anterior---->>>>> necesita las columnas + int mat5[][2]={1,2,3,4,5,6}; //cada 2 elementos, 1 fila. determina la cantidad de filas en funcion de la cantidad de columnas + int mat6[3][2]={1,2};//correcto.. da esos dos primeros valores y luego completa con ceros las demás posiciones + //tira warnimg por la falta de los braces + int mat7[][]={{1,2},{3,4}}; + int mat8[][]={1,2,3,4,5,6};//está muy mal + int mat9[][]={1,,3};//no se pueden dejar espacios vacíos cuando se comienza a inicializar + int mat10[3][2]={1,2,3,4,5,6,7,8};//los últimos dos valores los descarta, el resto los almacena correctamente + //además tira warning porque faltan los braces + //int mat11[3][2]={1};//warning: faltan los delimitadores de columnas + int mat11[3][2]={{1}};//el compilador se contenta con esto.. asigna el uno a la primera posición y luego completa con ceros + int mat12[][2] = {{1,2,3},{4,5,6},{8,9}};//no almacena y el valor 3 ni el 6 ya que no caben en la definición de las dimensiones + //el resto de los números los almacena de manera correcta + getch(); + return 0; + } diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/bin/Debug/clase 05 (macroreemplazos y macros multil\303\255nea).exe" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/bin/Debug/clase 05 (macroreemplazos y macros multil\303\255nea).exe" new file mode 100644 index 0000000..db89e63 Binary files /dev/null and "b/clase 05 (macroreemplazos y macros multil\303\255nea)/bin/Debug/clase 05 (macroreemplazos y macros multil\303\255nea).exe" differ diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).cbp" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).cbp" new file mode 100644 index 0000000..078b973 --- /dev/null +++ "b/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).cbp" @@ -0,0 +1,45 @@ + + + + + + diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).depend" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).depend" new file mode 100644 index 0000000..e02bf42 --- /dev/null +++ "b/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).depend" @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1472689641 source:d:\unlam\programaciÓn\fabian 2\clase 05 (macroreemplazos y macros multilínea)\main.c + "header.h" + +1472689639 d:\unlam\programaciÓn\fabian 2\clase 05 (macroreemplazos y macros multilínea)\header.h + + + + + diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).layout" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).layout" new file mode 100644 index 0000000..158293c --- /dev/null +++ "b/clase 05 (macroreemplazos y macros multil\303\255nea)/clase 05 (macroreemplazos y macros multil\303\255nea).layout" @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/header.h" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/header.h" new file mode 100644 index 0000000..a0604c0 --- /dev/null +++ "b/clase 05 (macroreemplazos y macros multil\303\255nea)/header.h" @@ -0,0 +1,53 @@ +#include +#include +#include +#include + +#define CUADRADO(x) ((x)*(x)) + +#define CUBO(x) (CUADRADO(x)*(x)) + +#define MAYOR(x,y) ((x)>(y)?(x):(y)) + +#define MENOR(x,y) if((x)<(y)) \ + menor=(x); \ + else \ + menor=(y) + +#define ABS(x) ((x)>0)?(x):(-(x)) + +#define PARTE_ENTERA(x) ((int)(x)) + +#define PARTE_DECIMAL(x) ((x)-PARTE_ENTERA(x)) + +#define FACTORIAL(x) fact=1; \ + for(i=1;i<=(x);i++) \ + fact*=i + +#define INTERCAMBIO(x,y) aux=(x); \ + (x)=(y); \ + (y)=aux; + +#define REDONDEO(x) (((x)-(int)(x))>0.5?((int)(x)+1):((int)(x))) + +#define REDONDEO_2(x) ((int)((x) + 0.5)) + +#define ES_BISIESTO(x) ((((x)%4==0&&(x)%100!=0)||((x)%400==0))) + +#define ES_BLANCO(x) ((x)==32) + +#define ES_DIGITO(x) (((x)>='0'&&(x)<='9')) + +#define ES_LETRA(x) ((x)>='A'&&(x)<='Z')||((x)>='a'&&(x)<='z') + +#define ES_MAYUSCULA(x) ((x)>='A'&&(x)<='Z') + +#define ES_MINUSCULA(x) ((x)>='a'&&(x)<='z') + +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +#define A_MINUSCULA(x) (((x)>='A'&&(x)<='Z')?((x)+32):(x)) + +#define REDONDEO_A_DOS_DECIMALES(x) (int)(x*100)/100.0 + +#define REDONDEO_A_N_DECIMALES(x,n) floor(x*(pow(10,n))+0.5)/pow(10,n) diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/main.c" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/main.c" new file mode 100644 index 0000000..3f89021 --- /dev/null +++ "b/clase 05 (macroreemplazos y macros multil\303\255nea)/main.c" @@ -0,0 +1,36 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x=5,y=3,fact,i,aux,blanco=' '; + printf("\n MACROS \n\n"); + printf("\n El cuadrado de 3 es: %d \n",CUADRADO(2+1)); + printf("\n El cubo de 3 es: %d \n",CUBO(2+1)); + printf("\n El mayor entre 5 y 3 es: %d \n",MAYOR(x,y)); + int menor; + MENOR(x,y); + printf("\n El menor entre 5 y 3 es: %d \n",menor); + printf("\n El valor absoluto de -2 es: %d \n",ABS(-2)); + printf("\n La parte entera de %f es: %d \n",2.35,PARTE_ENTERA(2.35)); + printf("\n La parte decimal de %f es: %f \n",2.35,PARTE_DECIMAL(2.35)); FACTORIAL(5); + printf("\n El factorial de %d es: %d \n",5,fact); + printf("\n Antes del intercambio: x=%d \t y=%d \n",x,y); + INTERCAMBIO(x,y); + printf("\n Después del intercambio: x=%d \t y=%d \n",x,y); + printf("\n El redondeo de %f es: %d \n",3.75,REDONDEO(3.75)); + printf("\n El redondeo de %f es: %d \n",3.25,REDONDEO_2(3.25)); + printf("\n El año %d %s bisiesto \n",2016,ES_BISIESTO(2016)?"es":"no es"); + printf("\n El caracter \"%c\" %s blanco \n",blanco,ES_BLANCO(blanco)?"es":"no es"); + printf("\n El caracter \"%d\" %s dígito \n",9,ES_DIGITO('9')?"es":"no es"); + printf("\n El caracter \"%c\" %s letra \n",'f',ES_LETRA('f')?"es":"no es"); + printf("\n El caracter \"%c\" %s maýuscula \n",'m',ES_MAYUSCULA('m')?"es":"no es"); + printf("\n Entonces, paso %c a mayúscula: %c \n",'m',A_MAYUSCULA('m')); + printf("\n El caracter \"%c\" %s maýuscula \n",'Y',ES_MINUSCULA('Y')?"es":"no es"); + printf("\n Entonces, paso %c a minúscula: %c \n",'Y',A_MINUSCULA('Y')); + float a=5.666666; + float b=a; + printf("\n El número %f redondeado a 2 decimales es %f \n",a,REDONDEO_A_DOS_DECIMALES(a)); + printf("\n El número %f redondeado a %d decimales es %f \n",b,4,REDONDEO_A_N_DECIMALES(b,4)); + getch(); + return 0; + } diff --git "a/clase 05 (macroreemplazos y macros multil\303\255nea)/obj/Debug/main.o" "b/clase 05 (macroreemplazos y macros multil\303\255nea)/obj/Debug/main.o" new file mode 100644 index 0000000..2e0e494 Binary files /dev/null and "b/clase 05 (macroreemplazos y macros multil\303\255nea)/obj/Debug/main.o" differ diff --git a/clase 05 (matriz como vector de punteros)/bin/Debug/clase 05 (matriz como vector de punteros).exe b/clase 05 (matriz como vector de punteros)/bin/Debug/clase 05 (matriz como vector de punteros).exe new file mode 100644 index 0000000..b55958c Binary files /dev/null and b/clase 05 (matriz como vector de punteros)/bin/Debug/clase 05 (matriz como vector de punteros).exe differ diff --git a/clase 05 (matriz como vector de punteros)/clase 05 (matriz como vector de punteros).cbp b/clase 05 (matriz como vector de punteros)/clase 05 (matriz como vector de punteros).cbp new file mode 100644 index 0000000..6bbfc46 --- /dev/null +++ b/clase 05 (matriz como vector de punteros)/clase 05 (matriz como vector de punteros).cbp @@ -0,0 +1,44 @@ + + + + + + diff --git a/clase 05 (matriz como vector de punteros)/clase 05 (matriz como vector de punteros).layout b/clase 05 (matriz como vector de punteros)/clase 05 (matriz como vector de punteros).layout new file mode 100644 index 0000000..de6073e --- /dev/null +++ b/clase 05 (matriz como vector de punteros)/clase 05 (matriz como vector de punteros).layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/clase 05 (matriz como vector de punteros)/main.c b/clase 05 (matriz como vector de punteros)/main.c new file mode 100644 index 0000000..481be97 --- /dev/null +++ b/clase 05 (matriz como vector de punteros)/main.c @@ -0,0 +1,35 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n\t\t MATRICES \n"); + //los elementos de las matrices se almacenan de manera consecutiva en la memoria + //se las suele ver como vectores de punteros, como si fuese un vector paralelo a las columnas de la matriz + //y cada elemento siendo un puntero a la dirección del primer elemento de la fila a la fila que está a su lado + //pero este vector de punteros no existe, es virtual + int i,j; + int mat[3][2]={{1,2},{3,4},{5,6}};//veamos los que ocurre con esta matriz + printf("\n MATRIZ: \t\t Contenido \t Dirección \n"); + for(i=0;i<3;i++) + { + for(j=0;j<2;j++) + printf("\n m[%d][%d]:\t\t\t %d \t %p",i,j,mat[i][j],&mat[i][j]); + printf("\n"); + } + printf("\n VECTOR DE PUNTEROS \t Contenido \t Dirección \n"); + for(i=0;i<6;i++) + printf("\n m[%d]: \t\t\t%p\t%p",i,mat[i],&mat[i]); + printf("\n\n Veamos algunos casos aparte: \n"); + printf("\n Dirección de mat: %p\n",&mat); + printf("\n Contenido de mat: %p\n\n",mat); + printf("\n mat[0]: %p\n",mat[0]); + printf("\n Contenido de mat[0]: %d\n",*mat[0]); + printf("\n Dirección de mat[0]: %p\n\n",&mat[0]); + printf("\n mat[1]: %p\n",mat[1]); + printf("\n Contenido de mat[1]: %d\n",*mat[1]); + printf("\n Dirección de mat[1]: %p\n",&mat[1]); + getch(); + return; + } diff --git a/clase 05 (matriz como vector de punteros)/obj/Debug/main.o b/clase 05 (matriz como vector de punteros)/obj/Debug/main.o new file mode 100644 index 0000000..10b729c Binary files /dev/null and b/clase 05 (matriz como vector de punteros)/obj/Debug/main.o differ diff --git a/clase 05 (tarea de matrices)/bin/Debug/clase 05 (tarea de matrices).exe b/clase 05 (tarea de matrices)/bin/Debug/clase 05 (tarea de matrices).exe new file mode 100644 index 0000000..8f7ade7 Binary files /dev/null and b/clase 05 (tarea de matrices)/bin/Debug/clase 05 (tarea de matrices).exe differ diff --git a/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).cbp b/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).cbp new file mode 100644 index 0000000..d5b7155 --- /dev/null +++ b/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).depend b/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).depend new file mode 100644 index 0000000..73d19f7 --- /dev/null +++ b/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472696776 source:d:\unlam\programaciÓn\fabian 2\clase 05 (tarea de matrices)\functions.c + "header.h" + +1472696836 d:\unlam\programaciÓn\fabian 2\clase 05 (tarea de matrices)\header.h + + + + +1472695770 source:d:\unlam\programaciÓn\fabian 2\clase 05 (tarea de matrices)\main.c + "header.h" + diff --git a/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).layout b/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).layout new file mode 100644 index 0000000..7bc6817 --- /dev/null +++ b/clase 05 (tarea de matrices)/clase 05 (tarea de matrices).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 05 (tarea de matrices)/functions.c b/clase 05 (tarea de matrices)/functions.c new file mode 100644 index 0000000..0a92df1 --- /dev/null +++ b/clase 05 (tarea de matrices)/functions.c @@ -0,0 +1,69 @@ +#include "header.h" +void cargar_matriz_cuadrada(int m[][N],int n) + { + int i,j; + for(i=0;i +#include +#include +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) +#define N 3 +void cargar_matriz_cuadrada(int[][N],int); +void mostrar_matriz_cuadrada(int[][N],int); +int elemento_ij(int*,int,int,int); +void mostrar_elementos_diagonal_principal(int[][N],int); +void mostrar_elementos_diagonal_secundaria(int[][N],int); +void mostrar_diagonal_principal(int[][N],int); +void mostrar_diagonal_secundaria(int[][N],int); diff --git a/clase 05 (tarea de matrices)/main.c b/clase 05 (tarea de matrices)/main.c new file mode 100644 index 0000000..8f5d443 --- /dev/null +++ b/clase 05 (tarea de matrices)/main.c @@ -0,0 +1,47 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int m[N][N]={{1,2,3},{4,5,6},{7,8,9}}; +// printf("\n\t\t MATRICES \n\n"); + //printf("\n Elemento ubicado:\t m= %d \n",elemento_ij(m,N,2,2)); +// printf("\n Cargue la matriz: \n\n"); +// cargar_matriz_cuadrada(m,N); +// printf("\n Esta es la matriz cargada: \n\n"); +// mostrar_matriz_cuadrada(m,N); + int i,j,op; + do + { + system("cls"); + printf("\n\t\t MATRICES \n\n"); + mostrar_matriz_cuadrada(m,N); + printf("\n Ubique un elemento de la matriz a partir de su fila y su columna: \n"); + do + { + printf("\n Ingrese su fila (1 a %d): \t",N); + scanf("%d",&i); + } + while(!DATO_VALIDO(i,1,N)); + do + { + printf("\n Ingrese su columna (1 a %d): \t",N); + scanf("%d",&j); + } + while(!DATO_VALIDO(j,1,N)); + printf("\n Elemento ubicado:\t m[%d][%d]= %d \n",i,j,elemento_ij(m,N,i-1,j)); + printf("\n Para repetir presione 1. Caso contrario, presione cualquier tecla: \t"); + scanf("%d",&op); + } + while(op==1); + printf("\n\n Elementos de la diagonal principal \n\n"); + mostrar_elementos_diagonal_principal(m,N); + printf("\n\n Elementos de la diagonal secundaria \n\n"); + mostrar_elementos_diagonal_secundaria(m,N); + printf("\n\n Diagonal Principal \n\n"); + mostrar_diagonal_principal(m,N); + printf("\n\n Diagonal Secundaria \n\n"); + mostrar_diagonal_secundaria(m,N); + printf("\n\n\n"); + getch(); + return 0; + } diff --git a/clase 05 (tarea de matrices)/obj/Debug/functions.o b/clase 05 (tarea de matrices)/obj/Debug/functions.o new file mode 100644 index 0000000..538a0c1 Binary files /dev/null and b/clase 05 (tarea de matrices)/obj/Debug/functions.o differ diff --git a/clase 05 (tarea de matrices)/obj/Debug/main.o b/clase 05 (tarea de matrices)/obj/Debug/main.o new file mode 100644 index 0000000..190dbed Binary files /dev/null and b/clase 05 (tarea de matrices)/obj/Debug/main.o differ diff --git a/clase 06 (algunas de las funciones de matrices)/bin/Debug/clase 06 (algunas de las funciones de matrices).exe b/clase 06 (algunas de las funciones de matrices)/bin/Debug/clase 06 (algunas de las funciones de matrices).exe new file mode 100644 index 0000000..487fcf0 Binary files /dev/null and b/clase 06 (algunas de las funciones de matrices)/bin/Debug/clase 06 (algunas de las funciones de matrices).exe differ diff --git a/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).cbp b/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).cbp new file mode 100644 index 0000000..9e62c7e --- /dev/null +++ b/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).depend b/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).depend new file mode 100644 index 0000000..663cee3 --- /dev/null +++ b/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473005417 source:d:\unlam\programaciÓn\fabian 2\clase 06 (algunas de las funciones de matrices)\functions.c + "header.h" + +1473005497 d:\unlam\programaciÓn\fabian 2\clase 06 (algunas de las funciones de matrices)\header.h + + + + +1473005436 source:d:\unlam\programaciÓn\fabian 2\clase 06 (algunas de las funciones de matrices)\main.c + "header.h" + diff --git a/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).layout b/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).layout new file mode 100644 index 0000000..39850ab --- /dev/null +++ b/clase 06 (algunas de las funciones de matrices)/clase 06 (algunas de las funciones de matrices).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 06 (algunas de las funciones de matrices)/functions.c b/clase 06 (algunas de las funciones de matrices)/functions.c new file mode 100644 index 0000000..ff5ec86 --- /dev/null +++ b/clase 06 (algunas de las funciones de matrices)/functions.c @@ -0,0 +1,193 @@ +#include "header.h" + +int* buscarValor(int *mat,int i,int j,int col) +{ + return (mat + ((i-1) * col ) + j-1); +} + +void trianguloSuperiorDerecho(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo superior derecho:"); + for(i = 0 ; i < fil ; i++) + { + for(j = i ; j < col ; j++) + printf(" %d",mat[i][j]); + } +} + +void trianguloSuperiorIzquierdo(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo superior izquierdo:"); + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j < col - i ; j++) + printf(" %d",mat[i][j]); + } +} + +void trianguloInferiorIzquierdo(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo inferior izquierdo:"); + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j <= i ; j++) + printf(" %d",mat[i][j]); + } +} + +void trianguloInferiorDerecho(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo inferior derecho:"); + for(i = 0 ; i < fil ; i++) + { + for(j = col - i - 1 ; j < col ; j++) + printf(" %d",mat[i][j]); + } +} + +///// sin diagonal/////////////////////////////// + +void trianguloSuperiorDerechoSD(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo superior derecho sin diagonal:"); + for(i = 0 ; i < fil ; i++) + { + for(j = i + 1 ; j < col ; j++) + printf(" %d",mat[i][j]); + } +} + +void trianguloSuperiorIzquierdoSD(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo superior izquierdo sin diagonal:"); + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j < col - i - 1 ; j++) + printf(" %d",mat[i][j]); + } +} + +void trianguloInferiorIzquierdoSD(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo inferior izquierdo sin diagonal:"); + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j <= i - 1; j++) + printf(" %d",mat[i][j]); + } +} + +void trianguloInferiorDerechoSD(int mat[][COL],int fil,int col) +{ + int i,j; + printf("\nElementos del triangulo inferior derecho sin diagonal:"); + for(i = 0 ; i < fil ; i++) + { + for(j = col - i ; j < col ; j++) + printf(" %d",mat[i][j]); + } +} +/* +int esIdentidad(int mat[][COL],int fil,int col) +{ + int i,j; + + for(i = 0 ; i < fil ; i++) + { + if((mat[i][i] != 1) + return FALSO; + for(j = i+1 ; j < col ; j++) + { + if((mat[i][j] != 0) || (mat[j][i] != 0)) + return FALSO; + } + } + + return VERDADERO; +} +*/ +void trasponerMatriz(int mat[][COL],int fil,int col) +{ + int i,j,aux; + + for(i = 0 ; i < fil ; i++) + { + for(j = i + 1 ; j < col ; j++) + { + aux = mat[i][j]; + mat[i][j] = mat[j][i]; + mat[j][i] = aux; + } + } +} + +void mostrarMatriz(int mat[][COL2],int fil,int col) +{ + int i,j; + + printf("\n Matriz\n\n"); + + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j < col ; j++) + printf(" %d",mat[i][j]); + printf("\n"); + } +} + +int productoDeMatrices(int mat[][COL],int mat2[][COL2],int matRes[][COL2],int fil,int col,int fil2,int col2) +{ + int i,j,k; + + if(col != fil2) + return 0; + + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j < col2 ; j++) + { + matRes[i][j] = 0; + for(k = 0 ; k < fil2 ; k++) + matRes[i][j] += mat[i][k] * mat2[k][j]; + } + } + + return 1; +} + +int esSimetrica(int mat[][COL],int fil,int col) +{ + int i,j; + + for(i = 1 ; i < fil ; i++) + { + for(j = i + 1 ; j < col ; j++) + { + if(mat[i][j] != mat[j][i]) + return 0; + } + } + + return 1; +} + +int esSimetrica2(int mat[][COL],int fil,int col) +{ + int i,j; + + for(i = 0 ; i < fil ; i++) + { + for(j = 0 ; j < col - i - 1 ; j++) + if(mat[i][j] != mat[fil - i][col - j]) + return 0; + } + + return 1; +} diff --git a/clase 06 (algunas de las funciones de matrices)/header.h b/clase 06 (algunas de las funciones de matrices)/header.h new file mode 100644 index 0000000..97f3138 --- /dev/null +++ b/clase 06 (algunas de las funciones de matrices)/header.h @@ -0,0 +1,30 @@ +#include +#include +#include + +#define FIL 4 +#define COL 4 +#define FIL2 2 +#define COL2 3 + +#define FALSO 0 +#define VERDADERO 1 + +int* buscarValor(int *mat,int i,int j,int col); + +void trianguloSuperiorDerecho(int mat[][COL],int fil,int col); +void trianguloSuperiorIzquierdo(int mat[][COL],int fil,int col); +void trianguloInferiorIzquierdo(int mat[][COL],int fil,int col); +void trianguloInferiorDerecho(int mat[][COL],int fil,int col); + +void trianguloInferiorIzquierdoSD(int mat[][COL],int fil,int col); +void trianguloInferiorDerechoSD(int mat[][COL],int fil,int col); +void trianguloSuperiorDerechoSD(int mat[][COL],int fil,int col); +void trianguloSuperiorIzquierdoSD(int mat[][COL],int fil,int col); + +int esIdentidad(int mat[][COL],int fil,int col); +void trasponerMatriz(int mat[][COL],int fil,int col); +void mostrarMatriz(int mat[][COL2],int fil,int col); +int productoDeMatrices(int mat[][COL],int mat2[][COL2],int matRes[][COL2],int fil,int col,int fil2,int col2); +int esSimetrica2(int mat[][COL],int fil,int col); +int esSimetrica(int mat[][COL],int fil,int col); diff --git a/clase 06 (algunas de las funciones de matrices)/main.c b/clase 06 (algunas de las funciones de matrices)/main.c new file mode 100644 index 0000000..ea9d27a --- /dev/null +++ b/clase 06 (algunas de las funciones de matrices)/main.c @@ -0,0 +1,28 @@ +#include "header.h" + +int main() +{ + int mat1[FIL][COL] = {{2,5,7,1},{3,4,1,7},{6,1,4,5},{1,6,3,2}}; + /* + int mat2[FIL2][COL2] = {{1,2,3},{4,5,6}}; + int matRes[FIL][COL2] = {{0,0,0},{0,0,0},{0,0,0}}; + + trianguloSuperiorDerecho(mat,FIL,COL); + trianguloSuperiorIzquierdo(mat,FIL,COL); + trianguloInferiorIzquierdo(mat,FIL,COL); + trianguloInferiorDerecho(mat,FIL,COL); + + trianguloSuperiorDerechoSD(mat,FIL,COL); + trianguloSuperiorIzquierdoSD(mat,FIL,COL); + trianguloInferiorIzquierdoSD(mat,FIL,COL); + trianguloInferiorDerechoSD(mat,FIL,COL); + */ + + if(esSimetrica2(mat1,FIL,COL)) + printf("\n Es simetrica"); + else + printf("\n No es simetrica"); + + printf("\n"); + return 0; +} diff --git a/clase 06 (algunas de las funciones de matrices)/obj/Debug/functions.o b/clase 06 (algunas de las funciones de matrices)/obj/Debug/functions.o new file mode 100644 index 0000000..1d6b752 Binary files /dev/null and b/clase 06 (algunas de las funciones de matrices)/obj/Debug/functions.o differ diff --git a/clase 06 (algunas de las funciones de matrices)/obj/Debug/main.o b/clase 06 (algunas de las funciones de matrices)/obj/Debug/main.o new file mode 100644 index 0000000..b8add8e Binary files /dev/null and b/clase 06 (algunas de las funciones de matrices)/obj/Debug/main.o differ diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/bin/Debug/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).exe" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/bin/Debug/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).exe" new file mode 100644 index 0000000..9e99fb8 Binary files /dev/null and "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/bin/Debug/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).exe" differ diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).cbp" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).cbp" new file mode 100644 index 0000000..816e8e9 --- /dev/null +++ "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).depend" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).depend" new file mode 100644 index 0000000..a77c54a --- /dev/null +++ "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473282625 source:d:\unlam\programaciÓn\fabian 2\clase 07 (algunas de las funciones de la librería string vistas en clase)\functions.c + "header.h" + +1473286243 d:\unlam\programaciÓn\fabian 2\clase 07 (algunas de las funciones de la librería string vistas en clase)\header.h + + + + + +1473277339 source:d:\unlam\programaciÓn\fabian 2\clase 07 (algunas de las funciones de la librería string vistas en clase)\main.c + "header.h" + diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).layout" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).layout" new file mode 100644 index 0000000..260b47b --- /dev/null +++ "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase).layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/functions.c" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/functions.c" new file mode 100644 index 0000000..74e9307 --- /dev/null +++ "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/functions.c" @@ -0,0 +1,61 @@ +#include "header.h" +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) // es mejor que escribir while(*s!='\0') ya que solo va a dar falso si es el caracter nulo + { + cont++; + s++; + } + return cont; + } +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } +char *str_cat(char *destino,const char *origen) + { + char *s=destino; + while(*destino) + destino++; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } +int str_cmpi(const char *s1,const char *s2) + { + while(tolower(*s1)==tolower(*s2)&&*s1&&*s2)//luego, cambiar la función tolower por la macro hecha por nosotros + { + s1++; + s2++; + } + return tolower(*s1)-tolower(*s2); + } +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/header.h" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/header.h" new file mode 100644 index 0000000..dcdca0b --- /dev/null +++ "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#include +size_t str_len(const char*); +char *str_cpy(char*,const char*); +char *str_cat(char*,const char*); +int str_cmp(const char*,const char*); +int str_cmpi(const char*,const char*); +char *str_chr(char*,int); diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/main.c" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/main.c" new file mode 100644 index 0000000..4c030de --- /dev/null +++ "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/main.c" @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cad1[6]="lunes"; + char cad2[7]="martes"; + printf("\n\n tamaño de la cadena: \t %d",str_len(cad2)); + str_cpy(cad1,cad2); + printf("\n\n resultado de la copia %s \n ",cad1); + str_cat(cad1,cad2); + printf("\n\n %s resultado e la concatenación \n",cad1); + printf("\n\n comparación entre cadena 1 y cadena 2: %d \n",str_cmp(cad1,cad2)); + printf("\n\n comparación entre cadena 1 y cadena 2, case insensitive: %d \n",str_cmpi(cad1,cad2)); + printf("\n\n busqueda de caracter en cadena: \t %s \n\n",str_chr(cad1,'r')); + getch(); + return 0; + } diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/obj/Debug/functions.o" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/obj/Debug/functions.o" new file mode 100644 index 0000000..eeaff67 Binary files /dev/null and "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/obj/Debug/functions.o" differ diff --git "a/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/obj/Debug/main.o" "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/obj/Debug/main.o" new file mode 100644 index 0000000..39afa0f Binary files /dev/null and "b/clase 07 (algunas de las funciones de la librer\303\255a string vistas en clase)/obj/Debug/main.o" differ diff --git "a/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/bin/Debug/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros).exe" "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/bin/Debug/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros).exe" new file mode 100644 index 0000000..b60e44d Binary files /dev/null and "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/bin/Debug/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros).exe" differ diff --git "a/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros).cbp" "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros).cbp" new file mode 100644 index 0000000..314bad0 --- /dev/null +++ "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros).cbp" @@ -0,0 +1,40 @@ + + + + + + diff --git "a/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/main.c" "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/main.c" new file mode 100644 index 0000000..21da119 --- /dev/null +++ "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/main.c" @@ -0,0 +1,69 @@ +#include +#include +#include +//#include bibliotecas de las que puedo sacar las funciones de string y char +//#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cad[3];//forma de reservar memoria para una cadena + //esta es la forma correcta de declarar una cadena + // \0 es el caracter de fin de una cadena + + char cad1[4]={'a','A','1','2'};//yo no tengo problemas con mostrar esta cadena--->>> asigno un caracter a cada posición + //dependiendo del compilador podría tirar error, ya que no tiene el caracter de fin de cadena + char cad2[4]={'A','B','C','D'}; + char cad3[]={'1','2','3','4'};//el compliador reserva cuatro espacios para los cuatro caracteres especificados + char cad4[9]={'a','b','c','d'};//aquí, como reservé lugar de sobra, el compilador cuenta con lugar para colocar \0 + //el resto de los espacios reservados se completan con \0, algo similar a lo que ocurre en el caso de los vectores comunes + //cuando hay lugar de sobra, donde el compilador completa con cero + char cad5[]="1234";//al poner comillas dobles estoy indicando que se trata de una cadena, y como o indico + //el tamaño tiene lugar para colocar \0 y reserva las posiciones de memoria necesarias para guardar la ceadena y el \0 + //las comillas dobles están explicitando que el último carcter de la cadens debe ser el caracter de fin de cadena + char cad6[3]="Sol";//aquí no hay espacio para poner el \0, por lo que no se coloca, ya que se prioriza guardar los caracteres + //al mostrar, puede verse la cadena anterior.. se detiene la impresión en pantalla cuando se encuentra el \0 + char cad7[3]="Lluvia";//ídem.. se prioriza guardar los tres caracteres que caban, y no se pone el \0.. al mostrar aparecen las cadenas anteriores + + char *cad8="Constantinopla";//se guarda el dato perfectamente.. + + *cad1='z';//se puede modificar el contenido de una cadena + + //*cad8='z';//explota, ya que estoy invadiendo memoria.. yo solo declare un puntero, no tamaño, por ello, no puede modificar algo fuera de esa dirección + + //cad1++; esto no puede hacerse ya que cad1 es un puntero constante a la dirección del primer elemento de la cadena + //el contenido puede modifiacarse, pero no el puntero + + //cad8++; al mostrar aparece onstantinopla + //esto se puede hacer ya que es un puntero común y corriente.. no puede modificar el contenido, pero sí puede mover el puntero + //acá moví el puntero, por lo tanto, cuando quiero mostrar, veo a partir del segundo caracter + + //NO DECLARAR CADENAS COMO LA OCTAVA CADENA ya que después no puedo mofificar la cadena + + // cad1=cad2 -->>>>>> HORROR--->>>>> esto no puede hacerse, ya que así no estoy asignando el contenido de una en la otra + // lo que estoy intentando hacer es que apunten a la misma dirección.. cosa que notiene sentido ya que son punteros constantes + // LAS VARIABLES DIMENSIONADAS NO PUEDEN ASIGNARSE CON = OJOOOO!!!! + + printf("\n\n CADENAS DE CARACTERES \n"); + printf("\n cadena 1: \t %s",cad1); + printf("\n cadena 2: \t %s",cad2);//al mostrar esta cadena muestra también cad1 ya que cad2 no tiene el \0 y no sabe dónde parar + //el orden en que muestra se debe a que el compilador reserva memoria de forna inversa a como el programador declara + printf("\n cadena 3: \t %s",cad3);//ídem caso anterior-->>> se agregan al final las cadenas de más arriba + printf("\n cadena 4: \t %s",cad4);//OK + printf("\n cadena 5: \t %s",cad5); + printf("\n cadena 6: \t %s",cad6); + printf("\n cadena 7: \t %s",cad7); + printf("\n cadena 8: \t %s",cad8); + + printf("\n\n TAMAÑO DE LAS CADENAS \n"); + printf("\n sizeof cadena 1: %d",sizeof(cad1)); + printf("\n sizeof cadena 2: %d",sizeof(cad2)); + printf("\n sizeof cadena 3: %d",sizeof(cad3)); + printf("\n sizeof cadena 4: %d",sizeof(cad4)); + printf("\n sizeof cadena 5: %d",sizeof(cad5)); + printf("\n sizeof cadena 6: %d",sizeof(cad6)); + printf("\n sizeof cadena 7: %d",sizeof(cad7)); + printf("\n sizeof cadena 8: %d",sizeof(cad8)); //reservó espacio para una dirección de memoria + printf("\n\n"); + getch(); + return 0; + } diff --git "a/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/obj/Debug/main.o" "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/obj/Debug/main.o" new file mode 100644 index 0000000..fab19c6 Binary files /dev/null and "b/clase 07 (cadenas de caracteres, sintaxis, inicializaci\303\263n y trato como punteros)/obj/Debug/main.o" differ diff --git a/clase 08 (grabar archivo binario)/bin/Debug/clase 08 (grabar archivo binario).exe b/clase 08 (grabar archivo binario)/bin/Debug/clase 08 (grabar archivo binario).exe new file mode 100644 index 0000000..ff86c83 Binary files /dev/null and b/clase 08 (grabar archivo binario)/bin/Debug/clase 08 (grabar archivo binario).exe differ diff --git a/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).cbp b/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).cbp new file mode 100644 index 0000000..94b25c5 --- /dev/null +++ b/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).depend b/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).depend new file mode 100644 index 0000000..c26cc7a --- /dev/null +++ b/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473537872 source:d:\unlam\programaciÓn\fabian 2\clase 08 (grabar archivo binario)\main.c + "header.h" + +1473537913 d:\unlam\programaciÓn\fabian 2\clase 08 (grabar archivo binario)\header.h + + + + + +1473538091 source:d:\unlam\programaciÓn\fabian 2\clase 08 (grabar archivo binario)\functions.c + "header.h" + diff --git a/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).layout b/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).layout new file mode 100644 index 0000000..624346c --- /dev/null +++ b/clase 08 (grabar archivo binario)/clase 08 (grabar archivo binario).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 08 (grabar archivo binario)/functions.c b/clase 08 (grabar archivo binario)/functions.c new file mode 100644 index 0000000..6b2a4e4 --- /dev/null +++ b/clase 08 (grabar archivo binario)/functions.c @@ -0,0 +1,119 @@ +#include "header.h" +char *modo_de_apertura() + { + int op,band=0; + char *modo; + printf("\n Ingrese modo de apertura: \n 1- write \t 2- append \n\n\t Opción: \t"); + do + { + if(band==1) + printf("\n\n La opción ingresada es incorrecta. Reingrésela: \t"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + if(op==1) + modo="wb"; + else + modo="ab"; + return modo; + } +void cargar_archivo(FILE **pf) + { + t_persona per; + ingresar_registro(&per); + if(per.dni==0) + return; + fwrite(&per,sizeof(t_persona),1,*pf); + printf("\n Registro grabado \n\n"); + cargar_archivo(pf); + } +void ingresar_registro(t_persona *per) + { + int band; + printf("\n\n CARGUE UN REGISTRO \n"); + printf("\n (para dejar de cargar registros, ingrese dni=0) \n"); + + band=0; + printf("\n Ingrese el DNI: \t"); + do + { + if(band==1) + printf("\n El dato ingresado es inválido. Reingréselo: \n\n\t\a\a"); + scanf("%d",&per->dni); + band=1; + } + while(per->dni<0); + if(per->dni==0) + return; + + band=0; + printf("\n Ingrese el nombre y apellido: \n\n\t"); + do + { + if(band==1) + printf("\n El campo ingresado está vacío. Reingréselo: \n\n\t\a\a"); + fflush(stdin); + gets(per->nomb); + fflush(stdin); + band=1; + } + while(str_len(per->nomb)==0); + + band=0; + printf("\n Ingrese la edad: \t"); + do + { + if(band==1) + printf("\n La edad ingresada es inválida. Reingrésela: \n\n\t\a\a"); + scanf("%d",&per->edad); + band=1; + } + while(per->edad<0); + + band=0; + printf("\n Ingrese la fecha de nacimiento en formato dd/mm/aaaa: \n\n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada es inválida. Reingrésela: \n\n\t\a\a"); + scanf("%d/%d/%d",&per->f_nac.d,&per->f_nac.m,&per->f_nac.a); + band=1; + } + while(!fecha_valida(per->f_nac)); + } +int fecha_valida(t_fecha f) + { + return (f.a>=1600&&f.m>=1&&f.m<=12&&f.d>=1&&f.d<=cant_dias_mes(f.m,f.a))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } diff --git a/clase 08 (grabar archivo binario)/header.h b/clase 08 (grabar archivo binario)/header.h new file mode 100644 index 0000000..3749231 --- /dev/null +++ b/clase 08 (grabar archivo binario)/header.h @@ -0,0 +1,26 @@ +#include +#include +#include +#include +#define DATO_VALIDO(x,li,ls) ((x)>=(ls)&&(x)<=(ls)) +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; +char *modo_de_apertura(); +void cargar_archivo(FILE**); +void ingresar_registro(t_persona*); +int fecha_valida(t_fecha); +int cant_dias_mes(int,int); +int bisiesto(int); +size_t str_len(const char*); +char *str_cpy(char*,const char*); diff --git a/clase 08 (grabar archivo binario)/main.c b/clase 08 (grabar archivo binario)/main.c new file mode 100644 index 0000000..9491e09 --- /dev/null +++ b/clase 08 (grabar archivo binario)/main.c @@ -0,0 +1,19 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + FILE*pf; + printf("\n\n GRABAR FICHERO BINARIO \n\n"); + pf=fopen("personas.dat",modo_de_apertura()); + if(!pf) + { + printf("\n El fichero no pudo ser grabado \n\n\a\a"); + exit(0); + } + cargar_archivo(&pf); + fclose(pf); + printf("\n\n El archivo \"personas.dat\" fue grabado exitosamente \n\n"); + printf("\n\n\t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/clase 08 (grabar archivo binario)/obj/Debug/functions.o b/clase 08 (grabar archivo binario)/obj/Debug/functions.o new file mode 100644 index 0000000..49348ad Binary files /dev/null and b/clase 08 (grabar archivo binario)/obj/Debug/functions.o differ diff --git a/clase 08 (grabar archivo binario)/obj/Debug/main.o b/clase 08 (grabar archivo binario)/obj/Debug/main.o new file mode 100644 index 0000000..93cc213 Binary files /dev/null and b/clase 08 (grabar archivo binario)/obj/Debug/main.o differ diff --git a/clase 08 (grabar archivo binario)/personas.dat b/clase 08 (grabar archivo binario)/personas.dat new file mode 100644 index 0000000..3b1330f Binary files /dev/null and b/clase 08 (grabar archivo binario)/personas.dat differ diff --git a/clase 08 (leer archivo binario)/bin/Debug/clase 08 (leer archivo binario).exe b/clase 08 (leer archivo binario)/bin/Debug/clase 08 (leer archivo binario).exe new file mode 100644 index 0000000..4d0a3ce Binary files /dev/null and b/clase 08 (leer archivo binario)/bin/Debug/clase 08 (leer archivo binario).exe differ diff --git a/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).cbp b/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).cbp new file mode 100644 index 0000000..5fa72d0 --- /dev/null +++ b/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).depend b/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).depend new file mode 100644 index 0000000..7ff5e3b --- /dev/null +++ b/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473538869 source:d:\unlam\programaciÓn\fabian 2\clase 08 (leer archivo binario)\functions.c + "header.h" + +1473538824 d:\unlam\programaciÓn\fabian 2\clase 08 (leer archivo binario)\header.h + + + + + +1473540481 source:d:\unlam\programaciÓn\fabian 2\clase 08 (leer archivo binario)\main.c + "header.h" + diff --git a/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).layout b/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).layout new file mode 100644 index 0000000..bf3dc80 --- /dev/null +++ b/clase 08 (leer archivo binario)/clase 08 (leer archivo binario).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 08 (leer archivo binario)/functions.c b/clase 08 (leer archivo binario)/functions.c new file mode 100644 index 0000000..d726781 --- /dev/null +++ b/clase 08 (leer archivo binario)/functions.c @@ -0,0 +1,11 @@ +#include "header.h" +void leer_archivo(FILE **pf) + { + t_persona per; + fread(&per,sizeof(t_persona),1,*pf); + while(!feof(*pf)) + { + printf("\n\n DNI: \t %d \t Nombre y apellido: \t %s \n Edad: \t %d \t Fecha de nacimiento: \t %d/%d/%d \n",per.dni,per.nomb,per.edad,per.f_nac.d,per.f_nac.m,per.f_nac.a); + fread(&per,sizeof(t_persona),1,*pf); + } + } diff --git a/clase 08 (leer archivo binario)/header.h b/clase 08 (leer archivo binario)/header.h new file mode 100644 index 0000000..548aed0 --- /dev/null +++ b/clase 08 (leer archivo binario)/header.h @@ -0,0 +1,18 @@ +#include +#include +#include +#include +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; +void leer_archivo(FILE**); diff --git a/clase 08 (leer archivo binario)/main.c b/clase 08 (leer archivo binario)/main.c new file mode 100644 index 0000000..b6792a3 --- /dev/null +++ b/clase 08 (leer archivo binario)/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + FILE *pf; + printf("\n\n LEER ARCHIVO BINARIO \n\n"); + + //no comentar el que quiera leer + //pf=fopen("personas.dat","rb"); + pf=fopen("personas_hardcodeado.dat","rb"); + + if(!pf) + { + printf("\n\n No se pudo abrir el archivo \n\n\a\a"); + return 0; + } + leer_archivo(&pf); + printf("\n\n El archivo fue leído correctamente \n\n"); + fclose(pf); + printf("\n\n\t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/clase 08 (leer archivo binario)/obj/Debug/functions.o b/clase 08 (leer archivo binario)/obj/Debug/functions.o new file mode 100644 index 0000000..69e0311 Binary files /dev/null and b/clase 08 (leer archivo binario)/obj/Debug/functions.o differ diff --git a/clase 08 (leer archivo binario)/obj/Debug/main.o b/clase 08 (leer archivo binario)/obj/Debug/main.o new file mode 100644 index 0000000..d331458 Binary files /dev/null and b/clase 08 (leer archivo binario)/obj/Debug/main.o differ diff --git a/clase 08 (leer archivo binario)/personas.dat b/clase 08 (leer archivo binario)/personas.dat new file mode 100644 index 0000000..105b70c Binary files /dev/null and b/clase 08 (leer archivo binario)/personas.dat differ diff --git a/clase 08 (leer archivo binario)/personas_hardcodeado.dat b/clase 08 (leer archivo binario)/personas_hardcodeado.dat new file mode 100644 index 0000000..fe055af Binary files /dev/null and b/clase 08 (leer archivo binario)/personas_hardcodeado.dat differ diff --git a/clase 08 (lote de prueba hardcodeando registros)/bin/Debug/clase 08 (lote de prueba hardcodeando registros).exe b/clase 08 (lote de prueba hardcodeando registros)/bin/Debug/clase 08 (lote de prueba hardcodeando registros).exe new file mode 100644 index 0000000..dd7f0a3 Binary files /dev/null and b/clase 08 (lote de prueba hardcodeando registros)/bin/Debug/clase 08 (lote de prueba hardcodeando registros).exe differ diff --git a/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).cbp b/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).cbp new file mode 100644 index 0000000..0efa565 --- /dev/null +++ b/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).cbp @@ -0,0 +1,45 @@ + + + + + + diff --git a/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).depend b/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).depend new file mode 100644 index 0000000..b913962 --- /dev/null +++ b/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).depend @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1473539999 source:d:\unlam\programaciÓn\fabian 2\clase 08 (lote de prueba hardcodeando registros)\main.c + "header.h" + +1473539189 d:\unlam\programaciÓn\fabian 2\clase 08 (lote de prueba hardcodeando registros)\header.h + + + + + diff --git a/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).layout b/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).layout new file mode 100644 index 0000000..0db6c95 --- /dev/null +++ b/clase 08 (lote de prueba hardcodeando registros)/clase 08 (lote de prueba hardcodeando registros).layout @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/clase 08 (lote de prueba hardcodeando registros)/header.h b/clase 08 (lote de prueba hardcodeando registros)/header.h new file mode 100644 index 0000000..cb3b374 --- /dev/null +++ b/clase 08 (lote de prueba hardcodeando registros)/header.h @@ -0,0 +1,17 @@ +#include +#include +#include +#include +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; diff --git a/clase 08 (lote de prueba hardcodeando registros)/main.c b/clase 08 (lote de prueba hardcodeando registros)/main.c new file mode 100644 index 0000000..60a309d --- /dev/null +++ b/clase 08 (lote de prueba hardcodeando registros)/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + FILE*pf; + t_persona personas[5]={ {39210915,"Fabián Escobar",21,{3,8,1995}}, + {38798544,"Damián Fernández",31,{4,7,1987}}, + {40546112,"Florencia Urban",18,{17,03,1998}}, + {38168964,"Jacinto Loma",22,{16,12,1997}}, + {40985546,"Lucía Bota",17,{5,12,1999}} }; + pf=fopen("personas_hardcodeado.dat","wb"); + if(!pf) + { + printf("\n\n No se pudo crear el archivo \n\n\a\a"); + exit(1); + } + fwrite(personas,sizeof(t_persona),5,pf); + fclose(pf); + printf("\n\n El archivo \"personas_hardcodeado.dat\" fue grabado exitosamente \n"); + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/clase 08 (lote de prueba hardcodeando registros)/obj/Debug/main.o b/clase 08 (lote de prueba hardcodeando registros)/obj/Debug/main.o new file mode 100644 index 0000000..7b5be81 Binary files /dev/null and b/clase 08 (lote de prueba hardcodeando registros)/obj/Debug/main.o differ diff --git a/clase 08 (lote de prueba hardcodeando registros)/personas_hardcodeado.dat b/clase 08 (lote de prueba hardcodeando registros)/personas_hardcodeado.dat new file mode 100644 index 0000000..fe055af Binary files /dev/null and b/clase 08 (lote de prueba hardcodeando registros)/personas_hardcodeado.dat differ diff --git a/clase 08 (moviendo el puntero del fichero)/bin/Debug/clase 08 (moviendo el puntero del fichero).exe b/clase 08 (moviendo el puntero del fichero)/bin/Debug/clase 08 (moviendo el puntero del fichero).exe new file mode 100644 index 0000000..99fc5c6 Binary files /dev/null and b/clase 08 (moviendo el puntero del fichero)/bin/Debug/clase 08 (moviendo el puntero del fichero).exe differ diff --git a/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).cbp b/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).cbp new file mode 100644 index 0000000..2652690 --- /dev/null +++ b/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).cbp @@ -0,0 +1,45 @@ + + + + + + diff --git a/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).depend b/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).depend new file mode 100644 index 0000000..07f4eff --- /dev/null +++ b/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).depend @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1473542789 source:d:\unlam\programaciÓn\fabian 2\clase 08 (moviendo el puntero del fichero)\main.c + "header.h" + +1473541525 d:\unlam\programaciÓn\fabian 2\clase 08 (moviendo el puntero del fichero)\header.h + + + + + diff --git a/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).layout b/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).layout new file mode 100644 index 0000000..a588468 --- /dev/null +++ b/clase 08 (moviendo el puntero del fichero)/clase 08 (moviendo el puntero del fichero).layout @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/clase 08 (moviendo el puntero del fichero)/header.h b/clase 08 (moviendo el puntero del fichero)/header.h new file mode 100644 index 0000000..86476ad --- /dev/null +++ b/clase 08 (moviendo el puntero del fichero)/header.h @@ -0,0 +1,18 @@ +#include +#include +#include +#include +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; + diff --git a/clase 08 (moviendo el puntero del fichero)/main.c b/clase 08 (moviendo el puntero del fichero)/main.c new file mode 100644 index 0000000..ff56881 --- /dev/null +++ b/clase 08 (moviendo el puntero del fichero)/main.c @@ -0,0 +1,35 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + FILE *pf; + t_persona per; + printf("\n\n MOVIENDO EL PUNTERO DEL FICHERO \n"); + pf=fopen("personas.dat","rb"); + if(!pf) + { + printf("\n\n El archivo está corrupto \n\n\a\a"); + exit(1); + } + + printf("\n\n Tercer registro del archivo \"personas.dat\": \n\n"); + fseek(pf,sizeof(t_persona)*2L,SEEK_CUR); + fread(&per,sizeof(t_persona),1,pf); + printf("\n\n DNI: \t %d \t Nombre y apellido: \t %s \n Edad: \t %d \t Fecha de nacimiento: \t %d/%d/%d \n",per.dni,per.nomb,per.edad,per.f_nac.d,per.f_nac.m,per.f_nac.a); + + printf("\n\n Rebobino el fichero \n"); + rewind(pf); + // fseek(pf,0L,SEEK_SET); es lo mismo que hacer esto + printf("\n\n Primer registro del archivo \"personas.dat\": \n\n"); + fread(&per,sizeof(t_persona),1,pf); + printf("\n\n DNI: \t %d \t Nombre y apellido: \t %s \n Edad: \t %d \t Fecha de nacimiento: \t %d/%d/%d \n",per.dni,per.nomb,per.edad,per.f_nac.d,per.f_nac.m,per.f_nac.a); + + printf("\n\n Tamaño de un registro en bytes: \t %d \n",ftell(pf)); + fseek(pf,0L,SEEK_END); + printf("\n\n Tamaño del fichero medido en bytes: \t %d \n",ftell(pf)); + printf("\n\n Cantidad de registros grabados en el fichero: \t %d \n",ftell(pf)/sizeof(t_persona)); + fclose(pf); + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/clase 08 (moviendo el puntero del fichero)/obj/Debug/main.o b/clase 08 (moviendo el puntero del fichero)/obj/Debug/main.o new file mode 100644 index 0000000..0f05fd4 Binary files /dev/null and b/clase 08 (moviendo el puntero del fichero)/obj/Debug/main.o differ diff --git a/clase 08 (moviendo el puntero del fichero)/personas.dat b/clase 08 (moviendo el puntero del fichero)/personas.dat new file mode 100644 index 0000000..105b70c Binary files /dev/null and b/clase 08 (moviendo el puntero del fichero)/personas.dat differ diff --git a/clase 09 (archivo bin a txt long fija y variable)/bin/Debug/clase 09 (archivo bin a txt long fija y variable).exe b/clase 09 (archivo bin a txt long fija y variable)/bin/Debug/clase 09 (archivo bin a txt long fija y variable).exe new file mode 100644 index 0000000..207e782 Binary files /dev/null and b/clase 09 (archivo bin a txt long fija y variable)/bin/Debug/clase 09 (archivo bin a txt long fija y variable).exe differ diff --git a/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).cbp b/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).cbp new file mode 100644 index 0000000..05f5429 --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).depend b/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).depend new file mode 100644 index 0000000..9cd3e67 --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).depend @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1473885502 source:d:\unlam\programaciÓn\fabian 2\clase 09 (archivo bin a txt long fija y variable)\functions.c + "header.h" + +1473885264 d:\unlam\programaciÓn\fabian 2\clase 09 (archivo bin a txt long fija y variable)\header.h + + + + + diff --git a/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).layout b/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).layout new file mode 100644 index 0000000..c742316 --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/clase 09 (archivo bin a txt long fija y variable).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 09 (archivo bin a txt long fija y variable)/functions.c b/clase 09 (archivo bin a txt long fija y variable)/functions.c new file mode 100644 index 0000000..923c7bf --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/functions.c @@ -0,0 +1,23 @@ +#include "header.h" +a_longitud_variable(FILE *pf_bin,FILE *pf_txt) + { + t_persona persona; + rewind(pf_bin); + fread(&persona,sizeof(t_persona),1,pf_bin); + while(!feof(pf_bin)) + { + fprintf(pf_txt,"%d|%s|%d|%d/%d/%d\n",persona.dni,persona.nomb,persona.edad,persona.f_nac.d,persona.f_nac.m,persona.f_nac.a); + fread(&persona,sizeof(t_persona),1,pf_bin); + } + } +a_longitud_fija(FILE *pf_bin,FILE *pf_txt) + { + t_persona persona; + rewind(pf_bin); + fread(&persona,sizeof(t_persona),1,pf_bin); + while(!feof(pf_bin)) + { + fprintf(pf_txt,"%8d %-31s %2d %02d/%02d/%02d \n",persona.dni,persona.nomb,persona.edad,persona.f_nac.d,persona.f_nac.m,persona.f_nac.a); + fread(&persona,sizeof(t_persona),1,pf_bin); + } + } diff --git a/clase 09 (archivo bin a txt long fija y variable)/header.h b/clase 09 (archivo bin a txt long fija y variable)/header.h new file mode 100644 index 0000000..719533c --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/header.h @@ -0,0 +1,21 @@ +#include +#include +#include +#include + +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; + +void a_longitud_variable(FILE*,FILE*); +void a_longitud_fija(FILE*,FILE*); diff --git a/clase 09 (archivo bin a txt long fija y variable)/longitud_fija.txt b/clase 09 (archivo bin a txt long fija y variable)/longitud_fija.txt new file mode 100644 index 0000000..61780c2 --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/longitud_fija.txt @@ -0,0 +1,8 @@ +39210915 Fabi n Escobar 21 03/08/1995 +37894876 Hern n Flores 24 06/09/1992 +39876584 Mariela Gonz lez 20 12/07/1996 +38746825 Juli n G¢mez 21 23/09/1994 +26458458 Jorge Mart¡nez 51 26/04/1965 +16548965 Maricel Sarate 53 05/05/1963 +40195488 Malena Igotes 19 13/03/1997 +12578445 Rogelio Fulgencio Adede 78 29/08/1938 diff --git a/clase 09 (archivo bin a txt long fija y variable)/longitud_variable.txt b/clase 09 (archivo bin a txt long fija y variable)/longitud_variable.txt new file mode 100644 index 0000000..92fbcf7 --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/longitud_variable.txt @@ -0,0 +1,8 @@ +39210915|Fabi n Escobar|21|3/8/1995 +37894876|Hern n Flores|24|6/9/1992 +39876584|Mariela Gonz lez|20|12/7/1996 +38746825|Juli n G¢mez|21|23/9/1994 +26458458|Jorge Mart¡nez|51|26/4/1965 +16548965|Maricel Sarate|53|5/5/1963 +40195488|Malena Igotes|19|13/3/1997 +12578445|Rogelio Fulgencio Adede|78|29/8/1938 diff --git a/clase 09 (archivo bin a txt long fija y variable)/main.c b/clase 09 (archivo bin a txt long fija y variable)/main.c new file mode 100644 index 0000000..0459f83 --- /dev/null +++ b/clase 09 (archivo bin a txt long fija y variable)/main.c @@ -0,0 +1,35 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PASAR ARCHIVO BINARIO A ARCHIVO DE TEXTO \n DE LONGITUD FIJA Y DE LONGITUD VARIABLE \n"); + FILE *pf_bin,*pf_txt_var,*pf_txt_fij; + pf_bin=fopen("personas.dat","rb"); + if(!pf_bin) + { + printf("\n No se pudo leer el archivo binario \n\a\a"); + exit(EXIT_FAILURE); + } + pf_txt_var=fopen("longitud_variable.txt","wt"); + if(!pf_txt_var) + { + printf("\n No se pudo crear el archivo de texto de longitud variable \n\a\a"); + fclose(pf_bin); + exit(EXIT_FAILURE); + } + pf_txt_fij=fopen("longitud_fija.txt","wt"); + if(!pf_txt_fij) + { + printf("\n No se pudo crear el archivo de texto de longitud fija \n\a\a"); + fclose(pf_bin); + fclose(pf_txt_var); + exit(EXIT_FAILURE); + } + a_longitud_variable(pf_bin,pf_txt_var); + a_longitud_fija(pf_bin,pf_txt_fij); + printf("\n\n Se ha creado el archivo de texto \"longitud_variable.txt\""); + printf("\n\n Se ha creado el archivo de texto \"longitud_fija.txt\""); + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/clase 09 (archivo bin a txt long fija y variable)/obj/Debug/functions.o b/clase 09 (archivo bin a txt long fija y variable)/obj/Debug/functions.o new file mode 100644 index 0000000..6f470c4 Binary files /dev/null and b/clase 09 (archivo bin a txt long fija y variable)/obj/Debug/functions.o differ diff --git a/clase 09 (archivo bin a txt long fija y variable)/obj/Debug/main.o b/clase 09 (archivo bin a txt long fija y variable)/obj/Debug/main.o new file mode 100644 index 0000000..b13f6ab Binary files /dev/null and b/clase 09 (archivo bin a txt long fija y variable)/obj/Debug/main.o differ diff --git a/clase 09 (archivo bin a txt long fija y variable)/personas.dat b/clase 09 (archivo bin a txt long fija y variable)/personas.dat new file mode 100644 index 0000000..230eab3 Binary files /dev/null and b/clase 09 (archivo bin a txt long fija y variable)/personas.dat differ diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/LEEME ANTES DE EJECUTAR EL PROYECTO.txt b/clase 09 (controlar y corregir edades de un archivo binario)/LEEME ANTES DE EJECUTAR EL PROYECTO.txt new file mode 100644 index 0000000..9ff6a4e --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/LEEME ANTES DE EJECUTAR EL PROYECTO.txt @@ -0,0 +1 @@ +CAMBIAR LA FECHA ACTUAL DENTRO DE LA FUNCIÓN QUE CALCULA LA EDAD ........!!!!!!!!!!! \ No newline at end of file diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/bin/Debug/clase 09 (controlar y corregir edades de un archivo binario).exe b/clase 09 (controlar y corregir edades de un archivo binario)/bin/Debug/clase 09 (controlar y corregir edades de un archivo binario).exe new file mode 100644 index 0000000..b28aecb Binary files /dev/null and b/clase 09 (controlar y corregir edades de un archivo binario)/bin/Debug/clase 09 (controlar y corregir edades de un archivo binario).exe differ diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).cbp b/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).cbp new file mode 100644 index 0000000..09d21fa --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).depend b/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).depend new file mode 100644 index 0000000..9c237cf --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473815362 source:d:\unlam\programaciÓn\fabian 2\clase 09 (controlar y corregir edades de un archivo binario)\functions.c + "header.h" + +1473813957 d:\unlam\programaciÓn\fabian 2\clase 09 (controlar y corregir edades de un archivo binario)\header.h + + + + + +1473815194 source:d:\unlam\programaciÓn\fabian 2\clase 09 (controlar y corregir edades de un archivo binario)\main.c + "header.h" + diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).layout b/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).layout new file mode 100644 index 0000000..2cf3fce --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/clase 09 (controlar y corregir edades de un archivo binario).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/functions.c b/clase 09 (controlar y corregir edades de un archivo binario)/functions.c new file mode 100644 index 0000000..ea5daf5 --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/functions.c @@ -0,0 +1,39 @@ +#include "header.h" +void mostrar_archivo(FILE *pf) + { + t_persona persona; + rewind(pf); + fread(&persona,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: \t %d \t Nombre y Apellido: \t %s \n Edad: \t %d \t Fecha de nacimiento: \t %d/%d/%d \n",persona.dni,persona.nomb,persona.edad,persona.f_nac.d,persona.f_nac.m,persona.f_nac.a); + fread(&persona,sizeof(t_persona),1,pf); + } + } +void controlar_y_corregir_edad(FILE *pf) + { + t_persona persona; + int edad; + rewind(pf); + fread(&persona,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + if(persona.edad!=(edad=calcular_edad(&persona.f_nac))) + { + persona.edad=edad; + fseek(pf,-sizeof(t_persona),SEEK_CUR); + fwrite(&persona,sizeof(t_persona),1,pf); + fseek(pf,0L,SEEK_CUR); + } + fread(&persona,sizeof(t_persona),1,pf); + } + } +int calcular_edad(t_fecha *f_nac) + { + t_fecha f_act = {13,9,2016};//debería ingresarse por teclado la edad o trabajar con la fecha del sistema ->> acá está hecho así porque la idea es utilizar este programa solo en esta oportinidad + int edad; + edad=f_act.a-f_nac->a; + if(f_act.mm||(f_act.m==f_nac->m&&f_act.dd)) + edad--; + return edad; + } diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/header.h b/clase 09 (controlar y corregir edades de un archivo binario)/header.h new file mode 100644 index 0000000..498565a --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/header.h @@ -0,0 +1,20 @@ +#include +#include +#include +#include +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; +void mostrar_archivo(FILE*); +void controlar_y_corregir_edad(FILE*); +int calcular_edad(t_fecha*); diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/main.c b/clase 09 (controlar y corregir edades de un archivo binario)/main.c new file mode 100644 index 0000000..7d9595c --- /dev/null +++ b/clase 09 (controlar y corregir edades de un archivo binario)/main.c @@ -0,0 +1,28 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n CONTROLAR Y CORREGIR EDADES \n"); + printf("\n\n Con este programa controlamos que las edades \n de los registros del archivo \"personas.dat\" tengan las edades que corresponden, \n y de no ser así, las corregimos \n"); + + FILE *pf; + pf=fopen("personas.dat","r+b"); + if(!pf) + { + printf("\n\n No se pudo abrir el archivo. \n No tiene sentido continuar con la ejecución del progra \n"); + printf("\n Programa abortado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n ARCHIVO ANTES DEL CONTROL \n"); + mostrar_archivo(pf); + + printf("\n ARCHIVO DESPUÉS DEL CONTROL \n"); + controlar_y_corregir_edad(pf); + mostrar_archivo(pf); + + fclose(pf); + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/obj/Debug/functions.o b/clase 09 (controlar y corregir edades de un archivo binario)/obj/Debug/functions.o new file mode 100644 index 0000000..91e61fe Binary files /dev/null and b/clase 09 (controlar y corregir edades de un archivo binario)/obj/Debug/functions.o differ diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/obj/Debug/main.o b/clase 09 (controlar y corregir edades de un archivo binario)/obj/Debug/main.o new file mode 100644 index 0000000..e17ac0c Binary files /dev/null and b/clase 09 (controlar y corregir edades de un archivo binario)/obj/Debug/main.o differ diff --git a/clase 09 (controlar y corregir edades de un archivo binario)/personas.dat b/clase 09 (controlar y corregir edades de un archivo binario)/personas.dat new file mode 100644 index 0000000..230eab3 Binary files /dev/null and b/clase 09 (controlar y corregir edades de un archivo binario)/personas.dat differ diff --git a/clase 09 (escribiendo algo en archivo de texto)/bin/Debug/clase 09 (escribiendo algo en archivo de texto).exe b/clase 09 (escribiendo algo en archivo de texto)/bin/Debug/clase 09 (escribiendo algo en archivo de texto).exe new file mode 100644 index 0000000..706c74c Binary files /dev/null and b/clase 09 (escribiendo algo en archivo de texto)/bin/Debug/clase 09 (escribiendo algo en archivo de texto).exe differ diff --git a/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).cbp b/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).cbp new file mode 100644 index 0000000..b7546ba --- /dev/null +++ b/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).cbp @@ -0,0 +1,45 @@ + + + + + + diff --git a/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).depend b/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).depend new file mode 100644 index 0000000..8cc30d8 --- /dev/null +++ b/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).depend @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1473882050 source:d:\unlam\programaciÓn\fabian 2\clase 09 (escribiendo algo en archivo de texto)\main.c + "header.h" + +1473880526 d:\unlam\programaciÓn\fabian 2\clase 09 (escribiendo algo en archivo de texto)\header.h + + + + + diff --git a/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).layout b/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).layout new file mode 100644 index 0000000..a5c46b3 --- /dev/null +++ b/clase 09 (escribiendo algo en archivo de texto)/clase 09 (escribiendo algo en archivo de texto).layout @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/clase 09 (escribiendo algo en archivo de texto)/fichero.txt b/clase 09 (escribiendo algo en archivo de texto)/fichero.txt new file mode 100644 index 0000000..2bd44a5 --- /dev/null +++ b/clase 09 (escribiendo algo en archivo de texto)/fichero.txt @@ -0,0 +1,43 @@ + + Principio del archivo de texto +a +b +c + + cada vez esto se pone más lindo +123456789 +123456789 + 123456789 + 123456789 + 123456789 + 123456789 + 123456789 123456789 123456789 + 123456789123456789123456789 + 0123456789 123456789 1234567890 + +Fabián Norberto Escobar +Fabián Norberto Escobar + Fabián Norberto Escobar + Fabián Norberto Escobar + Fabián Norberto Escobar + Fabián Norberto Escobar + Fabián Norberto Escobar + Fabián Norberto Escobar +Fabián Norberto EscobarFabián Norberto EscobarFabián Norberto Escobar + Fabián Norberto Escobar Fabián Norberto Escobar Fabián Norberto Escobar + Fabián Norberto Escobar 123456789 + Fabián Norberto Escobar 123456789 + Fabián Norberto Escobar 123456789 + Fabián Norberto Escobar 123456789 + 123456789 Fabián Norberto Escobar + 123456789 Fabián Norberto Escobar + 123456789 Fabián Norberto Escobar + 123456789 Fabián Norberto Escobar + Fabián Norberto Escobar 123456789 + Fabián Norberto Escobar 123456789 + Fabián Norberto Escobar 123456789 + Fabián Norberto Escobar 123456789 + 123456789 Fabián Norberto Escobar + 123456789 Fabián Norberto Escobar + 123456789 Fabián Norberto Escobar + 123456789 Fabián Norberto Escobar \ No newline at end of file diff --git a/clase 09 (escribiendo algo en archivo de texto)/header.h b/clase 09 (escribiendo algo en archivo de texto)/header.h new file mode 100644 index 0000000..272c310 --- /dev/null +++ b/clase 09 (escribiendo algo en archivo de texto)/header.h @@ -0,0 +1,5 @@ +#include +#include +#include +#include + diff --git a/clase 09 (escribiendo algo en archivo de texto)/main.c b/clase 09 (escribiendo algo en archivo de texto)/main.c new file mode 100644 index 0000000..b0a76e1 --- /dev/null +++ b/clase 09 (escribiendo algo en archivo de texto)/main.c @@ -0,0 +1,72 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n Escribiendo algo en un archivo \n"); + int num=123456789; + char cadena[30]="Fabián Norberto Escobar"; + FILE *pf; + pf=fopen("fichero.txt","wt"); + if(!pf) + { + printf("\n\n No se pudo generar el archivo"); + printf("\n\n No tiene sentido continuar con la ejecución del programa \n\n Programa evacuado \a\a"); + exit(EXIT_FAILURE); + } + fprintf(pf,"\n Principio del archivo de texto\n"); + + fputc('a',pf); + fputc('\n',pf); + fputc('b',pf); + fputc('\n',pf); + fputc('c',pf); + fputc('\n',pf); + + fputs("\n cada vez esto se pone más lindo \n",pf); + + fprintf(pf,"%d\n",num); + fprintf(pf,"%-d\n",num); + fprintf(pf," %d\n",num); + fprintf(pf," %-d\n",num); + fprintf(pf,"\t%d\n",num); + fprintf(pf,"\t%-d\n",num); + fprintf(pf," %d %d %d\n",num,num,num); + fprintf(pf," %d%d%d\n",num,num,num); + fprintf(pf," 0%d %d %0d0\n",num,num,num); + + fprintf(pf,"\n%s",cadena); + fprintf(pf,"\n%-s",cadena); + fprintf(pf,"\n %s",cadena); + fprintf(pf,"\n %-s",cadena); + fprintf(pf,"\n\t%s",cadena); + fprintf(pf,"\n\t %s",cadena); + fprintf(pf,"\n \t %s",cadena); + fprintf(pf,"\n \t %-s",cadena); + fprintf(pf,"\n%s%s%s",cadena,cadena,cadena); + fprintf(pf,"\n %s %s %s",cadena,cadena,cadena); + + fprintf(pf,"\n %s %d",cadena,num); + fprintf(pf,"\n %-s %d",cadena,num); + fprintf(pf,"\n %s %-d",cadena,num); + fprintf(pf,"\n %-s %-d",cadena,num); + + fprintf(pf,"\n %d %s",num,cadena); + fprintf(pf,"\n %-d %s",num,cadena); + fprintf(pf,"\n %d %-s",num,cadena); + fprintf(pf,"\n %-d %-s",num,cadena); + + fprintf(pf,"\n %40s %10d",cadena,num); + fprintf(pf,"\n %-40s %10d",cadena,num); + fprintf(pf,"\n %40s %-10d",cadena,num); + fprintf(pf,"\n %-40s %-10d",cadena,num); + + fprintf(pf,"\n %d %20s",num,cadena); + fprintf(pf,"\n %-20d %s",num,cadena); + fprintf(pf,"\n %d %-20s",num,cadena); + fprintf(pf,"\n %-20d %-s",num,cadena); + + fclose(pf); + printf("\n\n Se ha generado el archivo \"fichero.txt\" \n\n Fin del programa.. \n\n") +; getch(); + return 0; + } diff --git a/clase 09 (escribiendo algo en archivo de texto)/obj/Debug/main.o b/clase 09 (escribiendo algo en archivo de texto)/obj/Debug/main.o new file mode 100644 index 0000000..ac16a65 Binary files /dev/null and b/clase 09 (escribiendo algo en archivo de texto)/obj/Debug/main.o differ diff --git a/clase 10 (archivo txt long fija y variable a bin)/bin/Debug/clase 10 (archivo txt long fija y variable a bin).exe b/clase 10 (archivo txt long fija y variable a bin)/bin/Debug/clase 10 (archivo txt long fija y variable a bin).exe new file mode 100644 index 0000000..d837bb9 Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin)/bin/Debug/clase 10 (archivo txt long fija y variable a bin).exe differ diff --git a/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).cbp b/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).cbp new file mode 100644 index 0000000..6e09990 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).depend b/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).depend new file mode 100644 index 0000000..62d31a7 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474168373 source:d:\unlam\programaciÓn\fabian 2\clase 10 (archivo txt long fija y variable a bin)\functions.c + "header.h" + +1474163399 d:\unlam\programaciÓn\fabian 2\clase 10 (archivo txt long fija y variable a bin)\header.h + + + + + +1474168283 source:d:\unlam\programaciÓn\fabian 2\clase 10 (archivo txt long fija y variable a bin)\main.c + "header.h" + diff --git a/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).layout b/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).layout new file mode 100644 index 0000000..36532e3 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/clase 10 (archivo txt long fija y variable a bin).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 10 (archivo txt long fija y variable a bin)/functions.c b/clase 10 (archivo txt long fija y variable a bin)/functions.c new file mode 100644 index 0000000..ea7f921 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/functions.c @@ -0,0 +1,29 @@ +#include "header.h" + +void longitud_variable_a_binario(FILE *pf_txt_var,FILE *pf_bin_var) + { + t_persona persona; + rewind(pf_txt_var); + while(fscanf(pf_txt_var,"%d|%[^|]|%d|%d/%d/%d",&persona.dni,persona.nomb,&persona.edad,&persona.f_nac.d,&persona.f_nac.m,&persona.f_nac.a)!=EOF) + fwrite(&persona,sizeof(t_persona),1,pf_bin_var); + } + +void longitud_fija_a_binario(FILE *pf_txt_fij,FILE *pf_bin_fij) + { + t_persona persona; + rewind(pf_txt_fij); + while(fscanf(pf_txt_fij,"%8d%[^0123456789]%2d%2d/%2d/%4d",&persona.dni,persona.nomb,&persona.edad,&persona.f_nac.d,&persona.f_nac.m,&persona.f_nac.a)!=EOF) + fwrite(&persona,sizeof(t_persona),1,pf_bin_fij); + } + +//lo próximo lo dejo acá para controlar q lo haya hecho bien +void leer_archivo(FILE **pf) + { + t_persona per; + fread(&per,sizeof(t_persona),1,*pf); + while(!feof(*pf)) + { + printf("\n\n DNI: \t %d \t Nombre y apellido: \t %s \n Edad: \t %d \t Fecha de nacimiento: \t %d/%d/%d \n",per.dni,per.nomb,per.edad,per.f_nac.d,per.f_nac.m,per.f_nac.a); + fread(&per,sizeof(t_persona),1,*pf); + } + } diff --git a/clase 10 (archivo txt long fija y variable a bin)/header.h b/clase 10 (archivo txt long fija y variable a bin)/header.h new file mode 100644 index 0000000..91b84ec --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/header.h @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; + +void longitud_variable_a_binario(FILE*,FILE*); +void longitud_fija_a_binario(FILE*,FILE*); +void leer_archivo(FILE**); diff --git a/clase 10 (archivo txt long fija y variable a bin)/longitud_fija.txt b/clase 10 (archivo txt long fija y variable a bin)/longitud_fija.txt new file mode 100644 index 0000000..61780c2 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/longitud_fija.txt @@ -0,0 +1,8 @@ +39210915 Fabi n Escobar 21 03/08/1995 +37894876 Hern n Flores 24 06/09/1992 +39876584 Mariela Gonz lez 20 12/07/1996 +38746825 Juli n G¢mez 21 23/09/1994 +26458458 Jorge Mart¡nez 51 26/04/1965 +16548965 Maricel Sarate 53 05/05/1963 +40195488 Malena Igotes 19 13/03/1997 +12578445 Rogelio Fulgencio Adede 78 29/08/1938 diff --git a/clase 10 (archivo txt long fija y variable a bin)/longitud_variable.txt b/clase 10 (archivo txt long fija y variable a bin)/longitud_variable.txt new file mode 100644 index 0000000..92fbcf7 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/longitud_variable.txt @@ -0,0 +1,8 @@ +39210915|Fabi n Escobar|21|3/8/1995 +37894876|Hern n Flores|24|6/9/1992 +39876584|Mariela Gonz lez|20|12/7/1996 +38746825|Juli n G¢mez|21|23/9/1994 +26458458|Jorge Mart¡nez|51|26/4/1965 +16548965|Maricel Sarate|53|5/5/1963 +40195488|Malena Igotes|19|13/3/1997 +12578445|Rogelio Fulgencio Adede|78|29/8/1938 diff --git a/clase 10 (archivo txt long fija y variable a bin)/main.c b/clase 10 (archivo txt long fija y variable a bin)/main.c new file mode 100644 index 0000000..47b04e6 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin)/main.c @@ -0,0 +1,79 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PASAR ARCHIVO DE TEXTO DE LONGITUD FIJA Y VARIABLE \n A ARCHIVO DE TEXTO \n\n"); + FILE *pf_txt_var,*pf_txt_fij,*pf_bin_fij,*pf_bin_var; + pf_txt_fij=fopen("longitud_fija.txt","rb"); + if(!pf_txt_fij) + { + printf("\n No se pudo leer el archivo de texto de longitud fija \n\a\a"); + exit(EXIT_FAILURE); + } + pf_txt_var=fopen("longitud_variable.txt","rb"); + if(!pf_txt_var) + { + printf("\n No se pudo leer el archivo de texto de longitud variable \n\a\a"); + fclose(pf_txt_fij); + exit(EXIT_FAILURE); + } + pf_bin_fij=fopen("personas_fija.bin","wb"); + if(!pf_bin_fij) + { + printf("\n No se pudo crear el archivo binario para pasar \n el archivo de texto de longitud fija \n\a\a"); + fclose(pf_txt_fij); + fclose(pf_txt_var); + exit(EXIT_FAILURE); + } + pf_bin_var=fopen("personas_variable.bin","wb"); + if(!pf_bin_var) + { + printf("\n No se pudo crear el archivo binario para pasar \n el archivo de texto de longitud variable \n\a\a"); + fclose(pf_txt_fij); + fclose(pf_txt_var); + fclose(pf_bin_fij); + exit(EXIT_FAILURE); + } + longitud_variable_a_binario(pf_txt_var,pf_bin_var); + longitud_fija_a_binario(pf_txt_fij,pf_bin_fij); + fclose(pf_txt_var); + fclose(pf_txt_fij); + fclose(pf_bin_var); + fclose(pf_bin_fij); + printf("\n\n Se ha creado el archivo binario \"personas_fija.bin\""); + printf("\n\n Se ha creado el archivo binario \"personas_variable.bin\""); + + //---------------------------------------------------------------------------- + //acá controlo que esté todo funcionando OK + + FILE *pf,*pf2; + printf("\n\n BIN VAR \n\n"); + pf=fopen("personas_variable.bin","rb"); + + if(!pf) + { + printf("\n\n No se pudo abrir el archivo \n\n\a\a"); + return 0; + } + leer_archivo(&pf); + printf("\n\n El archivo fue leído correctamente \n\n"); + fclose(pf); + + printf("\n\n BIN FIJ \n\n"); + + pf2=fopen("personas_fija.bin","rb"); + + if(!pf2) + { + printf("\n\n No se pudo abrir el archivo \n\n\a\a"); + return 0; + } + leer_archivo(&pf2); + printf("\n\n El archivo fue leído correctamente \n\n"); + fclose(pf2); + + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git a/clase 10 (archivo txt long fija y variable a bin)/obj/Debug/functions.o b/clase 10 (archivo txt long fija y variable a bin)/obj/Debug/functions.o new file mode 100644 index 0000000..6c6a60f Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin)/obj/Debug/functions.o differ diff --git a/clase 10 (archivo txt long fija y variable a bin)/obj/Debug/main.o b/clase 10 (archivo txt long fija y variable a bin)/obj/Debug/main.o new file mode 100644 index 0000000..8dbb972 Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin)/obj/Debug/main.o differ diff --git a/clase 10 (archivo txt long fija y variable a bin)/personas_fija.bin b/clase 10 (archivo txt long fija y variable a bin)/personas_fija.bin new file mode 100644 index 0000000..d3e7c8e Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin)/personas_fija.bin differ diff --git a/clase 10 (archivo txt long fija y variable a bin)/personas_variable.bin b/clase 10 (archivo txt long fija y variable a bin)/personas_variable.bin new file mode 100644 index 0000000..23d000a Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin)/personas_variable.bin differ diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/bin/Debug/clase 10 (archivo txt long fija y variable a bin, forma lopez).exe b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/bin/Debug/clase 10 (archivo txt long fija y variable a bin, forma lopez).exe new file mode 100644 index 0000000..1c91aad Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/bin/Debug/clase 10 (archivo txt long fija y variable a bin, forma lopez).exe differ diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).cbp b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).cbp new file mode 100644 index 0000000..b98c055 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).depend b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).depend new file mode 100644 index 0000000..8654e8a --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474168247 source:d:\unlam\programaciÓn\fabian 2\clase 10 (archivo txt long fija y variable a bin, forma lopez)\main.c + "header.h" + +1474171509 d:\unlam\programaciÓn\fabian 2\clase 10 (archivo txt long fija y variable a bin, forma lopez)\header.h + + + + + +1474171100 source:d:\unlam\programaciÓn\fabian 2\clase 10 (archivo txt long fija y variable a bin, forma lopez)\functions.c + "header.h" + diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).layout b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).layout new file mode 100644 index 0000000..9a3e265 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/clase 10 (archivo txt long fija y variable a bin, forma lopez).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/functions.c b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/functions.c new file mode 100644 index 0000000..30b9442 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/functions.c @@ -0,0 +1,102 @@ +#include "header.h" + +void longitud_variable_a_binario(FILE *pf_txt_var,FILE *pf_bin_var) + { + t_persona persona; + rewind(pf_txt_var); + char linea[500],*aux; + while(fgets(linea,sizeof(linea),pf_txt_var)) + { + aux=str_chr(linea,'\n'); + *aux='\0'; + aux=str_rchr(linea,'|'); + sscanf(aux+1,"%d/%d/%d",&persona.f_nac.d,&persona.f_nac.m,&persona.f_nac.a); + *aux='\0'; + aux=str_rchr(linea,'|'); + sscanf(aux+1,"%d",&persona.edad); + *aux='\0'; + aux=str_rchr(linea,'|'); + str_cpy(persona.nomb,aux+1); + *aux='\0'; + sscanf(linea,"%d",&persona.dni); + fwrite(&persona,sizeof(t_persona),1,pf_bin_var); + } + } + +void longitud_fija_a_binario(FILE *pf_txt_fij,FILE *pf_bin_fij) + { + t_persona persona; + rewind(pf_txt_fij); + char linea[500],*aux; + while(fgets(linea,sizeof(linea),pf_txt_fij)) + { + aux=str_chr(linea,'\n'); + *aux='\0'; + aux-=11; + sscanf(aux,"%02d/%2d/%04d",&persona.f_nac.d,&persona.f_nac.m,&persona.f_nac.a); + *(aux-1)='\0'; + aux-=4; + sscanf(aux,"%d",&persona.edad); + *(aux+-1)='\0'; + aux-=32; + str_cpy(persona.nomb,aux); + trim(persona.nomb); + *aux='\0'; + sscanf(linea,"%d",&persona.dni); + fwrite(&persona,sizeof(t_persona),1,pf_bin_fij); + } + } + +char *trim(char *s) + { + char *inicio=s; + while(*s) + s++; + while(s>inicio&&*s==' ') + s--; + *s='\0'; + return inicio; + } + +char *str_chr(char *s,int c) + { + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; + } + +char *str_rchr(char *s,int c) + { + char *inicio=s; + while(*s) + s++; + while(s>inicio&&*s!=c) + s--; + return (*s==c)?s:NULL; + } + +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } + +//lo próximo lo dejo acá para controlar q lo haya hecho bien +void leer_archivo(FILE **pf) + { + t_persona per; + fread(&per,sizeof(t_persona),1,*pf); + while(!feof(*pf)) + { + printf("\n\n DNI: \t %d \t Nombre y apellido: \t %s \n Edad: \t %d \t Fecha de nacimiento: \t %d/%d/%d \n",per.dni,per.nomb,per.edad,per.f_nac.d,per.f_nac.m,per.f_nac.a); + fread(&per,sizeof(t_persona),1,*pf); + } + } + diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/header.h b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/header.h new file mode 100644 index 0000000..39946d9 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/header.h @@ -0,0 +1,28 @@ +#include +#include +#include +#include + +typedef struct + { + int d, + m, + a; + }t_fecha; +typedef struct + { + int dni; + char nomb[30]; + int edad; + t_fecha f_nac; + }t_persona; + +void longitud_variable_a_binario(FILE*,FILE*); +void longitud_fija_a_binario(FILE*,FILE*); + +char *str_chr(char*,int); +char *str_rchr(char*,int); +char *str_cpy(char*,const char*); +char *trim(char*); +void leer_archivo(FILE**); + diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/longitud_fija.txt b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/longitud_fija.txt new file mode 100644 index 0000000..61780c2 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/longitud_fija.txt @@ -0,0 +1,8 @@ +39210915 Fabi n Escobar 21 03/08/1995 +37894876 Hern n Flores 24 06/09/1992 +39876584 Mariela Gonz lez 20 12/07/1996 +38746825 Juli n G¢mez 21 23/09/1994 +26458458 Jorge Mart¡nez 51 26/04/1965 +16548965 Maricel Sarate 53 05/05/1963 +40195488 Malena Igotes 19 13/03/1997 +12578445 Rogelio Fulgencio Adede 78 29/08/1938 diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/longitud_variable.txt b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/longitud_variable.txt new file mode 100644 index 0000000..92fbcf7 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/longitud_variable.txt @@ -0,0 +1,8 @@ +39210915|Fabi n Escobar|21|3/8/1995 +37894876|Hern n Flores|24|6/9/1992 +39876584|Mariela Gonz lez|20|12/7/1996 +38746825|Juli n G¢mez|21|23/9/1994 +26458458|Jorge Mart¡nez|51|26/4/1965 +16548965|Maricel Sarate|53|5/5/1963 +40195488|Malena Igotes|19|13/3/1997 +12578445|Rogelio Fulgencio Adede|78|29/8/1938 diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/main.c b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/main.c new file mode 100644 index 0000000..5381a38 --- /dev/null +++ b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/main.c @@ -0,0 +1,80 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PASAR ARCHIVO DE TEXTO DE LONGITUD FIJA Y VARIABLE \n A ARCHIVO DE TEXTO \n\n"); + FILE *pf_txt_var,*pf_txt_fij,*pf_bin_fij,*pf_bin_var; + pf_txt_fij=fopen("longitud_fija.txt","rb"); + if(!pf_txt_fij) + { + printf("\n No se pudo leer el archivo de texto de longitud fija \n\a\a"); + exit(EXIT_FAILURE); + } + pf_txt_var=fopen("longitud_variable.txt","rb"); + if(!pf_txt_var) + { + printf("\n No se pudo leer el archivo de texto de longitud variable \n\a\a"); + fclose(pf_txt_fij); + exit(EXIT_FAILURE); + } + pf_bin_fij=fopen("personas_fija.bin","wb"); + if(!pf_bin_fij) + { + printf("\n No se pudo crear el archivo binario para pasar \n el archivo de texto de longitud fija \n\a\a"); + fclose(pf_txt_fij); + fclose(pf_txt_var); + exit(EXIT_FAILURE); + } + pf_bin_var=fopen("personas_variable.bin","wb"); + if(!pf_bin_var) + { + printf("\n No se pudo crear el archivo binario para pasar \n el archivo de texto de longitud variable \n\a\a"); + fclose(pf_txt_fij); + fclose(pf_txt_var); + fclose(pf_bin_fij); + exit(EXIT_FAILURE); + } + longitud_variable_a_binario(pf_txt_var,pf_bin_var); + longitud_fija_a_binario(pf_txt_fij,pf_bin_fij); + fclose(pf_txt_var); + fclose(pf_txt_fij); + fclose(pf_bin_var); + fclose(pf_bin_fij); + printf("\n\n Se ha creado el archivo binario \"personas_fija.bin\""); + printf("\n\n Se ha creado el archivo binario \"personas_variable.bin\""); + + //---------------------------------------------------------------------------- + //acá controlo que esté todo funcionando OK + + FILE *pf,*pf2; + printf("\n\n BIN VAR \n\n"); + pf=fopen("personas_variable.bin","rb"); + + if(!pf) + { + printf("\n\n No se pudo abrir el archivo \n\n\a\a"); + return 0; + } + leer_archivo(&pf); + printf("\n\n El archivo fue leído correctamente \n\n"); + fclose(pf); + + printf("\n\n BIN FIJ \n\n"); + + pf2=fopen("personas_fija.bin","rb"); + + if(!pf2) + { + printf("\n\n No se pudo abrir el archivo \n\n\a\a"); + return 0; + } + leer_archivo(&pf2); + printf("\n\n El archivo fue leído correctamente \n\n"); + fclose(pf2); + + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } + diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/obj/Debug/functions.o b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/obj/Debug/functions.o new file mode 100644 index 0000000..82c4e3e Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/obj/Debug/functions.o differ diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/obj/Debug/main.o b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/obj/Debug/main.o new file mode 100644 index 0000000..9fa2b34 Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/obj/Debug/main.o differ diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/personas_fija.bin b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/personas_fija.bin new file mode 100644 index 0000000..1ef5180 Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/personas_fija.bin differ diff --git a/clase 10 (archivo txt long fija y variable a bin, forma lopez)/personas_variable.bin b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/personas_variable.bin new file mode 100644 index 0000000..219a30f Binary files /dev/null and b/clase 10 (archivo txt long fija y variable a bin, forma lopez)/personas_variable.bin differ diff --git a/clase 10 (las variables viven dentro del bloque en que se declaran)/bin/Debug/clase 10 (las variables viven dentro del bloque en que se declaran).exe b/clase 10 (las variables viven dentro del bloque en que se declaran)/bin/Debug/clase 10 (las variables viven dentro del bloque en que se declaran).exe new file mode 100644 index 0000000..8ad17fc Binary files /dev/null and b/clase 10 (las variables viven dentro del bloque en que se declaran)/bin/Debug/clase 10 (las variables viven dentro del bloque en que se declaran).exe differ diff --git a/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).cbp b/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).cbp new file mode 100644 index 0000000..b06b29f --- /dev/null +++ b/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).depend b/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).depend new file mode 100644 index 0000000..410cd51 --- /dev/null +++ b/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).depend @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1474479562 source:d:\unlam\programaciÓn\fabian 2\clase 10 (las variables viven dentro del bloque en que se declaran)\main.c + + + + diff --git a/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).layout b/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).layout new file mode 100644 index 0000000..0904dd8 --- /dev/null +++ b/clase 10 (las variables viven dentro del bloque en que se declaran)/clase 10 (las variables viven dentro del bloque en que se declaran).layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/clase 10 (las variables viven dentro del bloque en que se declaran)/main.c b/clase 10 (las variables viven dentro del bloque en que se declaran)/main.c new file mode 100644 index 0000000..fc026e0 --- /dev/null +++ b/clase 10 (las variables viven dentro del bloque en que se declaran)/main.c @@ -0,0 +1,25 @@ +#include +#include + +int main() +{ + printf("\n\n Las variables solo viven dentro del bloque en que se declaran \n\n"); + int x=4,i=4; + for(i=0;i<10;i++) + { + int x,j; + x=i; + for(j=9;j>0;j--) + { + int x; + x=j; + printf("\n x= %d \t (dentro del segundo for, interno al primer for)",x); + } + printf("\n\n x= %d \t (dentro del primer for) \n",x); + } + printf("\n\n x= %d \t (fuera de ambos for) \n\n",x); + + system("pause"); + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + return 0; +} diff --git a/clase 10 (las variables viven dentro del bloque en que se declaran)/obj/Debug/main.o b/clase 10 (las variables viven dentro del bloque en que se declaran)/obj/Debug/main.o new file mode 100644 index 0000000..1c69898 Binary files /dev/null and b/clase 10 (las variables viven dentro del bloque en que se declaran)/obj/Debug/main.o differ diff --git a/clase 10 (mem din ejemplos de uso)/bin/Debug/clase 10 (mem din ejemplos de uso).exe b/clase 10 (mem din ejemplos de uso)/bin/Debug/clase 10 (mem din ejemplos de uso).exe new file mode 100644 index 0000000..28b7d38 Binary files /dev/null and b/clase 10 (mem din ejemplos de uso)/bin/Debug/clase 10 (mem din ejemplos de uso).exe differ diff --git a/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).cbp b/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).cbp new file mode 100644 index 0000000..0ba871a --- /dev/null +++ b/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).cbp @@ -0,0 +1,44 @@ + + + + + + diff --git a/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).depend b/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).depend new file mode 100644 index 0000000..1ff7b4c --- /dev/null +++ b/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).depend @@ -0,0 +1,11 @@ +# depslib dependency file v1.0 +1474486365 source:d:\unlam\programaciÓn\fabian 2\clase 10 (mem din ejemplos de uso)\main.c + "header.h" + +1474484702 d:\unlam\programaciÓn\fabian 2\clase 10 (mem din ejemplos de uso)\header.h + + + + + + diff --git a/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).layout b/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).layout new file mode 100644 index 0000000..06d0e18 --- /dev/null +++ b/clase 10 (mem din ejemplos de uso)/clase 10 (mem din ejemplos de uso).layout @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/clase 10 (mem din ejemplos de uso)/header.h b/clase 10 (mem din ejemplos de uso)/header.h new file mode 100644 index 0000000..494c907 --- /dev/null +++ b/clase 10 (mem din ejemplos de uso)/header.h @@ -0,0 +1,13 @@ +#include +#include +#include +#include +#include + +typedef struct + { + int dni; + char apellido[20]; + char nombre[30]; + float promedio; + }t_alumno; diff --git a/clase 10 (mem din ejemplos de uso)/main.c b/clase 10 (mem din ejemplos de uso)/main.c new file mode 100644 index 0000000..037ebb7 --- /dev/null +++ b/clase 10 (mem din ejemplos de uso)/main.c @@ -0,0 +1,55 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + //AL ASIGNAR MEMORIA DE FORMA DINÁMICA, SE ESTÁ UTILIZANDO UN ESPACIO DE LA MEMORIA QUE SE CONOCE COMO HEAP + //ES DE LIBRE ACCESO PARA EL PROGRAMADOR + //QUIEN ES EL RESPONSABLE DE SU LIBERACIÓN + + t_alumno *al; + al=(t_alumno*)malloc(sizeof(t_alumno));//asigno menoria en forma dinámica + al->dni=39210915; + strcpy(al->apellido,"Escobar"); + strcpy(al->nombre,"Fabián Norberto"); + al->promedio=10; + //free(al);//libero memoria + //si bien libero la memoria puedo seguir accediéndolo.. la liberación no borra los datos, solamente desvincula el espacio de memoria para que pueda ser nuevamente adjudicada + puts("\n\n \t\t ALUMNO "); + printf("\n\n DNI: %d \t Alumno: %s, %s \t Promedio: %.2f \n",al->dni,al->apellido,al->nombre,al->promedio); + + free(al); + + int n,i; + t_alumno *alus; + printf("\n memoria para cuántos alumnos reservo? \t "); + scanf("%d",&n); + if(n==0) + exit(1); + alus=(t_alumno*)calloc(n,sizeof(t_alumno));//asigno memoria con calloc + + puts("\n\n ALUMNOS"); + for(i=0;idni,al->apellido,al->nombre,al->promedio); + + realloc(alus,sizeof(t_alumno)*(n/=2));//reasigna los primeros 5 elementos-->> el espacio restante lo deja libre para el uso + puts("\n\n ALUMNOS"); + for(i=0;idni,al->apellido,al->nombre,al->promedio); + + //t_alumno vec[10]; + + //free(vec); no se puede hacer esto ya que free libera memoria reservada por el programador, + // y esta memoria le pertenece al compilador + + free(alus); + + t_alumno *ptr; + ptr=(t_alumno*)realloc(NULL,2);//funciona como malloc + realloc(ptr,0);//funciona como free + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/clase 10 (mem din ejemplos de uso)/obj/Debug/main.o b/clase 10 (mem din ejemplos de uso)/obj/Debug/main.o new file mode 100644 index 0000000..278d807 Binary files /dev/null and b/clase 10 (mem din ejemplos de uso)/obj/Debug/main.o differ diff --git "a/clase 10 (memoria din\303\241mica)/bin/Debug/clase 10 (memoria din\303\241mica).exe" "b/clase 10 (memoria din\303\241mica)/bin/Debug/clase 10 (memoria din\303\241mica).exe" new file mode 100644 index 0000000..4c9daa3 Binary files /dev/null and "b/clase 10 (memoria din\303\241mica)/bin/Debug/clase 10 (memoria din\303\241mica).exe" differ diff --git "a/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).cbp" "b/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).cbp" new file mode 100644 index 0000000..1935a2d --- /dev/null +++ "b/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).depend" "b/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).depend" new file mode 100644 index 0000000..3211438 --- /dev/null +++ "b/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).depend" @@ -0,0 +1,7 @@ +# depslib dependency file v1.0 +1474480996 source:d:\unlam\programaciÓn\fabian 2\clase 10 (memoria dinámica)\main.c + + + + + diff --git "a/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).layout" "b/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).layout" new file mode 100644 index 0000000..76fb671 --- /dev/null +++ "b/clase 10 (memoria din\303\241mica)/clase 10 (memoria din\303\241mica).layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/clase 10 (memoria din\303\241mica)/main.c" "b/clase 10 (memoria din\303\241mica)/main.c" new file mode 100644 index 0000000..2757323 --- /dev/null +++ "b/clase 10 (memoria din\303\241mica)/main.c" @@ -0,0 +1,39 @@ +#include +#include +#include +#include + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + system("COLOR A0"); + + printf("\n\n MEMORIA DINÁMICA \n\n"); + + int *numPtr, i; + size_t tamanyo=0; + + printf( "\n Introduzca el tamaño de la lista: \n\t" ); + scanf( "%d", &tamanyo ); + + puts( "\n Adjudicamos espacio a la lista. \n\t" ); + numPtr = (int *)malloc( tamanyo*sizeof(int) ); + + for( i=0; i + + + + + diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones).depend" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones).depend" new file mode 100644 index 0000000..d0d309e --- /dev/null +++ "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones).depend" @@ -0,0 +1,14 @@ +# depslib dependency file v1.0 +1474497875 source:d:\unlam\programaciÓn\fabian 2\clase 10 (ordenamiento por selección, puntero a funciones)\functions.c + "header.h" + +1474497685 d:\unlam\programaciÓn\fabian 2\clase 10 (ordenamiento por selección, puntero a funciones)\header.h + + + + + + +1474498104 source:d:\unlam\programaciÓn\fabian 2\clase 10 (ordenamiento por selección, puntero a funciones)\main.c + "header.h" + diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones).layout" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones).layout" new file mode 100644 index 0000000..35e10aa --- /dev/null +++ "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones).layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/functions.c" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/functions.c" new file mode 100644 index 0000000..0b14285 --- /dev/null +++ "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/functions.c" @@ -0,0 +1,109 @@ +#include "header.h" + +void ordenamiento_seleccion(void *v,int ce,size_t tam,t_cmp comparar)//void ordenamiento_seleccion(void *v,int ce,size_t tam,int(*comparar)(const void*,const void*)) + { + void *bmenor,*menor,*ult=v+(ce-1)*tam; + if(ce<=1) + return; + while(v*(int*)arg2) + return 1; + else + return 0; + } +*/ + +int comparar_float(const void *arg1,const void *arg2) + { + if(*(float*)arg1<*(float*)arg2) + return -1; + else + if(*(float*)arg1>*(float*)arg2) + return 1; + else + return 0; + } + +int comparar_char(const void *arg1,const void *arg2) + { + if(*(char*)arg1<*(char*)arg2) + return -1; + else + if(*(char*)arg1>*(char*)arg2) + return 1; + else + return 0; + } + +int comparar_string(const void *arg1,const void *arg2) + { + return str_icmp((char*)arg1,(char*)arg2); + } + +int comparar_apellido_personas(const void *arg1,const void *arg2) + { + return str_icmp(((t_persona*)arg1)->apellido,((t_persona*)arg2)->apellido); + } + +int comparar_nombre_personas(const void *arg1,const void *arg2) + { + return str_icmp(((t_persona*)arg1)->nombre,((t_persona*)arg2)->nombre); + } + +int comparar_dni_personas(const void *arg1,const void *arg2) + { + return ((t_persona*)arg1)->dni-((t_persona*)arg2)->dni; + } + +int comparar_edad_personas(const void *arg1,const void *arg2) + { + return ((t_persona*)arg1)->edad-((t_persona*)arg2)->edad; + } + +int str_icmp(const char *s1,const char *s2) + { + while(A_MAYUSCULA(*s1)==A_MAYUSCULA(*s2)&&*s1&&*s2) + { + s1++; + s2++; + } + return A_MAYUSCULA(*s1)-A_MAYUSCULA(*s2); + } diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/header.h" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/header.h" new file mode 100644 index 0000000..d310b4d --- /dev/null +++ "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/header.h" @@ -0,0 +1,28 @@ +#include +#include +#include +#include +#include +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +typedef struct + { + int dni; + char apellido[20]; + char nombre[25]; + int edad; + }t_persona; + +typedef int(*t_cmp)(const void*,const void*); + +void ordenamiento_seleccion(void*,int,size_t,t_cmp); +void intercambio(void*,void*,size_t); +int comparar_int(const void*,const void*); +int comparar_float(const void*,const void*); +int comparar_char(const void*,const void*); +int comparar_string(const void*,const void*); +int comparar_apellido_personas(const void*,const void*); +int comparar_nombre_personas(const void*,const void*); +int comparar_dni_personas(const void*,const void*); +int comparar_edad_personas(const void*,const void*); +int str_icmp(const char*,const char*); diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/main.c" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/main.c" new file mode 100644 index 0000000..4ec8ba7 --- /dev/null +++ "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/main.c" @@ -0,0 +1,111 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int i; + + printf("\n\n\t\t ORDENAMIENTO POR SELECCIÓN -- PUNTERO A FUNCIONES \n"); + printf("\n Uso una función que simula a QSORT de la bibioteca stdlib.h"); + printf("\n Sirve para ordenar cualquier cosa"); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ENTEROS"); + int v1[10]={2,5,6,4,7,8,1,9,3,0}; + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf(" %d",v1[i]); + ordenamiento_seleccion(v1,10,sizeof(int),comparar_int); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf(" %d",v1[i]); + getch(); + + printf("\n\n ORDENANDO ARRAY DE FLOTANTES"); + float v2[10]={2.33,5.26,6.89,4.47,7.18,8.94,1.02,9.23,3.55,0.11}; + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf(" %.2f",v2[i]); + ordenamiento_seleccion(v2,10,sizeof(float),comparar_float); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf(" %.2f",v2[i]); + getch(); + + printf("\n\n ORDENANDO ARRAY DE CARACTERES"); + char v3[10]={'r','h','f','o','j','l','a','x','w','s'}; + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf(" %c",v3[i]); + ordenamiento_seleccion(v3,10,sizeof(char),comparar_char); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf(" %c",v3[i]); + getch(); + + printf("\n\n ORDENANDO ARRAY DE STRINGS"); + char v4[10][15]={"Perro","Gato","Jirafa","Mono","Tucán","Koala","Toro","Burro","Loro","Delfín"}; + printf("\n\n Antes de ordenar\n"); + for(i=0;i<10;i++) + printf(" %s",v4[i]); + ordenamiento_seleccion(v4,10,sizeof(char)*15,comparar_string); + printf("\n\n Después de ordenar\n"); + for(i=0;i<10;i++) + printf(" %s",v4[i]); + getch(); + + t_persona personas[10]={ {32659449,"Ortúzar","Oriana Lucía",27}, + {18564966,"Gutierrez","Enrique Luis",50}, + {28946356,"Oberto","Jorge Ignacio",35}, + {26489494,"Echegaray","Malena Romina",33}, + {25648754,"Ulisotta","Juan Edgardo",34}, + {16514142,"Borrato","Jorge Esteban",54}, + {25648754,"Roberto","Sergio",31}, + {25648754,"Ascacibar","Andrea Julieta",35}, + {13648754,"Torres Rojas","Gilberto Pancracio",56}, + {36916554,"Cancarro","Matías Ignacio",25} }; + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR APELLIDO"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + ordenamiento_seleccion(personas,10,sizeof(t_persona),comparar_apellido_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR NOMBRE"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + ordenamiento_seleccion(personas,10,sizeof(t_persona),comparar_nombre_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR DNI"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + ordenamiento_seleccion(personas,10,sizeof(t_persona),comparar_dni_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR EDAD"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + ordenamiento_seleccion(personas,10,sizeof(t_persona),comparar_edad_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/obj/Debug/functions.o" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/obj/Debug/functions.o" new file mode 100644 index 0000000..12e2d3e Binary files /dev/null and "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/obj/Debug/functions.o" differ diff --git "a/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/obj/Debug/main.o" "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/obj/Debug/main.o" new file mode 100644 index 0000000..3fb9b58 Binary files /dev/null and "b/clase 10 (ordenamiento por selecci\303\263n, puntero a funciones)/obj/Debug/main.o" differ diff --git a/clase 10 (qsort)/bin/Debug/clase 10 (qsort).exe b/clase 10 (qsort)/bin/Debug/clase 10 (qsort).exe new file mode 100644 index 0000000..dfa1ae6 Binary files /dev/null and b/clase 10 (qsort)/bin/Debug/clase 10 (qsort).exe differ diff --git a/clase 10 (qsort)/clase 10 (qsort).cbp b/clase 10 (qsort)/clase 10 (qsort).cbp new file mode 100644 index 0000000..deaf420 --- /dev/null +++ b/clase 10 (qsort)/clase 10 (qsort).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 10 (qsort)/clase 10 (qsort).depend b/clase 10 (qsort)/clase 10 (qsort).depend new file mode 100644 index 0000000..8253381 --- /dev/null +++ b/clase 10 (qsort)/clase 10 (qsort).depend @@ -0,0 +1,14 @@ +# depslib dependency file v1.0 +1474498231 source:d:\unlam\programaciÓn\fabian 2\clase 10 (qsort)\functions.c + "header.h" + +1474498260 d:\unlam\programaciÓn\fabian 2\clase 10 (qsort)\header.h + + + + + + +1474498313 source:d:\unlam\programaciÓn\fabian 2\clase 10 (qsort)\main.c + "header.h" + diff --git a/clase 10 (qsort)/clase 10 (qsort).layout b/clase 10 (qsort)/clase 10 (qsort).layout new file mode 100644 index 0000000..a9f0447 --- /dev/null +++ b/clase 10 (qsort)/clase 10 (qsort).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 10 (qsort)/functions.c b/clase 10 (qsort)/functions.c new file mode 100644 index 0000000..fbe65cb --- /dev/null +++ b/clase 10 (qsort)/functions.c @@ -0,0 +1,77 @@ +#include "header.h" + +int comparar_int(const void *arg1,const void *arg2) + { + int *e1=(int*)arg1,*e2=(int*)arg2; + return *e1-*e2; + } + +/* +int comparar_int(const void *arg1,const void *arg2) + { + if(*(int*)arg1<*(int*)arg2) + return -1; + else + if(*(int*)arg1>*(int*)arg2) + return 1; + else + return 0; + } +*/ + +int comparar_float(const void *arg1,const void *arg2) + { + if(*(float*)arg1<*(float*)arg2) + return -1; + else + if(*(float*)arg1>*(float*)arg2) + return 1; + else + return 0; + } + +int comparar_char(const void *arg1,const void *arg2) + { + if(*(char*)arg1<*(char*)arg2) + return -1; + else + if(*(char*)arg1>*(char*)arg2) + return 1; + else + return 0; + } + +int comparar_string(const void *arg1,const void *arg2) + { + return str_icmp((char*)arg1,(char*)arg2); + } + +int comparar_apellido_personas(const void *arg1,const void *arg2) + { + return str_icmp(((t_persona*)arg1)->apellido,((t_persona*)arg2)->apellido); + } + +int comparar_nombre_personas(const void *arg1,const void *arg2) + { + return str_icmp(((t_persona*)arg1)->nombre,((t_persona*)arg2)->nombre); + } + +int comparar_dni_personas(const void *arg1,const void *arg2) + { + return ((t_persona*)arg1)->dni-((t_persona*)arg2)->dni; + } + +int comparar_edad_personas(const void *arg1,const void *arg2) + { + return ((t_persona*)arg1)->edad-((t_persona*)arg2)->edad; + } + +int str_icmp(const char *s1,const char *s2) + { + while(A_MAYUSCULA(*s1)==A_MAYUSCULA(*s2)&&*s1&&*s2) + { + s1++; + s2++; + } + return A_MAYUSCULA(*s1)-A_MAYUSCULA(*s2); + } diff --git a/clase 10 (qsort)/header.h b/clase 10 (qsort)/header.h new file mode 100644 index 0000000..3ae6ce1 --- /dev/null +++ b/clase 10 (qsort)/header.h @@ -0,0 +1,27 @@ +#include +#include +#include +#include +#include + +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +typedef struct + { + int dni; + char apellido[20]; + char nombre[25]; + int edad; + }t_persona; + +typedef int(*t_cmp)(const void*,const void*); + +int comparar_int(const void*,const void*); +int comparar_float(const void*,const void*); +int comparar_char(const void*,const void*); +int comparar_string(const void*,const void*); +int comparar_apellido_personas(const void*,const void*); +int comparar_nombre_personas(const void*,const void*); +int comparar_dni_personas(const void*,const void*); +int comparar_edad_personas(const void*,const void*); +int str_icmp(const char*,const char*); diff --git a/clase 10 (qsort)/main.c b/clase 10 (qsort)/main.c new file mode 100644 index 0000000..6436c53 --- /dev/null +++ b/clase 10 (qsort)/main.c @@ -0,0 +1,111 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int i; + + printf("\n\n\t\t\t QSORT"); + printf("\n\n Función de la biblioteca stdlib.h"); + printf("\n Sirve para ordenar cualquier cosa"); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ENTEROS"); + int v1[10]={2,5,6,4,7,8,1,9,3,0}; + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf(" %d",v1[i]); + qsort(v1,10,sizeof(int),comparar_int); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf(" %d",v1[i]); + getch(); + + printf("\n\n ORDENANDO ARRAY DE FLOTANTES"); + float v2[10]={2.33,5.26,6.89,4.47,7.18,8.94,1.02,9.23,3.55,0.11}; + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf(" %.2f",v2[i]); + qsort(v2,10,sizeof(float),comparar_float); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf(" %.2f",v2[i]); + getch(); + + printf("\n\n ORDENANDO ARRAY DE CARACTERES"); + char v3[10]={'r','h','f','o','j','l','a','x','w','s'}; + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf(" %c",v3[i]); + qsort(v3,10,sizeof(char),comparar_char); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf(" %c",v3[i]); + getch(); + + printf("\n\n ORDENANDO ARRAY DE STRINGS"); + char v4[10][15]={"Perro","Gato","Jirafa","Mono","Tucán","Koala","Toro","Burro","Loro","Delfín"}; + printf("\n\n Antes de ordenar\n"); + for(i=0;i<10;i++) + printf(" %s",v4[i]); + qsort(v4,10,sizeof(char)*15,comparar_string); + printf("\n\n Después de ordenar\n"); + for(i=0;i<10;i++) + printf(" %s",v4[i]); + getch(); + + t_persona personas[10]={ {32659449,"Ortúzar","Oriana Lucía",27}, + {18564966,"Gutierrez","Enrique Luis",50}, + {28946356,"Oberto","Jorge Ignacio",35}, + {26489494,"Echegaray","Malena Romina",33}, + {25648754,"Ulisotta","Juan Edgardo",34}, + {16514142,"Borrato","Jorge Esteban",54}, + {25648754,"Roberto","Sergio",31}, + {25648754,"Ascacibar","Andrea Julieta",35}, + {13648754,"Torres Rojas","Gilberto Pancracio",56}, + {36916554,"Cancarro","Matías Ignacio",25} }; + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR APELLIDO"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + qsort(personas,10,sizeof(t_persona),comparar_apellido_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR NOMBRE"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + qsort(personas,10,sizeof(t_persona),comparar_nombre_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR DNI"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + qsort(personas,10,sizeof(t_persona),comparar_dni_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n ORDENANDO ARRAY DE ESTRUCTURAS PERSONA POR EDAD"); + printf("\n\n Antes de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + qsort(personas,10,sizeof(t_persona),comparar_edad_personas); + printf("\n\n Después de ordenar"); + for(i=0;i<10;i++) + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n",personas[i].dni,personas[i].apellido,personas[i].nombre,personas[i].edad); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/clase 10 (qsort)/obj/Debug/functions.o b/clase 10 (qsort)/obj/Debug/functions.o new file mode 100644 index 0000000..aa432c9 Binary files /dev/null and b/clase 10 (qsort)/obj/Debug/functions.o differ diff --git a/clase 10 (qsort)/obj/Debug/main.o b/clase 10 (qsort)/obj/Debug/main.o new file mode 100644 index 0000000..b187e0d Binary files /dev/null and b/clase 10 (qsort)/obj/Debug/main.o differ diff --git "a/clase 11 (primitivas de pila din\303\241mica)/bin/Debug/clase 11 (primitivas de pila din\303\241mica).exe" "b/clase 11 (primitivas de pila din\303\241mica)/bin/Debug/clase 11 (primitivas de pila din\303\241mica).exe" new file mode 100644 index 0000000..d954f71 Binary files /dev/null and "b/clase 11 (primitivas de pila din\303\241mica)/bin/Debug/clase 11 (primitivas de pila din\303\241mica).exe" differ diff --git "a/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).cbp" "b/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).cbp" new file mode 100644 index 0000000..ca31af1 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).cbp" @@ -0,0 +1,53 @@ + + + + + + diff --git "a/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).depend" "b/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).depend" new file mode 100644 index 0000000..b9e5bda --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).depend" @@ -0,0 +1,37 @@ +# depslib dependency file v1.0 +1475429340 source:d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila dinámica)\functions.c + "header.h" + +1475429303 d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila dinámica)\header.h + + + + + "primitivas_pila_dinámica.h" + +1475429263 d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila dinámica)\primitivas_pila_dinámica.h + "dato.h" + +1475429252 d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila dinámica)\dato.h + +1475429352 source:d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila dinámica)\main.c + "header.h" + +1475429340 source:d:\unlam\programaciÓn\fabian\clase 11 (primitivas de pila dinámica)\functions.c + "header.h" + +1475429303 d:\unlam\programaciÓn\fabian\clase 11 (primitivas de pila dinámica)\header.h + + + + + "primitivas_pila_dinámica.h" + +1475429263 d:\unlam\programaciÓn\fabian\clase 11 (primitivas de pila dinámica)\primitivas_pila_dinámica.h + "dato.h" + +1475429252 d:\unlam\programaciÓn\fabian\clase 11 (primitivas de pila dinámica)\dato.h + +1475429352 source:d:\unlam\programaciÓn\fabian\clase 11 (primitivas de pila dinámica)\main.c + "header.h" + diff --git "a/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).layout" "b/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).layout" new file mode 100644 index 0000000..cf2d639 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/clase 11 (primitivas de pila din\303\241mica).layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 11 (primitivas de pila din\303\241mica)/dato.h" "b/clase 11 (primitivas de pila din\303\241mica)/dato.h" new file mode 100644 index 0000000..cd20726 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/dato.h" @@ -0,0 +1,4 @@ +typedef struct + { + int numero; + }t_dato; diff --git "a/clase 11 (primitivas de pila din\303\241mica)/functions.c" "b/clase 11 (primitivas de pila din\303\241mica)/functions.c" new file mode 100644 index 0000000..fa9a3a6 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/functions.c" @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato: \t %d \n",d->numero); + } diff --git "a/clase 11 (primitivas de pila din\303\241mica)/header.h" "b/clase 11 (primitivas de pila din\303\241mica)/header.h" new file mode 100644 index 0000000..01832b9 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "primitivas_pila_dinámica.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); + diff --git "a/clase 11 (primitivas de pila din\303\241mica)/main.c" "b/clase 11 (primitivas de pila din\303\241mica)/main.c" new file mode 100644 index 0000000..0f8181f --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/main.c" @@ -0,0 +1,45 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n USO DE PRIMITIVAS DE PILA DINÁMICA \n"); + t_pila pila; + t_dato dato; + + int i=0; + + crear_pila(&pila); + printf("\n Se ha creado una pila \n"); + + printf("\n Apilar \n"); + while(i<5) + { + cargar_dato(&dato); + apilar(&pila,&dato); + i++; + } + + if(!pila_vacia(&pila)) + ver_tope(&pila,&dato); + printf("\n Tope de la pila: \t %d \n",dato.numero); + + printf("\n Desapilar \n"); + while(i>0) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + i--; + } + + printf("\n Apilar algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + + printf("\n La pila se ha vaciado \n"); + vaciar_pila(&pila); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git "a/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/functions.o" "b/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/functions.o" new file mode 100644 index 0000000..10ccdb5 Binary files /dev/null and "b/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/functions.o" differ diff --git "a/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/main.o" "b/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/main.o" new file mode 100644 index 0000000..fa6f415 Binary files /dev/null and "b/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/main.o" differ diff --git "a/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/primitivas_pila_din\303\241mica.o" "b/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/primitivas_pila_din\303\241mica.o" new file mode 100644 index 0000000..9490bb7 Binary files /dev/null and "b/clase 11 (primitivas de pila din\303\241mica)/obj/Debug/primitivas_pila_din\303\241mica.o" differ diff --git "a/clase 11 (primitivas de pila din\303\241mica)/primitivas_pila_din\303\241mica.c" "b/clase 11 (primitivas de pila din\303\241mica)/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..0d475e8 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/clase 11 (primitivas de pila din\303\241mica)/primitivas_pila_din\303\241mica.h" "b/clase 11 (primitivas de pila din\303\241mica)/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..90e4155 --- /dev/null +++ "b/clase 11 (primitivas de pila din\303\241mica)/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,22 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); + diff --git "a/clase 11 (primitivas de pila est\303\241tica)/bin/Debug/clase 11 (primitivas de pila est\303\241tica).exe" "b/clase 11 (primitivas de pila est\303\241tica)/bin/Debug/clase 11 (primitivas de pila est\303\241tica).exe" new file mode 100644 index 0000000..6dd9e24 Binary files /dev/null and "b/clase 11 (primitivas de pila est\303\241tica)/bin/Debug/clase 11 (primitivas de pila est\303\241tica).exe" differ diff --git "a/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).cbp" "b/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).cbp" new file mode 100644 index 0000000..abf3127 --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).depend" "b/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).depend" new file mode 100644 index 0000000..c9299ee --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1474753479 source:d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila estática)\functions.c + "header.h" + +1474756723 d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila estática)\header.h + + + + + "primitivas_pila_estática.h" + +1474753032 source:d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila estática)\main.c + "header.h" + +1475027464 d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila estática)\primitivas_pila_estática.h + "dato.h" + +1474754039 source:d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila estática)\primitivas_pila_estática.c + "primitivas_pila_estática.h" + +1474756728 d:\unlam\programaciÓn\fabian 2\clase 11 (primitivas de pila estática)\dato.h + diff --git "a/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).layout" "b/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).layout" new file mode 100644 index 0000000..e76a26a --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/clase 11 (primitivas de pila est\303\241tica).layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 11 (primitivas de pila est\303\241tica)/dato.h" "b/clase 11 (primitivas de pila est\303\241tica)/dato.h" new file mode 100644 index 0000000..539db74 --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/clase 11 (primitivas de pila est\303\241tica)/functions.c" "b/clase 11 (primitivas de pila est\303\241tica)/functions.c" new file mode 100644 index 0000000..fa9a3a6 --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/functions.c" @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato: \t %d \n",d->numero); + } diff --git "a/clase 11 (primitivas de pila est\303\241tica)/header.h" "b/clase 11 (primitivas de pila est\303\241tica)/header.h" new file mode 100644 index 0000000..bd63fca --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "primitivas_pila_estática.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); diff --git "a/clase 11 (primitivas de pila est\303\241tica)/main.c" "b/clase 11 (primitivas de pila est\303\241tica)/main.c" new file mode 100644 index 0000000..026d101 --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/main.c" @@ -0,0 +1,41 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n USO DE PRIMITIVAS DE PILA ESTÁTICA \n"); + t_pila pila; + t_dato dato; + + crear_pila(&pila); + printf("\n Se ha creado una pila \n"); + + printf("\n Apilar \n"); + while(!pila_llena(&pila)) + { + cargar_dato(&dato); + apilar(&pila,&dato); + } + + if(!pila_vacia(&pila)) + ver_tope(&pila,&dato); + printf("\n Tope de la pila: \t %d \n",dato.numero); + + printf("\n Desapilar \n"); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + } + + printf("\n Apilar algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + + printf("\n La pila se ha vaciado \n"); + vaciar_pila(&pila); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git "a/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/functions.o" "b/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/functions.o" new file mode 100644 index 0000000..2c0c5c3 Binary files /dev/null and "b/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/functions.o" differ diff --git "a/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/main.o" "b/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/main.o" new file mode 100644 index 0000000..44d517d Binary files /dev/null and "b/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/main.o" differ diff --git "a/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/primitivas_pila_est\303\241tica.o" "b/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/primitivas_pila_est\303\241tica.o" new file mode 100644 index 0000000..8f4c603 Binary files /dev/null and "b/clase 11 (primitivas de pila est\303\241tica)/obj/Debug/primitivas_pila_est\303\241tica.o" differ diff --git "a/clase 11 (primitivas de pila est\303\241tica)/primitivas_pila_est\303\241tica.c" "b/clase 11 (primitivas de pila est\303\241tica)/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..c1da8f4 --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,48 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) + { + p->tope=0; + } + +int pila_llena(const t_pila *p) + { + return p->tope==TAM; + } + +int apilar(t_pila *p,const t_dato *d) + { + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return p->tope==0; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; + } + +void vaciar_pila(t_pila *p) + { + p->tope=0; + } + diff --git "a/clase 11 (primitivas de pila est\303\241tica)/primitivas_pila_est\303\241tica.h" "b/clase 11 (primitivas de pila est\303\241tica)/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..b227de3 --- /dev/null +++ "b/clase 11 (primitivas de pila est\303\241tica)/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 1 +#define OK 1 + +typedef struct + { + t_dato pila[TAM]; + int tope;//primera libre + }t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/clase 12 (primitivas de cola din\303\241mica)/bin/Debug/clase 12 (primitivas de cola din\303\241mica).exe" "b/clase 12 (primitivas de cola din\303\241mica)/bin/Debug/clase 12 (primitivas de cola din\303\241mica).exe" new file mode 100644 index 0000000..af00534 Binary files /dev/null and "b/clase 12 (primitivas de cola din\303\241mica)/bin/Debug/clase 12 (primitivas de cola din\303\241mica).exe" differ diff --git "a/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).cbp" "b/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).cbp" new file mode 100644 index 0000000..657d713 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).cbp" @@ -0,0 +1,53 @@ + + + + + + diff --git "a/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).depend" "b/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).depend" new file mode 100644 index 0000000..f509d63 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).depend" @@ -0,0 +1,19 @@ +# depslib dependency file v1.0 +1475434360 source:d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola dinámica)\functions.c + "header.h" + +1475436853 d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola dinámica)\header.h + + + + + "primitivas_cola_dinámica.h" + +1475435235 d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola dinámica)\primitivas_cola_dinámica.h + "dato.h" + +1475434968 d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola dinámica)\dato.h + +1475436804 source:d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola dinámica)\main.c + "header.h" + diff --git "a/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).layout" "b/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).layout" new file mode 100644 index 0000000..1e40bb7 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/clase 12 (primitivas de cola din\303\241mica).layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 12 (primitivas de cola din\303\241mica)/dato.h" "b/clase 12 (primitivas de cola din\303\241mica)/dato.h" new file mode 100644 index 0000000..523f493 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/dato.h" @@ -0,0 +1,5 @@ + +typedef struct + { + int numero; + }t_dato; diff --git "a/clase 12 (primitivas de cola din\303\241mica)/functions.c" "b/clase 12 (primitivas de cola din\303\241mica)/functions.c" new file mode 100644 index 0000000..fa9a3a6 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/functions.c" @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato: \t %d \n",d->numero); + } diff --git "a/clase 12 (primitivas de cola din\303\241mica)/header.h" "b/clase 12 (primitivas de cola din\303\241mica)/header.h" new file mode 100644 index 0000000..ed14ec5 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "primitivas_cola_dinámica.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); diff --git "a/clase 12 (primitivas de cola din\303\241mica)/main.c" "b/clase 12 (primitivas de cola din\303\241mica)/main.c" new file mode 100644 index 0000000..86a468b --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/main.c" @@ -0,0 +1,49 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n USO DE PRIMITIVAS DE COLA DINÁMICA \n"); + t_cola cola; + t_dato dato; + + int i=0; + + crear_cola(&cola); + printf("\n Se ha creado una cola \n"); + + printf("\n Acolar \n"); + while(i<5) + { + cargar_dato(&dato); + acolar(&cola,&dato); + i++; + } + + if(!cola_vacia(&cola)) + ver_primero_en_cola(&cola,&dato); + printf("\n Primero de la cola: \t %d \n",dato.numero); + + if(!cola_vacia(&cola)) + ver_ultimo_en_cola(&cola,&dato); + printf("\n Último de la cola: \t %d \n",dato.numero); + + printf("\n Desacolar \n"); + while(i>0) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + i--; + } + + printf("\n Acolar algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + + printf("\n La cola se ha vaciado \n"); + vaciar_cola(&cola); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git "a/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/functions.o" "b/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/functions.o" new file mode 100644 index 0000000..19ce6f2 Binary files /dev/null and "b/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/functions.o" differ diff --git "a/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/main.o" "b/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/main.o" new file mode 100644 index 0000000..84db3a5 Binary files /dev/null and "b/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/main.o" differ diff --git "a/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/primitivas_cola_din\303\241mica.o" "b/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/primitivas_cola_din\303\241mica.o" new file mode 100644 index 0000000..9632a74 Binary files /dev/null and "b/clase 12 (primitivas de cola din\303\241mica)/obj/Debug/primitivas_cola_din\303\241mica.o" differ diff --git "a/clase 12 (primitivas de cola din\303\241mica)/primitivas_cola_din\303\241mica.c" "b/clase 12 (primitivas de cola din\303\241mica)/primitivas_cola_din\303\241mica.c" new file mode 100644 index 0000000..c8a0a09 --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/primitivas_cola_din\303\241mica.c" @@ -0,0 +1,79 @@ +#include "primitivas_cola_dinámica.h" + +//no sé por qué si no incluyo las bibliotecas tira error +#include +#include + +void crear_cola(t_cola *c) + { + c->pri=NULL; + c->ult=NULL; + } + +int cola_llena(const t_cola *c) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int acolar(t_cola *c,const t_dato *d) + { + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=NULL; + if(c->ult==NULL) + c->pri=nuevo; + else + c->ult->sig=nuevo; + c->ult=nuevo; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->pri==NULL; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + t_nodo *aux=c->pri; + *d=aux->dato;//*d=c->prim->dato; + c->pri=aux->sig;//c->pri=c->pri->sig; + if(c->pri==NULL) + c->ult=NULL; + free(aux); + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + *d=c->pri->dato; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + *d=c->ult->dato; + return OK; + } + +void vaciar_cola(t_cola *c) + { + t_nodo *aux; + while(c->pri!=NULL) + { + aux=c->pri; + c->pri=aux->sig; + free(aux); + } + c->ult=NULL; + } diff --git "a/clase 12 (primitivas de cola din\303\241mica)/primitivas_cola_din\303\241mica.h" "b/clase 12 (primitivas de cola din\303\241mica)/primitivas_cola_din\303\241mica.h" new file mode 100644 index 0000000..35dfbee --- /dev/null +++ "b/clase 12 (primitivas de cola din\303\241mica)/primitivas_cola_din\303\241mica.h" @@ -0,0 +1,26 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef struct + { + t_nodo *pri; + t_nodo *ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/clase 12 (primitivas de cola est\303\241tica)/bin/Debug/clase 12 (primitivas de cola est\303\241tica).exe" "b/clase 12 (primitivas de cola est\303\241tica)/bin/Debug/clase 12 (primitivas de cola est\303\241tica).exe" new file mode 100644 index 0000000..06dc0a9 Binary files /dev/null and "b/clase 12 (primitivas de cola est\303\241tica)/bin/Debug/clase 12 (primitivas de cola est\303\241tica).exe" differ diff --git "a/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).cbp" "b/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).cbp" new file mode 100644 index 0000000..3a123df --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).depend" "b/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).depend" new file mode 100644 index 0000000..f0057c2 --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).depend" @@ -0,0 +1,19 @@ +# depslib dependency file v1.0 +1475434360 source:d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola estática)\functions.c + "header.h" + +1475434315 d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola estática)\header.h + + + + + "primitivas_cola_estática.h" + +1475433603 d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola estática)\primitivas_cola_estática.h + "dato.h" + +1475433078 d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola estática)\dato.h + +1475434601 source:d:\unlam\programaciÓn\fabian 2\clase 12 (primitivas de cola estática)\main.c + "header.h" + diff --git "a/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).layout" "b/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).layout" new file mode 100644 index 0000000..31b0bfc --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/clase 12 (primitivas de cola est\303\241tica).layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 12 (primitivas de cola est\303\241tica)/dato.h" "b/clase 12 (primitivas de cola est\303\241tica)/dato.h" new file mode 100644 index 0000000..e4d142e --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/clase 12 (primitivas de cola est\303\241tica)/functions.c" "b/clase 12 (primitivas de cola est\303\241tica)/functions.c" new file mode 100644 index 0000000..fa9a3a6 --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/functions.c" @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato: \t %d \n",d->numero); + } diff --git "a/clase 12 (primitivas de cola est\303\241tica)/header.h" "b/clase 12 (primitivas de cola est\303\241tica)/header.h" new file mode 100644 index 0000000..9736632 --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "primitivas_cola_estática.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); diff --git "a/clase 12 (primitivas de cola est\303\241tica)/main.c" "b/clase 12 (primitivas de cola est\303\241tica)/main.c" new file mode 100644 index 0000000..a9895b2 --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/main.c" @@ -0,0 +1,46 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n USO DE PRIMITIVAS DE COLA ESTÁTICA \n"); + t_cola cola; + t_dato dato; + + crear_cola(&cola); + printf("\n Se ha creado una cola \n"); + + printf("\n Acolar \n"); + while(!cola_llena(&cola)) + { + cargar_dato(&dato); + acolar(&cola,&dato); + } + + if(!cola_vacia(&cola)) + ver_primero_en_cola(&cola,&dato); + printf("\n Primero de la cola: \t %d \n",dato.numero); + + if(!cola_vacia(&cola)) + ver_ultimo_en_cola(&cola,&dato); + printf("\n Último de la cola: \t %d \n",dato.numero); + + printf("\n Desacolar \n"); + while(!cola_vacia(&cola)) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + } + + printf("\n Acolar algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + + printf("\n La cola se ha vaciado \n"); + vaciar_cola(&cola); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } + diff --git "a/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/functions.o" "b/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/functions.o" new file mode 100644 index 0000000..664798e Binary files /dev/null and "b/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/functions.o" differ diff --git "a/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/main.o" "b/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/main.o" new file mode 100644 index 0000000..3f13256 Binary files /dev/null and "b/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/main.o" differ diff --git "a/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/primitivas_cola_est\303\241tica.o" "b/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/primitivas_cola_est\303\241tica.o" new file mode 100644 index 0000000..388e454 Binary files /dev/null and "b/clase 12 (primitivas de cola est\303\241tica)/obj/Debug/primitivas_cola_est\303\241tica.o" differ diff --git "a/clase 12 (primitivas de cola est\303\241tica)/primitivas_cola_est\303\241tica.c" "b/clase 12 (primitivas de cola est\303\241tica)/primitivas_cola_est\303\241tica.c" new file mode 100644 index 0000000..111cbe5 --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/primitivas_cola_est\303\241tica.c" @@ -0,0 +1,63 @@ +#include "primitivas_cola_estática.h" + +void crear_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } + +int cola_llena(const t_cola *c) + { + return (c->ult+1)%TAM==c->pri&&c->ult!=-1; + } + +int acolar(t_cola *c,const t_dato *d) + { + if((c->ult+1)%TAM==c->pri&&c->ult!=-1) + return COLA_LLENA; + c->ult=(c->ult+1)%TAM; + c->cola[c->ult]=*d; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->ult==-1; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + if(c->pri==c->ult) + { + c->pri=0; + c->ult=-1; + } + else + c->pri=(c->pri+1)%TAM; + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->ult]; + return OK; + } + +void vaciar_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } diff --git "a/clase 12 (primitivas de cola est\303\241tica)/primitivas_cola_est\303\241tica.h" "b/clase 12 (primitivas de cola est\303\241tica)/primitivas_cola_est\303\241tica.h" new file mode 100644 index 0000000..54c94d6 --- /dev/null +++ "b/clase 12 (primitivas de cola est\303\241tica)/primitivas_cola_est\303\241tica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define COLA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct + { + t_dato cola[TAM]; + int pri; + int ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/clase 13 (primitivas de lista est\303\241tica)/bin/Debug/clase 13 (primitivas de lista est\303\241tica).exe" "b/clase 13 (primitivas de lista est\303\241tica)/bin/Debug/clase 13 (primitivas de lista est\303\241tica).exe" new file mode 100644 index 0000000..f3f4313 Binary files /dev/null and "b/clase 13 (primitivas de lista est\303\241tica)/bin/Debug/clase 13 (primitivas de lista est\303\241tica).exe" differ diff --git "a/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).cbp" "b/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).cbp" new file mode 100644 index 0000000..f50aac7 --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).cbp" @@ -0,0 +1,53 @@ + + + + + + diff --git "a/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).depend" "b/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).depend" new file mode 100644 index 0000000..a6f530a --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1476302958 source:d:\unlam\programaciÓn\fabian\clase 13 (primitivas de lista estática)\main.c + "header.h" + +1476302151 d:\unlam\programaciÓn\fabian\clase 13 (primitivas de lista estática)\header.h + + + + + "primitivas_lista_estática.h" + +1476302700 d:\unlam\programaciÓn\fabian\clase 13 (primitivas de lista estática)\primitivas_lista_estática.h + "dato.h" + +1476299277 d:\unlam\programaciÓn\fabian\clase 13 (primitivas de lista estática)\dato.h + +1476302796 source:d:\unlam\programaciÓn\fabian\clase 13 (primitivas de lista estática)\functions.c + "header.h" + +1476302902 source:d:\unlam\programaciÓn\fabian\clase 13 (primitivas de lista estática)\primitivas_lista_estática.c + "primitivas_lista_estática.h" + diff --git "a/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).layout" "b/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).layout" new file mode 100644 index 0000000..b507543 --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/clase 13 (primitivas de lista est\303\241tica).layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 13 (primitivas de lista est\303\241tica)/dato.h" "b/clase 13 (primitivas de lista est\303\241tica)/dato.h" new file mode 100644 index 0000000..36344e9 --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/clase 13 (primitivas de lista est\303\241tica)/functions.c" "b/clase 13 (primitivas de lista est\303\241tica)/functions.c" new file mode 100644 index 0000000..c354e4e --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/functions.c" @@ -0,0 +1,18 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(const t_dato *d) + { + printf("\n DATO: \t %d \n",d->numero); + } + +int comparar(const void *v1,const void *v2) + { + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; + } diff --git "a/clase 13 (primitivas de lista est\303\241tica)/header.h" "b/clase 13 (primitivas de lista est\303\241tica)/header.h" new file mode 100644 index 0000000..be5da97 --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "primitivas_lista_estática.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); +int comparar(const void*,const void*); diff --git "a/clase 13 (primitivas de lista est\303\241tica)/main.c" "b/clase 13 (primitivas de lista est\303\241tica)/main.c" new file mode 100644 index 0000000..67e3e64 --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/main.c" @@ -0,0 +1,46 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA ESTÁTICA \n"); + + t_lista lista; + t_dato dato; + + crear_lista(&lista); + printf("\n\n Se ha creado una lista \n"); + + printf("\n\n Cargue la lista: \n"); + while(!lista_llena(&lista)) + { + cargar_dato(&dato); + poner_en_lista(&lista,&dato,comparar); + } + printf("\n\n La lista está llena \n"); + + printf("\n\n Ver primero: \n"); + ver_primero_de_lista(&lista,&dato); + printf("\n\n El primero de la lista es: \n"); + mostrar_dato(&dato); + + printf("\n\n Sacar de la lista \n"); + while(!lista_vacia(&lista)) + { + sacar_de_lista(&lista,&dato); + mostrar_dato(&dato); + } + printf("\n\n La lista está vacía \n"); + + printf("\n\n Cargar algo: \n"); + cargar_dato(&dato); + poner_en_lista(&lista,&dato,comparar); + printf("\n\n El dato fue cargado \n"); + + vaciar_lista(&lista); + printf("\n\n La lista fue vaciada exitosamente \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git "a/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/functions.o" "b/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/functions.o" new file mode 100644 index 0000000..ba5f4e9 Binary files /dev/null and "b/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/functions.o" differ diff --git "a/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/main.o" "b/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/main.o" new file mode 100644 index 0000000..aaf10a0 Binary files /dev/null and "b/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/main.o" differ diff --git "a/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/primitivas_lista_est\303\241tica.o" "b/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/primitivas_lista_est\303\241tica.o" new file mode 100644 index 0000000..b793fd0 Binary files /dev/null and "b/clase 13 (primitivas de lista est\303\241tica)/obj/Debug/primitivas_lista_est\303\241tica.o" differ diff --git "a/clase 13 (primitivas de lista est\303\241tica)/primitivas_lista_est\303\241tica.c" "b/clase 13 (primitivas de lista est\303\241tica)/primitivas_lista_est\303\241tica.c" new file mode 100644 index 0000000..761fbff --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/primitivas_lista_est\303\241tica.c" @@ -0,0 +1,58 @@ +#include "primitivas_lista_estática.h" + +void crear_lista(t_lista *l) + { + l->indice=0; + l->ce=0; + } + +int lista_vacia(const t_lista *l) + { + return l->ce==0; + } + +int lista_llena(const t_lista *l) + { + return l->ce==TAM; + } + +int poner_en_lista(t_lista *l,const t_dato *d,t_cmp comparar) + { + int i,pos=0; + if(l->ce==TAM) + return LISTA_LLENA; + l->dato[l->indice]=*d; + while(l->ce>pos&&comparar((void*)&l->dato[l->pos[pos]],(void*)d)) + pos++; + for(i=l->ce;i>=pos;i--) + l->pos[pos]=l->indice; + l->indice++; + l->ce++; + return OK; + } + +int sacar_de_lista(t_lista *l,t_dato *d) + { + int i; + if(l->ce==0) + return LISTA_VACIA; + *d=l->dato[l->pos[0]]; + for(i=0;ice;i++) + l->pos[i]=l->pos[i+1]; + l->ce--; + return OK; + } + +int ver_primero_de_lista(const t_lista *l,t_dato *d) + { + if(l->ce==0) + return LISTA_VACIA; + *d=l->dato[l->pos[l->ce]]; + return OK; + } + +void vaciar_lista(t_lista *l) + { + l->indice=0; + l->ce=0; + } diff --git "a/clase 13 (primitivas de lista est\303\241tica)/primitivas_lista_est\303\241tica.h" "b/clase 13 (primitivas de lista est\303\241tica)/primitivas_lista_est\303\241tica.h" new file mode 100644 index 0000000..4d51456 --- /dev/null +++ "b/clase 13 (primitivas de lista est\303\241tica)/primitivas_lista_est\303\241tica.h" @@ -0,0 +1,23 @@ +#include "dato.h" + +#define LISTA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 + +typedef struct + { + t_dato dato[TAM]; + int pos[TAM]; + int indice; + int ce; + }t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int poner_en_lista(t_lista*,const t_dato*,t_cmp); +int sacar_de_lista(t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +void vaciar_lista(t_lista*); diff --git a/clase 13 y 14 (lista simplemente enlazada)/bin/Debug/clase 13 y 14 (lista simplemente enlazada).exe b/clase 13 y 14 (lista simplemente enlazada)/bin/Debug/clase 13 y 14 (lista simplemente enlazada).exe new file mode 100644 index 0000000..d301292 Binary files /dev/null and b/clase 13 y 14 (lista simplemente enlazada)/bin/Debug/clase 13 y 14 (lista simplemente enlazada).exe differ diff --git a/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).cbp b/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).cbp new file mode 100644 index 0000000..7157896 --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).depend b/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).depend new file mode 100644 index 0000000..a2fd0ab --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).depend @@ -0,0 +1,17 @@ +# depslib dependency file v1.0 +1476046191 source:d:\unlam\programaciÓn\fabian\clase 13 y 14 (lista simplemente enlazada)\functions.c + "header.h" + +1476046239 d:\unlam\programaciÓn\fabian\clase 13 y 14 (lista simplemente enlazada)\header.h + + + + + + "lista_simplemente_enlazada.h" + +1476046410 d:\unlam\programaciÓn\fabian\clase 13 y 14 (lista simplemente enlazada)\lista_simplemente_enlazada.h + "dato.h" + +1476046329 d:\unlam\programaciÓn\fabian\clase 13 y 14 (lista simplemente enlazada)\dato.h + diff --git a/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).layout b/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).layout new file mode 100644 index 0000000..946a44a --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/clase 13 y 14 (lista simplemente enlazada).layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/clase 13 y 14 (lista simplemente enlazada)/dato.h b/clase 13 y 14 (lista simplemente enlazada)/dato.h new file mode 100644 index 0000000..45b7594 --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/dato.h @@ -0,0 +1,16 @@ +typedef struct + { + int numero; + }t_dato; + +/* + +DATO QUE SE DEBE IMPLEMENTAR PARA USAR LAS FUNCIONES COMENTADAS + +typedef struct + { + long dni; + char ape[21]; + char nomb[21]; + }t_dato; +*/ diff --git a/clase 13 y 14 (lista simplemente enlazada)/functions.c b/clase 13 y 14 (lista simplemente enlazada)/functions.c new file mode 100644 index 0000000..11ff409 --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/functions.c @@ -0,0 +1,67 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n\n Ingrese dato a enlistar (número entero): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n\n Dato desenlistado: \t %d",d->numero); + } + +// A CONTINUACIÓN, FUNCIONES DE COMPARACIÓN QUE SE PUEDEN MANDAR COMO PARÁMETRO A LAS FUNCIONES DE LISTA + +int comparar_datos(const void *v1,const void *v2) + { + t_dato *i1=(t_dato*)v1,*i2=(t_dato*)v2; + return i1->numero - i2->numero; + } + +/* + +ESTAS FUNCIONES TIENEN SENTIDO SI SE IMPLEMENTAN CON UN DATO QUE CONTENGA DNI, APELLIDO Y NOMBRE + +int comparar_clave_dni(const void* v1,const void* v2) +{ + tDato *l1 = (tDato*)v1; + long *l2 = (long*)v2; + return l1->dni - *l2; +} + +int comparar_personas(const void *v1,const void *v2) +{ + int cmp; + tDato *a1 = (tDato*)v1, *a2 = (tDato*)v2; + if(!(cmp = strcmp(a1->ape,a2->ape))) + if(!(cmp = strcmp(a1->nomb,a2->nomb))) + return a1->dni - a2->dni; + return cmp; +} + +ESTA FUNCIÓN INTENTA COMPARAR PERSONAS EN UNA SOLA CADENA, PERO NO SIRVE PARA TODOS LOS CASOS + +int comparar_personas_en_cadena(const void *v1,const void *v2) +{ + tDato *a1 = (tDato*)v1, *a2 = (tDato*)v2; + char cad1[49],cad2[49]; + char cadDni[9]; + strcat(strcat(strcpy(cad1,a1->ape),a1->nomb),ltoa(a1->dni,cadDni,10)); + strcat(strcat(strcpy(cad1,a2->ape),a2->nomb),ltoa(a2->dni,cadDni,10)); + return strcmp(cad1,cad2); +} + + +// ESTA FUNCIÓN SIRVE PARA COMPARAR PERSONAS EN UNA SOLA CADENA + +int comparar_personas_en_cadena(const void *v1,const void *v2) +{ + t_dato *a1 = (t_dato*)v1, *a2 = (t_dato*)v2; + char cad1[50],cad2[50]; + sprintf(cad1,"%21s%21s%08ld",a1->ape,a1->nomb,a1->dni); + sprintf(cad2,"%21s%21s%08ld",a2->ape,a2->nomb,a2->dni); + return strcmp(cad1,cad2); +} + +*/ diff --git a/clase 13 y 14 (lista simplemente enlazada)/header.h b/clase 13 y 14 (lista simplemente enlazada)/header.h new file mode 100644 index 0000000..3ef56d7 --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/header.h @@ -0,0 +1,18 @@ +#include +#include +#include +#include +#include + +#include "lista_simplemente_enlazada.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); + +int comparar_datos(const void*,const void*); + +/* +int comparar_clave_dni(const void* v1,const void* v2) +int comparar_personas(const void *v1,const void *v2) +int comparar_personas_en_cadena(const void *v1,const void *v2) +*/ diff --git a/clase 13 y 14 (lista simplemente enlazada)/lista_simplemente_enlazada.c b/clase 13 y 14 (lista simplemente enlazada)/lista_simplemente_enlazada.c new file mode 100644 index 0000000..e2823de --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/lista_simplemente_enlazada.c @@ -0,0 +1,225 @@ +#include +#include + +#include "lista_simplemente_enlazada.h" + +void crear_lista(t_lista *l) + { + *l=NULL; + } + +void vaciar_lista(t_lista *l) + { + t_nodo *aux; + while(*l) + { + aux=*l; + *l=aux->sig; + free(aux); + } + } + +int lista_llena(const t_lista *l) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int lista_vacia(const t_lista *l) + { + return *l==NULL; + } + +int poner_en_lista_primero(t_lista *l,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int poner_en_lista_ultimo(t_lista *l,const t_dato *d) + { + while(*l) + l=&(*l)->sig; + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato=*d; + (*l)->sig=NULL; + return OK; + } + +int sacar_de_lista_primero(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + t_nodo *aux=*l; + *d=aux->dato; + *l=aux->sig; + free(aux); + return OK; + } + +int sacar_de_lista_ultimo(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + while(!(*l)->sig) + l=&(*l)->sig; + t_nodo *aux=*l; + *d=aux->dato; + *l=NULL; + free(aux); + return OK; + } + +int insertar_en_lista_por_posicion(t_lista *l,const t_dato *d,int *pos) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + while(*l&&*pos>1) + { + l=&(*l)->sig; + (*pos)--; + } + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int insertar_en_lista_ordenado_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d)<=0)) + l=&(*l)->sig; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int insertar_en_lista_ordenado_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar(&(*l)->dato,d)<0)) + l=&(*l)->sig; + if(*l&&!cmp) + return DUPLICADO; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +/* +ESTA FUNCIÓN SOLO TIENE SENTIDO SI SE IMPLEMENTA CON UN DATO QUE CONTENGA LOS CAMPOS CLAVE Y CANTIDAD DE REPETICIONES + +int insertar_si_no_existe_clave(t_lista *l,const t_dato *d,int clave) + { + while(*l&&(*l)->dato.clave!=clave) + l=&(*l)->sig; + if(*l) + { + ((*l)->dato.cant_rep)++; + return CLAVE_DUPLICADA; + } + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato.clave=clave; + (*l)->dato.cant_rep=0; + (*l)->sig=NULL; + return OK; + } +*/ + +int buscar_en_lista_ordenada(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d))<0) + l=&(*l)->sig; + if(*l&&!cmp) + return ENCONTRADO; + return NO_ENCONTRADO; + } + +int buscar_en_lista_desordenada(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d))!=0) + l=&(*l)->sig; + if(*l&&!cmp) + return ENCONTRADO; + return NO_ENCONTRADO; + } + +int eliminar_por_clave_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) + { + while(*l&&(comparar((void*)&(*l)->dato,clave)!=0)) + l=&(*l)->sig; + if(!*l) + return NO_ENCONTRADO; + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; + } + +int eliminar_por_clave_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,clave))<0) + l=&(*l)->sig; + if(*l&&!cmp) + { + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; + } + return NO_ENCONTRADO; + } + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) + { + int cmp; + t_nodo *aux; + while(*l&&(cmp=comparar((void*)&(*l)->dato,clave))<=0) + { + if(!cmp) + { + aux=*l; + *l=(*l)->sig; + free(aux); + } + l=&(*l)->sig; + } + } + +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) + { + t_nodo *aux; + while(*l) + { + if(!comparar((void*)&(*l)->dato,clave)) + { + aux=*l; + *l=(*l)->sig; + free(aux); + } + l=&(*l)->sig; + } + } diff --git a/clase 13 y 14 (lista simplemente enlazada)/lista_simplemente_enlazada.h b/clase 13 y 14 (lista simplemente enlazada)/lista_simplemente_enlazada.h new file mode 100644 index 0000000..2f3f9c5 --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/lista_simplemente_enlazada.h @@ -0,0 +1,48 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 +#define DUPLICADO 0 +#define CLAVE_DUPLICADA 1 +#define ENCONTRADO 1 +#define NO_ENCONTRADO 0 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +void vaciar_lista(t_lista*); + +int lista_llena(const t_lista*); +int lista_vacia(const t_lista*); + +int poner_en_lista_primero(t_lista*,const t_dato*); +int poner_en_lista_ultimo(t_lista*,const t_dato*); + +int sacar_de_lista_primero(t_lista*,t_dato*); +int sacar_de_lista_ultimo(t_lista*,t_dato*); + +int insertar_en_lista_por_posicion(t_lista*,const t_dato*,int*); +int insertar_en_lista_ordenado_con_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenado_sin_duplicado(t_lista*,const t_dato*,t_cmp); + +/* +int insertar_si_no_existe_clave(t_lista*,const t_dato*,int); +*/ + +int buscar_en_lista_ordenada(t_lista*,const t_dato*,t_cmp); +int buscar_en_lista_desordenada(t_lista*,const t_dato*,t_cmp); + +int eliminar_por_clave_en_lista_desordenada(t_lista*,void*,t_cmp); +int eliminar_por_clave_en_lista_ordenada(t_lista*,void*,t_cmp); + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista*,void*,t_cmp); +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista*,void*,t_cmp); diff --git a/clase 13 y 14 (lista simplemente enlazada)/main.c b/clase 13 y 14 (lista simplemente enlazada)/main.c new file mode 100644 index 0000000..1134866 --- /dev/null +++ b/clase 13 y 14 (lista simplemente enlazada)/main.c @@ -0,0 +1,96 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA SIMPLEMENTE ENLAZADA \n\a\a"); + + t_lista lista; + t_dato dato; + + crear_lista(&lista); + printf("\n Se ha creado una lista \n"); + + if(lista_vacia(&lista)) + printf("\n La lista está vacía \n"); + + printf("\n Cargamos 3 elementos \n"); + cargar_dato(&dato); + poner_en_lista_primero(&lista,&dato); + cargar_dato(&dato); + poner_en_lista_primero(&lista,&dato); + cargar_dato(&dato); + poner_en_lista_primero(&lista,&dato); + + if(lista_llena(&lista)) + printf("\n La lista está llena \n"); + else + printf("\n La lista no está llena \n"); + + printf("\n Sacamos el último \n"); + sacar_de_lista_ultimo(&lista,&dato); + mostrar_dato(&dato); + + printf("\n Ponemos uno al final \n"); + cargar_dato(&dato); + poner_en_lista_ultimo(&lista,&dato); + + printf("\n Sacamos el primero de la lista \n"); + sacar_de_lista_primero(&lista,&dato); + mostrar_dato(&dato); + + printf("\n Insertamos algo por posición \n \t Ingrese posición (por favor: pos>0): \n\n\t"); + int pos; + scanf("%d",&pos); + cargar_dato(&dato); + insertar_en_lista_por_posicion(&lista,&dato,&pos); + + printf("\n Saco de la pila hasta que queda vacía \n"); + while(!lista_vacia(&lista)) + { + sacar_de_lista_primero(&lista,&dato); + mostrar_dato(&dato); + } + + printf("\n La lista quedó vacía \n"); + + printf("\n Ingresamos un dato cualquiera: \n"); + cargar_dato(&dato); + + printf("\n Vacío la lista DE UNA \n"); + vaciar_lista(&lista); + + printf("\n\n Ahora voy a enlista los números 3, 6, 8 (en orden) \n"); + dato.numero=3; + poner_en_lista_ultimo(&lista,&dato); + dato.numero=6; + poner_en_lista_ultimo(&lista,&dato); + dato.numero=8; + poner_en_lista_ultimo(&lista,&dato); + + printf("\n Ahora voy a ingresar el 6 en orden sin duplicado \n"); + dato.numero=3; + if(!insertar_en_lista_ordenado_sin_duplicado(&lista,&dato,comparar_datos)) + printf("\n No se pudo insertar ya que el 3 ya está en la lista \n"); + + printf("\n Ahora ingreso el 7 sin duplicado \n"); + dato.numero=7; + if(insertar_en_lista_ordenado_sin_duplicado(&lista,&dato,comparar_datos)) + printf("\n Hecho \n"); + + printf("\n Finalmente inserto en orden pero acepto duplicado--> ingreso el 6 \n"); + dato.numero=6; + if(insertar_en_lista_ordenado_con_duplicado(&lista,&dato,comparar_datos)) + printf("\n Hecho \n"); + + printf("\n Saco de la pila hasta que queda vacía \n"); + while(!lista_vacia(&lista)) + { + sacar_de_lista_primero(&lista,&dato); + mostrar_dato(&dato); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/functions.o b/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/functions.o new file mode 100644 index 0000000..3c31e3e Binary files /dev/null and b/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/functions.o differ diff --git a/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/lista_simplemente_enlazada.o b/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/lista_simplemente_enlazada.o new file mode 100644 index 0000000..5e771b3 Binary files /dev/null and b/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/lista_simplemente_enlazada.o differ diff --git a/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/main.o b/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/main.o new file mode 100644 index 0000000..1748384 Binary files /dev/null and b/clase 13 y 14 (lista simplemente enlazada)/obj/Debug/main.o differ diff --git a/clase 15 (cola circular_lista circular implementada como cola)/bin/Debug/clase 15 (cola circular_lista circular implementada como cola).exe b/clase 15 (cola circular_lista circular implementada como cola)/bin/Debug/clase 15 (cola circular_lista circular implementada como cola).exe new file mode 100644 index 0000000..86edfb3 Binary files /dev/null and b/clase 15 (cola circular_lista circular implementada como cola)/bin/Debug/clase 15 (cola circular_lista circular implementada como cola).exe differ diff --git a/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).cbp b/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).cbp new file mode 100644 index 0000000..deb4c7c --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).depend b/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).depend new file mode 100644 index 0000000..11c6ef7 --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).depend @@ -0,0 +1,19 @@ +# depslib dependency file v1.0 +1476317835 source:d:\unlam\programaciÓn\fabian\clase 15 (cola circular_lista circular implementada como cola)\functions.c + "header.h" + +1476317818 d:\unlam\programaciÓn\fabian\clase 15 (cola circular_lista circular implementada como cola)\header.h + + + + + "primitivas_cola_circular.h" + +1476320267 d:\unlam\programaciÓn\fabian\clase 15 (cola circular_lista circular implementada como cola)\primitivas_cola_circular.h + "dato.h" + +1476317800 d:\unlam\programaciÓn\fabian\clase 15 (cola circular_lista circular implementada como cola)\dato.h + +1476317946 source:d:\unlam\programaciÓn\fabian\clase 15 (cola circular_lista circular implementada como cola)\main.c + "header.h" + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).layout b/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).layout new file mode 100644 index 0000000..a7e172c --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/clase 15 (cola circular_lista circular implementada como cola).layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/dato.h b/clase 15 (cola circular_lista circular implementada como cola)/dato.h new file mode 100644 index 0000000..3fc75a6 --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/dato.h @@ -0,0 +1,5 @@ +typedef struct + { + int numero; + }t_dato; + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/functions.c b/clase 15 (cola circular_lista circular implementada como cola)/functions.c new file mode 100644 index 0000000..9febf82 --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/functions.c @@ -0,0 +1,13 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(const t_dato *d) + { + printf("\n DATO: \t %d \n",d->numero); + } + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/header.h b/clase 15 (cola circular_lista circular implementada como cola)/header.h new file mode 100644 index 0000000..b7ed9b5 --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/header.h @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "primitivas_cola_circular.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/main.c b/clase 15 (cola circular_lista circular implementada como cola)/main.c new file mode 100644 index 0000000..4560cd7 --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/main.c @@ -0,0 +1,50 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n COLA CIRCULAR - LISTA CIRCULAR IMPLEMENTADA COMO COLA \n"); + t_lista cola; + t_dato dato; + + int i=0; + + crear_cola(&cola); + printf("\n Se ha creado una cola \n"); + + printf("\n Acolar \n"); + while(i<5) + { + cargar_dato(&dato); + acolar(&cola,&dato); + i++; + } + + if(!cola_vacia(&cola)) + ver_primero_en_cola(&cola,&dato); + printf("\n Primero de la cola: \t %d \n",dato.numero); + + if(!cola_vacia(&cola)) + ver_ultimo_en_cola(&cola,&dato); + printf("\n Último de la cola: \t %d \n",dato.numero); + + printf("\n Desacolar \n"); + while(i>0) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + i--; + } + + printf("\n Acolar algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + + printf("\n La cola se ha vaciado \n"); + vaciar_cola(&cola); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } + diff --git a/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/functions.o b/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/functions.o new file mode 100644 index 0000000..0a7d6c1 Binary files /dev/null and b/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/functions.o differ diff --git a/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/main.o b/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/main.o new file mode 100644 index 0000000..426260e Binary files /dev/null and b/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/main.o differ diff --git a/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/primitivas_cola_circular.o b/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/primitivas_cola_circular.o new file mode 100644 index 0000000..74c32c0 Binary files /dev/null and b/clase 15 (cola circular_lista circular implementada como cola)/obj/Debug/primitivas_cola_circular.o differ diff --git a/clase 15 (cola circular_lista circular implementada como cola)/primitivas_cola_circular.c b/clase 15 (cola circular_lista circular implementada como cola)/primitivas_cola_circular.c new file mode 100644 index 0000000..323f6b8 --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/primitivas_cola_circular.c @@ -0,0 +1,83 @@ +#include "primitivas_cola_circular.h" + +#include +#include + +void crear_cola(t_lista *c) + { + *c=NULL; + } + +int cola_vacia(const t_lista *c) + { + return *c==NULL; + } + +int cola_llena(const t_lista *c) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int acolar(t_lista *c,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*c) + nue->sig=nue; + else + { + nue->sig=(*c)->sig; + (*c)->sig=nue; + } + *c=nue; + return OK; + } + +int desacolar(t_lista *c,t_dato *d) + { + t_nodo *aux; + if(!*c) + return COLA_VACIA; + aux=(*c)->sig; + *d=aux->dato; + if(*c==aux) + *c=NULL; + else + (*c)->sig=aux->sig; + free(aux); + return OK; + } + +int ver_primero_en_cola(const t_lista *c,t_dato *d) + { + if(!*c) + return COLA_VACIA; + *d=(*c)->sig->dato; + return OK; + } + +int ver_ultimo_en_cola(const t_lista *c,t_dato *d) + { + if(!*c) + return COLA_VACIA; + *d=(*c)->dato; + return OK; + } + +void vaciar_cola(t_lista *c) + { + t_nodo *aux,*ult=*c; + *c=(*c)->sig; + while(*c&&*c!=ult) + { + aux=*c; + *c=aux->sig; + free(aux); + } + free(*c); + *c=NULL; + } diff --git a/clase 15 (cola circular_lista circular implementada como cola)/primitivas_cola_circular.h b/clase 15 (cola circular_lista circular implementada como cola)/primitivas_cola_circular.h new file mode 100644 index 0000000..cacddbc --- /dev/null +++ b/clase 15 (cola circular_lista circular implementada como cola)/primitivas_cola_circular.h @@ -0,0 +1,22 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +void crear_cola(t_lista*); +int cola_vacia(const t_lista*); +int cola_llena(const t_lista*); +int acolar(t_lista*,const t_dato*); +int desacolar(t_lista*,t_dato*); +int ver_primero_en_cola(const t_lista*,t_dato*); +int ver_ultimo_en_cola(const t_lista*,t_dato*); +void vaciar_cola(t_lista*); diff --git a/clase 15 (pila circular_lista circular implementada como pila)/bin/Debug/clase 15 (pila circular_lista circular implementada como pila).exe b/clase 15 (pila circular_lista circular implementada como pila)/bin/Debug/clase 15 (pila circular_lista circular implementada como pila).exe new file mode 100644 index 0000000..6b809b2 Binary files /dev/null and b/clase 15 (pila circular_lista circular implementada como pila)/bin/Debug/clase 15 (pila circular_lista circular implementada como pila).exe differ diff --git a/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).cbp b/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).cbp new file mode 100644 index 0000000..dc09f8a --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).cbp @@ -0,0 +1,53 @@ + + + + + + diff --git a/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).depend b/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).depend new file mode 100644 index 0000000..784bb06 --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).depend @@ -0,0 +1,19 @@ +# depslib dependency file v1.0 +1476314267 source:d:\unlam\programaciÓn\fabian\clase 15 (pila circular_lista circular implementada como pila)\functions.c + "header.h" + +1476314317 d:\unlam\programaciÓn\fabian\clase 15 (pila circular_lista circular implementada como pila)\header.h + + + + + "primitivas_pila_circular.h" + +1476314857 d:\unlam\programaciÓn\fabian\clase 15 (pila circular_lista circular implementada como pila)\primitivas_pila_circular.h + "dato.h" + +1476314212 d:\unlam\programaciÓn\fabian\clase 15 (pila circular_lista circular implementada como pila)\dato.h + +1476316642 source:d:\unlam\programaciÓn\fabian\clase 15 (pila circular_lista circular implementada como pila)\main.c + "header.h" + diff --git a/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).layout b/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).layout new file mode 100644 index 0000000..f494f4a --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/clase 15 (pila circular_lista circular implementada como pila).layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/clase 15 (pila circular_lista circular implementada como pila)/dato.h b/clase 15 (pila circular_lista circular implementada como pila)/dato.h new file mode 100644 index 0000000..cd20726 --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/dato.h @@ -0,0 +1,4 @@ +typedef struct + { + int numero; + }t_dato; diff --git a/clase 15 (pila circular_lista circular implementada como pila)/functions.c b/clase 15 (pila circular_lista circular implementada como pila)/functions.c new file mode 100644 index 0000000..a4b718c --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/functions.c @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(const t_dato *d) + { + printf("\n DATO: \t %d \n",d->numero); + } diff --git a/clase 15 (pila circular_lista circular implementada como pila)/header.h b/clase 15 (pila circular_lista circular implementada como pila)/header.h new file mode 100644 index 0000000..9ad5980 --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/header.h @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "primitivas_pila_circular.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); diff --git a/clase 15 (pila circular_lista circular implementada como pila)/main.c b/clase 15 (pila circular_lista circular implementada como pila)/main.c new file mode 100644 index 0000000..0a5c146 --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/main.c @@ -0,0 +1,46 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PILA CIRCULAR - LISTA CIRCULAR IMPLEMENTADA COMO PILA \n"); + t_lista pila; + t_dato dato; + + int i=0; + + crear_pila(&pila); + printf("\n Se ha creado una pila \n"); + + printf("\n Apilar \n"); + while(i<5) + { + cargar_dato(&dato); + apilar(&pila,&dato); + i++; + } + + if(!pila_vacia(&pila)) + ver_tope(&pila,&dato); + printf("\n Tope de la pila: \t %d \n",dato.numero); + + printf("\n Desapilar \n"); + while(i>0) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + i--; + } + + printf("\n Apilar algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + + printf("\n La pila se ha vaciado \n"); + vaciar_pila(&pila); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } + diff --git a/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/functions.o b/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/functions.o new file mode 100644 index 0000000..1fd996d Binary files /dev/null and b/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/functions.o differ diff --git a/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/main.o b/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/main.o new file mode 100644 index 0000000..5e169e5 Binary files /dev/null and b/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/main.o differ diff --git a/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/primitivas_pila_circular.o b/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/primitivas_pila_circular.o new file mode 100644 index 0000000..7f94a6d Binary files /dev/null and b/clase 15 (pila circular_lista circular implementada como pila)/obj/Debug/primitivas_pila_circular.o differ diff --git a/clase 15 (pila circular_lista circular implementada como pila)/primitivas_pila_circular.c b/clase 15 (pila circular_lista circular implementada como pila)/primitivas_pila_circular.c new file mode 100644 index 0000000..f020c42 --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/primitivas_pila_circular.c @@ -0,0 +1,72 @@ +#include "primitivas_pila_circular.h" + +#include +#include + +void crear_pila(t_lista *p) + { + *p=NULL; + } + +int pila_vacia(const t_lista *p) + { + return *p==NULL; + } + +int pila_llena(const t_lista *p) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int apilar(t_lista *p,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*p) + *p=nue; + else + nue->sig=(*p)->sig; + (*p)->sig=nue; + return OK; + } + +int desapilar(t_lista *p,t_dato *d) + { + t_nodo *aux; + if(!*p) + return PILA_VACIA; + aux=(*p)->sig; + *d=aux->dato; + if(*p==aux) + *p=NULL; + else + (*p)->sig=aux->sig; + free(aux); + return OK; + } + +int ver_tope(const t_lista *p,t_dato *d) + { + if(!*p) + return PILA_VACIA; + *d=(*p)->sig->dato; + return OK; + } + +void vaciar_pila(t_lista *p) + { + t_nodo *aux,*pri=*p; + *p=(*p)->sig; + while(*p&&*p!=pri) + { + aux=*p; + *p=aux->sig; + free(aux); + } + free(*p); + *p=NULL; + } diff --git a/clase 15 (pila circular_lista circular implementada como pila)/primitivas_pila_circular.h b/clase 15 (pila circular_lista circular implementada como pila)/primitivas_pila_circular.h new file mode 100644 index 0000000..5e04673 --- /dev/null +++ b/clase 15 (pila circular_lista circular implementada como pila)/primitivas_pila_circular.h @@ -0,0 +1,21 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define PILA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +void crear_pila(t_lista*); +int pila_vacia(const t_lista*); +int pila_llena(const t_lista*); +int apilar(t_lista*,const t_dato*); +int desapilar(t_lista*,t_dato*); +int ver_tope(const t_lista*,t_dato*); +void vaciar_pila(t_lista*); diff --git a/clase 15 (primitivas de lista circular)/bin/Debug/clase 15 (primitivas de lista circular).exe b/clase 15 (primitivas de lista circular)/bin/Debug/clase 15 (primitivas de lista circular).exe new file mode 100644 index 0000000..cc59263 Binary files /dev/null and b/clase 15 (primitivas de lista circular)/bin/Debug/clase 15 (primitivas de lista circular).exe differ diff --git a/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).cbp b/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).cbp new file mode 100644 index 0000000..8daa0e5 --- /dev/null +++ b/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).cbp @@ -0,0 +1,53 @@ + + + + + + diff --git a/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).depend b/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).depend new file mode 100644 index 0000000..a21138f --- /dev/null +++ b/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).depend @@ -0,0 +1,24 @@ +# depslib dependency file v1.0 +1476308706 source:d:\unlam\programaciÓn\fabian\clase 15 (primitivas de lista circular)\functions.c + "header.h" + +1476308684 d:\unlam\programaciÓn\fabian\clase 15 (primitivas de lista circular)\header.h + + + + + "primitivas_lista_circular.h" + +1476314534 d:\unlam\programaciÓn\fabian\clase 15 (primitivas de lista circular)\primitivas_lista_circular.h + "dato.h" + +1476308009 d:\unlam\programaciÓn\fabian\clase 15 (primitivas de lista circular)\dato.h + +1476311925 source:d:\unlam\programaciÓn\fabian\clase 15 (primitivas de lista circular)\main.c + "header.h" + +1476312095 source:d:\unlam\programaciÓn\fabian\clase 15 (primitivas de lista circular)\primitivas_lista_circular.c + "primitivas_lista_circular.h" + + + diff --git a/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).layout b/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).layout new file mode 100644 index 0000000..0db1019 --- /dev/null +++ b/clase 15 (primitivas de lista circular)/clase 15 (primitivas de lista circular).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 15 (primitivas de lista circular)/dato.h b/clase 15 (primitivas de lista circular)/dato.h new file mode 100644 index 0000000..cd20726 --- /dev/null +++ b/clase 15 (primitivas de lista circular)/dato.h @@ -0,0 +1,4 @@ +typedef struct + { + int numero; + }t_dato; diff --git a/clase 15 (primitivas de lista circular)/functions.c b/clase 15 (primitivas de lista circular)/functions.c new file mode 100644 index 0000000..9febf82 --- /dev/null +++ b/clase 15 (primitivas de lista circular)/functions.c @@ -0,0 +1,13 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); + } + +void mostrar_dato(const t_dato *d) + { + printf("\n DATO: \t %d \n",d->numero); + } + diff --git a/clase 15 (primitivas de lista circular)/header.h b/clase 15 (primitivas de lista circular)/header.h new file mode 100644 index 0000000..0eed3ae --- /dev/null +++ b/clase 15 (primitivas de lista circular)/header.h @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "primitivas_lista_circular.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); + diff --git a/clase 15 (primitivas de lista circular)/main.c b/clase 15 (primitivas de lista circular)/main.c new file mode 100644 index 0000000..bffbeef --- /dev/null +++ b/clase 15 (primitivas de lista circular)/main.c @@ -0,0 +1,52 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA CIRCULAR \n"); + + t_lista lista; + t_dato dato; + + int i; + + crear_lista(&lista); + printf("\n\n Se ha creado una lista \n"); + + printf("\n\n Cargue la lista: \n"); + for(i=0;i<5;i++) + { + cargar_dato(&dato); + poner_en_lista(&lista,&dato); + } + printf("\n\n Se ingresaron 5 elementos \n"); + + if(!lista_llena(&lista)) + printf("\n\n La lista no está llena \n"); + + printf("\n\n Ver primero: \n"); + ver_primero_de_lista(&lista,&dato); + printf("\n\n El primero de la lista es: \n"); + mostrar_dato(&dato); + + printf("\n\n Sacar de la lista \n"); + while(!lista_vacia(&lista)) + { + sacar_de_lista(&lista,&dato); + mostrar_dato(&dato); + } + printf("\n\n La lista está vacía \n"); + + printf("\n\n Cargar algo: \n"); + cargar_dato(&dato); + poner_en_lista(&lista,&dato); + printf("\n\n El dato fue cargado \n"); + + vaciar_lista(&lista); + printf("\n\n La lista fue vaciada exitosamente \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } + diff --git a/clase 15 (primitivas de lista circular)/obj/Debug/functions.o b/clase 15 (primitivas de lista circular)/obj/Debug/functions.o new file mode 100644 index 0000000..548857a Binary files /dev/null and b/clase 15 (primitivas de lista circular)/obj/Debug/functions.o differ diff --git a/clase 15 (primitivas de lista circular)/obj/Debug/main.o b/clase 15 (primitivas de lista circular)/obj/Debug/main.o new file mode 100644 index 0000000..2297a32 Binary files /dev/null and b/clase 15 (primitivas de lista circular)/obj/Debug/main.o differ diff --git a/clase 15 (primitivas de lista circular)/obj/Debug/primitivas_lista_circular.o b/clase 15 (primitivas de lista circular)/obj/Debug/primitivas_lista_circular.o new file mode 100644 index 0000000..da887e3 Binary files /dev/null and b/clase 15 (primitivas de lista circular)/obj/Debug/primitivas_lista_circular.o differ diff --git a/clase 15 (primitivas de lista circular)/primitivas_lista_circular.c b/clase 15 (primitivas de lista circular)/primitivas_lista_circular.c new file mode 100644 index 0000000..1b7e527 --- /dev/null +++ b/clase 15 (primitivas de lista circular)/primitivas_lista_circular.c @@ -0,0 +1,77 @@ +#include "primitivas_lista_circular.h" + +#include +#include + +void crear_lista(t_lista *l) + { + *l=NULL; + } + +int lista_vacia(const t_lista *l) + { + return *l==NULL; + } + +int lista_llena(const t_lista *l) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int poner_en_lista(t_lista *l,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*l) + { + *l=nue; + nue->sig=nue; + } + else + { + nue->sig=(*l)->sig; + (*l)->sig=nue; + } + return OK; + } + +int sacar_de_lista(t_lista *l,t_dato *d) + { + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + aux=(*l)->sig; + *d=aux->dato; + if(*l==aux) + *l=NULL; + else + (*l)->sig=aux->sig; + free(aux); + return OK; + } + +int ver_primero_de_lista(const t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + *d=(*l)->dato; + return OK; + } + +void vaciar_lista(t_lista *l) + { + t_nodo *aux,*pri=*l; + *l=(*l)->sig; + while(*l&&*l!=pri) + { + aux=*l; + *l=aux->sig; + free(aux); + } + free(*l); + *l=NULL; + } diff --git a/clase 15 (primitivas de lista circular)/primitivas_lista_circular.h b/clase 15 (primitivas de lista circular)/primitivas_lista_circular.h new file mode 100644 index 0000000..aa145bd --- /dev/null +++ b/clase 15 (primitivas de lista circular)/primitivas_lista_circular.h @@ -0,0 +1,21 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int poner_en_lista(t_lista*,const t_dato*); +int sacar_de_lista(t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +void vaciar_lista(t_lista*); diff --git a/clase 16 (lista doblemente enlazada)/bin/Debug/clase 16 (lista doblemente enlazada).exe b/clase 16 (lista doblemente enlazada)/bin/Debug/clase 16 (lista doblemente enlazada).exe new file mode 100644 index 0000000..04f09c2 Binary files /dev/null and b/clase 16 (lista doblemente enlazada)/bin/Debug/clase 16 (lista doblemente enlazada).exe differ diff --git a/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).cbp b/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).cbp new file mode 100644 index 0000000..e7bcfbc --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).cbp @@ -0,0 +1,53 @@ + + + + + + diff --git a/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).depend b/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).depend new file mode 100644 index 0000000..5eb0105 --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).depend @@ -0,0 +1,24 @@ +# depslib dependency file v1.0 +1476564826 source:d:\unlam\programaciÓn\fabian\clase 16 (lista doblemente enlazada)\functions.c + "header.h" + +1476564792 d:\unlam\programaciÓn\fabian\clase 16 (lista doblemente enlazada)\header.h + + + + + "lista_doblemente_enlazada.h" + +1476565276 d:\unlam\programaciÓn\fabian\clase 16 (lista doblemente enlazada)\lista_doblemente_enlazada.h + "dato.h" + +1476558637 d:\unlam\programaciÓn\fabian\clase 16 (lista doblemente enlazada)\dato.h + +1476565310 source:d:\unlam\programaciÓn\fabian\clase 16 (lista doblemente enlazada)\lista_doblemente_enlazada.c + "lista_doblemente_enlazada.h" + + + +1476565243 source:d:\unlam\programaciÓn\fabian\clase 16 (lista doblemente enlazada)\main.c + "header.h" + diff --git a/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).layout b/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).layout new file mode 100644 index 0000000..29c22d8 --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/clase 16 (lista doblemente enlazada).layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/clase 16 (lista doblemente enlazada)/dato.h b/clase 16 (lista doblemente enlazada)/dato.h new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/dato.h @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git a/clase 16 (lista doblemente enlazada)/functions.c b/clase 16 (lista doblemente enlazada)/functions.c new file mode 100644 index 0000000..ca8502f --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/functions.c @@ -0,0 +1,32 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d",d->numero); +} + +void ingresa_clave(int *clave) +{ + printf("\n\n Ingrese clave: \t"); + scanf("%d",clave); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} + +int comparar_claves(const void *v1,const void *v2) +{ + t_dato *e1=(t_dato*)v1; + int *e2=(int*)v2; + return e1->numero-*e2; +} + diff --git a/clase 16 (lista doblemente enlazada)/header.h b/clase 16 (lista doblemente enlazada)/header.h new file mode 100644 index 0000000..0172d97 --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/header.h @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +#include "lista_doblemente_enlazada.h" + +void cargar_dato(t_dato *d); +void mostrar_dato(const t_dato *d); +void ingresa_clave(int*); + +int comparar_enteros(const void*,const void*); +int comparar_claves(const void*,const void*); diff --git a/clase 16 (lista doblemente enlazada)/lista_doblemente_enlazada.c b/clase 16 (lista doblemente enlazada)/lista_doblemente_enlazada.c new file mode 100644 index 0000000..88cf49b --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/lista_doblemente_enlazada.c @@ -0,0 +1,236 @@ +#include "lista_doblemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int insertar_en_lista_ordenada_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(!(cmp=comparar((void*)&act->dato,(void*)d))) + return DUPLICADO; + if(cmp>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + act->dato=*d; + act->ant=ant; + act->sig=sig; + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + *l=act; + return OK; +} + +int insertar_en_lista_ordenada_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(comparar((void*)&act->dato,(void*)d)>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + act->dato=*d; + act->ant=ant; + act->sig=sig; + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + *l=act; + return OK; +} + +int eliminar_de_lista_ordenada_por_clave(t_lista *l,t_dato *d,void *clave,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant; + t_nodo *sig; + if(!act) + return LISTA_VACIA; + while(comparar((void*)&act->dato,clave)<0) + act=act->sig; + while(comparar((void*)&act->dato,clave)>0) + act=act->ant; + if(comparar((void*)&act->dato,clave)) + return NO_ENCONTRADO; + *d=act->dato; + ant=act->ant; + sig=act->sig; + if(ant) + { + ant->sig=act->sig; + *l=ant; + } + if(sig) + { + sig->ant=act->ant; + *l=sig; + } + if(!ant&&!sig) + *l=NULL; + free(act); + return OK; +} + +int eliminar_primero_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + while((*l)->ant) + l=&(*l)->ant; + aux=*l; + l=&(*l)->sig; + (*l)->ant=NULL; + *d=aux->dato; + free(aux); + return OK; +} + +int eliminar_ultimo_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + aux=*l; + l=&(*l)->ant; + (*l)->sig=NULL; + *d=aux->dato; + free(aux); + return OK; +} + +int ver_nodo_actual_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + *d=(*l)->dato; + return OK; +} + +int ver_primero_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->ant) + l=&(*l)->ant; + *d=(*l)->dato; + return OK; +} + +int ver_ultimo_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + *d=(*l)->dato; + return OK; +} + +void mostrar_lista_orden_ascendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->ant) + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + while((*l)->sig) + { + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + } +} + +void mostrar_lista_orden_descendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->sig) + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + while((*l)->ant) + { + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + } +} + +int contar_nodos_de_lista(const t_lista *l) +{ + int cont=0; + while((*l)->ant) + l=&(*l)->ant; + if(*l) + cont++; + while((*l)->sig) + { + l=&(*l)->sig; + cont++; + } + return cont; +} + +void vaciar_lista(t_lista *l) +{ + t_nodo *aux; + while((*l)->ant) + l=&(*l)->ant; + while((*l)->sig) + { + aux=*l; + l=&(*l)->sig; + free(aux); + } + *l=NULL; +} diff --git a/clase 16 (lista doblemente enlazada)/lista_doblemente_enlazada.h b/clase 16 (lista doblemente enlazada)/lista_doblemente_enlazada.h new file mode 100644 index 0000000..b1b87c4 --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/lista_doblemente_enlazada.h @@ -0,0 +1,40 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *ant; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int insertar_en_lista_ordenada_sin_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenada_con_duplicado(t_lista*,const t_dato*,t_cmp); +int eliminar_de_lista_ordenada_por_clave(t_lista*,t_dato*,void*,t_cmp); +int eliminar_primero_de_lista(t_lista*,t_dato*); +int eliminar_ultimo_de_lista(t_lista*,t_dato*); +int ver_nodo_actual_de_lista(const t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +int ver_ultimo_de_lista(const t_lista*,t_dato*); +void mostrar_lista_orden_ascendente(const t_lista*,t_mst); +void mostrar_lista_orden_descendente(const t_lista*,t_mst); +int contar_nodos_de_lista(const t_lista*); +void vaciar_lista(t_lista*); diff --git a/clase 16 (lista doblemente enlazada)/main.c b/clase 16 (lista doblemente enlazada)/main.c new file mode 100644 index 0000000..e39003e --- /dev/null +++ b/clase 16 (lista doblemente enlazada)/main.c @@ -0,0 +1,60 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA DOBLEMENETE ENLAZADA \n\a\a"); + + t_lista lista; + t_dato dato; + + crear_lista(&lista); + printf("\n\n Se ha creado una lista \n"); + + int i; + + printf("\n\n Cargar la lista: \n"); + for(i=0;i<5;i++) + { + cargar_dato(&dato); + insertar_en_lista_ordenada_sin_duplicado(&lista,&dato,comparar_enteros); + } + printf("\n\n Se ha cargado la lista \n"); + + if(!lista_llena(&lista)) + printf("\n\n La lista no está llena \n"); + + printf("\n\n Primero de la lista \n"); + ver_primero_de_lista(&lista,&dato); + mostrar_dato(&dato); + + printf("\n\n Último de la lista \n"); + ver_ultimo_de_lista(&lista,&dato); + mostrar_dato(&dato); + + int clave; + printf("\n\n Eliminar de la lista por clave \n"); + printf("\n Ingrese clave a eliminar: \n"); + ingresa_clave(&clave); + + if(eliminar_de_lista_ordenada_con_clave(&lista,&dato,&clave,comparar_claves)) + { + printf("\n\n Se ha eliminado exitosamente este elemento de la lista \n"); + mostrar_dato(&dato); + } + else + printf("\n\n No se ha encontrado un elemento con esa clave \n"); + + printf("\n\n Esta es la lista que ha quedado: \n"); + mostrar_lista(&lista,mostrar_dato); + + printf("\n\n Vaciar la lista \n"); + vaciar_lista(&lista); + + if(lista_vacia(&lista)) + printf("\n\n La lista se ha vaciado exitosamente \ns"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/clase 16 (lista doblemente enlazada)/obj/Debug/functions.o b/clase 16 (lista doblemente enlazada)/obj/Debug/functions.o new file mode 100644 index 0000000..95835b3 Binary files /dev/null and b/clase 16 (lista doblemente enlazada)/obj/Debug/functions.o differ diff --git a/clase 16 (lista doblemente enlazada)/obj/Debug/lista_doblemente_enlazada.o b/clase 16 (lista doblemente enlazada)/obj/Debug/lista_doblemente_enlazada.o new file mode 100644 index 0000000..acc8989 Binary files /dev/null and b/clase 16 (lista doblemente enlazada)/obj/Debug/lista_doblemente_enlazada.o differ diff --git a/clase 16 (lista doblemente enlazada)/obj/Debug/main.o b/clase 16 (lista doblemente enlazada)/obj/Debug/main.o new file mode 100644 index 0000000..ffef758 Binary files /dev/null and b/clase 16 (lista doblemente enlazada)/obj/Debug/main.o differ diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/bin/Debug/clase 17 (funciones iterativas vs funciones recursivas).exe b/clase 17 (funciones iterativas vs funciones recursivas)/bin/Debug/clase 17 (funciones iterativas vs funciones recursivas).exe new file mode 100644 index 0000000..2574cee Binary files /dev/null and b/clase 17 (funciones iterativas vs funciones recursivas)/bin/Debug/clase 17 (funciones iterativas vs funciones recursivas).exe differ diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).cbp b/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).cbp new file mode 100644 index 0000000..b4f974b --- /dev/null +++ b/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).depend b/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).depend new file mode 100644 index 0000000..c76ecb5 --- /dev/null +++ b/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1477249387 source:d:\unlam\programaciÓn\fabian\clase 17 (funciones iterativas vs funciones recursivas)\functions.c + "header.h" + +1477248829 d:\unlam\programaciÓn\fabian\clase 17 (funciones iterativas vs funciones recursivas)\header.h + + + + + +1477249336 source:d:\unlam\programaciÓn\fabian\clase 17 (funciones iterativas vs funciones recursivas)\main.c + "header.h" + diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).layout b/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).layout new file mode 100644 index 0000000..8d58a10 --- /dev/null +++ b/clase 17 (funciones iterativas vs funciones recursivas)/clase 17 (funciones iterativas vs funciones recursivas).layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/functions.c b/clase 17 (funciones iterativas vs funciones recursivas)/functions.c new file mode 100644 index 0000000..68d4238 --- /dev/null +++ b/clase 17 (funciones iterativas vs funciones recursivas)/functions.c @@ -0,0 +1,14 @@ +#include "header.h" + +int factorial_iterativo(int x) +{ + int i,fact=1; + for(i=1;i<=x;i++) + fact*=i; + return fact; +} + +int factorial_recursivo(int x) +{ + return (x<=1)?1:x*factorial_recursivo(x-1); +} diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/header.h b/clase 17 (funciones iterativas vs funciones recursivas)/header.h new file mode 100644 index 0000000..ddf285f --- /dev/null +++ b/clase 17 (funciones iterativas vs funciones recursivas)/header.h @@ -0,0 +1,7 @@ +#include +#include +#include +#include + +int factorial_iterativo(int x); +int factorial_recursivo(int x); diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/main.c b/clase 17 (funciones iterativas vs funciones recursivas)/main.c new file mode 100644 index 0000000..38da24d --- /dev/null +++ b/clase 17 (funciones iterativas vs funciones recursivas)/main.c @@ -0,0 +1,24 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n FUNCIONES ITERATIVAS VS FUNCIONES RECURSIVAS \n"); + + //las funciones recursivas son aquellas que se invocan a sí misma + //hay lenguajes que no permiten la recursividad, no es el caso de C + //todas las funciones iterativas se pueden escribir de forma recursiva, y viceversa, en general + //las funciones recursivas consumen más memoria y son más lentas que las funciones iterativas + //pero hay algunos casos en que encontrar la forma iterativa de una función recursiva es muy complicado + //las funciones recursivas, en algunos casos, son muy fáciles + //toda función recursiva debe tener una consulta--> la condición de fin + //las funciones recursivas vasn delegando el problema hasta que se llegue a la condición de fin + //cada invocación recibe el valor siguiente, pero no lo modifica para el entorno local de quien la invoca + + printf("\n\n factorial_iterativo(5): \t %d",factorial_iterativo(5)); + printf("\n\n factorial_recursivo(5): \t %d",factorial_recursivo(5)); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; +} diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/obj/Debug/functions.o b/clase 17 (funciones iterativas vs funciones recursivas)/obj/Debug/functions.o new file mode 100644 index 0000000..7eab65e Binary files /dev/null and b/clase 17 (funciones iterativas vs funciones recursivas)/obj/Debug/functions.o differ diff --git a/clase 17 (funciones iterativas vs funciones recursivas)/obj/Debug/main.o b/clase 17 (funciones iterativas vs funciones recursivas)/obj/Debug/main.o new file mode 100644 index 0000000..bda1cd4 Binary files /dev/null and b/clase 17 (funciones iterativas vs funciones recursivas)/obj/Debug/main.o differ diff --git a/clase 17 (recursividad)/bin/Debug/clase 17 (recursividad).exe b/clase 17 (recursividad)/bin/Debug/clase 17 (recursividad).exe new file mode 100644 index 0000000..8ba3dcf Binary files /dev/null and b/clase 17 (recursividad)/bin/Debug/clase 17 (recursividad).exe differ diff --git a/clase 17 (recursividad)/clase 17 (recursividad).cbp b/clase 17 (recursividad)/clase 17 (recursividad).cbp new file mode 100644 index 0000000..f6c808b --- /dev/null +++ b/clase 17 (recursividad)/clase 17 (recursividad).cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/clase 17 (recursividad)/clase 17 (recursividad).depend b/clase 17 (recursividad)/clase 17 (recursividad).depend new file mode 100644 index 0000000..2e51f9f --- /dev/null +++ b/clase 17 (recursividad)/clase 17 (recursividad).depend @@ -0,0 +1,24 @@ +# depslib dependency file v1.0 +1477265045 source:d:\unlam\programaciÓn\fabian\clase 17 (recursividad)\main.c + "header.h" + +1477265019 d:\unlam\programaciÓn\fabian\clase 17 (recursividad)\header.h + + + + + "lista_simplemente_enlazada.h" + +1477264949 source:d:\unlam\programaciÓn\fabian\clase 17 (recursividad)\functions.c + "header.h" + +1476046425 source:d:\unlam\programaciÓn\fabian\clase 17 (recursividad)\lista_simplemente_enlazada.c + + + "lista_simplemente_enlazada.h" + +1476046410 d:\unlam\programaciÓn\fabian\clase 17 (recursividad)\lista_simplemente_enlazada.h + "dato.h" + +1477263580 d:\unlam\programaciÓn\fabian\clase 17 (recursividad)\dato.h + diff --git a/clase 17 (recursividad)/clase 17 (recursividad).layout b/clase 17 (recursividad)/clase 17 (recursividad).layout new file mode 100644 index 0000000..d95ae94 --- /dev/null +++ b/clase 17 (recursividad)/clase 17 (recursividad).layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/clase 17 (recursividad)/dato.h b/clase 17 (recursividad)/dato.h new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ b/clase 17 (recursividad)/dato.h @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git a/clase 17 (recursividad)/functions.c b/clase 17 (recursividad)/functions.c new file mode 100644 index 0000000..afea01f --- /dev/null +++ b/clase 17 (recursividad)/functions.c @@ -0,0 +1,251 @@ +#include "header.h" + +void cadena_encolumnada(char *s) +{ + if(*s) + { + printf("\n\t %c",*s); + cadena_encolumnada(s+1); + } +} + +void cadena_encolumnada_al_reves(char *s) +{ + if(*s) + { + cadena_encolumnada_al_reves(s+1); + printf("\n\t %c",*s); + } +} + +void cadena_encolumnada_doble_con_repeticion(char *s) +{ + if(*s) + { + printf("\n\t %c",*s); + cadena_encolumnada_doble_con_repeticion(s+1); + printf("\n\t %c",*s); + } +} + +void cadena_encolumnada_doble_sin_repeticion(char *s) +{ + if(*s) + { + printf("\n\t %c",*s); + cadena_encolumnada_doble_sin_repeticion(s+1); + if(*(s+1)) + printf("\n\t %c",*s); + } +} + +void cadena_en_triangulo_1(char *s) +{ + if(*s) + { + printf("\n\t %s",s); + cadena_en_triangulo_1(s+1); + } +} + +void cadena_en_triangulo_2(char *s) +{ + if(*s) + { + cadena_en_triangulo_2(s+1); + printf("\n\t %s",s); + } +} + +void cadena_en_triangulo_3(char *s) +{ + char *inicio=s; + int i=0; + while(*s) + { + i++; + s++; + } + s=inicio; + cadena_en_triangulo_3_recursiva(s,i); +} + +void cadena_en_triangulo_3_recursiva(char *s,int i) +{ + char *inicio=s; + if(*s&&i>0) + { + int j; + printf("\n\t "); + for(j=0;j0) + { + cadena_en_triangulo_4_recursiva(s,i-1); + int j; + printf("\n\t "); + for(j=0;j0) + cambio_de_base(base,n/base); + printf("%d",n%base); +} + +void caracter_en_triangulo(char c,int n) +{ + if(n>0) + { + printf("\n\t"); + int i; + for(i=0;i0) + { + caracter_en_triangulo_inverso(c,n-1); + printf("\n\t"); + int i; + for(i=0;i0) + { + int i; + printf("\n\t"); + for(i=0;i0) + { + int i; + printf("\n\t"); + for(i=0;i1) + { + printf("\n\t"); + for(i=0;idato.numero); + mostrar_lista_ordenada(&(*l)->sig); + } +} + +void mostrar_en_reversa_lista_ordenada(const t_lista *l) +{ + if(*l) + { + mostrar_en_reversa_lista_ordenada(&(*l)->sig); + printf("\t %d",(*l)->dato.numero); + } +} diff --git a/clase 17 (recursividad)/header.h b/clase 17 (recursividad)/header.h new file mode 100644 index 0000000..3a723d2 --- /dev/null +++ b/clase 17 (recursividad)/header.h @@ -0,0 +1,40 @@ +#include +#include +#include +#include + +#include "lista_simplemente_enlazada.h" + +void cadena_encolumnada(char*); +void cadena_encolumnada_al_reves(char*); + +void cadena_encolumnada_doble_con_repeticion(char*); +void cadena_encolumnada_doble_sin_repeticion(char*); + +void cadena_en_triangulo_1(char*); +void cadena_en_triangulo_2(char*); + +void cadena_en_triangulo_3(char*); +void cadena_en_triangulo_3_recursiva(char*,int); + +void cadena_en_triangulo_4(char*); +void cadena_en_triangulo_4_recursiva(char*,int); + +void numero_encolumnado(int); +void numero_encolumnado_al_reves(int); + +void numero_encolumnado_doble_con_repeticion(int); +void numero_encolumnado_doble_sin_repeticion(int); + +void numero_en_triangulo_1(int); +void numero_en_triangulo_2(int); + +void cambio_de_base(int,int); + +void caracter_en_triangulo(char,int); +void caracter_en_triangulo_inverso(char,int); +void caracter_en_doble_triangulo_con_repeticion(char,int); +void caracter_en_doble_triangulo_sin_repeticion(char,int); + +void mostrar_lista_ordenada(const t_lista *l); +void mostrar_en_reversa_lista_ordenada(const t_lista*); diff --git a/clase 17 (recursividad)/lista_simplemente_enlazada.c b/clase 17 (recursividad)/lista_simplemente_enlazada.c new file mode 100644 index 0000000..e2823de --- /dev/null +++ b/clase 17 (recursividad)/lista_simplemente_enlazada.c @@ -0,0 +1,225 @@ +#include +#include + +#include "lista_simplemente_enlazada.h" + +void crear_lista(t_lista *l) + { + *l=NULL; + } + +void vaciar_lista(t_lista *l) + { + t_nodo *aux; + while(*l) + { + aux=*l; + *l=aux->sig; + free(aux); + } + } + +int lista_llena(const t_lista *l) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int lista_vacia(const t_lista *l) + { + return *l==NULL; + } + +int poner_en_lista_primero(t_lista *l,const t_dato *d) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int poner_en_lista_ultimo(t_lista *l,const t_dato *d) + { + while(*l) + l=&(*l)->sig; + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato=*d; + (*l)->sig=NULL; + return OK; + } + +int sacar_de_lista_primero(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + t_nodo *aux=*l; + *d=aux->dato; + *l=aux->sig; + free(aux); + return OK; + } + +int sacar_de_lista_ultimo(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + while(!(*l)->sig) + l=&(*l)->sig; + t_nodo *aux=*l; + *d=aux->dato; + *l=NULL; + free(aux); + return OK; + } + +int insertar_en_lista_por_posicion(t_lista *l,const t_dato *d,int *pos) + { + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + while(*l&&*pos>1) + { + l=&(*l)->sig; + (*pos)--; + } + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int insertar_en_lista_ordenado_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d)<=0)) + l=&(*l)->sig; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +int insertar_en_lista_ordenado_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar(&(*l)->dato,d)<0)) + l=&(*l)->sig; + if(*l&&!cmp) + return DUPLICADO; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } + +/* +ESTA FUNCIÓN SOLO TIENE SENTIDO SI SE IMPLEMENTA CON UN DATO QUE CONTENGA LOS CAMPOS CLAVE Y CANTIDAD DE REPETICIONES + +int insertar_si_no_existe_clave(t_lista *l,const t_dato *d,int clave) + { + while(*l&&(*l)->dato.clave!=clave) + l=&(*l)->sig; + if(*l) + { + ((*l)->dato.cant_rep)++; + return CLAVE_DUPLICADA; + } + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato.clave=clave; + (*l)->dato.cant_rep=0; + (*l)->sig=NULL; + return OK; + } +*/ + +int buscar_en_lista_ordenada(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d))<0) + l=&(*l)->sig; + if(*l&&!cmp) + return ENCONTRADO; + return NO_ENCONTRADO; + } + +int buscar_en_lista_desordenada(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d))!=0) + l=&(*l)->sig; + if(*l&&!cmp) + return ENCONTRADO; + return NO_ENCONTRADO; + } + +int eliminar_por_clave_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) + { + while(*l&&(comparar((void*)&(*l)->dato,clave)!=0)) + l=&(*l)->sig; + if(!*l) + return NO_ENCONTRADO; + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; + } + +int eliminar_por_clave_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,clave))<0) + l=&(*l)->sig; + if(*l&&!cmp) + { + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; + } + return NO_ENCONTRADO; + } + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) + { + int cmp; + t_nodo *aux; + while(*l&&(cmp=comparar((void*)&(*l)->dato,clave))<=0) + { + if(!cmp) + { + aux=*l; + *l=(*l)->sig; + free(aux); + } + l=&(*l)->sig; + } + } + +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) + { + t_nodo *aux; + while(*l) + { + if(!comparar((void*)&(*l)->dato,clave)) + { + aux=*l; + *l=(*l)->sig; + free(aux); + } + l=&(*l)->sig; + } + } diff --git a/clase 17 (recursividad)/lista_simplemente_enlazada.h b/clase 17 (recursividad)/lista_simplemente_enlazada.h new file mode 100644 index 0000000..2f3f9c5 --- /dev/null +++ b/clase 17 (recursividad)/lista_simplemente_enlazada.h @@ -0,0 +1,48 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 +#define DUPLICADO 0 +#define CLAVE_DUPLICADA 1 +#define ENCONTRADO 1 +#define NO_ENCONTRADO 0 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +void vaciar_lista(t_lista*); + +int lista_llena(const t_lista*); +int lista_vacia(const t_lista*); + +int poner_en_lista_primero(t_lista*,const t_dato*); +int poner_en_lista_ultimo(t_lista*,const t_dato*); + +int sacar_de_lista_primero(t_lista*,t_dato*); +int sacar_de_lista_ultimo(t_lista*,t_dato*); + +int insertar_en_lista_por_posicion(t_lista*,const t_dato*,int*); +int insertar_en_lista_ordenado_con_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenado_sin_duplicado(t_lista*,const t_dato*,t_cmp); + +/* +int insertar_si_no_existe_clave(t_lista*,const t_dato*,int); +*/ + +int buscar_en_lista_ordenada(t_lista*,const t_dato*,t_cmp); +int buscar_en_lista_desordenada(t_lista*,const t_dato*,t_cmp); + +int eliminar_por_clave_en_lista_desordenada(t_lista*,void*,t_cmp); +int eliminar_por_clave_en_lista_ordenada(t_lista*,void*,t_cmp); + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista*,void*,t_cmp); +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista*,void*,t_cmp); diff --git a/clase 17 (recursividad)/main.c b/clase 17 (recursividad)/main.c new file mode 100644 index 0000000..aa992a0 --- /dev/null +++ b/clase 17 (recursividad)/main.c @@ -0,0 +1,146 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n RECURSIVIDAD \n\a\a"); + + //----------------------------------------------------------------------------------------------------------------------- + + char cadena[]="hola"; + printf("\n\n CADENA: \t *%s*",cadena); + + printf("\n\n CADENA ENCOLUMNADA \n"); + printf("\n\t *"); + cadena_encolumnada(cadena); + printf("\n\t *"); + + printf("\n\n CADENA ENCOLUMNADA AL REVÉS \n"); + printf("\n\t *"); + cadena_encolumnada_al_reves(cadena); + printf("\n\t *"); + + printf("\n\n CADENA ENCOLUMNADA DOBLE CON REPETICIÓN \n"); + printf("\n\t *"); + cadena_encolumnada_doble_con_repeticion(cadena); + printf("\n\t *"); + + printf("\n\n CADENA ENCOLUMNADA DOBLE SIN REPETICIÓN \n"); + printf("\n\t *"); + cadena_encolumnada_doble_sin_repeticion(cadena); + printf("\n\t *"); + + printf("\n\n CADENA EN TRIÁNGULO 1 \n"); + printf("\n\t *"); + cadena_en_triangulo_1(cadena); + printf("\n\t *"); + + printf("\n\n CADENA EN TRIÁNGULO 2 \n"); + printf("\n\t *"); + cadena_en_triangulo_2(cadena); + printf("\n\t *"); + + printf("\n\n CADENA EN TRIÁNGULO 3 \n"); + printf("\n\t *"); + cadena_en_triangulo_3(cadena); + printf("\n\t *"); + + printf("\n\n CADENA EN TRIÁNGULO 4 \n"); + printf("\n\t *"); + cadena_en_triangulo_4(cadena); + printf("\n\t *"); + + //------------------------------------------------------------------------------------------------------------------------ + + int numero=1234; + printf("\n\n NÚMERO: \t *%d*",numero); + + printf("\n\n NÚMERO ENCOLUMNADO \n"); + printf("\n\t *"); + numero_encolumnado(numero); + printf("\n\t *"); + + printf("\n\n NÚMERO ENCOLUMNADO AL REVÉS \n"); + printf("\n\t *"); + numero_encolumnado_al_reves(numero); + printf("\n\t *"); + + printf("\n\n NÚMERO ENCOLUMNADO DOBLE CON REPETICIÓN \n"); + printf("\n\t *"); + numero_encolumnado_doble_con_repeticion(numero); + printf("\n\t *"); + + printf("\n\n NÚMERO ENCOLUMNADO DOBLE SIN REPETICIÓN \n"); + printf("\n\t *"); + numero_encolumnado_doble_sin_repeticion(numero); + printf("\n\t *"); + + printf("\n\n NÚMERO EN TRIÁNGULO 1 \n"); + printf("\n\t *"); + numero_en_triangulo_1(numero); + printf("\n\t *"); + + printf("\n\n NÚMERO EN TRIÁNGULO 2 \n"); + printf("\n\t *"); + numero_en_triangulo_2(numero); + printf("\n\t *"); + + //----------------------------------------------------------------------------------------------------------------------- + + printf("\n\n CAMBIO DE BASE \n"); + printf("\n\t %d \t ---a base %d---> \t",4,2); + cambio_de_base(2,4); + + printf("\n\n CAMBIO DE BASE \n"); + printf("\n\t %d \t ---a base %d---> \t",9,2); + cambio_de_base(2,9); + + printf("\n\n CAMBIO DE BASE \n"); + printf("\n\t %d \t ---a base %d---> \t",13,2); + cambio_de_base(2,13); + + //----------------------------------------------------------------------------------------------------------------------- + + printf("\n\n CARACTER EN TRIÁNGULO \n"); + printf("\n Caracter: %c \t Lado: %d \n",'*',3); + caracter_en_triangulo('*',3); + + printf("\n\n CARACTER EN TRIÁNGULO INVERSO \n"); + printf("\n Caracter: %c \t Lado: %d \n",'*',3); + caracter_en_triangulo_inverso('*',3); + + printf("\n\n CARACTER EN DOBLE TRIÁNGULO CON REPETICIÓN \n"); + printf("\n Caracter: %c \t Lado: %d \n",'*',3); + caracter_en_doble_triangulo_con_repeticion('*',3); + + printf("\n\n CARACTER EN DOBLE TRIÁNGULO SIN REPETICIÓN \n"); + printf("\n Caracter: %c \t Lado: %d \n",'*',3); + caracter_en_doble_triangulo_sin_repeticion('*',3); + + //-------------------------------------------------------------------------------------------------------------------------- + + t_lista lista; + crear_lista(&lista); + + t_dato dato; + dato.numero=5; + poner_en_lista_primero(&lista,&dato); + dato.numero=4; + poner_en_lista_primero(&lista,&dato); + dato.numero=3; + poner_en_lista_primero(&lista,&dato); + dato.numero=2; + poner_en_lista_primero(&lista,&dato); + dato.numero=1; + poner_en_lista_primero(&lista,&dato); + + printf("\n\n LISTA SIMPLEMENTE ENLAZADA \n"); + printf("\n Lista en orden original \n\n"); + mostrar_lista_ordenada(&lista); + printf("\n\n Lista en orden inverso \n\n"); + mostrar_en_reversa_lista_ordenada(&lista); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/clase 17 (recursividad)/obj/Debug/functions.o b/clase 17 (recursividad)/obj/Debug/functions.o new file mode 100644 index 0000000..8b473d0 Binary files /dev/null and b/clase 17 (recursividad)/obj/Debug/functions.o differ diff --git a/clase 17 (recursividad)/obj/Debug/lista_simplemente_enlazada.o b/clase 17 (recursividad)/obj/Debug/lista_simplemente_enlazada.o new file mode 100644 index 0000000..bc4341a Binary files /dev/null and b/clase 17 (recursividad)/obj/Debug/lista_simplemente_enlazada.o differ diff --git a/clase 17 (recursividad)/obj/Debug/main.o b/clase 17 (recursividad)/obj/Debug/main.o new file mode 100644 index 0000000..272cc94 Binary files /dev/null and b/clase 17 (recursividad)/obj/Debug/main.o differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_de_prueba.jpg" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_de_prueba.jpg" new file mode 100644 index 0000000..bae2f70 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_de_prueba.jpg" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_inorden.dat" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_inorden.dat" new file mode 100644 index 0000000..344ec09 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_inorden.dat" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_inorden.txt" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_inorden.txt" new file mode 100644 index 0000000..c2b279f --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_inorden.txt" @@ -0,0 +1 @@ +3|4|5|6|7| \ No newline at end of file diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_posorden.dat" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_posorden.dat" new file mode 100644 index 0000000..d5f09bf Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_posorden.dat" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_posorden.txt" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_posorden.txt" new file mode 100644 index 0000000..a26a2ab --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_posorden.txt" @@ -0,0 +1 @@ +3|6|5|7|4| \ No newline at end of file diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_preorden.dat" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_preorden.dat" new file mode 100644 index 0000000..6b59bf6 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_preorden.dat" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_preorden.txt" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_preorden.txt" new file mode 100644 index 0000000..c1f28a9 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/arbol_en_preorden.txt" @@ -0,0 +1 @@ +4|3|7|5|6| \ No newline at end of file diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/bin/Debug/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).exe" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/bin/Debug/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).exe" new file mode 100644 index 0000000..b29d78c Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/bin/Debug/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).exe" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).cbp" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).cbp" new file mode 100644 index 0000000..1ac5f29 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).cbp" @@ -0,0 +1,57 @@ + + + + + + diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).depend" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).depend" new file mode 100644 index 0000000..15c6bc9 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).depend" @@ -0,0 +1,32 @@ +# depslib dependency file v1.0 +1477771753 source:d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\functions.c + "header.h" + +1477771772 d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\header.h + + + + + "primitivas_árbol.h" + +1478047778 d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\primitivas_árbol.h + "primitivas_pila_dinámica.h" + + + +1477766164 d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\dato.h + +1477786496 source:d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\main.c + "header.h" + +1477786472 source:d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\primitivas_árbol.c + "primitivas_árbol.h" + +1477843548 d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\primitivas_pila_dinámica.h + "dato.h" + +1477843602 source:d:\unlam\programaciÓn\fabian\clase 20 (árbol binario de expresión y de búsqueda)\primitivas_pila_dinámica.c + "primitivas_pila_dinámica.h" + + + diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).layout" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).layout" new file mode 100644 index 0000000..b50a548 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda).layout" @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/dato.h" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/dato.h" new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/dato.h" @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/functions.c" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/functions.c" new file mode 100644 index 0000000..8beb6f0 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/functions.c" @@ -0,0 +1,24 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} + +void mostrar_nodo(const void *v) +{ + t_dato *d=(t_dato*)v; + printf("\t %d",d->numero); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/header.h" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/header.h" new file mode 100644 index 0000000..2319870 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +#include "primitivas_árbol.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); +void mostrar_nodo(const void*); +int comparar_enteros(const void*,const void*); diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/main.c" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/main.c" new file mode 100644 index 0000000..52d089e --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/main.c" @@ -0,0 +1,126 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + printf("\n\n \t\t ÁRBOL \n\a\a"); + + t_arbol arbol; + t_dato dato; + + crear_arbol(&arbol); + printf("\n\n Se ha creado un árbol \n"); + + if(arbol_vacio(&arbol)) + printf("\n\n El árbol está vacío \n"); + if(!arbol_lleno(&arbol)) + printf("\n\n El árbol no está lleno \n"); + + printf("\n\n Cargamos cinco elementos al árbol \n"); + int i; + for(i=0;i<5;i++) + { + cargar_dato(&dato); + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + //insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + } + printf("\n\n El árbol tiene algunos elementos \n"); + + printf("\n\n Recorremos el árbol \n"); + printf("\n\n INORDEN \n\t Notación Infija Usual: \t"); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); + printf("\n\n PREORDEN \n\t Notación Polaca: \t\t"); + recorrer_arbol_preorden_recursiva(&arbol,mostrar_nodo); + printf("\n\n POSORDEN \n\t Notación Polaca Inversa: \t"); + recorrer_arbol_posorden_recursiva(&arbol,mostrar_nodo); + /* + printf("\n\n INORDEN \n\t Notación Infija Usual: \t"); + recorrer_arbol_inorden_iterativa(&arbol,mostrar_nodo); + printf("\n\n PREORDEN \n\t Notación Polaca: \t"); + recorrer_arbol_preorden_iterativa(&arbol,mostrar_nodo); + printf("\n\n POSORDEN \n\t Notación Polaca Inversa: \t"); + recorrer_arbol_posorden_iterativa(&arbol,mostrar_nodo); + */ + + FILE *pf_bin_inorden,*pf_bin_preorden,*pf_bin_posorden; + FILE *pf_txt_inorden,*pf_txt_preorden,*pf_txt_posorden; + + pf_bin_inorden=fopen("arbol_en_inorden.dat","wb"); + if(!pf_bin_inorden) + { + printf("\n\n No se pudo crear el archivo binario para el árbol en inorden \n\a\a"); + exit(EXIT_FAILURE); + } + + pf_bin_preorden=fopen("arbol_en_preorden.dat","wb"); + if(!pf_bin_preorden) + { + printf("\n\n No se pudo crear el archivo binario para el árbol en preorden \n\a\a"); + fclose(pf_bin_inorden); + exit(EXIT_FAILURE); + } + + pf_bin_posorden=fopen("arbol_en_posorden.dat","wb"); + if(!pf_bin_posorden) + { + printf("\n\n No se pudo crear el archivo binario para el árbol en posorden \n\a\a"); + fclose(pf_bin_inorden); + fclose(pf_bin_preorden); + exit(EXIT_FAILURE); + } + + pf_txt_inorden=fopen("arbol_en_inorden.txt","wt"); + if(!pf_txt_inorden) + { + printf("\n\n No se pudo crear el archivo de texto para el árbol en inorden \n\a\a"); + fclose(pf_bin_inorden); + fclose(pf_bin_preorden); + fclose(pf_bin_posorden); + exit(EXIT_FAILURE); + } + + pf_txt_preorden=fopen("arbol_en_preorden.txt","wt"); + if(!pf_txt_preorden) + { + printf("\n\n No se pudo crear el archivo de texto para el árbol en preorden \n\a\a"); + fclose(pf_bin_inorden); + fclose(pf_bin_preorden); + fclose(pf_bin_posorden); + fclose(pf_txt_inorden); + exit(EXIT_FAILURE); + } + + pf_txt_posorden=fopen("arbol_en_posorden.txt","wt"); + if(!pf_txt_posorden) + { + printf("\n\n No se pudo crear el archivo de texto para el árbol en posorden \n\a\a"); + fclose(pf_bin_inorden); + fclose(pf_bin_preorden); + fclose(pf_bin_posorden); + fclose(pf_txt_inorden); + fclose(pf_txt_preorden); + exit(EXIT_FAILURE); + } + + grabar_arbol_en_inorden_en_archivo_binario(&arbol,pf_bin_inorden); + grabar_arbol_en_preorden_en_archivo_binario(&arbol,pf_bin_preorden); + grabar_arbol_en_posorden_en_archivo_binario(&arbol,pf_bin_posorden); + + grabar_arbol_en_inorden_en_archivo_de_texto(&arbol,pf_txt_inorden); + grabar_arbol_en_preorden_en_archivo_de_texto(&arbol,pf_txt_preorden); + grabar_arbol_en_posorden_en_archivo_de_texto(&arbol,pf_txt_posorden); + + fclose(pf_bin_inorden); + fclose(pf_bin_preorden); + fclose(pf_bin_posorden); + + fclose(pf_txt_inorden); + fclose(pf_txt_preorden); + fclose(pf_txt_posorden); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/functions.o" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/functions.o" new file mode 100644 index 0000000..2393797 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/functions.o" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/main.o" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/main.o" new file mode 100644 index 0000000..ba6c4a6 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/main.o" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/primitivas_pila_din\303\241mica.o" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/primitivas_pila_din\303\241mica.o" new file mode 100644 index 0000000..29fde57 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/primitivas_pila_din\303\241mica.o" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/primitivas_\303\241rbol.o" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/primitivas_\303\241rbol.o" new file mode 100644 index 0000000..cbd62b3 Binary files /dev/null and "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/obj/Debug/primitivas_\303\241rbol.o" differ diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_pila_din\303\241mica.c" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..b2dede4 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo_pila)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo_pila *nuevo=(t_nodo_pila*)malloc(sizeof(t_nodo_pila)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo_pila *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo_pila *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_pila_din\303\241mica.h" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..de93910 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo_pila + { + t_dato dato; + struct s_nodo_pila *sig; + }t_nodo_pila; + +typedef t_nodo_pila* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_\303\241rbol.c" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_\303\241rbol.c" new file mode 100644 index 0000000..46ce1f4 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_\303\241rbol.c" @@ -0,0 +1,366 @@ +#include "primitivas_árbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + } + free((t_nodo*)*a); + *a=NULL; +} + +int arbol_vacio(const t_arbol *a) +{ + return *a==NULL; +} + +int arbol_lleno(const t_arbol *a) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +void recorrer_arbol_inorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_inorden_recursiva(&(*a)->izq,mostrar); + mostrar(&(*a)->dato); + recorrer_arbol_inorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_preorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + recorrer_arbol_preorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_preorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_posorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_posorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_posorden_recursiva(&(*a)->der,mostrar); + mostrar(&(*a)->dato); + } +} + +void recorrer_arbol_inorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_preorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_posorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +int insertar_en_arbol_recursiva(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + if(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + return insertar_en_arbol_recursiva(&(*a)->izq,d,comparar); + if(comparar((void*)&(*a)->dato,(void*)d)<0) + return insertar_en_arbol_recursiva(&(*a)->der,d,comparar); + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int buscar_en_arbol_recursiva(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + return buscar_en_arbol_recursiva(&(*a)->izq,d,comparar); + else + return buscar_en_arbol_recursiva(&(*a)->der,d,comparar); + } + return NO_ENCONTRADO; +} + +int buscar_en_arbol_iterativa(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NO_ENCONTRADO; +} + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *padre=*a; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return NULL; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(const t_arbol *a,t_dato *d,t_cmp comparar,t_nodo *padre) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return padre; + padre=*a; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_iterativa(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *padre=*a; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return (padre!=*a)?padre:NULL; + padre=*a; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NULL; +} + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->izq,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->der,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + } +} + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->izq,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->der,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + } +} + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + fread(&dato,sizeof(t_nodo),1,pf); + while(!feof(pf)) + { + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + fread(&dato,sizeof(t_nodo),1,pf); + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + int cant_reg=ftell(pf)/sizeof(t_dato); + while(cant_reg) + { + fseek(pf,(cant_reg-1)*sizeof(t_dato),SEEK_SET); + cant_reg--; + fread(&dato,sizeof(t_dato),1,pf); + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + } + return OK; +} + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + { + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + t_pila pila; + crear_pila(&pila); + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + apilar(&pila,&dato); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + } + return OK; +} diff --git "a/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_\303\241rbol.h" "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_\303\241rbol.h" new file mode 100644 index 0000000..761e8b7 --- /dev/null +++ "b/clase 20 (\303\241rbol binario de expresi\303\263n y de b\303\272squeda)/primitivas_\303\241rbol.h" @@ -0,0 +1,60 @@ +#include "primitivas_pila_dinámica.h" + +#include +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *izq; + struct s_nodo *der; +}t_nodo; + +typedef t_nodo* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol*); +void vaciar_arbol(t_arbol*); + +int arbol_vacio(const t_arbol*); +int arbol_lleno(const t_arbol*); + +void recorrer_arbol_inorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_preorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_posorden_recursiva(const t_arbol*,t_mst); + +void recorrer_arbol_inorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_preorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_posorden_iterativa(const t_arbol*,t_mst); + +int insertar_en_arbol_recursiva(t_arbol*,const t_dato*,t_cmp); +int insertar_en_arbol_iterativa(t_arbol*,const t_dato*,t_cmp); + +int buscar_en_arbol_recursiva(const t_arbol*,t_dato*,t_cmp); +int buscar_en_arbol_iterativa(const t_arbol*,t_dato*,t_cmp); + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva(const t_arbol*,t_dato*,t_cmp); +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(const t_arbol*,t_dato*,t_cmp,t_nodo*); +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_iterativa(const t_arbol*,t_dato*,t_cmp); + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol*,FILE*); + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol*,FILE*); + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); diff --git "a/clase 22 (\303\241rbol - clase 2)/arbol.bin" "b/clase 22 (\303\241rbol - clase 2)/arbol.bin" new file mode 100644 index 0000000..cdaad98 Binary files /dev/null and "b/clase 22 (\303\241rbol - clase 2)/arbol.bin" differ diff --git "a/clase 22 (\303\241rbol - clase 2)/bin/Debug/clase 22 (\303\241rbol - clase 2).exe" "b/clase 22 (\303\241rbol - clase 2)/bin/Debug/clase 22 (\303\241rbol - clase 2).exe" new file mode 100644 index 0000000..62f6094 Binary files /dev/null and "b/clase 22 (\303\241rbol - clase 2)/bin/Debug/clase 22 (\303\241rbol - clase 2).exe" differ diff --git "a/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).cbp" "b/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).cbp" new file mode 100644 index 0000000..e9601f3 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).cbp" @@ -0,0 +1,56 @@ + + + + + + diff --git "a/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).depend" "b/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).depend" new file mode 100644 index 0000000..90c314b --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).depend" @@ -0,0 +1,32 @@ +# depslib dependency file v1.0 +1478044265 source:d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\functions.c + "header.h" + +1477771772 d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\header.h + + + + + "primitivas_árbol.h" + +1478484034 d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\primitivas_árbol.h + "primitivas_pila_dinámica.h" + + + +1477843548 d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\primitivas_pila_dinámica.h + "dato.h" + +1477766164 d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\dato.h + +1477843602 source:d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\primitivas_pila_dinámica.c + "primitivas_pila_dinámica.h" + + + +1478489073 source:d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\main.c + "header.h" + +1478487881 source:d:\unlam\programaciÓn\fabian\clase 22 (árbol - clase 2)\primitivas_árbol.c + "primitivas_árbol.h" + diff --git "a/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).layout" "b/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).layout" new file mode 100644 index 0000000..baa6bc6 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/clase 22 (\303\241rbol - clase 2).layout" @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/clase 22 (\303\241rbol - clase 2)/dato.h" "b/clase 22 (\303\241rbol - clase 2)/dato.h" new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/dato.h" @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git "a/clase 22 (\303\241rbol - clase 2)/functions.c" "b/clase 22 (\303\241rbol - clase 2)/functions.c" new file mode 100644 index 0000000..8beb6f0 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/functions.c" @@ -0,0 +1,24 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} + +void mostrar_nodo(const void *v) +{ + t_dato *d=(t_dato*)v; + printf("\t %d",d->numero); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} diff --git "a/clase 22 (\303\241rbol - clase 2)/header.h" "b/clase 22 (\303\241rbol - clase 2)/header.h" new file mode 100644 index 0000000..2319870 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +#include "primitivas_árbol.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); +void mostrar_nodo(const void*); +int comparar_enteros(const void*,const void*); diff --git "a/clase 22 (\303\241rbol - clase 2)/main.c" "b/clase 22 (\303\241rbol - clase 2)/main.c" new file mode 100644 index 0000000..c92e8e8 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/main.c" @@ -0,0 +1,239 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + printf("\n\n \t\t ÁRBOL \n\a\a"); + + t_arbol arbol; + t_dato dato; + + crear_arbol(&arbol); + printf("\n\n Se ha creado un árbol \n"); + + if(arbol_vacio(&arbol)) + printf("\n\n El árbol está vacío \n"); + if(!arbol_lleno(&arbol)) + printf("\n\n El árbol no está lleno \n"); + + printf("\n\n Cargamos elementos al árbol \n"); + + dato.numero=50; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=25; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=12; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=40; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=20; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=30; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=18; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=75; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=60; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=90; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=70; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + dato.numero=100; + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + + printf("\n\n El árbol ha sido cargado \n\n"); + + /* + int i; + for(i=0;i<12;i++) + { + cargar_dato(&dato); + insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros); + //insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + } + printf("\n\n El árbol tiene algunos elementos \n"); + + FILE *pf; + pf=fopen("arbol.bin","wb"); + if(!pf) + { + printf("\n\n No se pudo crear el archivo. \n Programa evacuado \n\n"); + exit(EXIT_FAILURE); + } + + grabar_arbol_en_preorden_en_archivo_binario(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue grabado \n\n"); + + vaciar_arbol(&arbol); + printf("\n\n El árbol fue vaciado \n\n"); + + pf=fopen("arbol.bin","rb"); + if(!pf) + { + printf("\n\n No se pudo leer el archivo \n\n"); + exit(EXIT_FAILURE); + } + + if(cargar_arbol_en_preorden_desde_archivo_binario(&arbol,pf,comparar_enteros)) + printf("\n\n El árbol fue cargado con el archivo \n\n"); + else + printf("\n\n El árbol no se pudo cargar \n\n"); + */ + + printf("\n\n Recorremos el árbol \n"); + printf("\n\n INORDEN \n\t Notación Infija Usual: \t"); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); + printf("\n\n PREORDEN \n\t Notación Polaca: \t\t"); + recorrer_arbol_preorden_recursiva(&arbol,mostrar_nodo); + printf("\n\n POSORDEN \n\t Notación Polaca Inversa: \t"); + recorrer_arbol_posorden_recursiva(&arbol,mostrar_nodo); + + + int nivel=2; + + printf("\n\n CONTAR"); + + printf("\n\n Cantidad de nodos: \t %d",contar_nodos(&arbol)); + printf("\n\n Cantidad de hojas: \t %d",contar_hojas(&arbol)); + printf("\n\n Cantidad de no hojas: \t %d",contar_no_hojas(&arbol)); + + printf("\n\n Cantidad de nodos con hijos solo por izquierda: \t %d",contar_nodos_con_hijos_solo_por_izquierda(&arbol)); + printf("\n\n Cantidad de nodos con hijos solo por derecha: \t %d",contar_nodos_con_hijos_solo_por_derecha(&arbol)); + printf("\n\n Cantidad de nodos con hijos por izq o der: \t %d",contar_nodos_con_hijos_por_izquierda_o_por_derecha(&arbol)); + printf("\n\n Cantidad de nodos con hijos por izq o der exclusiva: \t %d",contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&arbol)); + printf("\n\n Cantidad de nodos con hijos por izq y der: \t %d",contar_nodos_con_hijos_por_izquierda_y_por_derecha(&arbol)); + + printf("\n\n Cantidad de nodos del nivel %d: \t %d",nivel,contar_nodos_de_un_nivel(&arbol,nivel)); + printf("\n\n Cantidad de nodos hasta el nivel %d: \t %d",nivel,contar_nodos_hasta_un_nivel(&arbol,nivel)); + printf("\n\n Cantidad de nodos hasta el nivel %d inclusive: \t %d",nivel,contar_nodos_hasta_un_nivel_inclusive(&arbol,nivel)); + printf("\n\n Cantidad de nodos desde el nivel %d: \t %d",nivel,contar_nodos_desde_un_nivel(&arbol,nivel)); + printf("\n\n Cantidad de nodos desde el nivel %d inclusive: \t %d",nivel,contar_nodos_desde_un_nivel_inclusive(&arbol,nivel)); + + + printf("\n\n MOSTRAR"); + + printf("\n\n Mostrar nodos: \n\n"); + mostrar_nodos(&arbol,mostrar_nodo); + printf("\n\n Mostrar hojas: \n\n"); + mostrar_hojas(&arbol,mostrar_nodo); + printf("\n\n Mostrar de no hojas \n\n"); + mostrar_no_hojas(&arbol,mostrar_nodo); + + printf("\n\n Mostrar nodos con hijos solo por izquierda \n\n"); + mostrar_nodos_con_hijos_solo_por_izquierda(&arbol,mostrar_nodo); + printf("\n\n Mostrar nodos con hijos solo por derecha \n\n"); + mostrar_nodos_con_hijos_solo_por_derecha(&arbol,mostrar_nodo); + printf("\n\n Mostrar nodos con hijos por izq o der \n\n"); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&arbol,mostrar_nodo); + printf("\n\n Mostrar nodos con hijos por izq o der exclusiva \n\n"); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&arbol,mostrar_nodo); + printf("\n\n Mostrar nodos con hijos por izq y der \n\n"); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&arbol,mostrar_nodo); + + printf("\n\n Mostrar nodos del nivel %d \n\n",nivel); + mostrar_nodos_de_un_nivel(&arbol,nivel,mostrar_nodo); + printf("\n\n Mostrar nodos hasta el nivel %d \n\n",nivel); + mostrar_nodos_hasta_un_nivel(&arbol,nivel,mostrar_nodo); + printf("\n\n Mostrar nodos hasta el nivel %d inclusive \n\n",nivel); + mostrar_nodos_hasta_un_nivel_inclusive(&arbol,nivel,mostrar_nodo); + printf("\n\n Mostrar nodos desde el nivel %d \n\n",nivel); + mostrar_nodos_desde_un_nivel(&arbol,nivel,mostrar_nodo); + printf("\n\n Mostrar nodos desde el nivel %d inclusive \n\n",nivel); + mostrar_nodos_desde_un_nivel_inclusive(&arbol,nivel,mostrar_nodo); + + + + printf("\n\n MOSTRAR Y CONTAR \n\n"); + + printf("\n\n nodos: \t %d \n\n",mostrar_y_contar_nodos(&arbol,mostrar_nodo)); + printf("\n\n hojas: \t %d \n\n",mostrar_y_contar_hojas(&arbol,mostrar_nodo)); + printf("\n\n no hojas: \t %d \n\n",mostrar_y_contar_no_hojas(&arbol,mostrar_nodo)); + + printf("\n\n nodos con hijos solo por izquierda: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&arbol,mostrar_nodo)); + printf("\n\n nodos con hijos solo por derecha: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&arbol,mostrar_nodo)); + printf("\n\n nodos con hijos por izq o der: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&arbol,mostrar_nodo)); + printf("\n\n nodos con hijos por izq o der exclusiva: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&arbol,mostrar_nodo)); + printf("\n\n nodos con hijos por izq y der: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&arbol,mostrar_nodo)); + + printf("\n\n nodos del nivel %d: \t %d \n\n",nivel,mostrar_y_contar_nodos_de_un_nivel(&arbol,nivel,mostrar_nodo)); + printf("\n\n nodos hasta el nivel %d: \t %d \n\n",nivel,mostrar_y_contar_nodos_hasta_un_nivel(&arbol,nivel,mostrar_nodo)); + printf("\n\n nodos hasta el nivel %d inclusive: \t %d \n\n",nivel,mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&arbol,nivel,mostrar_nodo)); + printf("\n\n nodos desde el nivel %d: \t %d \n\n",nivel,mostrar_y_contar_nodos_desde_un_nivel(&arbol,nivel,mostrar_nodo)); + printf("\n\n nodos desde el nivel %d inclusive: \t %d \n\n",nivel,mostrar_y_contar_nodos_desde_un_nivel_inclusive(&arbol,nivel,mostrar_nodo)); + + + +/* + printf("\n\n pos podar hojas \n\n"); + podar_hojas(&arbol); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); +*/ + +/* + printf("\n\n pos podar hasta nivel \n\n"); + podar_hasta_nivel(&arbol,nivel); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); +*/ +/* + printf("\n\n pos podar hasta nivel inclusive \n\n"); + podar_hasta_nivel_inclusive(&arbol,nivel); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); +*/ + +// int altura=2; +/* + printf("\n\n pos podar hasta altura \n\n"); + podar_hasta_altura(&arbol,altura); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); +*/ + +/* + printf("\n\n pos podar hasta altura inclusive \n\n"); + podar_hasta_altura_inclusive(&arbol,altura); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); +*/ + + printf("\n\n Calcular altura: \t %d",calcular_altura(&arbol)); + printf("\n\n Calcular nivel: \t %d",calcular_nivel(&arbol)); + + printf("\n\n El árbol %s semibalanceado",arbol_semibalanceado(&arbol)?"es":"no es"); + printf("\n\n El árbol %s balanceado",arbol_balanceado(&arbol)?"es":"no es"); + + FILE *pf; + pf=fopen("arbol.bin","wb"); + if(!pf) + { + printf("\n\n No se pudo crear el archivo \n\n"); + exit(EXIT_FAILURE); + } + grabar_arbol_en_inorden_en_archivo_binario(&arbol,pf); + printf("\n\n Archivo grabado \n\n"); + fclose(pf); + talar_arbol(&arbol); + printf("\n\n árbol talado \n"); + + pf=fopen("arbol.bin","rb"); + if(!pf) + { + printf("\n\n No se pudo leer el archivo \n\n"); + exit(EXIT_FAILURE); + } + printf("\n\n Archivo abierto \n\n"); + + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(&arbol,pf,comparar_enteros); + printf("\n\n Árbol cargado lo más balanceado posible \n\n"); + recorrer_arbol_preorden_recursiva(&arbol,mostrar_nodo); + + + + + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git "a/clase 22 (\303\241rbol - clase 2)/obj/Debug/functions.o" "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/functions.o" new file mode 100644 index 0000000..71e1fc6 Binary files /dev/null and "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/functions.o" differ diff --git "a/clase 22 (\303\241rbol - clase 2)/obj/Debug/main.o" "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/main.o" new file mode 100644 index 0000000..d29b64b Binary files /dev/null and "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/main.o" differ diff --git "a/clase 22 (\303\241rbol - clase 2)/obj/Debug/primitivas_pila_din\303\241mica.o" "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/primitivas_pila_din\303\241mica.o" new file mode 100644 index 0000000..488c647 Binary files /dev/null and "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/primitivas_pila_din\303\241mica.o" differ diff --git "a/clase 22 (\303\241rbol - clase 2)/obj/Debug/primitivas_\303\241rbol.o" "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/primitivas_\303\241rbol.o" new file mode 100644 index 0000000..79cac5e Binary files /dev/null and "b/clase 22 (\303\241rbol - clase 2)/obj/Debug/primitivas_\303\241rbol.o" differ diff --git "a/clase 22 (\303\241rbol - clase 2)/primitivas_pila_din\303\241mica.c" "b/clase 22 (\303\241rbol - clase 2)/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..b2dede4 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo_pila)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo_pila *nuevo=(t_nodo_pila*)malloc(sizeof(t_nodo_pila)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo_pila *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo_pila *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/clase 22 (\303\241rbol - clase 2)/primitivas_pila_din\303\241mica.h" "b/clase 22 (\303\241rbol - clase 2)/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..de93910 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo_pila + { + t_dato dato; + struct s_nodo_pila *sig; + }t_nodo_pila; + +typedef t_nodo_pila* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/clase 22 (\303\241rbol - clase 2)/primitivas_\303\241rbol.c" "b/clase 22 (\303\241rbol - clase 2)/primitivas_\303\241rbol.c" new file mode 100644 index 0000000..a78ebba --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/primitivas_\303\241rbol.c" @@ -0,0 +1,973 @@ +#include "primitivas_árbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + } + free(*a); + *a=NULL; +} + +int arbol_vacio(const t_arbol *a) +{ + return *a==NULL; +} + +int arbol_lleno(const t_arbol *a) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +void recorrer_arbol_inorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_inorden_recursiva(&(*a)->izq,mostrar); + mostrar(&(*a)->dato); + recorrer_arbol_inorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_preorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + recorrer_arbol_preorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_preorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_posorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_posorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_posorden_recursiva(&(*a)->der,mostrar); + mostrar(&(*a)->dato); + } +} + +void recorrer_arbol_inorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_preorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_posorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +int insertar_en_arbol_recursiva(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + if(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + return insertar_en_arbol_recursiva(&(*a)->izq,d,comparar); + if(comparar((void*)&(*a)->dato,(void*)d)<0) + return insertar_en_arbol_recursiva(&(*a)->der,d,comparar); + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int buscar_en_arbol_recursiva(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + return buscar_en_arbol_recursiva(&(*a)->izq,d,comparar); + else + return buscar_en_arbol_recursiva(&(*a)->der,d,comparar); + } + return NO_ENCONTRADO; +} + +int buscar_en_arbol_iterativa(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NO_ENCONTRADO; +} + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *padre=*a; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return NULL; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(const t_arbol *a,t_dato *d,t_cmp comparar,t_nodo *padre) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return padre; + padre=*a; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_iterativa(const t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *padre=*a; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return (padre!=*a)?padre:NULL; + padre=*a; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NULL; +} + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->izq,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->der,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + } +} + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->izq,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->der,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + } +} + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + fread(&dato,sizeof(t_dato),1,pf); + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + int cant_reg=ftell(pf)/sizeof(t_dato); + while(cant_reg) + { + fseek(pf,(cant_reg-1)*sizeof(t_dato),SEEK_SET); + cant_reg--; + fread(&dato,sizeof(t_dato),1,pf); + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + } + return OK; +} + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + { + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_nodo *raiz=*a; + t_pila pila; + crear_pila(&pila); + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + apilar(&pila,&dato); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)&dato)>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=dato; + (*a)->izq=NULL; + (*a)->der=NULL; + *a=raiz; + } + return OK; +} + +int contar_nodos(const t_arbol *a) +{ + if(*a) + return contar_nodos(&(*a)->izq)+contar_nodos(&(*a)->der)+1; + return 0; +} + +int contar_hojas(const t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + return 1; + return contar_hojas(&(*a)->izq)+contar_hojas(&(*a)->der); + } + return 0; +} + +int contar_no_hojas(const t_arbol *a) +{ + if(*a) + if((*a)->izq||(*a)->der) + return contar_no_hojas(&(*a)->izq)+contar_no_hojas(&(*a)->der)+1; + return 0; +} + +int contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + return contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq)+1; + return contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq)+contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + return contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq)+1; + return contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_solo_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + return contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + return contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + return contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_de_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel) + return contar_nodos_de_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_de_un_nivel(&(*a)->der,nivel-1); + return 1; + } + return 0; +} + +int contar_nodos_hasta_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + if(nivel) + return contar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_hasta_un_nivel(&(*a)->der,nivel-1)+1; + return 0; +} + +int contar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel) + return contar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1)+1; + return 1; + } + return 0; +} + +int contar_nodos_desde_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel>=0) + return contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel(&(*a)->der,nivel-1); + return contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel(&(*a)->der,nivel-1)+1; + } + return 0; +} + +int contar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel>=1) + return contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1); + return contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1)+1; + } + return 0; +} + +void mostrar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + mostrar_nodos(&(*a)->izq,mostrar); + mostrar_nodos(&(*a)->der,mostrar); + } +} + +void mostrar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + mostrar(&(*a)->dato); + mostrar_hojas(&(*a)->izq,mostrar); + mostrar_hojas(&(*a)->der,mostrar); + } +} + +void mostrar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + mostrar(&(*a)->dato); + mostrar_no_hojas(&(*a)->izq,mostrar); + mostrar_no_hojas(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + { + mostrar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + } + else + mostrar(&(*a)->dato); + } +} + +void mostrar_nodos_hasta_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + { + mostrar(&(*a)->dato); + mostrar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_hasta_un_nivel(&(*a)->der,nivel-1,mostrar); + } + } +} + +void mostrar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + if(nivel) + { + mostrar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + } + } +} + +void mostrar_nodos_desde_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel<0) + mostrar(&(*a)->dato); + mostrar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar); + } +} + +void mostrar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel<=0) + mostrar(&(*a)->dato); + mostrar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + } +} + +int mostrar_y_contar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos(&(*a)->izq,mostrar)+mostrar_y_contar_nodos(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + { + mostrar(&(*a)->dato); + return 1; + } + return mostrar_y_contar_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_hojas(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + if((*a)->izq||(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_no_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_no_hojas(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } + return 0; +} + + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + return mostrar_y_contar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return 1; + } + return 0; +} + +int mostrar_y_contar_nodos_hasta_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + if(nivel) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_hasta_un_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + if(nivel) + return mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + return 1; + } + return 0; +} + +int mostrar_y_contar_nodos_desde_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=0) + return mostrar_y_contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=1) + return mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +void talar_arbol(t_arbol *a) +{ + *a=NULL; +} + +void podar_hojas(t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + { + free(*a); + *a=NULL; + } + else + { + podar_hojas(&(*a)->izq); + podar_hojas(&(*a)->der); + } + } +} + +void podar_hasta_nivel(t_arbol *a,int nivel) +{ + if(*a) + { + podar_hasta_nivel(&(*a)->izq,nivel-1); + podar_hasta_nivel(&(*a)->der,nivel-1); + if(nivel<0) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_nivel_inclusive(t_arbol *a,int nivel) +{ + if(*a) + { + podar_hasta_nivel_inclusive(&(*a)->izq,nivel-1); + podar_hasta_nivel_inclusive(&(*a)->der,nivel-1); + if(!nivel) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_altura(t_arbol *a,int altura) +{ + if(*a) + { + podar_hasta_altura(&(*a)->izq,altura-1); + podar_hasta_altura(&(*a)->der,altura-1); + if(!altura) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_altura_inclusive(t_arbol *a,int altura) +{ + if(*a) + { + podar_hasta_altura_inclusive(&(*a)->izq,altura-1); + podar_hasta_altura_inclusive(&(*a)->der,altura-1); + if(altura<=1) + { + free(*a); + *a=NULL; + } + } +} + +int calcular_nivel(const t_arbol *a) +{ + if(*a) + { + int niv_izq=calcular_nivel(&(*a)->izq); + int niv_der=calcular_nivel(&(*a)->der); + return (niv_izq>=niv_der)?niv_izq+1:niv_der+1; + } + return -1; +} + +int calcular_altura(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (alt_izq>=alt_der)?alt_izq+1:alt_der+1; + } + return 0; +} + +int arbol_semibalanceado(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (ABS(alt_izq-alt_der)>1)?0:arbol_semibalanceado(&(*a)->izq)&&arbol_semibalanceado(&(*a)->der); + } + return 1; +} + +int arbol_balanceado(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (alt_izq!=alt_der)?0:arbol_balanceado(&(*a)->izq)&&arbol_balanceado(&(*a)->der); + } + return 1; +} + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(t_arbol *a,FILE *pf,t_cmp comparar) +{ + return cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,1,ftell(pf)/sizeof(t_dato),comparar); +} + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(t_arbol *a,FILE *pf,int pri,int ult,t_cmp comparar) +{ + int medio=pri+(ult-pri)/2+(((ult-pri+1)%2)==0)?1:0; + t_dato dato; + + if(ult-pri<2) + { + fseek(pf,pri*sizeof(t_dato),SEEK_SET); + fread(&dato,sizeof(t_dato),1,pf); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + return 0; + + if(ult!=pri) + { + fseek(pf,ult*sizeof(t_dato),SEEK_SET); + fread(&dato,sizeof(t_dato),1,pf); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + return 0; + } + return 1; + } + else + { + fseek(pf,medio*sizeof(t_dato),SEEK_SET); + fread(&dato,sizeof(t_dato),1,pf); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + return 0; + + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,pri,medio-1,comparar); + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,medio+1,ult,comparar); + } +} diff --git "a/clase 22 (\303\241rbol - clase 2)/primitivas_\303\241rbol.h" "b/clase 22 (\303\241rbol - clase 2)/primitivas_\303\241rbol.h" new file mode 100644 index 0000000..f6c56b6 --- /dev/null +++ "b/clase 22 (\303\241rbol - clase 2)/primitivas_\303\241rbol.h" @@ -0,0 +1,127 @@ +#include "primitivas_pila_dinámica.h" + +#include +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +#define ABS(x) ((x)>0)?(x):(-(x)) + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *izq; + struct s_nodo *der; +}t_nodo; + +typedef t_nodo* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol*); +void vaciar_arbol(t_arbol*); + +int arbol_vacio(const t_arbol*); +int arbol_lleno(const t_arbol*); + +void recorrer_arbol_inorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_preorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_posorden_recursiva(const t_arbol*,t_mst); + +void recorrer_arbol_inorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_preorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_posorden_iterativa(const t_arbol*,t_mst); + +int insertar_en_arbol_recursiva(t_arbol*,const t_dato*,t_cmp); +int insertar_en_arbol_iterativa(t_arbol*,const t_dato*,t_cmp); + +int buscar_en_arbol_recursiva(const t_arbol*,t_dato*,t_cmp); +int buscar_en_arbol_iterativa(const t_arbol*,t_dato*,t_cmp); + +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva(const t_arbol*,t_dato*,t_cmp); +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(const t_arbol*,t_dato*,t_cmp,t_nodo*); +t_nodo *buscar_en_arbol_y_retornar_direccion_padre_iterativa(const t_arbol*,t_dato*,t_cmp); + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol*,FILE*); + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol*,FILE*); + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); + +int contar_nodos(const t_arbol*); +int contar_hojas(const t_arbol*); +int contar_no_hojas(const t_arbol*); + +int contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*); +int contar_nodos_con_hijos_solo_por_derecha(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*); + +int contar_nodos_de_un_nivel(const t_arbol*,int); +int contar_nodos_hasta_un_nivel(const t_arbol*,int); +int contar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int); +int contar_nodos_desde_un_nivel(const t_arbol*,int); +int contar_nodos_desde_un_nivel_inclusive(const t_arbol*,int); + +void mostrar_nodos(const t_arbol*,t_mst); +void mostrar_hojas(const t_arbol*,t_mst); +void mostrar_no_hojas(const t_arbol*,t_mst); + +void mostrar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +void mostrar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_hasta_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int,t_mst); +void mostrar_nodos_desde_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_desde_un_nivel_inclusive(const t_arbol*,int,t_mst); + +int mostrar_y_contar_nodos(const t_arbol*,t_mst); +int mostrar_y_contar_hojas(const t_arbol*,t_mst); +int mostrar_y_contar_no_hojas(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_hasta_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_desde_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_desde_un_nivel_inclusive(const t_arbol*,int,t_mst); + +void talar_arbol(t_arbol*); + +void podar_hojas(t_arbol*); +void podar_hasta_nivel(t_arbol*,int); +void podar_hasta_nivel_inclusive(t_arbol*,int); +void podar_hasta_altura(t_arbol*,int); +void podar_hasta_altura_inclusive(t_arbol*,int); + +int calcular_nivel(const t_arbol*); +int calcular_altura(const t_arbol*); + +int arbol_semibalanceado(const t_arbol*); +int arbol_balanceado(const t_arbol*); + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(t_arbol*,FILE*,int,int,t_cmp); diff --git a/cociente y resto/bin/Debug/cociente y resto.exe b/cociente y resto/bin/Debug/cociente y resto.exe new file mode 100644 index 0000000..08b4144 Binary files /dev/null and b/cociente y resto/bin/Debug/cociente y resto.exe differ diff --git a/cociente y resto/cociente y resto.cbp b/cociente y resto/cociente y resto.cbp new file mode 100644 index 0000000..e041eba --- /dev/null +++ b/cociente y resto/cociente y resto.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/cociente y resto/cociente y resto.depend b/cociente y resto/cociente y resto.depend new file mode 100644 index 0000000..e9d760a --- /dev/null +++ b/cociente y resto/cociente y resto.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471571178 source:d:\unlam\programaciÓn\fabian 2da\cociente y resto\funciones.c + "encabezados.h" + +1471571141 d:\unlam\programaciÓn\fabian 2da\cociente y resto\encabezados.h + + + + +1471571401 source:d:\unlam\programaciÓn\fabian 2da\cociente y resto\main.c + "encabezados.h" + diff --git a/cociente y resto/cociente y resto.layout b/cociente y resto/cociente y resto.layout new file mode 100644 index 0000000..68b6ed5 --- /dev/null +++ b/cociente y resto/cociente y resto.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/cociente y resto/encabezados.h b/cociente y resto/encabezados.h new file mode 100644 index 0000000..b47c3f7 --- /dev/null +++ b/cociente y resto/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +void cociente_y_resto(int,int,int*,int*); + diff --git a/cociente y resto/funciones.c b/cociente y resto/funciones.c new file mode 100644 index 0000000..090ac42 --- /dev/null +++ b/cociente y resto/funciones.c @@ -0,0 +1,6 @@ +#include "encabezados.h" +void cociente_y_resto(int a,int b,int *c,int *d) + { + *c=a/b; + *d=a%b; + } diff --git a/cociente y resto/main.c b/cociente y resto/main.c new file mode 100644 index 0000000..46c8073 --- /dev/null +++ b/cociente y resto/main.c @@ -0,0 +1,36 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int dividendo,divisor,cociente,resto,band1,band2; + band1=band2=0;//banderas para tirar mensajes de error + printf("\n\t\t COCIENTE Y RESTO \n"); + printf("\n Ingrese dos números enteros positivos para calcular \n el cociente y el resto entre ellos \n\n"); + do + { + if(band1==1) + printf("\n El número ingresado no es un entero positivo. \n Reingréselo: \n\a\a"); + printf("\n Dividendo: \t\t"); + scanf("%d",÷ndo); + band1=1; + } + while(dividendo<0); + do + { + if(band2==1) + { + if(divisor==0) + printf("\n La división por cero es una indeterminación matemática. \n Reingrese el número: \n\a\a"); + else + printf("\n El número ingresado no es un entero positivo. \n Reingréselo: \n\a\a"); + } + printf("\n Divisor: \t\t"); + scanf("%d",&divisor); + band2=1; + } + while(divisor<1); + cociente_y_resto(dividendo,divisor,&cociente,&resto); + printf("\n\n\n Cociente: \t %d \n\n Resto: \t %d \n\n",cociente,resto); + getch(); + return 0; + } diff --git a/cociente y resto/obj/Debug/funciones.o b/cociente y resto/obj/Debug/funciones.o new file mode 100644 index 0000000..4142fd9 Binary files /dev/null and b/cociente y resto/obj/Debug/funciones.o differ diff --git a/cociente y resto/obj/Debug/main.o b/cociente y resto/obj/Debug/main.o new file mode 100644 index 0000000..90ad845 Binary files /dev/null and b/cociente y resto/obj/Debug/main.o differ diff --git "a/cola de espera en un cajero autom\303\241tico/bin/Debug/cola de espera en un cajero autom\303\241tico.exe" "b/cola de espera en un cajero autom\303\241tico/bin/Debug/cola de espera en un cajero autom\303\241tico.exe" new file mode 100644 index 0000000..78e155f Binary files /dev/null and "b/cola de espera en un cajero autom\303\241tico/bin/Debug/cola de espera en un cajero autom\303\241tico.exe" differ diff --git "a/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.cbp" "b/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.cbp" new file mode 100644 index 0000000..5091762 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.cbp" @@ -0,0 +1,49 @@ + + + + + + diff --git "a/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.depend" "b/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.depend" new file mode 100644 index 0000000..64cad59 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.depend" @@ -0,0 +1,20 @@ +# depslib dependency file v1.0 +1475455262 source:d:\unlam\programaciÓn\fabian 2\cola de espera en un cajero automático\main.c + "header.h" + +1475455123 d:\unlam\programaciÓn\fabian 2\cola de espera en un cajero automático\header.h + + + + + + "primitivas_cola_estática.h" + +1475433603 d:\unlam\programaciÓn\fabian 2\cola de espera en un cajero automático\primitivas_cola_estática.h + "dato.h" + +1475454947 d:\unlam\programaciÓn\fabian 2\cola de espera en un cajero automático\dato.h + +1475434668 source:d:\unlam\programaciÓn\fabian 2\cola de espera en un cajero automático\primitivas_cola_estática.c + "primitivas_cola_estática.h" + diff --git "a/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.layout" "b/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.layout" new file mode 100644 index 0000000..76d89f0 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/cola de espera en un cajero autom\303\241tico.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/cola de espera en un cajero autom\303\241tico/dato.h" "b/cola de espera en un cajero autom\303\241tico/dato.h" new file mode 100644 index 0000000..553890c --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/dato.h" @@ -0,0 +1,7 @@ +#define TAM 5 + +typedef struct + { + char persona[20]; + int cont; + }t_dato; diff --git "a/cola de espera en un cajero autom\303\241tico/header.h" "b/cola de espera en un cajero autom\303\241tico/header.h" new file mode 100644 index 0000000..9959f96 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/header.h" @@ -0,0 +1,8 @@ +#include +#include +#include +#include +#include + +#include "primitivas_cola_estática.h" + diff --git "a/cola de espera en un cajero autom\303\241tico/main.c" "b/cola de espera en un cajero autom\303\241tico/main.c" new file mode 100644 index 0000000..de67637 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/main.c" @@ -0,0 +1,72 @@ +#include "header.h" + +// ESTE PROGRAMA SOLAMENTE MUESTRA LA LÓGICA DE COMO SIMULARLO +// SE PODRÍAN CARGAR LOS DATOS DE CADA PERSONA QUE ENTRA Y SALE DEL CAJERO +// Y AGREGAR TODO LO QUE A UNO SE LE PUEDA OCURRIR + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + puts("\n\n COLA DE ESPERA EN UN CAJERO AUTOMÁTICO \n\a\a"); + + puts("\n\n Simulación de la cola de espera, suponiendo que:"); + puts("\n - cada cliente demora en el cajero un tiempo aleatorio \n de 1, 3 o 5 minutos con igual probabilidad."); + puts("\n - los clientes llegan al cajero de a uno, con un intervalo \n de arribo aleatorio de 1, 5 o 9 minutos, con igual probabilidad."); + puts("\n\n La simulación termina después de que la cola queda vacía cinco veces. \n\n"); + + puts("\n Para comenzar la simulación, presione una tecla cualquiera \n\n"); + getch(); + + puts("\n\n COLA DE CAJERO AUTOMÁTICO"); + puts("\n ------------------------- \n\n"); + + t_cola cola; + crear_cola(&cola); + + t_dato cliente_entrada; + strcpy(cliente_entrada.persona,"Persona"); + t_dato cliente_salida; + strcpy(cliente_salida.persona,"Persona"); + + cliente_entrada.cont=0; + + int ocurrencia_entrada[3]={1,3,5}; + int ocurrencia_salida[3]={1,5,9}; + + int tiempo=0; + int no_hay_cola=0; + int tiempo_ocurrencia=rand()%3; + + while(no_hay_cola!=5) + { + if(ocurrencia_entrada[tiempo_ocurrencia]==tiempo) + if(!cola_vacia(&cola)) + { + desacolar(&cola,&cliente_salida); + printf("\n\n \t\t\t %s --> Sale \n",cliente_salida.persona); + if(cola_vacia(&cola)) + { + no_hay_cola++; + printf("\n\n Se ha vaciado la cola de espera \n\n"); + } + } + + if(ocurrencia_salida[tiempo_ocurrencia]==tiempo) + { + cliente_entrada.cont++; + printf("\n\n \t Entra --> %s \n",cliente_entrada.persona); + if(!cola_llena(&cola)) + acolar(&cola,&cliente_entrada); + } + + (tiempo==9)?tiempo=0:tiempo++; + tiempo_ocurrencia=rand()%3; + + } + + puts("\n\n Fin de la simulación \n\n"); + + puts("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } diff --git "a/cola de espera en un cajero autom\303\241tico/obj/Debug/main.o" "b/cola de espera en un cajero autom\303\241tico/obj/Debug/main.o" new file mode 100644 index 0000000..cdbeb96 Binary files /dev/null and "b/cola de espera en un cajero autom\303\241tico/obj/Debug/main.o" differ diff --git "a/cola de espera en un cajero autom\303\241tico/obj/Debug/primitivas_cola_est\303\241tica.o" "b/cola de espera en un cajero autom\303\241tico/obj/Debug/primitivas_cola_est\303\241tica.o" new file mode 100644 index 0000000..04fb819 Binary files /dev/null and "b/cola de espera en un cajero autom\303\241tico/obj/Debug/primitivas_cola_est\303\241tica.o" differ diff --git "a/cola de espera en un cajero autom\303\241tico/primitivas_cola_est\303\241tica.c" "b/cola de espera en un cajero autom\303\241tico/primitivas_cola_est\303\241tica.c" new file mode 100644 index 0000000..111cbe5 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/primitivas_cola_est\303\241tica.c" @@ -0,0 +1,63 @@ +#include "primitivas_cola_estática.h" + +void crear_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } + +int cola_llena(const t_cola *c) + { + return (c->ult+1)%TAM==c->pri&&c->ult!=-1; + } + +int acolar(t_cola *c,const t_dato *d) + { + if((c->ult+1)%TAM==c->pri&&c->ult!=-1) + return COLA_LLENA; + c->ult=(c->ult+1)%TAM; + c->cola[c->ult]=*d; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->ult==-1; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + if(c->pri==c->ult) + { + c->pri=0; + c->ult=-1; + } + else + c->pri=(c->pri+1)%TAM; + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->ult]; + return OK; + } + +void vaciar_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } diff --git "a/cola de espera en un cajero autom\303\241tico/primitivas_cola_est\303\241tica.h" "b/cola de espera en un cajero autom\303\241tico/primitivas_cola_est\303\241tica.h" new file mode 100644 index 0000000..54c94d6 --- /dev/null +++ "b/cola de espera en un cajero autom\303\241tico/primitivas_cola_est\303\241tica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define COLA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct + { + t_dato cola[TAM]; + int pri; + int ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/bin/Debug/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.exe" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/bin/Debug/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.exe" new file mode 100644 index 0000000..662bf00 Binary files /dev/null and "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/bin/Debug/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.exe" differ diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.cbp" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.cbp" new file mode 100644 index 0000000..7bde3c7 --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.layout" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.layout" new file mode 100644 index 0000000..0ad1b7c --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola.bin" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola.bin" new file mode 100644 index 0000000..5c9a726 Binary files /dev/null and "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola.bin" differ diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola.txt" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola.txt" new file mode 100644 index 0000000..fa0aca9 --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/cola.txt" @@ -0,0 +1 @@ +7|5|3| \ No newline at end of file diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/dato.h" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/dato.h" new file mode 100644 index 0000000..e4d142e --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/functions.c" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/functions.c" new file mode 100644 index 0000000..f46d09f --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/functions.c" @@ -0,0 +1,149 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato a acolar (número): \t\a\a"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato acolado: \t %d \n",d->numero); + } + +int menu(void) + { + int op,bandera; + bandera=0; + do + { + if(bandera==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe \a\a"); + getch(); + system("cls"); + } + + printf("\n\t\t ************************"); + printf("\n\t\t * MENÚ - COLA DINÁMICA *\a\a"); + printf("\n\t\t ************************"); + + printf("\n\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Crear cola"); + printf("\n 2- Acolar"); + printf("\n 3- Desacolar"); + printf("\n 4- ¿Cola llena?"); + printf("\n 5- ¿Cola vacía?"); + printf("\n 6- Ver primero en cola"); + printf("\n 7- Ver último en cola"); + printf("\n 8- Vaciar cola"); + printf("\n 9- Borrar cola"); + printf("\n 10- Exportar cola a archivo binario"); + printf("\n 11- Exportar cola a archivo de texto"); + printf("\n 12- Cargar cola desde archivo binario"); + printf("\n 13- Cargar cola desde archivo de texto"); + printf("\n\n 0- SALIR"); + + printf("\n\n \t\t\t\t Opción: \t"); + scanf("%d",&op); + bandera=1; + } + while(!DATO_VALIDO(op,0,13)); + + return op; + } + +int exportar_cola_a_archivo_bin(t_cola *cola) + { + FILE *pf; + pf=fopen("cola.bin","wb"); + if(!pf) + return 0; + + t_dato dato; + t_cola cola_inversa; + crear_cola(&cola_inversa); + + while(!cola_vacia(cola)) + { + desacolar(cola,&dato); + acolar(&cola_inversa,&dato); + } + + while(!cola_vacia(&cola_inversa)) + { + desacolar(&cola_inversa,&dato); + fwrite(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int exportar_cola_a_archivo_txt(t_cola *cola) + { + FILE *pf; + pf=fopen("cola.txt","wt"); + if(!pf) + return 0; + + t_dato dato; + t_cola cola_inversa; + crear_cola(&cola_inversa); + + while(!cola_vacia(cola)) + { + desacolar(cola,&dato); + acolar(&cola_inversa,&dato); + } + + while(!cola_vacia(&cola_inversa)) + { + desacolar(&cola_inversa,&dato); + fprintf(pf,"%d|",dato.numero); + } + + fclose(pf); + return 1; + } + +int cargar_cola_desde_archivo_bin(t_cola *cola) + { + t_dato dato; + FILE *pf; + pf=fopen("cola.bin","rb"); + if(!pf) + return 0; + + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + acolar(cola,&dato); + fread(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int cargar_cola_desde_archivo_txt(t_cola *cola) + { + t_dato dato; + + FILE *pf; + pf=fopen("cola.txt","rt"); + if(!pf) + return 0; + + fscanf(pf,"%d|",&dato.numero); + while(!feof(pf)) + { + acolar(cola,&dato); + fscanf(pf,"%d|",&dato.numero); + } + + fclose(pf); + return 1; + } diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/header.h" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/header.h" new file mode 100644 index 0000000..d2d462c --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/header.h" @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +#include "primitivas_cola_dinámica.h" + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); +int menu(void); +int exportar_cola_a_archivo_bin(t_cola*); +int exportar_cola_a_archivo_txt(t_cola*); +int cargar_cola_desde_archivo_bin(t_cola*); +int cargar_cola_desde_archivo_txt(t_cola*); diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/main.c" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/main.c" new file mode 100644 index 0000000..cda5e66 --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/main.c" @@ -0,0 +1,256 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 8B"); + + t_cola cola; + t_dato dato; + int op,respuesta,bandera,existe_cola=0; + + op=menu(); + system("cls"); + while(op!=0) + { + switch(op) + { + + case 1: if(existe_cola) + { + printf("\n\n Ya se ha creado una cola. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Creación de cola cancelada \a\a"); + break; + } + } + crear_cola(&cola); + existe_cola=1; + printf("\n\n Se ha creado una cola \n\a\a"); + break; + + case 2: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede acolar.\n\a\a"); + break; + } + if(cola_llena(&cola)) + { + printf("\n\n La cola está llena. No puede acolar \n\a\a"); + break; + } + cargar_dato(&dato); + system("cls"); + acolar(&cola,&dato); + printf("\n\n El dato ha sido acolado exitosamente \n\a\a"); + break; + + case 3: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede desacolar.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No puede desacolar. \n\a\a"); + break; + } + desacolar(&cola,&dato); + printf("\n\n El dato fue desacolado exitosamente \n\a\a"); + mostrar_dato(&dato); + break; + + case 4: if(!existe_cola) + { + printf("\n\n No se ha creado una cola \n\a\a"); + break; + } + printf("\n La cola %s está llena \n\a\a",cola_llena(&cola)?"":"no"); + break; + + case 5: if(!existe_cola) + { + printf("\n\n No se ha creado una cola.\n\a\a"); + break; + } + printf("\n La cola %s está vacía \n\a\a",cola_vacia(&cola)?"":"no"); + break; + + case 6: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede ver el primero de la cola.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido ver el primero de la cola. \a\a"); + break; + } + ver_primero_en_cola(&cola,&dato); + printf("\n\n El primero de la cola es: \t %d \n\a\a",dato.numero); + break; + + case 7: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede ver el último de la cola.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido ver el último de la cola. \a\a"); + break; + } + ver_ultimo_en_cola(&cola,&dato); + printf("\n\n El último de la cola es: \t %d \n\a\a",dato.numero); + break; + + case 8: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede vaciar la cola.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido vaciarla. \a\a"); + break; + } + vaciar_cola(&cola); + printf("\n\n La cola ha sido vaciada exitosamente \n\a\a"); + break; + + case 9: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No se la puede borrar. \a\a"); + break; + } + existe_cola=0; + printf("\n\n La cola fue borrada exitosamente \a\a"); + break; + + case 10: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No se la puede exportar. \a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_cola_a_archivo_bin(&cola)) + { + printf("\n\n Falló la exportación de la cola a archivo binario \a\a"); + break; + } + printf("\n\n La cola ha sido exportada a archivo binario exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La cola quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 11:if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No se la puede exportar. \a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_cola_a_archivo_txt(&cola)) + { + printf("\n\n Falló la exportación de la cola a archivo de texto \a\a"); + break; + } + printf("\n\n La cola ha sido exportada a archivo de texto exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La cola quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 12:if(existe_cola) + { + printf("\n\n Ya se ha creado una cola. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de cola cancelada \a\a"); + break; + } + existe_cola=0; + } + system("cls"); + if(!cargar_cola_desde_archivo_bin(&cola)) + { + printf("\n\n Falló la carga de la cola desde archivo binario \a\a"); + break; + } + existe_cola=1; + printf("\n\n Se ha cargado una cola desde archivo binario exitosamente \n\a\a"); + break; + + case 13:if(existe_cola) + { + printf("\n\n Ya se ha creado una cola. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de cola cancelada \a\a"); + break; + } + existe_cola=0; + } + system("cls"); + if(!cargar_cola_desde_archivo_bin(&cola)) + { + printf("\n\n Falló la carga de la cola desde archivo de texto \a\a"); + break; + } + existe_cola=1; + printf("\n\n Se ha cargado una cola desde archivo de texto exitosamente \n\a\a"); + break; + } + + getch(); + system("cls"); + op=menu(); + system("cls"); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" new file mode 100644 index 0000000..757bc62 Binary files /dev/null and "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" differ diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" new file mode 100644 index 0000000..4b50562 Binary files /dev/null and "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" differ diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_cola_din\303\241mica.o" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_cola_din\303\241mica.o" new file mode 100644 index 0000000..aa4a2e6 Binary files /dev/null and "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_cola_din\303\241mica.o" differ diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_din\303\241mica.c" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_din\303\241mica.c" new file mode 100644 index 0000000..c8a0a09 --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_din\303\241mica.c" @@ -0,0 +1,79 @@ +#include "primitivas_cola_dinámica.h" + +//no sé por qué si no incluyo las bibliotecas tira error +#include +#include + +void crear_cola(t_cola *c) + { + c->pri=NULL; + c->ult=NULL; + } + +int cola_llena(const t_cola *c) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int acolar(t_cola *c,const t_dato *d) + { + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=NULL; + if(c->ult==NULL) + c->pri=nuevo; + else + c->ult->sig=nuevo; + c->ult=nuevo; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->pri==NULL; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + t_nodo *aux=c->pri; + *d=aux->dato;//*d=c->prim->dato; + c->pri=aux->sig;//c->pri=c->pri->sig; + if(c->pri==NULL) + c->ult=NULL; + free(aux); + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + *d=c->pri->dato; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->pri==NULL) + return COLA_VACIA; + *d=c->ult->dato; + return OK; + } + +void vaciar_cola(t_cola *c) + { + t_nodo *aux; + while(c->pri!=NULL) + { + aux=c->pri; + c->pri=aux->sig; + free(aux); + } + c->ult=NULL; + } diff --git "a/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_din\303\241mica.h" "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_din\303\241mica.h" new file mode 100644 index 0000000..35dfbee --- /dev/null +++ "b/cola din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_din\303\241mica.h" @@ -0,0 +1,26 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef struct + { + t_nodo *pri; + t_nodo *ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/bin/Debug/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.exe" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/bin/Debug/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.exe" new file mode 100644 index 0000000..ddffdeb Binary files /dev/null and "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/bin/Debug/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.exe" differ diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.cbp" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.cbp" new file mode 100644 index 0000000..caf7626 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.depend" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.depend" new file mode 100644 index 0000000..cdff737 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1475439806 source:d:\unlam\programaciÓn\fabian 2\cola estática_menú_primitivas y pasaje a archivos\functions.c + "header.h" + +1475439602 d:\unlam\programaciÓn\fabian 2\cola estática_menú_primitivas y pasaje a archivos\header.h + + + + + "primitivas_cola_estática.h" + +1475433603 d:\unlam\programaciÓn\fabian 2\cola estática_menú_primitivas y pasaje a archivos\primitivas_cola_estática.h + "dato.h" + +1474765137 d:\unlam\programaciÓn\fabian 2\cola estática_menú_primitivas y pasaje a archivos\dato.h + +1475439817 source:d:\unlam\programaciÓn\fabian 2\cola estática_menú_primitivas y pasaje a archivos\main.c + "header.h" + +1475434668 source:d:\unlam\programaciÓn\fabian 2\cola estática_menú_primitivas y pasaje a archivos\primitivas_cola_estática.c + "primitivas_cola_estática.h" + diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.layout" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.layout" new file mode 100644 index 0000000..e9aeff1 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola.bin" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola.bin" new file mode 100644 index 0000000..5c9a726 Binary files /dev/null and "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola.bin" differ diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola.txt" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola.txt" new file mode 100644 index 0000000..fa0aca9 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/cola.txt" @@ -0,0 +1 @@ +7|5|3| \ No newline at end of file diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/dato.h" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/dato.h" new file mode 100644 index 0000000..e4d142e --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/functions.c" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/functions.c" new file mode 100644 index 0000000..e7247ea --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/functions.c" @@ -0,0 +1,149 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato a acolar (número): \t\a\a"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato acolado: \t %d \n",d->numero); + } + +int menu(void) + { + int op,bandera; + bandera=0; + do + { + if(bandera==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe \a\a"); + getch(); + system("cls"); + } + + printf("\n\t\t ************************"); + printf("\n\t\t * MENÚ - COLA ESTÁTICA *\a\a"); + printf("\n\t\t ************************"); + + printf("\n\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Crear cola"); + printf("\n 2- Acolar"); + printf("\n 3- Desacolar"); + printf("\n 4- ¿Cola llena?"); + printf("\n 5- ¿Cola vacía?"); + printf("\n 6- Ver primero en cola"); + printf("\n 7- Ver último en cola"); + printf("\n 8- Vaciar cola"); + printf("\n 9- Borrar cola"); + printf("\n 10- Exportar cola a archivo binario"); + printf("\n 11- Exportar cola a archivo de texto"); + printf("\n 12- Cargar cola desde archivo binario"); + printf("\n 13- Cargar cola desde archivo de texto"); + printf("\n\n 0- SALIR"); + + printf("\n\n \t\t\t\t Opción: \t"); + scanf("%d",&op); + bandera=1; + } + while(!DATO_VALIDO(op,0,13)); + + return op; + } + +int exportar_cola_a_archivo_bin(t_cola *cola) + { + FILE *pf; + pf=fopen("cola.bin","wb"); + if(!pf) + return 0; + + t_dato dato; + t_cola cola_inversa; + crear_cola(&cola_inversa); + + while(!cola_vacia(cola)) + { + desacolar(cola,&dato); + acolar(&cola_inversa,&dato); + } + + while(!cola_vacia(&cola_inversa)) + { + desacolar(&cola_inversa,&dato); + fwrite(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int exportar_cola_a_archivo_txt(t_cola *cola) + { + FILE *pf; + pf=fopen("cola.txt","wt"); + if(!pf) + return 0; + + t_dato dato; + t_cola cola_inversa; + crear_cola(&cola_inversa); + + while(!cola_vacia(cola)) + { + desacolar(cola,&dato); + acolar(&cola_inversa,&dato); + } + + while(!cola_vacia(&cola_inversa)) + { + desacolar(&cola_inversa,&dato); + fprintf(pf,"%d|",dato.numero); + } + + fclose(pf); + return 1; + } + +int cargar_cola_desde_archivo_bin(t_cola *cola) + { + t_dato dato; + FILE *pf; + pf=fopen("cola.bin","rb"); + if(!pf) + return 0; + + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + acolar(cola,&dato); + fread(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int cargar_cola_desde_archivo_txt(t_cola *cola) + { + t_dato dato; + + FILE *pf; + pf=fopen("cola.txt","rt"); + if(!pf) + return 0; + + fscanf(pf,"%d|",&dato.numero); + while(!feof(pf)) + { + acolar(cola,&dato); + fscanf(pf,"%d|",&dato.numero); + } + + fclose(pf); + return 1; + } diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/header.h" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/header.h" new file mode 100644 index 0000000..e274a8d --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/header.h" @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +#include "primitivas_cola_estática.h" + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); +int menu(void); +int exportar_cola_a_archivo_bin(t_cola*); +int exportar_cola_a_archivo_txt(t_cola*); +int cargar_cola_desde_archivo_bin(t_cola*); +int cargar_cola_desde_archivo_txt(t_cola*); diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/main.c" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/main.c" new file mode 100644 index 0000000..cda5e66 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/main.c" @@ -0,0 +1,256 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 8B"); + + t_cola cola; + t_dato dato; + int op,respuesta,bandera,existe_cola=0; + + op=menu(); + system("cls"); + while(op!=0) + { + switch(op) + { + + case 1: if(existe_cola) + { + printf("\n\n Ya se ha creado una cola. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Creación de cola cancelada \a\a"); + break; + } + } + crear_cola(&cola); + existe_cola=1; + printf("\n\n Se ha creado una cola \n\a\a"); + break; + + case 2: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede acolar.\n\a\a"); + break; + } + if(cola_llena(&cola)) + { + printf("\n\n La cola está llena. No puede acolar \n\a\a"); + break; + } + cargar_dato(&dato); + system("cls"); + acolar(&cola,&dato); + printf("\n\n El dato ha sido acolado exitosamente \n\a\a"); + break; + + case 3: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede desacolar.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No puede desacolar. \n\a\a"); + break; + } + desacolar(&cola,&dato); + printf("\n\n El dato fue desacolado exitosamente \n\a\a"); + mostrar_dato(&dato); + break; + + case 4: if(!existe_cola) + { + printf("\n\n No se ha creado una cola \n\a\a"); + break; + } + printf("\n La cola %s está llena \n\a\a",cola_llena(&cola)?"":"no"); + break; + + case 5: if(!existe_cola) + { + printf("\n\n No se ha creado una cola.\n\a\a"); + break; + } + printf("\n La cola %s está vacía \n\a\a",cola_vacia(&cola)?"":"no"); + break; + + case 6: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede ver el primero de la cola.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido ver el primero de la cola. \a\a"); + break; + } + ver_primero_en_cola(&cola,&dato); + printf("\n\n El primero de la cola es: \t %d \n\a\a",dato.numero); + break; + + case 7: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede ver el último de la cola.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido ver el último de la cola. \a\a"); + break; + } + ver_ultimo_en_cola(&cola,&dato); + printf("\n\n El último de la cola es: \t %d \n\a\a",dato.numero); + break; + + case 8: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No puede vaciar la cola.\n\a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido vaciarla. \a\a"); + break; + } + vaciar_cola(&cola); + printf("\n\n La cola ha sido vaciada exitosamente \n\a\a"); + break; + + case 9: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No se la puede borrar. \a\a"); + break; + } + existe_cola=0; + printf("\n\n La cola fue borrada exitosamente \a\a"); + break; + + case 10: if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No se la puede exportar. \a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_cola_a_archivo_bin(&cola)) + { + printf("\n\n Falló la exportación de la cola a archivo binario \a\a"); + break; + } + printf("\n\n La cola ha sido exportada a archivo binario exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La cola quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 11:if(!existe_cola) + { + printf("\n\n No se ha creado una cola. No se la puede exportar. \a\a"); + break; + } + if(cola_vacia(&cola)) + { + printf("\n\n La cola está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_cola_a_archivo_txt(&cola)) + { + printf("\n\n Falló la exportación de la cola a archivo de texto \a\a"); + break; + } + printf("\n\n La cola ha sido exportada a archivo de texto exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La cola quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 12:if(existe_cola) + { + printf("\n\n Ya se ha creado una cola. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de cola cancelada \a\a"); + break; + } + existe_cola=0; + } + system("cls"); + if(!cargar_cola_desde_archivo_bin(&cola)) + { + printf("\n\n Falló la carga de la cola desde archivo binario \a\a"); + break; + } + existe_cola=1; + printf("\n\n Se ha cargado una cola desde archivo binario exitosamente \n\a\a"); + break; + + case 13:if(existe_cola) + { + printf("\n\n Ya se ha creado una cola. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de cola cancelada \a\a"); + break; + } + existe_cola=0; + } + system("cls"); + if(!cargar_cola_desde_archivo_bin(&cola)) + { + printf("\n\n Falló la carga de la cola desde archivo de texto \a\a"); + break; + } + existe_cola=1; + printf("\n\n Se ha cargado una cola desde archivo de texto exitosamente \n\a\a"); + break; + } + + getch(); + system("cls"); + op=menu(); + system("cls"); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" new file mode 100644 index 0000000..e3acf56 Binary files /dev/null and "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" differ diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" new file mode 100644 index 0000000..e178fc4 Binary files /dev/null and "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" differ diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_cola_est\303\241tica.o" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_cola_est\303\241tica.o" new file mode 100644 index 0000000..a9bf1b6 Binary files /dev/null and "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_cola_est\303\241tica.o" differ diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_est\303\241tica.c" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_est\303\241tica.c" new file mode 100644 index 0000000..111cbe5 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_est\303\241tica.c" @@ -0,0 +1,63 @@ +#include "primitivas_cola_estática.h" + +void crear_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } + +int cola_llena(const t_cola *c) + { + return (c->ult+1)%TAM==c->pri&&c->ult!=-1; + } + +int acolar(t_cola *c,const t_dato *d) + { + if((c->ult+1)%TAM==c->pri&&c->ult!=-1) + return COLA_LLENA; + c->ult=(c->ult+1)%TAM; + c->cola[c->ult]=*d; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->ult==-1; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + if(c->pri==c->ult) + { + c->pri=0; + c->ult=-1; + } + else + c->pri=(c->pri+1)%TAM; + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->ult]; + return OK; + } + +void vaciar_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } diff --git "a/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_est\303\241tica.h" "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_est\303\241tica.h" new file mode 100644 index 0000000..54c94d6 --- /dev/null +++ "b/cola est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_cola_est\303\241tica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define COLA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct + { + t_dato cola[TAM]; + int pri; + int ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/compilaci\303\263n condicional y directivas al preprocesador de C/bin/Debug/compilaci\303\263n condicional y directivas al preprocesador de C.exe" "b/compilaci\303\263n condicional y directivas al preprocesador de C/bin/Debug/compilaci\303\263n condicional y directivas al preprocesador de C.exe" new file mode 100644 index 0000000..95a359a Binary files /dev/null and "b/compilaci\303\263n condicional y directivas al preprocesador de C/bin/Debug/compilaci\303\263n condicional y directivas al preprocesador de C.exe" differ diff --git "a/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.cbp" "b/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.cbp" new file mode 100644 index 0000000..a8bdbd2 --- /dev/null +++ "b/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.depend" "b/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.depend" new file mode 100644 index 0000000..1879ac0 --- /dev/null +++ "b/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.depend" @@ -0,0 +1,5 @@ +# depslib dependency file v1.0 +1482868519 source:d:\unlam\programaciÓn\fabian\compilación condicional y directivas al preprocesador de c\main.c + + + diff --git "a/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.layout" "b/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.layout" new file mode 100644 index 0000000..2606c5a --- /dev/null +++ "b/compilaci\303\263n condicional y directivas al preprocesador de C/compilaci\303\263n condicional y directivas al preprocesador de C.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/compilaci\303\263n condicional y directivas al preprocesador de C/main.c" "b/compilaci\303\263n condicional y directivas al preprocesador de C/main.c" new file mode 100644 index 0000000..ecaa50d --- /dev/null +++ "b/compilaci\303\263n condicional y directivas al preprocesador de C/main.c" @@ -0,0 +1,36 @@ +#include +#include +#include +#include + +#define DEPURAR 1 +#define HOLA(x) printf("\n Hola " #x "\n") + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + + #if DEPURAR + HOLA(mundo); + #endif // DEPURAR + + #undef NULL + + #ifndef NULL + #define NULL 1 + #endif // NULL + + #ifdef NULL + printf("\n NULL: %i \n",NULL); + #endif // NULL + + printf("\n Línea del código fuente actual: %d \n",__LINE__); + printf("\n Nombre del archivo fuente: \n %s \n",__FILE__); + printf("\n Fecha de compilación del fuente: %s \n",__DATE__); + printf("\n Hora de compilación del fuente: %s \n\n",__TIME__); + + assert(NULL == 0); // si el argumento de assert es falso, assert imoprime un mensaje de error en la consola, + // y luego invoca a la función abort para que detenga la ejecución del programa + + return 0; +} diff --git "a/compilaci\303\263n condicional y directivas al preprocesador de C/obj/Debug/main.o" "b/compilaci\303\263n condicional y directivas al preprocesador de C/obj/Debug/main.o" new file mode 100644 index 0000000..ae09040 Binary files /dev/null and "b/compilaci\303\263n condicional y directivas al preprocesador de C/obj/Debug/main.o" differ diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/bin/Debug/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.exe" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/bin/Debug/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.exe" new file mode 100644 index 0000000..05a5986 Binary files /dev/null and "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/bin/Debug/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.exe" differ diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.cbp" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.cbp" new file mode 100644 index 0000000..63f27b0 --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.depend" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.depend" new file mode 100644 index 0000000..c38a440 --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474579550 source:d:\unlam\programaciÓn\fabian 2\contar si múltiplos de n, los números de un txt\functions.c + "header.h" + +1474579435 d:\unlam\programaciÓn\fabian 2\contar si múltiplos de n, los números de un txt\header.h + + + + + +1474579569 source:d:\unlam\programaciÓn\fabian 2\contar si múltiplos de n, los números de un txt\main.c + "header.h" + diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.layout" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.layout" new file mode 100644 index 0000000..3892dc1 --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/contar si m\303\272ltiplos de n, los n\303\272meros de un txt.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/datos.txt" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/datos.txt" new file mode 100644 index 0000000..c5a88bd --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/datos.txt" @@ -0,0 +1,63 @@ + 41 18467 6334 26500 + 19169 15724 11478 29358 26962 24464 + 5705 28145 23281 16827 9961 491 2995 + 11942 4827 5436 + 32391 14604 3902 153 292 + 12382 + 17421 18716 + 19718 19895 5447 21726 + 14771 11538 1869 19912 25667 26299 17035 + 9894 28703 23811 31322 30333 + 17673 4664 15141 + 7711 28253 + 6868 25547 27644 32662 32757 20037 + 12859 8723 9741 27529 778 + 12316 3035 22190 1842 288 30106 9040 + 8942 19264 22648 27446 + 23805 15890 6729 24370 15350 + 15006 31101 + 24393 3548 19629 + 12623 24084 19954 18756 + 11840 + 4966 7376 + 13931 26308 16944 32439 24626 + 11323 5537 21538 16118 2082 22929 + 16541 4833 31115 4639 + 29658 22704 9930 13977 2306 31673 22386 + 5021 + 28745 26924 19072 6270 5829 26777 15573 + 5097 + 16512 23986 13290 9161 18636 22355 24767 + 23655 + 15574 4031 12052 27350 1150 16941 21724 + 13966 3430 + 31107 30191 18007 11337 + 15457 12287 27753 + 10383 14945 + 8909 + 32209 9758 24221 18588 6422 24946 27506 + 13030 16413 + 29168 900 32591 18762 1655 + 17410 6359 27624 20537 + 21548 6483 27595 4041 3602 24350 10291 + 30836 9374 11020 + 4596 24021 + 27348 + 23199 19668 24484 8281 4734 53 1999 + 26418 27938 6900 3788 18127 + 467 3728 14893 24648 + 22483 17807 + 2421 14310 6617 + 22813 9514 + 14309 + 7616 18935 17451 20600 + 5249 16519 31556 22798 30303 6224 11008 + 5844 32609 14989 + 32702 3195 + 20485 3093 14343 30523 1587 29314 9503 + 7448 + 25200 13458 6618 20580 19796 + 14798 15281 19589 20798 + 28009 27157 + 20472 + 23622 18538 12292 6038 24179 18190 29657 diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/functions.c" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/functions.c" new file mode 100644 index 0000000..0f8538a --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/functions.c" @@ -0,0 +1,143 @@ +#include "header.h" + +char *leer_cadena_numerica(FILE *pf) + { + char s[6]; + fflush(stdin); + fscanf(pf,"%6s",s); + return s; + } + +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } + +int mi_atoi(char *s) + { + int i=0,signo=1; + if(!s) + return 0; + if(!ES_DIGITO(*s)) + { + while(*s==' ') + s++; + if(*s=='-') + { + signo=-1; + s++; + } + else + if(*s=='+') + s++; + } + while(ES_DIGITO(*s)) + { + i*=10; + i+=(*s-'0'); + s++; + } + return i*signo; + } + +int es_numero(char *s) + { + if(!s) + return 0; + if(!ES_DIGITO(*s)) + { + while(ES_BLANCO(*s)) + s++; + if(ES_SIGNO(*s)) + { + s++; + } + else + if(!ES_DIGITO(*s)) + return 0; + } + while(ES_DIGITO(*s)) + { + s++; + } + return *s?0:1; + } + +int es_capicua(char *s1) + { + while(ES_BLANCO(*s1)||ES_SIGNO(*s1)) + s1++; + int i,longitud=str_len(s1),punto_medio=longitud/2; + char *s2=s1+longitud-1; + for(i=0;i<=punto_medio;i++) + if(*s1++!=*s2--) + return 0; + return 1; + } + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +int es_multiplo_de_5(char *s) + { + while(*s) + s++; + s--; + return (*s=='5'||(*s=='0'))?1:0; + } + +int es_multiplo_de_6(char *s) + { + while(*s) + s++; + s--; + if(*s!='0'&&(*s!='2')&&(*s!='4')&&(*s!='6')&&(*s!='8')) + return 0; + int acum=0; + while(ES_DIGITO(*s)) + { + acum=acum+A_NUMERO(*s); + s--; + } + return acum%3==0?1:0; + } + +int es_multiplo_de_11(char *s) + { + int signo=1,acum=0; + while(!ES_DIGITO(*s)) + s++; + while(*s) + { + acum+=signo*A_NUMERO(*s); + signo*=-1; + s++; + } + return (acum==0||acum%11==0)?1:0; + } + +int es_mayor(char *s1,char *s2) + { + return (mi_atoi(s1)>mi_atoi(s2))?1:0; + } + +void nueva_cadena_numerica(FILE *pf,char *s) + { + fprintf(pf,"%-s\n",s); + } diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/header.h" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/header.h" new file mode 100644 index 0000000..6c7d882 --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/header.h" @@ -0,0 +1,24 @@ +#include +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +#define ES_DIGITO(x) (((x)>='0'&&(x)<='9')) +#define ES_BLANCO(x) ((x)==' ') +#define ES_SIGNO(x) ((x)=='+'||(x)=='-') +#define A_NUMERO(x) ((x)-48) +#define MAYOR(x,y) ((x)>(y)?(x):(y)) + +char *leer_cadena_numerica(FILE*); +char *str_cpy(char*,const char*); +int mi_atoi(char*); +int es_numero(char*); +size_t str_len(const char*); +int es_capicua(char*); +int es_multiplo_de_5(char*); +int es_multiplo_de_6(char*); +int es_multiplo_de_11(char*); +int es_mayor(char*,char*); +void nueva_cadena_numerica(FILE*,char*); diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/main.c" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/main.c" new file mode 100644 index 0000000..c2f5ec0 --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/main.c" @@ -0,0 +1,57 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n CONTAR SI MÚLTIPLOS DE N, LOS NÚMEROS DE UN TXT \n"); + + FILE *pf_lectura; + pf_lectura=fopen("datos.txt","rt"); + if(!pf_lectura) + { + printf("\n\n No se ha podido leer el archivo \"datos.txt\" \n\n Programa abortado.. \n\n"); + exit(EXIT_FAILURE); + } + + FILE *pf_escritura; + pf_escritura=fopen("mayores que 100.txt","wt"); + if(!pf_escritura) + { + printf("\n\n No se ha podido crear el archivo \"mayores que 100.txt\" \n\n Programa abortado.. \n\n"); + fclose(pf_lectura); + exit(EXIT_FAILURE); + } + + int cuenta_multiplos_de_5=0,cuenta_multiplos_de_6=0,cuenta_multiplos_de_11=0; + char cadena[6]; + + while(!feof(pf_lectura)) + { + str_cpy(cadena,leer_cadena_numerica(pf_lectura)); + if(!es_numero(cadena)) + break; + if(es_multiplo_de_5(cadena)) + cuenta_multiplos_de_5++; + if(es_multiplo_de_6(cadena)) + cuenta_multiplos_de_6++; + if(es_multiplo_de_11(cadena)) + cuenta_multiplos_de_11++; + if(es_mayor(cadena,"100")) + nueva_cadena_numerica(pf_escritura,cadena); + } + + fclose(pf_lectura); + fclose(pf_escritura); + + printf("\n RESULTADO de los números leídos del archivo \"datos.txt\" \n"); + printf("\n Cantidad de múltiplos de 5: \t %d",cuenta_multiplos_de_5); + printf("\n Cantidad de múltiplos de 6: \t %d",cuenta_multiplos_de_6); + printf("\n Cantidad de múltiplos de 11: \t %d",cuenta_multiplos_de_11); + + printf("\n\n Se ha generado un fichero de texto \"mayores que 100.txt\" \n donde se encuenran los números leídos del archivo \"datos.txt\" \n que cumplen con dicha condición \n\n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/mayores que 100.txt" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/mayores que 100.txt" new file mode 100644 index 0000000..051931b --- /dev/null +++ "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/mayores que 100.txt" @@ -0,0 +1,242 @@ +18467 +6334 +26500 +19169 +15724 +11478 +29358 +26962 +24464 +5705 +28145 +23281 +16827 +9961 +491 +2995 +11942 +4827 +5436 +32391 +14604 +3902 +153 +292 +12382 +17421 +18716 +19718 +19895 +5447 +21726 +14771 +11538 +1869 +19912 +25667 +26299 +17035 +9894 +28703 +23811 +31322 +30333 +17673 +4664 +15141 +7711 +28253 +6868 +25547 +27644 +32662 +32757 +20037 +12859 +8723 +9741 +27529 +778 +12316 +3035 +22190 +1842 +288 +30106 +9040 +8942 +19264 +22648 +27446 +23805 +15890 +6729 +24370 +15350 +15006 +31101 +24393 +3548 +19629 +12623 +24084 +19954 +18756 +11840 +4966 +7376 +13931 +26308 +16944 +32439 +24626 +11323 +5537 +21538 +16118 +2082 +22929 +16541 +4833 +31115 +4639 +29658 +22704 +9930 +13977 +2306 +31673 +22386 +5021 +28745 +26924 +19072 +6270 +5829 +26777 +15573 +5097 +16512 +23986 +13290 +9161 +18636 +22355 +24767 +23655 +15574 +4031 +12052 +27350 +1150 +16941 +21724 +13966 +3430 +31107 +30191 +18007 +11337 +15457 +12287 +27753 +10383 +14945 +8909 +32209 +9758 +24221 +18588 +6422 +24946 +27506 +13030 +16413 +29168 +900 +32591 +18762 +1655 +17410 +6359 +27624 +20537 +21548 +6483 +27595 +4041 +3602 +24350 +10291 +30836 +9374 +11020 +4596 +24021 +27348 +23199 +19668 +24484 +8281 +4734 +1999 +26418 +27938 +6900 +3788 +18127 +467 +3728 +14893 +24648 +22483 +17807 +2421 +14310 +6617 +22813 +9514 +14309 +7616 +18935 +17451 +20600 +5249 +16519 +31556 +22798 +30303 +6224 +11008 +5844 +32609 +14989 +32702 +3195 +20485 +3093 +14343 +30523 +1587 +29314 +9503 +7448 +25200 +13458 +6618 +20580 +19796 +14798 +15281 +19589 +20798 +28009 +27157 +20472 +23622 +18538 +12292 +6038 +24179 +18190 +29657 diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/obj/Debug/functions.o" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/obj/Debug/functions.o" new file mode 100644 index 0000000..67955ed Binary files /dev/null and "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/obj/Debug/functions.o" differ diff --git "a/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/obj/Debug/main.o" "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/obj/Debug/main.o" new file mode 100644 index 0000000..b857205 Binary files /dev/null and "b/contar si m\303\272ltiplos de n, los n\303\272meros de un txt/obj/Debug/main.o" differ diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/bin/Debug/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.exe" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/bin/Debug/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.exe" new file mode 100644 index 0000000..f0bc721 Binary files /dev/null and "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/bin/Debug/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.exe" differ diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.cbp" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.cbp" new file mode 100644 index 0000000..3a0e2dd --- /dev/null +++ "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.depend" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.depend" new file mode 100644 index 0000000..27e891e --- /dev/null +++ "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.depend" @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1473641801 source:d:\unlam\programaciÓn\fabian 2\conversión_atoi,atof,atol,itoa,ftoa,ltoa\main.c + "header.h" + +1473639685 d:\unlam\programaciÓn\fabian 2\conversión_atoi,atof,atol,itoa,ftoa,ltoa\header.h + + + + + diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.layout" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.layout" new file mode 100644 index 0000000..c828720 --- /dev/null +++ "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa.layout" @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/header.h" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/header.h" new file mode 100644 index 0000000..272c310 --- /dev/null +++ "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/header.h" @@ -0,0 +1,5 @@ +#include +#include +#include +#include + diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/main.c" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/main.c" new file mode 100644 index 0000000..d67b9e8 --- /dev/null +++ "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/main.c" @@ -0,0 +1,21 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cad[5]; + printf("\n\n Conversiones de tipo"); + printf("\n -------------------- \n\n"); + + printf("\n Cadena: \t %s \t---ATOI--->> \t Entero: \t %d \n","-67489jknf",atoi("-67489")); + printf("\n Cadena: \t %s \t---ATOF--->> \t Flotante: \t %f \n","-5.0326e5",atof("-5.0326e5")); + printf("\n Cadena: \t %s \t---ATOL--->> \t Entero largo: \t %li \n","+76454865fsg",atol("+76454865")); + + printf("\n Entero: \t %d \t---ITOA--->> \t Cadena: \t %s \n",6545,itoa(6545,cad,10)); + printf("\n Entero: \t %d \t---ITOA--->> \t Cadena (en binario): \t %s \n",6545,itoa(6545,cad,2)); + printf("\n Entero: \t %d \t---ITOA--->> \t Cadena (en hexadecimal): \t %s \n",3578,itoa(3578,cad,16)); + //printf("\n Flotante: \t %f \t---FTOA--->> \t Cadena: \t %s \n",0.1455454e7,ftoa(0.1455454e7,cad,10)); + printf("\n Entero largo: \t %f \t---LTOA--->> \t Cadena: \t %s \n",+0.1455454e7,ltoa(+0.1455454e7,cad,10)); + + getch(); + return 0; + } diff --git "a/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/obj/Debug/main.o" "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/obj/Debug/main.o" new file mode 100644 index 0000000..cc37013 Binary files /dev/null and "b/conversi\303\263n_atoi,atof,atol,itoa,ftoa,ltoa/obj/Debug/main.o" differ diff --git "a/conversi\303\263n_simulacro de atof/bin/Debug/conversi\303\263n_simulacro de atof.exe" "b/conversi\303\263n_simulacro de atof/bin/Debug/conversi\303\263n_simulacro de atof.exe" new file mode 100644 index 0000000..2299348 Binary files /dev/null and "b/conversi\303\263n_simulacro de atof/bin/Debug/conversi\303\263n_simulacro de atof.exe" differ diff --git "a/conversi\303\263n_simulacro de atof/conversi\303\263n_simulacro de atof.cbp" "b/conversi\303\263n_simulacro de atof/conversi\303\263n_simulacro de atof.cbp" new file mode 100644 index 0000000..7f5b09f --- /dev/null +++ "b/conversi\303\263n_simulacro de atof/conversi\303\263n_simulacro de atof.cbp" @@ -0,0 +1,41 @@ + + + + + + diff --git "a/conversi\303\263n_simulacro de atof/conversi\303\263n_simulacro de atof.depend" "b/conversi\303\263n_simulacro de atof/conversi\303\263n_simulacro de atof.depend" new file mode 100644 index 0000000..0562dca --- /dev/null +++ "b/conversi\303\263n_simulacro de atof/conversi\303\263n_simulacro de atof.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473634956 source:d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atof\functions.c + "header.h" + +1473634186 d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atof\header.h + + + + + +1473633718 source:d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atof\main.c + "header.h" + diff --git "a/conversi\303\263n_simulacro de atof/functions.c" "b/conversi\303\263n_simulacro de atof/functions.c" new file mode 100644 index 0000000..b562799 --- /dev/null +++ "b/conversi\303\263n_simulacro de atof/functions.c" @@ -0,0 +1,67 @@ +#include "header.h" +double mi_atof(char *s) + { + int signo=1; + double val=0,pos=1; + if(!s) + return 0; + if(!ES_NUMERO(*s)) + { + while(*s==' ') + s++; + if(*s=='-') + { + signo=-1; + s++; + } + else + if(*s=='+') + s++; + } + while(ES_NUMERO(*s)) + { + val*=10; + val+=(*s-'0'); + s++; + } + if(A_MINUSCULA(*s)=='e') + return val*pow(10,mi_atoi(++s)); + else + if(*s!='.') + return val*signo; + s++; + while(ES_NUMERO(*s)) + { + val+=(*s-'0')*(pos/=10); + s++; + } + if(A_MINUSCULA(*s)=='e') + return val*pow(10,mi_atoi(++s)); + return val*signo; + } +int mi_atoi(char *s) + { + int i=0,signo=1; + if(!s) + return 0; + if(!ES_NUMERO(*s)) + { + while(*s==' ') + s++; + if(*s=='-') + { + signo=-1; + s++; + } + else + if(*s=='+') + s++; + } + while(ES_NUMERO(*s)) + { + i*=10; + i+=(*s-'0'); + s++; + } + return i*signo; + } diff --git "a/conversi\303\263n_simulacro de atof/header.h" "b/conversi\303\263n_simulacro de atof/header.h" new file mode 100644 index 0000000..2d10973 --- /dev/null +++ "b/conversi\303\263n_simulacro de atof/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#include +#define TOPE 50 +#define ES_NUMERO(x) ((x)>='0'&&(x)<='9') +#define A_MINUSCULA(x) (((x)>='A'&&(x)<='Z')?((x)+32):(x)) + +double mi_atof(char*); +int mi_atoi(char*); diff --git "a/conversi\303\263n_simulacro de atof/main.c" "b/conversi\303\263n_simulacro de atof/main.c" new file mode 100644 index 0000000..d8146b2 --- /dev/null +++ "b/conversi\303\263n_simulacro de atof/main.c" @@ -0,0 +1,13 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[TOPE]; + printf("\n\n ATOF \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena); + printf("\n\n Cadena convertida a flotante: \t %f \n\n",mi_atof(cadena)); + getch(); + return 0; + } diff --git "a/conversi\303\263n_simulacro de atof/obj/Debug/functions.o" "b/conversi\303\263n_simulacro de atof/obj/Debug/functions.o" new file mode 100644 index 0000000..27cbcf2 Binary files /dev/null and "b/conversi\303\263n_simulacro de atof/obj/Debug/functions.o" differ diff --git "a/conversi\303\263n_simulacro de atof/obj/Debug/main.o" "b/conversi\303\263n_simulacro de atof/obj/Debug/main.o" new file mode 100644 index 0000000..3a42389 Binary files /dev/null and "b/conversi\303\263n_simulacro de atof/obj/Debug/main.o" differ diff --git "a/conversi\303\263n_simulacro de atoi/bin/Debug/conversi\303\263n_simulacro de atoi.exe" "b/conversi\303\263n_simulacro de atoi/bin/Debug/conversi\303\263n_simulacro de atoi.exe" new file mode 100644 index 0000000..722cf58 Binary files /dev/null and "b/conversi\303\263n_simulacro de atoi/bin/Debug/conversi\303\263n_simulacro de atoi.exe" differ diff --git "a/conversi\303\263n_simulacro de atoi/conversi\303\263n_simulacro de atoi.cbp" "b/conversi\303\263n_simulacro de atoi/conversi\303\263n_simulacro de atoi.cbp" new file mode 100644 index 0000000..3dc2fda --- /dev/null +++ "b/conversi\303\263n_simulacro de atoi/conversi\303\263n_simulacro de atoi.cbp" @@ -0,0 +1,40 @@ + + + + + + diff --git "a/conversi\303\263n_simulacro de atoi/conversi\303\263n_simulacro de atoi.depend" "b/conversi\303\263n_simulacro de atoi/conversi\303\263n_simulacro de atoi.depend" new file mode 100644 index 0000000..3307f24 --- /dev/null +++ "b/conversi\303\263n_simulacro de atoi/conversi\303\263n_simulacro de atoi.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473632997 source:d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atoi\functions.c + "header.h" + +1473633354 d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atoi\header.h + + + + +1473632958 source:d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atoi\main.c + "header.h" + diff --git "a/conversi\303\263n_simulacro de atoi/functions.c" "b/conversi\303\263n_simulacro de atoi/functions.c" new file mode 100644 index 0000000..3dbd961 --- /dev/null +++ "b/conversi\303\263n_simulacro de atoi/functions.c" @@ -0,0 +1,27 @@ +#include "header.h" +int mi_atoi(char *s) + { + int i=0,signo=1; + if(!s) + return 0; + if(!ES_NUMERO(*s)) + { + while(*s==' ') + s++; + if(*s=='-') + { + signo=-1; + s++; + } + else + if(*s=='+') + s++; + } + while(ES_NUMERO(*s)) + { + i*=10; + i+=(*s-'0'); + s++; + } + return i*signo; + } diff --git "a/conversi\303\263n_simulacro de atoi/header.h" "b/conversi\303\263n_simulacro de atoi/header.h" new file mode 100644 index 0000000..aaf5e6f --- /dev/null +++ "b/conversi\303\263n_simulacro de atoi/header.h" @@ -0,0 +1,6 @@ +#include +#include +#include +#define TOPE 50 +#define ES_NUMERO(x) ((x)>='0'&&(x)<='9') +int mi_atoi(char*); diff --git "a/conversi\303\263n_simulacro de atoi/main.c" "b/conversi\303\263n_simulacro de atoi/main.c" new file mode 100644 index 0000000..b598cc9 --- /dev/null +++ "b/conversi\303\263n_simulacro de atoi/main.c" @@ -0,0 +1,13 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[TOPE]; + printf("\n\n ATOI \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena); + printf("\n\n Cadena convertida a entero: \t %d \n\n",mi_atoi(cadena)); + getch(); + return 0; + } diff --git "a/conversi\303\263n_simulacro de atoi/obj/Debug/functions.o" "b/conversi\303\263n_simulacro de atoi/obj/Debug/functions.o" new file mode 100644 index 0000000..e2de2af Binary files /dev/null and "b/conversi\303\263n_simulacro de atoi/obj/Debug/functions.o" differ diff --git "a/conversi\303\263n_simulacro de atoi/obj/Debug/main.o" "b/conversi\303\263n_simulacro de atoi/obj/Debug/main.o" new file mode 100644 index 0000000..547b3f8 Binary files /dev/null and "b/conversi\303\263n_simulacro de atoi/obj/Debug/main.o" differ diff --git "a/conversi\303\263n_simulacro de atol/bin/Debug/conversi\303\263n_simulacro de atol.exe" "b/conversi\303\263n_simulacro de atol/bin/Debug/conversi\303\263n_simulacro de atol.exe" new file mode 100644 index 0000000..fd9ec99 Binary files /dev/null and "b/conversi\303\263n_simulacro de atol/bin/Debug/conversi\303\263n_simulacro de atol.exe" differ diff --git "a/conversi\303\263n_simulacro de atol/conversi\303\263n_simulacro de atol.cbp" "b/conversi\303\263n_simulacro de atol/conversi\303\263n_simulacro de atol.cbp" new file mode 100644 index 0000000..e421ba0 --- /dev/null +++ "b/conversi\303\263n_simulacro de atol/conversi\303\263n_simulacro de atol.cbp" @@ -0,0 +1,41 @@ + + + + + + diff --git "a/conversi\303\263n_simulacro de atol/conversi\303\263n_simulacro de atol.depend" "b/conversi\303\263n_simulacro de atol/conversi\303\263n_simulacro de atol.depend" new file mode 100644 index 0000000..db179cb --- /dev/null +++ "b/conversi\303\263n_simulacro de atol/conversi\303\263n_simulacro de atol.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473636973 source:d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atol\functions.c + "header.h" + +1473636978 d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atol\header.h + + + + + +1473636959 source:d:\unlam\programaciÓn\fabian 2\conversión_simulacro de atol\main.c + "header.h" + diff --git "a/conversi\303\263n_simulacro de atol/functions.c" "b/conversi\303\263n_simulacro de atol/functions.c" new file mode 100644 index 0000000..707c57f --- /dev/null +++ "b/conversi\303\263n_simulacro de atol/functions.c" @@ -0,0 +1,28 @@ +#include "header.h" +long int mi_atol(char *s) + { + long int i=0,signo=1; + if(!s) + return 0; + if(!ES_NUMERO(*s)) + { + while(*s==' ') + s++; + if(*s=='-') + { + signo=-1; + s++; + } + else + if(*s=='+') + s++; + } + while(ES_NUMERO(*s)) + { + i*=10; + i+=(*s-'0'); + s++; + } + return i*signo; + } + diff --git "a/conversi\303\263n_simulacro de atol/header.h" "b/conversi\303\263n_simulacro de atol/header.h" new file mode 100644 index 0000000..efbac93 --- /dev/null +++ "b/conversi\303\263n_simulacro de atol/header.h" @@ -0,0 +1,8 @@ +#include +#include +#include +#include +#define TOPE 50 +#define ES_NUMERO(x) ((x)>='0'&&(x)<='9') +long int mi_atol(char*); + diff --git "a/conversi\303\263n_simulacro de atol/main.c" "b/conversi\303\263n_simulacro de atol/main.c" new file mode 100644 index 0000000..649eb9c --- /dev/null +++ "b/conversi\303\263n_simulacro de atol/main.c" @@ -0,0 +1,14 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[TOPE]; + printf("\n\n ATOL \n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + fflush(stdin); + gets(cadena); + printf("\n\n Cadena convertida a entero largo: \t %ld \n\n",mi_atol(cadena)); + getch(); + return 0; + } + diff --git "a/conversi\303\263n_simulacro de atol/obj/Debug/functions.o" "b/conversi\303\263n_simulacro de atol/obj/Debug/functions.o" new file mode 100644 index 0000000..bf313ed Binary files /dev/null and "b/conversi\303\263n_simulacro de atol/obj/Debug/functions.o" differ diff --git "a/conversi\303\263n_simulacro de atol/obj/Debug/main.o" "b/conversi\303\263n_simulacro de atol/obj/Debug/main.o" new file mode 100644 index 0000000..74a246f Binary files /dev/null and "b/conversi\303\263n_simulacro de atol/obj/Debug/main.o" differ diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/bin/Debug/convertir cada caracter de un texto a su caracter inmediato posterior.exe b/convertir cada caracter de un texto a su caracter inmediato posterior/bin/Debug/convertir cada caracter de un texto a su caracter inmediato posterior.exe new file mode 100644 index 0000000..45f8d2d Binary files /dev/null and b/convertir cada caracter de un texto a su caracter inmediato posterior/bin/Debug/convertir cada caracter de un texto a su caracter inmediato posterior.exe differ diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.cbp b/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.cbp new file mode 100644 index 0000000..80341be --- /dev/null +++ b/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.depend b/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.depend new file mode 100644 index 0000000..1c1a8ad --- /dev/null +++ b/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1483212465 source:d:\unlam\programaciÓn\fabian\programas en c\convertir cada caracter de un texto a su caracter inmediato posterior\funciones.c + "header.h" + +1483211441 d:\unlam\programaciÓn\fabian\programas en c\convertir cada caracter de un texto a su caracter inmediato posterior\header.h + + + + + +1483212248 source:d:\unlam\programaciÓn\fabian\programas en c\convertir cada caracter de un texto a su caracter inmediato posterior\main.c + "header.h" + diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.layout b/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.layout new file mode 100644 index 0000000..bdd8c5f --- /dev/null +++ b/convertir cada caracter de un texto a su caracter inmediato posterior/convertir cada caracter de un texto a su caracter inmediato posterior.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/funciones.c b/convertir cada caracter de un texto a su caracter inmediato posterior/funciones.c new file mode 100644 index 0000000..7afde2f --- /dev/null +++ b/convertir cada caracter de un texto a su caracter inmediato posterior/funciones.c @@ -0,0 +1,33 @@ +#include "header.h" + +void ingresar_texto(char texto[]) +{ + int i; + + for(i=0;texto[i-1]!='.'&&i +#include +#include +#include + +#define TAM 1000 + +void ingresar_texto(char texto[]); +void grabar_archivo(char texto[],FILE *archivo); +void mostrar_texto(char texto[]); +void mostrar_texto_convertido(char texto[]); diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/main.c b/convertir cada caracter de un texto a su caracter inmediato posterior/main.c new file mode 100644 index 0000000..c1b7fd7 --- /dev/null +++ b/convertir cada caracter de un texto a su caracter inmediato posterior/main.c @@ -0,0 +1,35 @@ +#include "header.h" + +int main() +{ + char texto[TAM]; + FILE *archivo; + + setlocale(LC_CTYPE,"Spanish"); + + archivo=fopen("texto.txt","wt"); + if(!archivo) + { + printf("\n\n Sin memoria para archivo. Ejecucuión de programa detenida. \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n Convertir cada caracter de un texto a su caracter inmediato posterior: \n"); + + printf("\n Ingrese el texto: \n\n"); + ingresar_texto(texto); + + system("cls"); + + printf("\n Texto ingresado: \n\n"); + mostrar_texto(texto); + + printf("\n Texto convertido: \n\n"); + mostrar_texto_convertido(texto); + + grabar_archivo(texto,archivo); + printf("\n\n Se ha grabado exitosamente el archivo texto.txt \n"); + + getch(); + return 0; +} diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/obj/Debug/funciones.o b/convertir cada caracter de un texto a su caracter inmediato posterior/obj/Debug/funciones.o new file mode 100644 index 0000000..82698b2 Binary files /dev/null and b/convertir cada caracter de un texto a su caracter inmediato posterior/obj/Debug/funciones.o differ diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/obj/Debug/main.o b/convertir cada caracter de un texto a su caracter inmediato posterior/obj/Debug/main.o new file mode 100644 index 0000000..504ea41 Binary files /dev/null and b/convertir cada caracter de un texto a su caracter inmediato posterior/obj/Debug/main.o differ diff --git a/convertir cada caracter de un texto a su caracter inmediato posterior/texto.txt b/convertir cada caracter de un texto a su caracter inmediato posterior/texto.txt new file mode 100644 index 0000000..a097ec1 --- /dev/null +++ b/convertir cada caracter de un texto a su caracter inmediato posterior/texto.txt @@ -0,0 +1 @@ +este es un archivo de prueba \ No newline at end of file diff --git a/craps_juego de azar/bin/Debug/craps_juego de azar.exe b/craps_juego de azar/bin/Debug/craps_juego de azar.exe new file mode 100644 index 0000000..a1da5b6 Binary files /dev/null and b/craps_juego de azar/bin/Debug/craps_juego de azar.exe differ diff --git a/craps_juego de azar/craps_juego de azar.cbp b/craps_juego de azar/craps_juego de azar.cbp new file mode 100644 index 0000000..490999a --- /dev/null +++ b/craps_juego de azar/craps_juego de azar.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/craps_juego de azar/craps_juego de azar.depend b/craps_juego de azar/craps_juego de azar.depend new file mode 100644 index 0000000..9017366 --- /dev/null +++ b/craps_juego de azar/craps_juego de azar.depend @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1482711822 source:d:\unlam\programaciÓn\fabian\craps_juego de azar\main.c + + + + diff --git a/craps_juego de azar/craps_juego de azar.layout b/craps_juego de azar/craps_juego de azar.layout new file mode 100644 index 0000000..bbbaadb --- /dev/null +++ b/craps_juego de azar/craps_juego de azar.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/craps_juego de azar/main.c b/craps_juego de azar/main.c new file mode 100644 index 0000000..42b87af --- /dev/null +++ b/craps_juego de azar/main.c @@ -0,0 +1,122 @@ +/* Craps */ + +/* +Uno de los juegos de azar más populares es el juego de dados conocido como “craps”, el cual se juega en casinos +y patios traseros alrededor del mundo. Las reglas del juego son simples. + +El jugador tira dos dados. Cada dado tiene seis caras. Estas caras contienen 1, 2, 3, 4, 5 y 6 puntos. Una vez que +los dados caen, se calcula la suma de los puntos que se encuentran en las caras que ven hacia arriba. + +Si la suma es igual a 7 u 11 en el primer tiro, el jugador gana. + +Si la suma es 2, 3 o 12 en el primer tiro (llamado “craps”),el jugador pierde (es decir, la “casa” gana). + +Si la suma es 4, 5, 6, 8, 9, o 10 en el primer tiro, entonces la suma se convierte en el “punto” del jugador. + +Para ganar, usted debe continuar tirando los dados hasta que “haga su +punto”. El jugador pierde si tira un 7 antes de hacer su punto. +*/ + +#include +#include +#include /* contiene el prototipo de la función time, quien retorna la hora indicada por el reloj del sistema, en segundos*/ + +/* constantes de enumeración que representan el estado del juego */ +enum Estatus { CONTINUA, GANA, PIERDE }; + +int tiraDados( void ); /* prototipo de la función para tirar los dados */ + +/* la función main comienza la ejecución del programa */ +int main() +{ + int suma; /* suma del tiro de dados */ + int miPunto; /* punto ganado */ + + enum Estatus estatusJuego; /* puede contener CONTINUA, GANA o PIERDE */ + + printf("\n\n CRAPS \n\n"); + + /* randomiza el generador de números aleatorios mediante la función time, asignando como semilla a la hora del sistema, en segundos*/ + srand( time( NULL ) ); + + suma = tiraDados(); /* primer tiro de los dados */ + + /* determina el estado del juego basado en la suma de los dados */ + switch( suma ) + { + + /* gana en el primer tiro */ + case 7: + case 11: + estatusJuego = GANA; + break; + + /* pierde en el primer tiro */ + case 2: + case 3: + case 12: + estatusJuego = PIERDE; + break; + + /* recuerda el punto */ + default: + estatusJuego = CONTINUA; + miPunto = suma; + printf( "Su punto es %d\n", miPunto ); + break; /* opcional */ + + } /* fin de switch */ + + /* mientras el juego no se complete */ + while ( estatusJuego == CONTINUA ) + { + suma = tiraDados(); /* tira de nuevo los dados */ + + /* determina el estatus del juego */ + if ( suma == miPunto ) /* gana por punto */ + { + estatusJuego = GANA; /* fin del juego, el jugador gana */ + } /* fin de if */ + else + { + if ( suma == 7 ) /* pierde al tirar 7 */ + { + estatusJuego = PIERDE; /* termina el juego, el jugador pierde */ + } /* fin de if */ + + } /* fin de else */ + + } /* fin de while */ + + /* despliega mensaje de triunfo o derrota */ + if ( estatusJuego == GANA ) /* ¿Ganó el jugador? */ + { + printf( "El jugador gana \n" ); + } /* fin de if */ + else /* el jugador pierde */ + { + printf( "El jugador pierde\n" ); + } /* fin de else */ + + return 0; /* indica terminación exitosa */ + +} /* fin de main */ + +/* tiro de dados, calcula la suma y despliega los resultados */ +int tiraDados( void ) +{ + int dado1; /* primer dado */ + int dado2; /* segundo dado */ + int sumaTemp; /* suma de los dados */ + + dado1 = 1 + ( rand() % 6 ); /* toma el aleatorio para el dado1 */ + dado2 = 1 + ( rand() % 6 ); /* toma el aleatorio para el dado2 */ + + sumaTemp = dado1 + dado2; /* suma el dado1 y el dado2 */ + + /* despliega los resultados de este tiro */ + printf( "El jugador tiro %d + %d = %d\n", dado1, dado2, sumaTemp ); + + return sumaTemp; /* devuelve la suma de los dados */ + +} /* fin de la función tiraDados */ diff --git a/craps_juego de azar/obj/Debug/main.o b/craps_juego de azar/obj/Debug/main.o new file mode 100644 index 0000000..91da85b Binary files /dev/null and b/craps_juego de azar/obj/Debug/main.o differ diff --git "a/c\303\263digo ascii/bin/Debug/c\303\263digo ascii.exe" "b/c\303\263digo ascii/bin/Debug/c\303\263digo ascii.exe" new file mode 100644 index 0000000..cfa7d74 Binary files /dev/null and "b/c\303\263digo ascii/bin/Debug/c\303\263digo ascii.exe" differ diff --git "a/c\303\263digo ascii/c\303\263digo ascii.cbp" "b/c\303\263digo ascii/c\303\263digo ascii.cbp" new file mode 100644 index 0000000..e920bf9 --- /dev/null +++ "b/c\303\263digo ascii/c\303\263digo ascii.cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/c\303\263digo ascii/c\303\263digo ascii.depend" "b/c\303\263digo ascii/c\303\263digo ascii.depend" new file mode 100644 index 0000000..e8d2fbd --- /dev/null +++ "b/c\303\263digo ascii/c\303\263digo ascii.depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1471469241 source:d:\unlam\programaciÓn\fabian 2da cursada\código ascii\main.c + + + + diff --git "a/c\303\263digo ascii/c\303\263digo ascii.layout" "b/c\303\263digo ascii/c\303\263digo ascii.layout" new file mode 100644 index 0000000..eddc820 --- /dev/null +++ "b/c\303\263digo ascii/c\303\263digo ascii.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/c\303\263digo ascii/main.c" "b/c\303\263digo ascii/main.c" new file mode 100644 index 0000000..1868e18 --- /dev/null +++ "b/c\303\263digo ascii/main.c" @@ -0,0 +1,26 @@ +#include +#include +#include +void main() + { + setlocale(LC_CTYPE,"Spanish"); + int i; + printf("\n\t\t\t ****************\n"); + printf(" \t\t\t * CÓDIGO ASCII *\n"); + printf(" \t\t\t ****************\n"); + /* para ver el código ascii muestro los números desde el cero hasta el 255, + con las máscaras de enteros y de char para ver el nu´mero y el caracter */ + printf("\n\t\t\t CARACTERES DE CONTROL\n");//desde el cerp hasta el 31 + for(i=0;i<=9;i++) + printf("\n\t\t Código Ascii:\t %d _____ Caracter: %c \n",i,i); + printf("\n \t\t Código Ascii:\t %d _____ Caracter: %c",10,10);//separo el número 10 porque había un error + for(i=11;i<=31;i++) + printf("\n\t\t Código Ascii:\t %d _____ Caracter: %c \n",i,i); + printf("\n\t\t\t CARACTERES IMPRIMIBLES\n");//desde el 32 hasta el 127 + for(i=32;i<=127;i+=2) + printf("\n Código Ascii:\t %d _____ Caracter: %c \t Código Ascii:\t %d _____ Caracter: %c \n",i,i,i+1,i+1); + printf("\n\t\t CARACTERES IMPRIMIBLES EXTENDIDO\n");//desde el 128 hasta el 255 + for(i=128;i<=255;i+=2) + printf("\n Código Ascii:\t %d _____ Caracter: %c \t Código Ascii:\t %d _____ Caracter: %c \n",i,i,i+1,i+1); + getch(); + } diff --git "a/c\303\263digo ascii/obj/Debug/main.o" "b/c\303\263digo ascii/obj/Debug/main.o" new file mode 100644 index 0000000..093dbc6 Binary files /dev/null and "b/c\303\263digo ascii/obj/Debug/main.o" differ diff --git "a/depurando el programa del m\303\241ximo/bin/Debug/depurando el programa del m\303\241ximo.exe" "b/depurando el programa del m\303\241ximo/bin/Debug/depurando el programa del m\303\241ximo.exe" new file mode 100644 index 0000000..136dc09 Binary files /dev/null and "b/depurando el programa del m\303\241ximo/bin/Debug/depurando el programa del m\303\241ximo.exe" differ diff --git "a/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.cbp" "b/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.cbp" new file mode 100644 index 0000000..cb7bea9 --- /dev/null +++ "b/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.cbp" @@ -0,0 +1,42 @@ + + + + + + diff --git "a/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.depend" "b/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.depend" new file mode 100644 index 0000000..37f3eaf --- /dev/null +++ "b/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1482698396 source:d:\unlam\programaciÓn\fabian\depurando el programa del máximo\main.cpp + + + + diff --git "a/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.layout" "b/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.layout" new file mode 100644 index 0000000..47a4168 --- /dev/null +++ "b/depurando el programa del m\303\241ximo/depurando el programa del m\303\241ximo.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/depurando el programa del m\303\241ximo/main.cpp" "b/depurando el programa del m\303\241ximo/main.cpp" new file mode 100644 index 0000000..a82f0d2 --- /dev/null +++ "b/depurando el programa del m\303\241ximo/main.cpp" @@ -0,0 +1,34 @@ +#include +#include +#include + +using namespace std; + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + + cout << endl << endl << "\t\t Máximo" << endl << endl; + + int n,maximo; + + cout << endl << "Ingrese números (finalice con -1):" << endl; + cin >> n; + + maximo=n; + + while(n!=-1) + { + if(n>maximo) + maximo=n; + + cin >> n; + } + + cout << endl << "Máximo: \t" << maximo << endl; + + cout << endl << endl << "\t\t\t\t\t Fin del programa \a" << endl << endl; + + getch(); + return 0; +} diff --git "a/depurando el programa del m\303\241ximo/obj/Debug/main.o" "b/depurando el programa del m\303\241ximo/obj/Debug/main.o" new file mode 100644 index 0000000..4c3d06c Binary files /dev/null and "b/depurando el programa del m\303\241ximo/obj/Debug/main.o" differ diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/bin/Debug/direcci\303\263n de memoria de un elemento dentro de un array.exe" "b/direcci\303\263n de memoria de un elemento dentro de un array/bin/Debug/direcci\303\263n de memoria de un elemento dentro de un array.exe" new file mode 100644 index 0000000..51803fa Binary files /dev/null and "b/direcci\303\263n de memoria de un elemento dentro de un array/bin/Debug/direcci\303\263n de memoria de un elemento dentro de un array.exe" differ diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.cbp" "b/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.cbp" new file mode 100644 index 0000000..63101b2 --- /dev/null +++ "b/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.depend" "b/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.depend" new file mode 100644 index 0000000..b14f11b --- /dev/null +++ "b/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473621933 source:d:\unlam\programaciÓn\fabian 2\dirección de memoria de un elemento dentro de un array\functions.c + "header.h" + +1473621690 d:\unlam\programaciÓn\fabian 2\dirección de memoria de un elemento dentro de un array\header.h + + + + +1473622261 source:d:\unlam\programaciÓn\fabian 2\dirección de memoria de un elemento dentro de un array\main.c + "header.h" + diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.layout" "b/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.layout" new file mode 100644 index 0000000..c4052b0 --- /dev/null +++ "b/direcci\303\263n de memoria de un elemento dentro de un array/direcci\303\263n de memoria de un elemento dentro de un array.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/functions.c" "b/direcci\303\263n de memoria de un elemento dentro de un array/functions.c" new file mode 100644 index 0000000..08d1813 --- /dev/null +++ "b/direcci\303\263n de memoria de un elemento dentro de un array/functions.c" @@ -0,0 +1,31 @@ +#include "header.h" +void cargar_array(int *v,int ce) + { + int i; + for(i=1;i<=ce;i++) + { + printf("\n Ingrese el elemento número %d del array: \t",i); + scanf("%d",v); + v++; + } + } +void mostrar_array(int *v,int ce) + { + int *fin=v+ce; + while(v +#include +#include +#define TOPE 10 +void cargar_array(int*,int); +void mostrar_array(int*,int); +int *buscar_direccion(int*,int,int); diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/main.c" "b/direcci\303\263n de memoria de un elemento dentro de un array/main.c" new file mode 100644 index 0000000..a3c6315 --- /dev/null +++ "b/direcci\303\263n de memoria de un elemento dentro de un array/main.c" @@ -0,0 +1,29 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int v[TOPE],n,op,*dir; + printf("\n\n DIRECCIÓN DE MEMORIA DE UN ELEMENTO DENTRO DE UN ARRAY \n"); + printf("\n Se le solicita que cargue un array de enteros, con %d posiciones \n\n",TOPE); + cargar_array(v,TOPE); + printf("\n\n El array fue cargado correctamente \n\n"); + printf("\n\n Sus elementos son: \n"); + mostrar_array(v,TOPE); + printf("\n\n BUSCAR ELEMENTO \n"); + do + { + printf("\n Ingrese un entero para buscar su dirección de memoria dentro del array: \n\n\t\t"); + scanf("%d",&n); + dir=buscar_direccion(v,TOPE,n); + if(dir!=NULL) + printf("\n Dirección de memoria: \t %p",dir); + else + printf("\n El elemento buscado no se encuentra en el array \n\n\a\a"); + printf("\n\n Para realizar una nueva búsqueda presione 1 \n Caso contrario, presione cualquier tecla: \t"); + scanf("%d",&op); + } + while(op==1); + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/obj/Debug/functions.o" "b/direcci\303\263n de memoria de un elemento dentro de un array/obj/Debug/functions.o" new file mode 100644 index 0000000..cefb277 Binary files /dev/null and "b/direcci\303\263n de memoria de un elemento dentro de un array/obj/Debug/functions.o" differ diff --git "a/direcci\303\263n de memoria de un elemento dentro de un array/obj/Debug/main.o" "b/direcci\303\263n de memoria de un elemento dentro de un array/obj/Debug/main.o" new file mode 100644 index 0000000..fb338e6 Binary files /dev/null and "b/direcci\303\263n de memoria de un elemento dentro de un array/obj/Debug/main.o" differ diff --git "a/enumeraci\303\263n_conjunto de identificadores/bin/Debug/enumeraci\303\263n_conjunto de identificadores.exe" "b/enumeraci\303\263n_conjunto de identificadores/bin/Debug/enumeraci\303\263n_conjunto de identificadores.exe" new file mode 100644 index 0000000..fbd1e57 Binary files /dev/null and "b/enumeraci\303\263n_conjunto de identificadores/bin/Debug/enumeraci\303\263n_conjunto de identificadores.exe" differ diff --git "a/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.cbp" "b/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.cbp" new file mode 100644 index 0000000..9ed6770 --- /dev/null +++ "b/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.depend" "b/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.depend" new file mode 100644 index 0000000..1948183 --- /dev/null +++ "b/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1482792292 source:d:\unlam\programaciÓn\fabian\enumeración_conjunto de identificadores\main.c + + + + diff --git "a/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.layout" "b/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.layout" new file mode 100644 index 0000000..61a1253 --- /dev/null +++ "b/enumeraci\303\263n_conjunto de identificadores/enumeraci\303\263n_conjunto de identificadores.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/enumeraci\303\263n_conjunto de identificadores/main.c" "b/enumeraci\303\263n_conjunto de identificadores/main.c" new file mode 100644 index 0000000..30e808e --- /dev/null +++ "b/enumeraci\303\263n_conjunto de identificadores/main.c" @@ -0,0 +1,39 @@ +#include +#include +#include + +int main() +{ + enum estados{NADA,PUNTO,LINEA,TRIANGULO,CUADRADO,PENTAGONO}; + // la enumeración asigna a un conjunto de identificadores constantes, valores comenzando por el 0 e incrementándose en 1 + + srand(time(NULL)); + + switch(rand()%6) + { + case NADA: + puts("NADA"); + break; + + case PUNTO: + puts("PUNTO"); + break; + + case LINEA: + puts("LINEA"); + break; + + case TRIANGULO: + puts("TRIANGULO"); + break; + + case CUADRADO: + puts("CUADRADO"); + break; + + case PENTAGONO: + puts("PENTAGONO"); + break; + } + return 0; +} diff --git "a/enumeraci\303\263n_conjunto de identificadores/obj/Debug/main.o" "b/enumeraci\303\263n_conjunto de identificadores/obj/Debug/main.o" new file mode 100644 index 0000000..8cfd1cd Binary files /dev/null and "b/enumeraci\303\263n_conjunto de identificadores/obj/Debug/main.o" differ diff --git a/estudiantes y empleados/bin/Debug/estudiantes y empleados.exe b/estudiantes y empleados/bin/Debug/estudiantes y empleados.exe new file mode 100644 index 0000000..5773d0d Binary files /dev/null and b/estudiantes y empleados/bin/Debug/estudiantes y empleados.exe differ diff --git a/estudiantes y empleados/empleados.bin b/estudiantes y empleados/empleados.bin new file mode 100644 index 0000000..d299229 Binary files /dev/null and b/estudiantes y empleados/empleados.bin differ diff --git a/estudiantes y empleados/estudiantes y empleados.cbp b/estudiantes y empleados/estudiantes y empleados.cbp new file mode 100644 index 0000000..0cbc99d --- /dev/null +++ b/estudiantes y empleados/estudiantes y empleados.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/estudiantes y empleados/estudiantes y empleados.depend b/estudiantes y empleados/estudiantes y empleados.depend new file mode 100644 index 0000000..b3d8d14 --- /dev/null +++ b/estudiantes y empleados/estudiantes y empleados.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474158159 source:d:\unlam\programaciÓn\fabian 2\estudiantes y empleados\functions.c + "header.h" + +1474158698 d:\unlam\programaciÓn\fabian 2\estudiantes y empleados\header.h + + + + + +1473972870 source:d:\unlam\programaciÓn\fabian 2\estudiantes y empleados\main.c + "header.h" + diff --git a/estudiantes y empleados/estudiantes y empleados.layout b/estudiantes y empleados/estudiantes y empleados.layout new file mode 100644 index 0000000..b6e282a --- /dev/null +++ b/estudiantes y empleados/estudiantes y empleados.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/estudiantes y empleados/estudiantes.bin b/estudiantes y empleados/estudiantes.bin new file mode 100644 index 0000000..b26921d Binary files /dev/null and b/estudiantes y empleados/estudiantes.bin differ diff --git a/estudiantes y empleados/functions.c b/estudiantes y empleados/functions.c new file mode 100644 index 0000000..120e8a3 --- /dev/null +++ b/estudiantes y empleados/functions.c @@ -0,0 +1,112 @@ +#include "header.h" + +int abrir_archivo(FILE **pf,const char *ruta,const char *modo_tipo,int mensaje) + { + *pf=fopen(ruta,modo_tipo); + if(!*pf) + if(mensaje) + { + printf("\n\n No se pudo abrir el archivo %s con el modo_tipo %s \n\n\a\a",ruta,modo_tipo); + return FALSO; + } + return VERDADERO; + } + +void mostrar_archivo_empleados(FILE *pf) + { + t_empleados registro; + rewind(pf); + fread(®istro,sizeof(t_empleados),1,pf); + while(!feof(pf)) + { + printf("\n\n DNI: \t\t %d \n Apellido: \t %s \n Nombre: \t %s \n Sueldo: \t %.2lf",registro.dni,registro.apellido,registro.nombre,registro.sueldo); + fread(®istro,sizeof(t_empleados),1,pf); + } + } + +void mostrar_archivo_estudiantes(FILE *pf) + { + t_estudiantes registro; + rewind(pf); + fread(®istro,sizeof(t_estudiantes),1,pf); + while(!feof(pf)) + { + printf("\n\n DNI: \t\t %d \n Apellido: \t %s \n Nombre: \t %s \n Promedio: \t %.2f",registro.dni,registro.apellido,registro.nombre,registro.promedio); + fread(®istro,sizeof(t_estudiantes),1,pf); + } + } + +void modificar_archivo_empleados(FILE *pf_empleados,FILE *pf_estudiantes) + { + int comparador; + + t_empleados empleado; + t_estudiantes estudiante; + + rewind(pf_empleados); + rewind(pf_estudiantes); + + fread(&empleado,sizeof(t_empleados),1,pf_empleados); + fread(&estudiante,sizeof(t_estudiantes),1,pf_estudiantes); + + while(!feof(pf_empleados)&&!feof(pf_estudiantes)) + { + if(estudiante.promedio<=7) + { + fread(&estudiante,sizeof(t_estudiantes),1,pf_estudiantes); + continue; + } + + comparador=comparacion_de_registros(&empleado,&estudiante); + + if(comparador<0) + { + fread(&empleado,sizeof(t_empleados),1,pf_empleados); + continue; + } + else + if(comparador>0) + { + fread(&estudiante,sizeof(t_estudiantes),1,pf_estudiantes); + continue; + } + else + { + empleado.sueldo+=empleado.sueldo*0.0728; + fseek(pf_empleados,-sizeof(t_empleados),SEEK_CUR); + fwrite(&empleado,sizeof(t_empleados),1,pf_empleados); + fseek(pf_empleados,0L,SEEK_CUR); + } + + fread(&empleado,sizeof(t_empleados),1,pf_empleados); + fread(&estudiante,sizeof(t_estudiantes),1,pf_estudiantes); + } + } + +int comparacion_de_registros(t_empleados *empleado,t_estudiantes *estudiante) + { + int comparador; + if((comparador=str_cmp(empleado->apellido,estudiante->apellido))==0) + if((comparador=str_cmp(empleado->nombre,estudiante->nombre))==0) + if(empleado->dni==estudiante->dni) + return IGUAL; + else + if(empleado->dni>estudiante->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } diff --git a/estudiantes y empleados/header.h b/estudiantes y empleados/header.h new file mode 100644 index 0000000..0e031da --- /dev/null +++ b/estudiantes y empleados/header.h @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +#define SIN_MENSAJE 0 +#define CON_MENSAJE 1 + +#define VERDADERO 1 +#define FALSO 0 + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[20]; + char nombre[30]; + double sueldo; + }t_empleados; + +typedef struct + { + int dni; + char apellido[20]; + char nombre[30]; + float promedio; + }t_estudiantes; + +int abrir_archivo(FILE**,const char*,const char*,int); +void mostrar_archivo_empleados(FILE*); +void mostrar_archivo_estudiantes(FILE*); +void modificar_archivo_empleados(FILE*,FILE*); +int comparacion_de_registros(t_empleados*,t_estudiantes*); +int str_cmp(const char*,const char*); diff --git a/estudiantes y empleados/main.c b/estudiantes y empleados/main.c new file mode 100644 index 0000000..17035f5 --- /dev/null +++ b/estudiantes y empleados/main.c @@ -0,0 +1,85 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 4E"); + + printf("\n\t\t ***************************"); + printf("\n\t\t * ESTUDIANTES Y EMPLEADOS *"); + printf("\n\t\t ***************************\n\n"); + + FILE *pf_empleados,*pf_estudiantes; + + t_empleados empleados[9]={ {11111111,"Anchorena","Fernando",12999.99}, + {22222222,"Barreda","Armando",1999.99}, + {33333333,"Dorrego","Gonzalo",27999.99}, + {44444444,"Fernández","Jimena",13999.99}, + {55555555,"Higuita","Fulano",5999.99}, + {66666666,"Lorenzetti","Mariana",22999.99}, + {77777777,"Nicoletti","Paula",11999.99}, + {83648466,"Pereyra","Teodoro",2999.99}, + {99999999,"Torrente","Ramiro",17999.99} }; + + t_estudiantes estudiantes[9]={ {11111110,"Aguirre","Pancracio",4.26}, + {11111111,"Anchorena","Fernando",7.98}, + {33333333,"Dorrego","Gonzalo",7.37}, + {44444444,"Fernández","Jimena",7.29}, + {58468488,"Gladiolo","Narciso",9.87}, + {66666666,"Lorenzetti","Mariana",7.25}, + {77777777,"Nicoletti","Paula",8.26}, + {88888888,"Quijano","Alfonso",2.23}, + {99999999,"Torrente","Ramiro",6.77} }; + + abrir_archivo(&pf_empleados,"empleados.bin","wb",CON_MENSAJE); + abrir_archivo(&pf_estudiantes,"estudiantes.bin","wb",CON_MENSAJE); + + fwrite(&empleados,sizeof(t_empleados),9,pf_empleados); + fwrite(&estudiantes,sizeof(t_estudiantes),9,pf_estudiantes); + + fclose(pf_empleados); + fclose(pf_estudiantes); + + printf("\n\n Se ha generado un lote de datos \n\n --->>> archivos binarios \"empleados.bin\" y \"estudiantes.bin\" \n"); + getch(); + + system("cls"); + + printf("\n\t\t ***************************"); + printf("\n\t\t * ESTUDIANTES Y EMPLEADOS *"); + printf("\n\t\t ***************************"); + + if(!abrir_archivo(&pf_empleados,"empleados.bin","r+b",CON_MENSAJE)) + { + printf("\n\n Programa evacuado \n"); + exit(EXIT_FAILURE); + } + if(!abrir_archivo(&pf_estudiantes,"estudiantes.bin","rb",CON_MENSAJE)) + { + fclose(pf_empleados); + printf("\n\n Programa evacuado \n"); + exit(EXIT_FAILURE); + } + + printf("\n\n En este programa se actualizarán los sueldos de los empleados"); + printf("\n que sean estudiantes y tengan un promedio superior a 7,"); + printf("\n otorgándoles un aumento del 7.28%c \n",37); + getch(); + + printf("\n\n\n ARCHIVO DE ESTUDIANTES \n"); + mostrar_archivo_estudiantes(pf_estudiantes); + getch(); + + printf("\n\n\n ARCHIVO DE EMPLEADOS ANTES DE LA MODIFICACIÓN \n"); + mostrar_archivo_empleados(pf_empleados); + getch(); + + modificar_archivo_empleados(pf_empleados,pf_estudiantes); + + printf("\n\n\n ARCHIVO DE EMPLEADOS DESPUÉS DE LA MODIFICACIÓN \n"); + mostrar_archivo_empleados(pf_empleados); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + return 0; + } diff --git a/estudiantes y empleados/obj/Debug/functions.o b/estudiantes y empleados/obj/Debug/functions.o new file mode 100644 index 0000000..c9cdecd Binary files /dev/null and b/estudiantes y empleados/obj/Debug/functions.o differ diff --git a/estudiantes y empleados/obj/Debug/main.o b/estudiantes y empleados/obj/Debug/main.o new file mode 100644 index 0000000..36f3ed7 Binary files /dev/null and b/estudiantes y empleados/obj/Debug/main.o differ diff --git a/factorial recursiva/bin/Debug/factorial recursiva.exe b/factorial recursiva/bin/Debug/factorial recursiva.exe new file mode 100644 index 0000000..2258019 Binary files /dev/null and b/factorial recursiva/bin/Debug/factorial recursiva.exe differ diff --git a/factorial recursiva/encabezados.h b/factorial recursiva/encabezados.h new file mode 100644 index 0000000..90c209d --- /dev/null +++ b/factorial recursiva/encabezados.h @@ -0,0 +1,4 @@ +#include +#include +#include +int factorial(int); diff --git a/factorial recursiva/factorial recursiva.cbp b/factorial recursiva/factorial recursiva.cbp new file mode 100644 index 0000000..c419b70 --- /dev/null +++ b/factorial recursiva/factorial recursiva.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/factorial recursiva/factorial recursiva.depend b/factorial recursiva/factorial recursiva.depend new file mode 100644 index 0000000..820bd01 --- /dev/null +++ b/factorial recursiva/factorial recursiva.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471479069 source:d:\unlam\programaciÓn\fabian 2da\factorial recursiva\funciones.c + "encabezados.h" + +1471478313 d:\unlam\programaciÓn\fabian 2da\factorial recursiva\encabezados.h + + + + +1471478963 source:d:\unlam\programaciÓn\fabian 2da\factorial recursiva\main.c + "encabezados.h" + diff --git a/factorial recursiva/factorial recursiva.layout b/factorial recursiva/factorial recursiva.layout new file mode 100644 index 0000000..4a3b052 --- /dev/null +++ b/factorial recursiva/factorial recursiva.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/factorial recursiva/funciones.c b/factorial recursiva/funciones.c new file mode 100644 index 0000000..976869f --- /dev/null +++ b/factorial recursiva/funciones.c @@ -0,0 +1,8 @@ +#include "encabezados.h" +int factorial(int n) + { + if(n<=1) + return 1; + else + return n*factorial(n-1);//aplico la propiedad del factorial hasta llegar al 1 + } diff --git a/factorial recursiva/main.c b/factorial recursiva/main.c new file mode 100644 index 0000000..a8b7002 --- /dev/null +++ b/factorial recursiva/main.c @@ -0,0 +1,18 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n,fact; + printf("\n\t\t FACTORIAL \n"); + printf("\n Ingrese un número natural (o cero) para calcular su factorial: \n\n\t\t"); + scanf("%d",&n); + if(n<0) + { + printf("\n No se puede calcular el factorial de un número negativo \n\n"); + exit(0); + } + fact=factorial(n); + printf("\n El factorial de %d es %d \n\n",n,fact); + getch(); + return 0; + } diff --git a/factorial recursiva/obj/Debug/funciones.o b/factorial recursiva/obj/Debug/funciones.o new file mode 100644 index 0000000..49b169c Binary files /dev/null and b/factorial recursiva/obj/Debug/funciones.o differ diff --git a/factorial recursiva/obj/Debug/main.o b/factorial recursiva/obj/Debug/main.o new file mode 100644 index 0000000..e13aebb Binary files /dev/null and b/factorial recursiva/obj/Debug/main.o differ diff --git a/factorial/bin/Debug/factorial.exe b/factorial/bin/Debug/factorial.exe new file mode 100644 index 0000000..7483d6b Binary files /dev/null and b/factorial/bin/Debug/factorial.exe differ diff --git a/factorial/encabezados.h b/factorial/encabezados.h new file mode 100644 index 0000000..90c209d --- /dev/null +++ b/factorial/encabezados.h @@ -0,0 +1,4 @@ +#include +#include +#include +int factorial(int); diff --git a/factorial/factorial.cbp b/factorial/factorial.cbp new file mode 100644 index 0000000..43f6ec7 --- /dev/null +++ b/factorial/factorial.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/factorial/factorial.depend b/factorial/factorial.depend new file mode 100644 index 0000000..4b398eb --- /dev/null +++ b/factorial/factorial.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471477762 source:d:\unlam\programaciÓn\fabian 2da\factorial\funciones.c + "encabezados.h" + +1471479309 d:\unlam\programaciÓn\fabian 2da\factorial\encabezados.h + + + + +1471479359 source:d:\unlam\programaciÓn\fabian 2da\factorial\main.c + "encabezados.h" + diff --git a/factorial/factorial.layout b/factorial/factorial.layout new file mode 100644 index 0000000..0e1e934 --- /dev/null +++ b/factorial/factorial.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/factorial/funciones.c b/factorial/funciones.c new file mode 100644 index 0000000..ae00daf --- /dev/null +++ b/factorial/funciones.c @@ -0,0 +1,9 @@ +#include "encabezados.h" +int factorial(int n) + { + int f,i; + f=1; + for(i=1;i<=n;i++) + f*=i;//multiplico a 1 por los sucesivos números hasta el del que busco el factorial x la expansión del factorial + return f; + } diff --git a/factorial/main.c b/factorial/main.c new file mode 100644 index 0000000..a8b7002 --- /dev/null +++ b/factorial/main.c @@ -0,0 +1,18 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n,fact; + printf("\n\t\t FACTORIAL \n"); + printf("\n Ingrese un número natural (o cero) para calcular su factorial: \n\n\t\t"); + scanf("%d",&n); + if(n<0) + { + printf("\n No se puede calcular el factorial de un número negativo \n\n"); + exit(0); + } + fact=factorial(n); + printf("\n El factorial de %d es %d \n\n",n,fact); + getch(); + return 0; + } diff --git a/factorial/obj/Debug/funciones.o b/factorial/obj/Debug/funciones.o new file mode 100644 index 0000000..879dabd Binary files /dev/null and b/factorial/obj/Debug/funciones.o differ diff --git a/factorial/obj/Debug/main.o b/factorial/obj/Debug/main.o new file mode 100644 index 0000000..a07fb74 Binary files /dev/null and b/factorial/obj/Debug/main.o differ diff --git a/fechas_calcular edad/bin/Debug/fechas_calcular edad.exe b/fechas_calcular edad/bin/Debug/fechas_calcular edad.exe new file mode 100644 index 0000000..4bfaaa4 Binary files /dev/null and b/fechas_calcular edad/bin/Debug/fechas_calcular edad.exe differ diff --git a/fechas_calcular edad/fechas_calcular edad.cbp b/fechas_calcular edad/fechas_calcular edad.cbp new file mode 100644 index 0000000..c7689ae --- /dev/null +++ b/fechas_calcular edad/fechas_calcular edad.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/fechas_calcular edad/fechas_calcular edad.depend b/fechas_calcular edad/fechas_calcular edad.depend new file mode 100644 index 0000000..ed033f6 --- /dev/null +++ b/fechas_calcular edad/fechas_calcular edad.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471751236 source:d:\unlam\programaciÓn\fabian 2da\fechas_calcular edad\funciones.c + "header.h" + +1471751242 d:\unlam\programaciÓn\fabian 2da\fechas_calcular edad\header.h + + + + +1471752479 source:d:\unlam\programaciÓn\fabian 2da\fechas_calcular edad\main.c + "header.h" + diff --git a/fechas_calcular edad/fechas_calcular edad.layout b/fechas_calcular edad/fechas_calcular edad.layout new file mode 100644 index 0000000..f045ca3 --- /dev/null +++ b/fechas_calcular edad/fechas_calcular edad.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/fechas_calcular edad/funciones.c b/fechas_calcular edad/funciones.c new file mode 100644 index 0000000..aecf02e --- /dev/null +++ b/fechas_calcular edad/funciones.c @@ -0,0 +1,22 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +int calcula_edad(tFecha f_nac,tFecha f_act) + { + int edad; + edad=f_act.anio-f_nac.anio; + if(f_act.mes +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +int calcula_edad(tFecha f_nac,tFecha f_act); diff --git a/fechas_calcular edad/main.c b/fechas_calcular edad/main.c new file mode 100644 index 0000000..1f0727e --- /dev/null +++ b/fechas_calcular edad/main.c @@ -0,0 +1,35 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f_nac,f_act; + int band; + band=0; + printf("\n ***** CALCULAR EDAD ***** \n"); + printf("\n Ingrese la fecha de nacimiento en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f_nac.dia,&f_nac.mes,&f_nac.anio); + band=1; + } + while(!fecha_valida(f_nac)); + band=0; + printf("\n Ingrese la fecha actual en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f_act.dia,&f_act.mes,&f_act.anio); + band=1; + } + while(!fecha_valida(f_act)); + if(f_act.anio>f_nac.anio||(f_act.anio==f_nac.anio&&(f_act.mes>f_nac.mes||(f_act.mes==f_nac.mes&&f_act.dia>=f_nac.dia)))) + printf("\n\t %c Edad: %d \n\n",16,calcula_edad(f_nac,f_act)); + else + printf("\n La fecha actual es inferior a la fecha de nacimiento \n\n"); + getch(); + return 0; + } + diff --git a/fechas_calcular edad/obj/Debug/funciones.o b/fechas_calcular edad/obj/Debug/funciones.o new file mode 100644 index 0000000..947e385 Binary files /dev/null and b/fechas_calcular edad/obj/Debug/funciones.o differ diff --git a/fechas_calcular edad/obj/Debug/main.o b/fechas_calcular edad/obj/Debug/main.o new file mode 100644 index 0000000..92dc5de Binary files /dev/null and b/fechas_calcular edad/obj/Debug/main.o differ diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/bin/Debug/fechas_diferencia de d\303\255as entre dos fechas.exe" "b/fechas_diferencia de d\303\255as entre dos fechas/bin/Debug/fechas_diferencia de d\303\255as entre dos fechas.exe" new file mode 100644 index 0000000..f4daaaa Binary files /dev/null and "b/fechas_diferencia de d\303\255as entre dos fechas/bin/Debug/fechas_diferencia de d\303\255as entre dos fechas.exe" differ diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.cbp" "b/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.cbp" new file mode 100644 index 0000000..8471913 --- /dev/null +++ "b/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.depend" "b/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.depend" new file mode 100644 index 0000000..731b70d --- /dev/null +++ "b/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1471804773 source:d:\unlam\programaciÓn\fabian 2da\fechas_diferencia de días entre dos fechas\funciones.c + "header.h" + +1471801065 d:\unlam\programaciÓn\fabian 2da\fechas_diferencia de días entre dos fechas\header.h + + + + + +1471799377 source:d:\unlam\programaciÓn\fabian 2da\fechas_diferencia de días entre dos fechas\main.c + "header.h" + diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.layout" "b/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.layout" new file mode 100644 index 0000000..57e80c8 --- /dev/null +++ "b/fechas_diferencia de d\303\255as entre dos fechas/fechas_diferencia de d\303\255as entre dos fechas.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/funciones.c" "b/fechas_diferencia de d\303\255as entre dos fechas/funciones.c" new file mode 100644 index 0000000..ff72bbe --- /dev/null +++ "b/fechas_diferencia de d\303\255as entre dos fechas/funciones.c" @@ -0,0 +1,37 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +int julianos(tFecha f) + { + int i,jul; + jul=f.dia; + for(i=1;i +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +int julianos(tFecha); +int diferencia_de_dias(tFecha,tFecha); diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/main.c" "b/fechas_diferencia de d\303\255as entre dos fechas/main.c" new file mode 100644 index 0000000..fdd0b8d --- /dev/null +++ "b/fechas_diferencia de d\303\255as entre dos fechas/main.c" @@ -0,0 +1,46 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f_inf,f_sup; + int band,band2; + band=band2=0; + do + { + if(band2==1) + { + printf("\n Las fechas no fueron ingresadas en el orden correcto. Reingréselas. \n\a\a"); + printf("\n Presione una tecla cualquiera para continuar \n\n"); + getch(); + system("cls"); + band=band2=0; + } + printf("\n ***** DIFERENCIA DE DÍAS ENTRE DOS FECHAS ***** \n"); + printf("\n Ingrese la fecha inferior en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f_inf.dia,&f_inf.mes,&f_inf.anio); + band=1; + } + while(!fecha_valida(f_inf)); + band=0; + printf("\n Ingrese la fecha superior en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f_sup.dia,&f_sup.mes,&f_sup.anio); + band=1; + } + while(!fecha_valida(f_sup)); + band2=1; + } + while(!(f_sup.anio>f_inf.anio||(f_sup.anio==f_inf.anio&&(f_sup.mes>f_inf.mes||(f_sup.mes==f_inf.mes&&f_sup.dia>=f_inf.dia))))); + printf("\n\n La diferencia de días entre éstas fechas es: \t %d \n\n\a\a",diferencia_de_dias(f_inf,f_sup)); + getch(); + return 0; + } + + diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/obj/Debug/funciones.o" "b/fechas_diferencia de d\303\255as entre dos fechas/obj/Debug/funciones.o" new file mode 100644 index 0000000..ee91132 Binary files /dev/null and "b/fechas_diferencia de d\303\255as entre dos fechas/obj/Debug/funciones.o" differ diff --git "a/fechas_diferencia de d\303\255as entre dos fechas/obj/Debug/main.o" "b/fechas_diferencia de d\303\255as entre dos fechas/obj/Debug/main.o" new file mode 100644 index 0000000..f6537fb Binary files /dev/null and "b/fechas_diferencia de d\303\255as entre dos fechas/obj/Debug/main.o" differ diff --git "a/fechas_d\303\255as gregorianos/bin/Debug/fechas_d\303\255as gregorianos.exe" "b/fechas_d\303\255as gregorianos/bin/Debug/fechas_d\303\255as gregorianos.exe" new file mode 100644 index 0000000..9027a71 Binary files /dev/null and "b/fechas_d\303\255as gregorianos/bin/Debug/fechas_d\303\255as gregorianos.exe" differ diff --git "a/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.cbp" "b/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.cbp" new file mode 100644 index 0000000..4afb117 --- /dev/null +++ "b/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.depend" "b/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.depend" new file mode 100644 index 0000000..a4beea7 --- /dev/null +++ "b/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1471805815 source:d:\unlam\programaciÓn\fabian 2da\fechas_días gregorianos\funciones.c + "header.h" + +1471805570 d:\unlam\programaciÓn\fabian 2da\fechas_días gregorianos\header.h + + + + + +1471805970 source:d:\unlam\programaciÓn\fabian 2da\fechas_días gregorianos\main.c + "header.h" + diff --git "a/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.layout" "b/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.layout" new file mode 100644 index 0000000..41b7dcb --- /dev/null +++ "b/fechas_d\303\255as gregorianos/fechas_d\303\255as gregorianos.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/fechas_d\303\255as gregorianos/funciones.c" "b/fechas_d\303\255as gregorianos/funciones.c" new file mode 100644 index 0000000..5458dc7 --- /dev/null +++ "b/fechas_d\303\255as gregorianos/funciones.c" @@ -0,0 +1,41 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +int julianos(tFecha f) + { + int i,jul; + jul=f.dia; + for(i=1;i +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +int julianos(tFecha); +int gregorianos(tFecha); + diff --git "a/fechas_d\303\255as gregorianos/main.c" "b/fechas_d\303\255as gregorianos/main.c" new file mode 100644 index 0000000..9519b4d --- /dev/null +++ "b/fechas_d\303\255as gregorianos/main.c" @@ -0,0 +1,22 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band; + band=0; + printf("\n ***** DÍAS GREGORIANOS ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + printf("\n\t %c Días gregorianos: %d \n\n",16,gregorianos(f)); + getch(); + return 0; + } + diff --git "a/fechas_d\303\255as gregorianos/obj/Debug/funciones.o" "b/fechas_d\303\255as gregorianos/obj/Debug/funciones.o" new file mode 100644 index 0000000..44b8262 Binary files /dev/null and "b/fechas_d\303\255as gregorianos/obj/Debug/funciones.o" differ diff --git "a/fechas_d\303\255as gregorianos/obj/Debug/main.o" "b/fechas_d\303\255as gregorianos/obj/Debug/main.o" new file mode 100644 index 0000000..0b7155d Binary files /dev/null and "b/fechas_d\303\255as gregorianos/obj/Debug/main.o" differ diff --git "a/fechas_d\303\255as julianos/bin/Debug/fechas_d\303\255as julianos.exe" "b/fechas_d\303\255as julianos/bin/Debug/fechas_d\303\255as julianos.exe" new file mode 100644 index 0000000..bf3828d Binary files /dev/null and "b/fechas_d\303\255as julianos/bin/Debug/fechas_d\303\255as julianos.exe" differ diff --git "a/fechas_d\303\255as julianos/fechas_d\303\255as julianos.cbp" "b/fechas_d\303\255as julianos/fechas_d\303\255as julianos.cbp" new file mode 100644 index 0000000..37a2da5 --- /dev/null +++ "b/fechas_d\303\255as julianos/fechas_d\303\255as julianos.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/fechas_d\303\255as julianos/fechas_d\303\255as julianos.depend" "b/fechas_d\303\255as julianos/fechas_d\303\255as julianos.depend" new file mode 100644 index 0000000..6475e40 --- /dev/null +++ "b/fechas_d\303\255as julianos/fechas_d\303\255as julianos.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471749988 source:d:\unlam\programaciÓn\fabian 2da\fechas_días julianos\main.c + "header.h" + +1471749259 d:\unlam\programaciÓn\fabian 2da\fechas_días julianos\header.h + + + + +1471749501 source:d:\unlam\programaciÓn\fabian 2da\fechas_días julianos\funciones.c + "header.h" + diff --git "a/fechas_d\303\255as julianos/fechas_d\303\255as julianos.layout" "b/fechas_d\303\255as julianos/fechas_d\303\255as julianos.layout" new file mode 100644 index 0000000..6918dd2 --- /dev/null +++ "b/fechas_d\303\255as julianos/fechas_d\303\255as julianos.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/fechas_d\303\255as julianos/funciones.c" "b/fechas_d\303\255as julianos/funciones.c" new file mode 100644 index 0000000..12512c2 --- /dev/null +++ "b/fechas_d\303\255as julianos/funciones.c" @@ -0,0 +1,22 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +int julianos(tFecha f) + { + int i,jul; + jul=f.dia; + for(i=1;i +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +int julianos(tFecha); diff --git "a/fechas_d\303\255as julianos/main.c" "b/fechas_d\303\255as julianos/main.c" new file mode 100644 index 0000000..61c8871 --- /dev/null +++ "b/fechas_d\303\255as julianos/main.c" @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band; + band=0; + printf("\n ***** DÍAS JULIANOS ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + printf("\n\t %c Días julianos: %d \n\n",16,julianos(f)); + getch(); + return 0; + } + + diff --git "a/fechas_d\303\255as julianos/obj/Debug/funciones.o" "b/fechas_d\303\255as julianos/obj/Debug/funciones.o" new file mode 100644 index 0000000..b196682 Binary files /dev/null and "b/fechas_d\303\255as julianos/obj/Debug/funciones.o" differ diff --git "a/fechas_d\303\255as julianos/obj/Debug/main.o" "b/fechas_d\303\255as julianos/obj/Debug/main.o" new file mode 100644 index 0000000..8c18cbd Binary files /dev/null and "b/fechas_d\303\255as julianos/obj/Debug/main.o" differ diff --git a/fechas_es fecha correcta/bin/Debug/fechas_es fecha correcta.exe b/fechas_es fecha correcta/bin/Debug/fechas_es fecha correcta.exe new file mode 100644 index 0000000..e18e106 Binary files /dev/null and b/fechas_es fecha correcta/bin/Debug/fechas_es fecha correcta.exe differ diff --git a/fechas_es fecha correcta/fechas_es fecha correcta.cbp b/fechas_es fecha correcta/fechas_es fecha correcta.cbp new file mode 100644 index 0000000..b918c9e --- /dev/null +++ b/fechas_es fecha correcta/fechas_es fecha correcta.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/fechas_es fecha correcta/fechas_es fecha correcta.depend b/fechas_es fecha correcta/fechas_es fecha correcta.depend new file mode 100644 index 0000000..26e1b3b --- /dev/null +++ b/fechas_es fecha correcta/fechas_es fecha correcta.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472317974 source:d:\unlam\programaciÓn\fabian 2da\fechas_es fecha correcta\funciones.c + "header.h" + +1471741006 d:\unlam\programaciÓn\fabian 2da\fechas_es fecha correcta\header.h + + + + +1471743627 source:d:\unlam\programaciÓn\fabian 2da\fechas_es fecha correcta\main.c + "header.h" + diff --git a/fechas_es fecha correcta/fechas_es fecha correcta.layout b/fechas_es fecha correcta/fechas_es fecha correcta.layout new file mode 100644 index 0000000..646894d --- /dev/null +++ b/fechas_es fecha correcta/fechas_es fecha correcta.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/fechas_es fecha correcta/funciones.c b/fechas_es fecha correcta/funciones.c new file mode 100644 index 0000000..711e14e --- /dev/null +++ b/fechas_es fecha correcta/funciones.c @@ -0,0 +1,14 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } diff --git a/fechas_es fecha correcta/header.h b/fechas_es fecha correcta/header.h new file mode 100644 index 0000000..192be75 --- /dev/null +++ b/fechas_es fecha correcta/header.h @@ -0,0 +1,12 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); diff --git a/fechas_es fecha correcta/main.c b/fechas_es fecha correcta/main.c new file mode 100644 index 0000000..9ed64e0 --- /dev/null +++ b/fechas_es fecha correcta/main.c @@ -0,0 +1,12 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + printf("\n ***** VALIDACIÓN DE FECHAS ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + printf("\n La fecha %s válida \n",fecha_valida(f)?"es":"no es"); + getch(); + return; + } diff --git a/fechas_es fecha correcta/obj/Debug/funciones.o b/fechas_es fecha correcta/obj/Debug/funciones.o new file mode 100644 index 0000000..a490296 Binary files /dev/null and b/fechas_es fecha correcta/obj/Debug/funciones.o differ diff --git a/fechas_es fecha correcta/obj/Debug/main.o b/fechas_es fecha correcta/obj/Debug/main.o new file mode 100644 index 0000000..6a58e74 Binary files /dev/null and b/fechas_es fecha correcta/obj/Debug/main.o differ diff --git a/fechas_fecha anterior/bin/Debug/fechas_fecha anterior.exe b/fechas_fecha anterior/bin/Debug/fechas_fecha anterior.exe new file mode 100644 index 0000000..aa75dcc Binary files /dev/null and b/fechas_fecha anterior/bin/Debug/fechas_fecha anterior.exe differ diff --git a/fechas_fecha anterior/fechas_fecha anterior.cbp b/fechas_fecha anterior/fechas_fecha anterior.cbp new file mode 100644 index 0000000..53b4af4 --- /dev/null +++ b/fechas_fecha anterior/fechas_fecha anterior.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/fechas_fecha anterior/fechas_fecha anterior.depend b/fechas_fecha anterior/fechas_fecha anterior.depend new file mode 100644 index 0000000..a2c6c8f --- /dev/null +++ b/fechas_fecha anterior/fechas_fecha anterior.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471744380 source:d:\unlam\programaciÓn\fabian 2da\fechas_fecha anterior\funciones.c + "header.h" + +1471743808 d:\unlam\programaciÓn\fabian 2da\fechas_fecha anterior\header.h + + + + +1471743846 source:d:\unlam\programaciÓn\fabian 2da\fechas_fecha anterior\main.c + "header.h" + diff --git a/fechas_fecha anterior/fechas_fecha anterior.layout b/fechas_fecha anterior/fechas_fecha anterior.layout new file mode 100644 index 0000000..ff86665 --- /dev/null +++ b/fechas_fecha anterior/fechas_fecha anterior.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/fechas_fecha anterior/funciones.c b/fechas_fecha anterior/funciones.c new file mode 100644 index 0000000..55947c2 --- /dev/null +++ b/fechas_fecha anterior/funciones.c @@ -0,0 +1,31 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +tFecha fecha_anterior(tFecha f) + { + if(f.dia>1) + f.dia--; + else + { + if(f.mes==1) + { + f.mes=12; + f.anio--; + } + else + f.mes--; + f.dia=cant_dias_mes(f.mes,f.anio); + } + return f; + } diff --git a/fechas_fecha anterior/header.h b/fechas_fecha anterior/header.h new file mode 100644 index 0000000..ccdac9e --- /dev/null +++ b/fechas_fecha anterior/header.h @@ -0,0 +1,13 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +tFecha fecha_anterior(tFecha); diff --git a/fechas_fecha anterior/main.c b/fechas_fecha anterior/main.c new file mode 100644 index 0000000..70fd8a2 --- /dev/null +++ b/fechas_fecha anterior/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band; + band=0; + printf("\n ***** FECHA ANTERIOR ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + f=fecha_anterior(f); + printf("\n La fecha anterior a la ingresada es %d/%d/%d \n\n",f.dia,f.mes,f.anio); + getch(); + return 0; + } + diff --git a/fechas_fecha anterior/obj/Debug/funciones.o b/fechas_fecha anterior/obj/Debug/funciones.o new file mode 100644 index 0000000..b35d29e Binary files /dev/null and b/fechas_fecha anterior/obj/Debug/funciones.o differ diff --git a/fechas_fecha anterior/obj/Debug/main.o b/fechas_fecha anterior/obj/Debug/main.o new file mode 100644 index 0000000..5fc662f Binary files /dev/null and b/fechas_fecha anterior/obj/Debug/main.o differ diff --git a/fechas_fecha siguiente/bin/Debug/fechas_fecha siguiente.exe b/fechas_fecha siguiente/bin/Debug/fechas_fecha siguiente.exe new file mode 100644 index 0000000..098c694 Binary files /dev/null and b/fechas_fecha siguiente/bin/Debug/fechas_fecha siguiente.exe differ diff --git a/fechas_fecha siguiente/fechas_fecha siguiente.cbp b/fechas_fecha siguiente/fechas_fecha siguiente.cbp new file mode 100644 index 0000000..d2ebc7c --- /dev/null +++ b/fechas_fecha siguiente/fechas_fecha siguiente.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/fechas_fecha siguiente/fechas_fecha siguiente.depend b/fechas_fecha siguiente/fechas_fecha siguiente.depend new file mode 100644 index 0000000..e69c043 --- /dev/null +++ b/fechas_fecha siguiente/fechas_fecha siguiente.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471741956 source:d:\unlam\programaciÓn\fabian 2da\fechas_fecha siguiente\funciones.c + "header.h" + +1471742554 d:\unlam\programaciÓn\fabian 2da\fechas_fecha siguiente\header.h + + + + +1471743549 source:d:\unlam\programaciÓn\fabian 2da\fechas_fecha siguiente\main.c + "header.h" + diff --git a/fechas_fecha siguiente/fechas_fecha siguiente.layout b/fechas_fecha siguiente/fechas_fecha siguiente.layout new file mode 100644 index 0000000..9286aa8 --- /dev/null +++ b/fechas_fecha siguiente/fechas_fecha siguiente.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/fechas_fecha siguiente/funciones.c b/fechas_fecha siguiente/funciones.c new file mode 100644 index 0000000..d035ceb --- /dev/null +++ b/fechas_fecha siguiente/funciones.c @@ -0,0 +1,31 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +tFecha fecha_siguiente(tFecha f) + { + if(f.dia==cant_dias_mes(f.mes,f.anio)) + { + f.dia=1; + if(f.mes==12) + { + f.mes=1; + f.anio++; + } + else + f.mes++; + } + else + f.dia++; + return f; + } diff --git a/fechas_fecha siguiente/header.h b/fechas_fecha siguiente/header.h new file mode 100644 index 0000000..9017e75 --- /dev/null +++ b/fechas_fecha siguiente/header.h @@ -0,0 +1,13 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +tFecha fecha_siguiente(tFecha); diff --git a/fechas_fecha siguiente/main.c b/fechas_fecha siguiente/main.c new file mode 100644 index 0000000..799fedd --- /dev/null +++ b/fechas_fecha siguiente/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band; + band=0; + printf("\n ***** FECHA SIGUIENTE ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + f=fecha_siguiente(f); + printf("\n La fecha siguiente a la ingresada es %d/%d/%d \n\n",f.dia,f.mes,f.anio); + getch(); + return 0; + } + diff --git a/fechas_fecha siguiente/obj/Debug/funciones.o b/fechas_fecha siguiente/obj/Debug/funciones.o new file mode 100644 index 0000000..e4e96f7 Binary files /dev/null and b/fechas_fecha siguiente/obj/Debug/funciones.o differ diff --git a/fechas_fecha siguiente/obj/Debug/main.o b/fechas_fecha siguiente/obj/Debug/main.o new file mode 100644 index 0000000..fa7de9e Binary files /dev/null and b/fechas_fecha siguiente/obj/Debug/main.o differ diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/bin/Debug/fechas_nombre del d\303\255a de la semana de una fecha.exe" "b/fechas_nombre del d\303\255a de la semana de una fecha/bin/Debug/fechas_nombre del d\303\255a de la semana de una fecha.exe" new file mode 100644 index 0000000..9ec5b45 Binary files /dev/null and "b/fechas_nombre del d\303\255a de la semana de una fecha/bin/Debug/fechas_nombre del d\303\255a de la semana de una fecha.exe" differ diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.cbp" "b/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.cbp" new file mode 100644 index 0000000..1c9c20e --- /dev/null +++ "b/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.depend" "b/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.depend" new file mode 100644 index 0000000..3c7b743 --- /dev/null +++ "b/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.depend" @@ -0,0 +1,23 @@ +# depslib dependency file v1.0 +1471748759 source:d:\unlam\programaciÓn\fabian 2da\fechas_nombre del día de la semana de una fecha\funciones.c + "header.h" + +1471748764 d:\unlam\programaciÓn\fabian 2da\fechas_nombre del día de la semana de una fecha\header.h + + + + +1471748814 source:d:\unlam\programaciÓn\fabian 2da\fechas_nombre del día de la semana de una fecha\main.c + "header.h" + +1472318543 source:d:\unlam\programaciÓn\fabian 2\fechas_nombre del día de la semana de una fecha\funciones.c + "header.h" + +1471748764 d:\unlam\programaciÓn\fabian 2\fechas_nombre del día de la semana de una fecha\header.h + + + + +1471748814 source:d:\unlam\programaciÓn\fabian 2\fechas_nombre del día de la semana de una fecha\main.c + "header.h" + diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.layout" "b/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.layout" new file mode 100644 index 0000000..0765b13 --- /dev/null +++ "b/fechas_nombre del d\303\255a de la semana de una fecha/fechas_nombre del d\303\255a de la semana de una fecha.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/funciones.c" "b/fechas_nombre del d\303\255a de la semana de una fecha/funciones.c" new file mode 100644 index 0000000..181aace --- /dev/null +++ "b/fechas_nombre del d\303\255a de la semana de una fecha/funciones.c" @@ -0,0 +1,32 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +int dia_de_la_semana(tFecha f) + { + int result1,result2,result3,result4,result5; + int regular[]={0,3,3,6,1,4,6,2,5,0,3,5}; + int noregular[]={0,3,4,0,2,5,0,3,6,1,4,6}; + f.mes=(bisiesto(f.anio))?noregular[f.mes-1]:regular[f.mes-1]; + result1=(f.anio-1)%7; + result2=(f.anio-1)/4; + result3=(3*(((f.anio-1)/100)+1))/4; + result4=(result2-result3)%7; + result5=f.dia%7; + return (result1+result4+f.mes+result5)%7; + } +void nombre_de_dia(int x) + { + char nombre[7][10]={"Domingo","Lunes","Martes","Miércoles","Jueves","Viernes","Sábado"}; + puts(nombre[x]); + } diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/header.h" "b/fechas_nombre del d\303\255a de la semana de una fecha/header.h" new file mode 100644 index 0000000..7e32938 --- /dev/null +++ "b/fechas_nombre del d\303\255a de la semana de una fecha/header.h" @@ -0,0 +1,14 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +int dia_de_la_semana(tFecha); +void nombre_de_dia(int); diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/main.c" "b/fechas_nombre del d\303\255a de la semana de una fecha/main.c" new file mode 100644 index 0000000..f84f5d4 --- /dev/null +++ "b/fechas_nombre del d\303\255a de la semana de una fecha/main.c" @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band; + band=0; + printf("\n ***** NOMBRE DEL DÍA DE LA SEMANA DE UNA FECHA ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + printf("\n El día de la semana de esta fecha es: "); + nombre_de_dia(dia_de_la_semana(f)); + printf("\n\n"); + return 0; + } + diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/obj/Debug/funciones.o" "b/fechas_nombre del d\303\255a de la semana de una fecha/obj/Debug/funciones.o" new file mode 100644 index 0000000..468c9f8 Binary files /dev/null and "b/fechas_nombre del d\303\255a de la semana de una fecha/obj/Debug/funciones.o" differ diff --git "a/fechas_nombre del d\303\255a de la semana de una fecha/obj/Debug/main.o" "b/fechas_nombre del d\303\255a de la semana de una fecha/obj/Debug/main.o" new file mode 100644 index 0000000..ec432e2 Binary files /dev/null and "b/fechas_nombre del d\303\255a de la semana de una fecha/obj/Debug/main.o" differ diff --git "a/fechas_restar n d\303\255as/bin/Debug/fechas_restar n d\303\255as.exe" "b/fechas_restar n d\303\255as/bin/Debug/fechas_restar n d\303\255as.exe" new file mode 100644 index 0000000..3aa7cb5 Binary files /dev/null and "b/fechas_restar n d\303\255as/bin/Debug/fechas_restar n d\303\255as.exe" differ diff --git "a/fechas_restar n d\303\255as/fechas_restar n d\303\255as.cbp" "b/fechas_restar n d\303\255as/fechas_restar n d\303\255as.cbp" new file mode 100644 index 0000000..4423630 --- /dev/null +++ "b/fechas_restar n d\303\255as/fechas_restar n d\303\255as.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/fechas_restar n d\303\255as/fechas_restar n d\303\255as.depend" "b/fechas_restar n d\303\255as/fechas_restar n d\303\255as.depend" new file mode 100644 index 0000000..58af74d --- /dev/null +++ "b/fechas_restar n d\303\255as/fechas_restar n d\303\255as.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471746488 source:d:\unlam\programaciÓn\fabian 2da\fechas_restar n días\funciones.c + "header.h" + +1471746022 d:\unlam\programaciÓn\fabian 2da\fechas_restar n días\header.h + + + + +1471746058 source:d:\unlam\programaciÓn\fabian 2da\fechas_restar n días\main.c + "header.h" + diff --git "a/fechas_restar n d\303\255as/fechas_restar n d\303\255as.layout" "b/fechas_restar n d\303\255as/fechas_restar n d\303\255as.layout" new file mode 100644 index 0000000..e13258e --- /dev/null +++ "b/fechas_restar n d\303\255as/fechas_restar n d\303\255as.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/fechas_restar n d\303\255as/funciones.c" "b/fechas_restar n d\303\255as/funciones.c" new file mode 100644 index 0000000..323d365 --- /dev/null +++ "b/fechas_restar n d\303\255as/funciones.c" @@ -0,0 +1,29 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +tFecha restar_n_dias(tFecha f,int n) + { + f.dia-=n; + while(f.dia<1) + { + f.mes--; + if(f.mes==0) + { + f.mes=12; + f.anio--; + } + f.dia+=cant_dias_mes(f.mes,f.anio); + } + return f; + } diff --git "a/fechas_restar n d\303\255as/header.h" "b/fechas_restar n d\303\255as/header.h" new file mode 100644 index 0000000..dcc921f --- /dev/null +++ "b/fechas_restar n d\303\255as/header.h" @@ -0,0 +1,14 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +tFecha restar_n_dias(tFecha,int); + diff --git "a/fechas_restar n d\303\255as/main.c" "b/fechas_restar n d\303\255as/main.c" new file mode 100644 index 0000000..b89a53e --- /dev/null +++ "b/fechas_restar n d\303\255as/main.c" @@ -0,0 +1,29 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band,n; + band=0; + printf("\n ***** RESTAR N DÍAS A UNA FECHA ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + do + { + printf("\n Ingrese la cantidad de días que desea restar: \t\t"); + scanf("%d",&n); + } + while(n<0); + f=restar_n_dias(f,n); + printf("\n %c La fecha resultante es %d/%d/%d \n\n",16,f.dia,f.mes,f.anio); + getch(); + return 0; + } + diff --git "a/fechas_restar n d\303\255as/obj/Debug/funciones.o" "b/fechas_restar n d\303\255as/obj/Debug/funciones.o" new file mode 100644 index 0000000..ccb9b09 Binary files /dev/null and "b/fechas_restar n d\303\255as/obj/Debug/funciones.o" differ diff --git "a/fechas_restar n d\303\255as/obj/Debug/main.o" "b/fechas_restar n d\303\255as/obj/Debug/main.o" new file mode 100644 index 0000000..c68e8ca Binary files /dev/null and "b/fechas_restar n d\303\255as/obj/Debug/main.o" differ diff --git "a/fechas_sumar n d\303\255as/bin/Debug/fechas_sumar n d\303\255as.exe" "b/fechas_sumar n d\303\255as/bin/Debug/fechas_sumar n d\303\255as.exe" new file mode 100644 index 0000000..eec9aa1 Binary files /dev/null and "b/fechas_sumar n d\303\255as/bin/Debug/fechas_sumar n d\303\255as.exe" differ diff --git "a/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.cbp" "b/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.cbp" new file mode 100644 index 0000000..823f0c1 --- /dev/null +++ "b/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.depend" "b/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.depend" new file mode 100644 index 0000000..2865147 --- /dev/null +++ "b/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471745228 source:d:\unlam\programaciÓn\fabian 2da\fechas_sumar n días\funciones.c + "header.h" + +1471745119 d:\unlam\programaciÓn\fabian 2da\fechas_sumar n días\header.h + + + + +1471745416 source:d:\unlam\programaciÓn\fabian 2da\fechas_sumar n días\main.c + "header.h" + diff --git "a/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.layout" "b/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.layout" new file mode 100644 index 0000000..988baf5 --- /dev/null +++ "b/fechas_sumar n d\303\255as/fechas_sumar n d\303\255as.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/fechas_sumar n d\303\255as/funciones.c" "b/fechas_sumar n d\303\255as/funciones.c" new file mode 100644 index 0000000..194480c --- /dev/null +++ "b/fechas_sumar n d\303\255as/funciones.c" @@ -0,0 +1,29 @@ +#include "header.h" +int fecha_valida(tFecha f) + { + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio))?1:0; + } +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } +tFecha sumar_n_dias(tFecha f,int n) + { + f.dia+=n; + while(f.dia>cant_dias_mes(f.mes,f.anio)) + { + f.dia-=cant_dias_mes(f.mes,f.anio); + f.mes++; + if(f.mes>12) + { + f.mes==1; + f.anio++; + } + } + return f; + } diff --git "a/fechas_sumar n d\303\255as/header.h" "b/fechas_sumar n d\303\255as/header.h" new file mode 100644 index 0000000..c6ff9c3 --- /dev/null +++ "b/fechas_sumar n d\303\255as/header.h" @@ -0,0 +1,13 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); +tFecha sumar_n_dias(tFecha,int); diff --git "a/fechas_sumar n d\303\255as/main.c" "b/fechas_sumar n d\303\255as/main.c" new file mode 100644 index 0000000..cfbdd48 --- /dev/null +++ "b/fechas_sumar n d\303\255as/main.c" @@ -0,0 +1,29 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + int band,n; + band=0; + printf("\n ***** SUMAR N DÍAS A UNA FECHA ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + do + { + if(band==1) + printf("\n La fecha ingresada no existe. Reingrésela: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + band=1; + } + while(!fecha_valida(f)); + do + { + printf("\n Ingrese la cantidad de días que desea sumar: \t\t"); + scanf("%d",&n); + } + while(n<0); + f=sumar_n_dias(f,n); + printf("\n %c La fecha resultante es %d/%d/%d \n\n",16,f.dia,f.mes,f.anio); + getch(); + return 0; + } + diff --git "a/fechas_sumar n d\303\255as/obj/Debug/funciones.o" "b/fechas_sumar n d\303\255as/obj/Debug/funciones.o" new file mode 100644 index 0000000..f84c835 Binary files /dev/null and "b/fechas_sumar n d\303\255as/obj/Debug/funciones.o" differ diff --git "a/fechas_sumar n d\303\255as/obj/Debug/main.o" "b/fechas_sumar n d\303\255as/obj/Debug/main.o" new file mode 100644 index 0000000..cf3b0a5 Binary files /dev/null and "b/fechas_sumar n d\303\255as/obj/Debug/main.o" differ diff --git "a/generador de n\303\272meros pseudo aleatorios/bin/Debug/generador de n\303\272meros pseudo aleatorios.exe" "b/generador de n\303\272meros pseudo aleatorios/bin/Debug/generador de n\303\272meros pseudo aleatorios.exe" new file mode 100644 index 0000000..1f62a0f Binary files /dev/null and "b/generador de n\303\272meros pseudo aleatorios/bin/Debug/generador de n\303\272meros pseudo aleatorios.exe" differ diff --git "a/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.cbp" "b/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.cbp" new file mode 100644 index 0000000..9ff2f8b --- /dev/null +++ "b/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.depend" "b/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.depend" new file mode 100644 index 0000000..6d7085d --- /dev/null +++ "b/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.depend" @@ -0,0 +1,7 @@ +# depslib dependency file v1.0 +1474503622 source:d:\unlam\programaciÓn\fabian 2\generador de números pseudo aleatorios\main.c + + + + + diff --git "a/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.layout" "b/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.layout" new file mode 100644 index 0000000..eb57619 --- /dev/null +++ "b/generador de n\303\272meros pseudo aleatorios/generador de n\303\272meros pseudo aleatorios.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/generador de n\303\272meros pseudo aleatorios/main.c" "b/generador de n\303\272meros pseudo aleatorios/main.c" new file mode 100644 index 0000000..00c03a0 --- /dev/null +++ "b/generador de n\303\272meros pseudo aleatorios/main.c" @@ -0,0 +1,19 @@ +#include +#include +#include +#include + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n \t GENERADOR DE NÚMEROS PSEUDO ALEATORIOS -- FUNCIÓN RAND \n"); + printf("\n Ingrese la cantidad de números pseudo aleatorios que desea generar: \n\n\t\t"); + int n,i; + scanf("%d",&n); + puts("\n\n\a\a"); + for(i=0;i + + + + + diff --git a/getc y putc/getc y putc.layout b/getc y putc/getc y putc.layout new file mode 100644 index 0000000..c779d16 --- /dev/null +++ b/getc y putc/getc y putc.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/getc y putc/main.c b/getc y putc/main.c new file mode 100644 index 0000000..b3a389d --- /dev/null +++ b/getc y putc/main.c @@ -0,0 +1,19 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + char c; + printf("\n\n GETC Y PUTC \n"); + printf("\n\n GETC toma un entero desde un stream y retorna su ascii \n"); + printf("\n PUTC pone un caracter en un stream y retorna su ascii \n"); + printf("\n\n Tomaremos un caracter desde stdin, usando getc: \n\t "); + c=(char)getc(stdin); + printf("\n\n Y lo retornamos por stdout, usando putc: \n\t"); + putc(c,stdout); + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/getc y putc/obj/Debug/main.o b/getc y putc/obj/Debug/main.o new file mode 100644 index 0000000..50b4dcd Binary files /dev/null and b/getc y putc/obj/Debug/main.o differ diff --git a/getchar y putchar/bin/Debug/getchar y putchar.exe b/getchar y putchar/bin/Debug/getchar y putchar.exe new file mode 100644 index 0000000..fd71d97 Binary files /dev/null and b/getchar y putchar/bin/Debug/getchar y putchar.exe differ diff --git a/getchar y putchar/getchar y putchar.cbp b/getchar y putchar/getchar y putchar.cbp new file mode 100644 index 0000000..3fdb907 --- /dev/null +++ b/getchar y putchar/getchar y putchar.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/getchar y putchar/getchar y putchar.depend b/getchar y putchar/getchar y putchar.depend new file mode 100644 index 0000000..9650616 --- /dev/null +++ b/getchar y putchar/getchar y putchar.depend @@ -0,0 +1,8 @@ +# depslib dependency file v1.0 +1473711292 source:d:\unlam\programaciÓn\fabian 2\getchar y putchar\main.c + + + + + + diff --git a/getchar y putchar/getchar y putchar.layout b/getchar y putchar/getchar y putchar.layout new file mode 100644 index 0000000..b80df6e --- /dev/null +++ b/getchar y putchar/getchar y putchar.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/getchar y putchar/main.c b/getchar y putchar/main.c new file mode 100644 index 0000000..23f1034 --- /dev/null +++ b/getchar y putchar/main.c @@ -0,0 +1,26 @@ +#include +#include +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n GETCHAR \n"); + printf("\n Ingrese un caracter: \t"); + printf("\n El caracter que usted ingresó fue: %c \n",getchar()); + + printf("\n\n PUTCHAR \n"); + char nombre[30]; + int i; + printf("\n Ahora escribe tu nombre: \t"); + fflush(stdin); + gets(nombre); + printf("\n Tu nombre escrito al revés es: \t"); + for(i=strlen(nombre)-1;i>=0;i--) + putchar(nombre[i]); + + printf("\n\n\n\n \t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/getchar y putchar/obj/Debug/main.o b/getchar y putchar/obj/Debug/main.o new file mode 100644 index 0000000..f24d05d Binary files /dev/null and b/getchar y putchar/obj/Debug/main.o differ diff --git a/gets y puts/bin/Debug/gets y puts.exe b/gets y puts/bin/Debug/gets y puts.exe new file mode 100644 index 0000000..994e6a6 Binary files /dev/null and b/gets y puts/bin/Debug/gets y puts.exe differ diff --git a/gets y puts/gets y puts.cbp b/gets y puts/gets y puts.cbp new file mode 100644 index 0000000..54c9907 --- /dev/null +++ b/gets y puts/gets y puts.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/gets y puts/gets y puts.depend b/gets y puts/gets y puts.depend new file mode 100644 index 0000000..e19368f --- /dev/null +++ b/gets y puts/gets y puts.depend @@ -0,0 +1,7 @@ +# depslib dependency file v1.0 +1473709889 source:d:\unlam\programaciÓn\fabian 2\gets y puts\main.c + + + + + diff --git a/gets y puts/gets y puts.layout b/gets y puts/gets y puts.layout new file mode 100644 index 0000000..71f70f3 --- /dev/null +++ b/gets y puts/gets y puts.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/gets y puts/main.c b/gets y puts/main.c new file mode 100644 index 0000000..e53cb84 --- /dev/null +++ b/gets y puts/main.c @@ -0,0 +1,24 @@ +#include +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char entrada[81]; + char salida[81]="Fui escrito en pantalla por puts"; + + printf("\n\n GETS \n"); + printf("\n Escribe una oración: \n"); + printf("\n La oración que escribiste fue \"%s\" \n",gets(entrada)); + + printf("\n\n PUTS \n\n"); + if(puts(salida)==0) + printf("\n Puts funcionó correctamente \n"); + else + printf("\n Puts no ha funcionado como se esperaba \n"); + + printf("\n\n \t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/gets y puts/obj/Debug/main.o b/gets y puts/obj/Debug/main.o new file mode 100644 index 0000000..4eaf4d9 Binary files /dev/null and b/gets y puts/obj/Debug/main.o differ diff --git a/goto/bin/Debug/goto.exe b/goto/bin/Debug/goto.exe new file mode 100644 index 0000000..5a0d2d3 Binary files /dev/null and b/goto/bin/Debug/goto.exe differ diff --git a/goto/goto.cbp b/goto/goto.cbp new file mode 100644 index 0000000..12b9366 --- /dev/null +++ b/goto/goto.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/goto/goto.depend b/goto/goto.depend new file mode 100644 index 0000000..0b92dee --- /dev/null +++ b/goto/goto.depend @@ -0,0 +1,5 @@ +# depslib dependency file v1.0 +1482704322 source:d:\unlam\programaciÓn\fabian\goto\main.c + + + diff --git a/goto/goto.layout b/goto/goto.layout new file mode 100644 index 0000000..fda98c3 --- /dev/null +++ b/goto/goto.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/goto/main.c b/goto/main.c new file mode 100644 index 0000000..e789670 --- /dev/null +++ b/goto/main.c @@ -0,0 +1,14 @@ +#include +#include + +int main() +{ + printf("Hello world!\n"); + + goto msj; + + return 0; + + msj: printf("Bye world!\n"); + return 0; +} diff --git a/goto/obj/Debug/main.o b/goto/obj/Debug/main.o new file mode 100644 index 0000000..134545f Binary files /dev/null and b/goto/obj/Debug/main.o differ diff --git "a/impresi\303\263n en bits de un entero no signado/bin/Debug/impresi\303\263n en bits de un entero no signado.exe" "b/impresi\303\263n en bits de un entero no signado/bin/Debug/impresi\303\263n en bits de un entero no signado.exe" new file mode 100644 index 0000000..914f83f Binary files /dev/null and "b/impresi\303\263n en bits de un entero no signado/bin/Debug/impresi\303\263n en bits de un entero no signado.exe" differ diff --git "a/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.cbp" "b/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.cbp" new file mode 100644 index 0000000..e3aaa41 --- /dev/null +++ "b/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.depend" "b/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.depend" new file mode 100644 index 0000000..0cd70bc --- /dev/null +++ "b/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.depend" @@ -0,0 +1,4 @@ +# depslib dependency file v1.0 +1482800188 source:d:\unlam\programaciÓn\fabian\impresión en bits de un entero no signado\main.c + + diff --git "a/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.layout" "b/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.layout" new file mode 100644 index 0000000..8034ee2 --- /dev/null +++ "b/impresi\303\263n en bits de un entero no signado/impresi\303\263n en bits de un entero no signado.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/impresi\303\263n en bits de un entero no signado/main.c" "b/impresi\303\263n en bits de un entero no signado/main.c" new file mode 100644 index 0000000..8531e60 --- /dev/null +++ "b/impresi\303\263n en bits de un entero no signado/main.c" @@ -0,0 +1,40 @@ +#include + +void despliegaBits( unsigned valor ); /* prototipo */ + +int main() +{ + unsigned x; /* variable para almacenar la entrada del usuario */ + + printf( "Introduzca un entero sin signo: " ); + scanf( "%u", &x ); + + despliegaBits( x ); + + return 0; /* indica terminación exitosa */ +} /* fin de main */ + +/* despliega los bits de un valor entero sin signo */ +void despliegaBits( unsigned valor ) +{ + unsigned c; /* contador */ + + /* define despliegaMascara y desplaza 31 bits hacia la izquierda */ + unsigned despliegaMascara = 1 << 31; + + printf( "%10u = ", valor ); + + /* ciclo a través de los bits */ + for ( c = 1; c <= 32; c++ ) + { + putchar( valor & despliegaMascara ? '1' : '0' ); + valor <<= 1; /* desplaza valor 1 hacia la izquierda */ + + if ( c % 8 == 0 ) /* despliega espacio después de 8 bits */ + { + putchar( ' ' ); + } /* fin de if */ + } /* fin de for */ + + putchar( '\n' ); +} /* fin de la función despliegaBits */ diff --git "a/impresi\303\263n en bits de un entero no signado/obj/Debug/main.o" "b/impresi\303\263n en bits de un entero no signado/obj/Debug/main.o" new file mode 100644 index 0000000..2fd10ab Binary files /dev/null and "b/impresi\303\263n en bits de un entero no signado/obj/Debug/main.o" differ diff --git a/impuestos de empleados por sus sueldos/IMPUESTOS.bin b/impuestos de empleados por sus sueldos/IMPUESTOS.bin new file mode 100644 index 0000000..fee3755 Binary files /dev/null and b/impuestos de empleados por sus sueldos/IMPUESTOS.bin differ diff --git a/impuestos de empleados por sus sueldos/arbol.c b/impuestos de empleados por sus sueldos/arbol.c new file mode 100644 index 0000000..89bb072 --- /dev/null +++ b/impuestos de empleados por sus sueldos/arbol.c @@ -0,0 +1,72 @@ +#include "arbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato_arbol *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return FALSO; + } + + *a=(t_nodo_arbol*)malloc(sizeof(t_nodo_arbol)); + if(!*a) + return MEMORIA_LLENA; + + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + + return VERDADERO; +} + +int buscar_en_arbol_iterativa_y_retornar_dato(t_arbol *a,t_dato_arbol *d,void *clave,t_cmp comparar) +{ + int cmp; + + while(*a) + { + if((cmp=comparar((void*)&(*a)->dato,clave))==0) + { + *d=(*a)->dato; + return VERDADERO; + } + + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + + return FALSO; +} + +int buscar_en_arbol_iterativa_y_actualizar_dato(t_arbol *a,const t_dato_arbol *d,void *clave,t_cmp comparar) +{ + int cmp; + + while(*a) + { + if((cmp=comparar((void*)&(*a)->dato,clave))==0) + { + (*a)->dato=*d; + return VERDADERO; + } + + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + + return FALSO; +} diff --git a/impuestos de empleados por sus sueldos/arbol.h b/impuestos de empleados por sus sueldos/arbol.h new file mode 100644 index 0000000..70a41cc --- /dev/null +++ b/impuestos de empleados por sus sueldos/arbol.h @@ -0,0 +1,31 @@ +#include +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 + +#define FALSO 0 +#define VERDADERO 1 + +typedef struct +{ + int codigo_concepto; + float importe_concepto; +}t_dato_arbol; + +typedef struct s_nodo_arbol +{ + t_dato_arbol dato; + struct s_nodo_arbol *izq; + struct s_nodo_arbol *der; +}t_nodo_arbol; + +typedef t_nodo_arbol* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_arbol(t_arbol *a); +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato_arbol *d,t_cmp comparar); + +int buscar_en_arbol_iterativa_y_retornar_dato(t_arbol *a,t_dato_arbol *d,void *clave,t_cmp comparar); +int buscar_en_arbol_iterativa_y_actualizar_dato(t_arbol *a,const t_dato_arbol *d,void *clave,t_cmp comparar); diff --git a/impuestos de empleados por sus sueldos/bin/Debug/impuestos de empleados por sus sueldos.exe b/impuestos de empleados por sus sueldos/bin/Debug/impuestos de empleados por sus sueldos.exe new file mode 100644 index 0000000..38f7e5c Binary files /dev/null and b/impuestos de empleados por sus sueldos/bin/Debug/impuestos de empleados por sus sueldos.exe differ diff --git a/impuestos de empleados por sus sueldos/funciones.c b/impuestos de empleados por sus sueldos/funciones.c new file mode 100644 index 0000000..95af945 --- /dev/null +++ b/impuestos de empleados por sus sueldos/funciones.c @@ -0,0 +1,176 @@ +#include "header.h" + +void generar_lista_de_conceptos_por_empleado(t_lista *l) +{ + t_dato_lista datos[50]= + { + {"20364851654",123456}, + {"12625841417",234567}, + {"14782365955",123456}, + {"95959545285",123456}, + {"65568684848",234567}, + {"85282963962",345678}, + {"14782142452",345678}, + {"12165484145",345678}, + {"12625841417",234567}, + {"96358414785",234567}, + {"20364851654",456789}, + {"85282963962",456789}, + {"14782365955",456789}, + {"78958858928",456789}, + {"95959545285",567899}, + {"12165484145",567899}, + {"14782142452",567899}, + {"74125885236",567899}, + {"65568684848",987654}, + {"95959545285",987654}, + {"12625841417",987654}, + {"14782365955",987654}, + {"78958858928",876543}, + {"85282963962",876543}, + {"65568684848",876543}, + {"14782365955",654321}, + {"96358414785",654321}, + {"74125885236",654321}, + {"20364851654",654321}, + {"12165484145",147852}, + {"12625841417",147852}, + {"96358414785",147852}, + {"74185296385",147852}, + {"74125885236",147852}, + {"95959545285",963258}, + {"14782142452",963258}, + {"14782365955",963258}, + {"20364851654",963258}, + {"12165484145",963258}, + {"74185296385",321456}, + {"96358414785",321456}, + {"65568684848",321456}, + {"85282963962",321456}, + {"20364851654",747485}, + {"14782142452",747485}, + {"74125885236",747485}, + {"78958858928",653298}, + {"74185296385",653298}, + {"85282963962",653298}, + {"65568684848",653298} + }; + + int i; + for(i=0; i<50; i++) + { + if(!insertar_en_lista_ordenada_con_duplicados(l,&datos[i],comparar_cuit)) + { + printf("\n\n Sin memoria para cargar la lista de conceptos por empleado \n\n\a\a"); + exit(EXIT_FAILURE); + } + } +} + +void generar_arbol_de_importes_de_conceptos(t_arbol *a) +{ + t_dato_arbol datos[12]= + { + {123456,7500}, + {234567,5900}, + {345678,7400}, + {456789,6300}, + {567899,8100}, + {987654,6900}, + {876543,7900}, + {147852,4600}, + {963258,5600}, + {321456,6700}, + {747485,9800}, + {653298,8800} + }; + + int i; + for(i=0; i<12; i++) + { + if(!insertar_en_arbol_iterativa(a,&datos[i],comparar_codigo_concepto)) + { + printf("\n\n Sin memoria para cargar el árbol de conceptos \n\n\a\a"); + exit(EXIT_FAILURE); + } + } +} + +void generar_archivo_de_impuestos(t_lista *l,t_arbol *a,FILE *pf) +{ + t_dato_lista dato_lista; + t_dato_lista anterior; + + t_dato_arbol dato_arbol; + t_registro registro; + + float sueldo=0; + int bandera; + + ver_primero_de_lista(l,&anterior); + + while(!lista_vacia(l)) + { + sacar_primero_de_lista(l,&dato_lista); + + if(comparar_cuit(&anterior,&dato_lista)==FALSO) + { + buscar_en_arbol_iterativa_y_retornar_dato(a,&dato_arbol,(void*)&dato_lista.codigo_concepto,comparar_codigo_concepto); + + if(dato_arbol.importe_concepto!=0) + sueldo+=dato_arbol.importe_concepto; + else + { + printf("\n\n No se registra el importe de un concepto \a\a"); + printf("\n\n Ingrese importe de concepto %d: \t",dato_arbol.codigo_concepto); + + bandera=0; + do + { + if(bandera==1) + printf("\n\n El importe de concepto ingresado es inválido. \n\n Reingresar: \t"); + + fflush(stdin); + scanf("%f",&dato_arbol.importe_concepto); + + bandera=1; + } + while(dato_arbol.importe_concepto<=0); + + sueldo+=dato_arbol.importe_concepto; + buscar_en_arbol_iterativa_y_actualizar_dato(a,&dato_arbol,(void*)&dato_lista.codigo_concepto,comparar_codigo_concepto); + } + } + else + { + str_cpy(registro.cuit,dato_lista.cuit); + registro.sueldo_total=sueldo; + registro.importe_impuesto=calcular_impuesto(sueldo); + fwrite(®istro,sizeof(t_registro),1,pf); + anterior=dato_lista; + sueldo=0; + } + } + + str_cpy(registro.cuit,dato_lista.cuit); + registro.sueldo_total=sueldo; + registro.importe_impuesto=calcular_impuesto(sueldo); + fwrite(®istro,sizeof(t_registro),1,pf); + + fclose(pf); +} + +float calcular_impuesto(float sueldo) +{ + if(sueldo<10000) + return 0; + if(sueldo<15000) + return 5*sueldo/100; + if(sueldo<20000) + return 10*sueldo/100; + if(sueldo<25000) + return 15*sueldo/100; + if(sueldo<50000) + return 20*sueldo/100; + return 25*sueldo/100; +} diff --git a/impuestos de empleados por sus sueldos/header.h b/impuestos de empleados por sus sueldos/header.h new file mode 100644 index 0000000..0d0536b --- /dev/null +++ b/impuestos de empleados por sus sueldos/header.h @@ -0,0 +1,28 @@ +#include "lista_doblemente_enlazada.h" +#include "arbol.h" + +#include +#include +#include +#include + +typedef struct +{ + char cuit[12]; + float sueldo_total; + float importe_impuesto; +}t_registro; + +/// prototipos cadena +char *str_cpy(char *destino,const char *origen); +int str_cmp(const char *s1,const char *s2); + +/// prototipos comparaciones +int comparar_cuit(const void *v1,const void *v2); +int comparar_codigo_concepto(const void *v1,const void *v2); + +/// prototipos funciones +void generar_lista_de_conceptos_por_empleado(t_lista *l); +void generar_arbol_de_importes_de_conceptos(t_arbol *a); +void generar_archivo_de_impuestos(t_lista *l,t_arbol *a,FILE *pf); +float calcular_impuesto(float sueldo); diff --git a/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.cbp b/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.cbp new file mode 100644 index 0000000..679ba7f --- /dev/null +++ b/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.cbp @@ -0,0 +1,59 @@ + + + + + + diff --git a/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.depend b/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.depend new file mode 100644 index 0000000..eb13fc6 --- /dev/null +++ b/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.depend @@ -0,0 +1,35 @@ +# depslib dependency file v1.0 +1480291280 source:d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\arbol.c + "arbol.h" + +1480289982 d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\arbol.h + + + +1480284382 source:d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\comparaciones.c + "header.h" + +1480290195 d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\header.h + "lista_doblemente_enlazada.h" + "arbol.h" + + + + + +1480290067 d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\lista_doblemente_enlazada.h + + + +1480294200 source:d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\funciones.c + "header.h" + +1480293888 source:d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\lista_doblemente_enlazada.c + "lista_doblemente_enlazada.h" + +1480294051 source:d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\main.c + "header.h" + +1480290496 source:d:\unlam\programaciÓn\fabian\impuestos de empleados por sus sueldos\utilidades.c + "header.h" + diff --git a/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.layout b/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.layout new file mode 100644 index 0000000..1e976c8 --- /dev/null +++ b/impuestos de empleados por sus sueldos/impuestos de empleados por sus sueldos.layout @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/impuestos de empleados por sus sueldos/lista_doblemente_enlazada.c b/impuestos de empleados por sus sueldos/lista_doblemente_enlazada.c new file mode 100644 index 0000000..d6bea10 --- /dev/null +++ b/impuestos de empleados por sus sueldos/lista_doblemente_enlazada.c @@ -0,0 +1,87 @@ +#include "lista_doblemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int insertar_en_lista_ordenada_con_duplicados(t_lista *l,const t_dato_lista *d,t_cmp comparar) +{ + t_nodo_lista *act=*l; + t_nodo_lista *ant=NULL; + t_nodo_lista *sig=NULL; + + if(act) + { + while(act->sig&&comparar((void*)&act->sig,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->sig,(void*)d)>0) + act=act->ant; + + if(comparar((void*)&act->sig,(void*)d)>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + + act=(t_nodo_lista*)malloc(sizeof(t_nodo_lista)); + if(!act) + return MEMORIA_LLENA; + + act->dato=*d; + act->ant=ant; + act->sig=sig; + + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + + *l=act; + return VERDADERO; +} + +int sacar_primero_de_lista(t_lista *l,t_dato_lista *d) +{ + t_nodo_lista *aux; + + if(!*l) + return FALSO; + + while((*l)->ant) + *l=(*l)->ant; + + aux=*l; + *l=(*l)->sig; + if(*l) + (*l)->ant=NULL; + + *d=aux->dato; + free(aux); + + return VERDADERO; +} + +int ver_primero_de_lista(const t_lista *l,t_dato_lista *d) +{ + if(!*l) + return FALSO; + + while((*l)->ant) + l=&(*l)->ant; + + *d=(*l)->dato; + + return VERDADERO; +} diff --git a/impuestos de empleados por sus sueldos/lista_doblemente_enlazada.h b/impuestos de empleados por sus sueldos/lista_doblemente_enlazada.h new file mode 100644 index 0000000..fdbc187 --- /dev/null +++ b/impuestos de empleados por sus sueldos/lista_doblemente_enlazada.h @@ -0,0 +1,33 @@ +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 + +#define FALSO 0 +#define VERDADERO 1 + +typedef struct +{ + char cuit[12]; + int codigo_concepto; +}t_dato_lista; + +typedef struct s_nodo_lista +{ + t_dato_lista dato; + struct s_nodo_lista *ant; + struct s_nodo_lista *sig; +}t_nodo_lista; + +typedef t_nodo_lista* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista *l); +int lista_vacia(const t_lista *l); + +int insertar_en_lista_ordenada_con_duplicados(t_lista *l,const t_dato_lista *d,t_cmp comparar); +int sacar_primero_de_lista(t_lista *l,t_dato_lista *d); + +int ver_primero_de_lista(const t_lista *l,t_dato_lista *d); diff --git a/impuestos de empleados por sus sueldos/main.c b/impuestos de empleados por sus sueldos/main.c new file mode 100644 index 0000000..5768deb --- /dev/null +++ b/impuestos de empleados por sus sueldos/main.c @@ -0,0 +1,40 @@ +#include "header.h" + +int main() +{ + t_lista lista; + t_arbol arbol; + + FILE *pf; + + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 9F"); + + printf("\n\n IMPUESTOS DE EMPLEADOS POR SU SUELDO \n"); + + crear_lista(&lista); + printf("\n\n Se ha creado una lista \n"); + + crear_arbol(&arbol); + printf("\n\n Se ha creado un árbol \n"); + + generar_lista_de_conceptos_por_empleado(&lista); + printf("\n\n La lista de conceptos por empleado ha sido generada exitosamente \n"); + + generar_arbol_de_importes_de_conceptos(&arbol); + printf("\n\n El árbol de importes de conceptos ha sido generado exitosamente \n"); + + pf=fopen("IMPUESTOS.bin","wb"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo de impuestos \n\n\a\a"); + exit(EXIT_FAILURE); + } + + generar_archivo_de_impuestos(&lista,&arbol,pf); + printf("\n\n El archivo de impuestos ha sido generado exitosamente"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/impuestos de empleados por sus sueldos/obj/Debug/arbol.o b/impuestos de empleados por sus sueldos/obj/Debug/arbol.o new file mode 100644 index 0000000..97e7158 Binary files /dev/null and b/impuestos de empleados por sus sueldos/obj/Debug/arbol.o differ diff --git a/impuestos de empleados por sus sueldos/obj/Debug/comparaciones.o b/impuestos de empleados por sus sueldos/obj/Debug/comparaciones.o new file mode 100644 index 0000000..ff52e10 Binary files /dev/null and b/impuestos de empleados por sus sueldos/obj/Debug/comparaciones.o differ diff --git a/impuestos de empleados por sus sueldos/obj/Debug/funciones.o b/impuestos de empleados por sus sueldos/obj/Debug/funciones.o new file mode 100644 index 0000000..a7ce805 Binary files /dev/null and b/impuestos de empleados por sus sueldos/obj/Debug/funciones.o differ diff --git a/impuestos de empleados por sus sueldos/obj/Debug/lista_doblemente_enlazada.o b/impuestos de empleados por sus sueldos/obj/Debug/lista_doblemente_enlazada.o new file mode 100644 index 0000000..89cbf41 Binary files /dev/null and b/impuestos de empleados por sus sueldos/obj/Debug/lista_doblemente_enlazada.o differ diff --git a/impuestos de empleados por sus sueldos/obj/Debug/main.o b/impuestos de empleados por sus sueldos/obj/Debug/main.o new file mode 100644 index 0000000..f96f1e0 Binary files /dev/null and b/impuestos de empleados por sus sueldos/obj/Debug/main.o differ diff --git a/impuestos de empleados por sus sueldos/obj/Debug/utilidades.o b/impuestos de empleados por sus sueldos/obj/Debug/utilidades.o new file mode 100644 index 0000000..674452c Binary files /dev/null and b/impuestos de empleados por sus sueldos/obj/Debug/utilidades.o differ diff --git a/impuestos de empleados por sus sueldos/utilidades.c b/impuestos de empleados por sus sueldos/utilidades.c new file mode 100644 index 0000000..5878579 --- /dev/null +++ b/impuestos de empleados por sus sueldos/utilidades.c @@ -0,0 +1,41 @@ +#include "header.h" + +char *str_cpy(char *destino,const char *origen) +{ + char *inicio=destino; + + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + + *destino='\0'; + return inicio; +} + +int str_cmp(const char *s1,const char *s2) +{ + while(*s1&&*s2&&*s1==*s2) + { + s1++; + s2++; + } + + return *s1-*s2; +} + +int comparar_cuit(const void *v1,const void *v2) +{ + t_dato_lista *dato1=(t_dato_lista*)v1; + t_dato_lista *dato2=(t_dato_lista*)v2; + return str_cmp(dato1->cuit,dato2->cuit); +} + +int comparar_codigo_concepto(const void *v1,const void *v2) +{ + t_dato_lista *dato=(t_dato_lista*)v1; + int *codigo_concepto=(int*)v2; + return dato->codigo_concepto-*codigo_concepto; +} diff --git a/intercambio de dos elementos con punteros/bin/Debug/intercambio de dos elementos con punteros.exe b/intercambio de dos elementos con punteros/bin/Debug/intercambio de dos elementos con punteros.exe new file mode 100644 index 0000000..54ab158 Binary files /dev/null and b/intercambio de dos elementos con punteros/bin/Debug/intercambio de dos elementos con punteros.exe differ diff --git a/intercambio de dos elementos con punteros/funciones.c b/intercambio de dos elementos con punteros/funciones.c new file mode 100644 index 0000000..7fa0cc8 --- /dev/null +++ b/intercambio de dos elementos con punteros/funciones.c @@ -0,0 +1,12 @@ +#include "header.h" +void mostrar(int a,int b) + { + printf("\n Primer número: %d \n Segundo número: %d \n",a,b); + } +void intercambiar(int *a,int *b) + { + int aux; + aux=*a; + *a=*b; + *b=aux; + } diff --git a/intercambio de dos elementos con punteros/header.h b/intercambio de dos elementos con punteros/header.h new file mode 100644 index 0000000..c64fb61 --- /dev/null +++ b/intercambio de dos elementos con punteros/header.h @@ -0,0 +1,5 @@ +#include +#include +#include +void mostrar(int,int); +void intercambiar(int*,int*); diff --git a/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.cbp b/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.cbp new file mode 100644 index 0000000..1d7ff71 --- /dev/null +++ b/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.depend b/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.depend new file mode 100644 index 0000000..b271f0e --- /dev/null +++ b/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472069724 source:d:\unlam\programaciÓn\fabian 2da\intercambio de dos elementos con punteros\funciones.c + "header.h" + +1472069660 d:\unlam\programaciÓn\fabian 2da\intercambio de dos elementos con punteros\header.h + + + + +1472070019 source:d:\unlam\programaciÓn\fabian 2da\intercambio de dos elementos con punteros\main.c + "header.h" + diff --git a/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.layout b/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.layout new file mode 100644 index 0000000..1a22d9d --- /dev/null +++ b/intercambio de dos elementos con punteros/intercambio de dos elementos con punteros.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/intercambio de dos elementos con punteros/main.c b/intercambio de dos elementos con punteros/main.c new file mode 100644 index 0000000..563390d --- /dev/null +++ b/intercambio de dos elementos con punteros/main.c @@ -0,0 +1,18 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x,y; + printf("\n INTERCAMBIO DE ELEMENTOS USANDO PUNTEROS \n"); + printf("\n Ingrese un número entero: \n\n\t\t"); + scanf("%d",&x); + printf("\n Ingrese un número entero: \n\n\t\t"); + scanf("%d",&y); + mostrar(x,y); + printf("\n Los elementos son intercambiados \n"); + intercambiar(&x,&y);//mando las direcciones de memoria para retocar los valores en memoria principal y no en la memoria local + mostrar(x,y); + getch(); + return 0; + } + diff --git a/intercambio de dos elementos con punteros/obj/Debug/funciones.o b/intercambio de dos elementos con punteros/obj/Debug/funciones.o new file mode 100644 index 0000000..6a4657b Binary files /dev/null and b/intercambio de dos elementos con punteros/obj/Debug/funciones.o differ diff --git a/intercambio de dos elementos con punteros/obj/Debug/main.o b/intercambio de dos elementos con punteros/obj/Debug/main.o new file mode 100644 index 0000000..87b19ad Binary files /dev/null and b/intercambio de dos elementos con punteros/obj/Debug/main.o differ diff --git a/lanzamiento de dado/bin/Debug/lanzamiento de dado.exe b/lanzamiento de dado/bin/Debug/lanzamiento de dado.exe new file mode 100644 index 0000000..e755964 Binary files /dev/null and b/lanzamiento de dado/bin/Debug/lanzamiento de dado.exe differ diff --git a/lanzamiento de dado/lanzamiento de dado.cbp b/lanzamiento de dado/lanzamiento de dado.cbp new file mode 100644 index 0000000..dfcf78f --- /dev/null +++ b/lanzamiento de dado/lanzamiento de dado.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/lanzamiento de dado/lanzamiento de dado.depend b/lanzamiento de dado/lanzamiento de dado.depend new file mode 100644 index 0000000..590a6c7 --- /dev/null +++ b/lanzamiento de dado/lanzamiento de dado.depend @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1482795298 source:d:\unlam\programaciÓn\fabian\lanzamiento de dado\main.c + + + + diff --git a/lanzamiento de dado/lanzamiento de dado.layout b/lanzamiento de dado/lanzamiento de dado.layout new file mode 100644 index 0000000..7d824a6 --- /dev/null +++ b/lanzamiento de dado/lanzamiento de dado.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/lanzamiento de dado/main.c b/lanzamiento de dado/main.c new file mode 100644 index 0000000..7da9e2e --- /dev/null +++ b/lanzamiento de dado/main.c @@ -0,0 +1,34 @@ +// Lanza un dado de seis lados 6000 veces */ +#include +#include +#include +#define TAMANIO 7 + +/* la función main comienza la ejecución del programa */ +int main() +{ + int cara; /* valor aleatorio del dado entre 1 a 6 */ + int tiro; /* contador de tiros 1 a 6000 */ + int frecuencia[ TAMANIO ] = { 0 }; /* inicializa a cero la cuenta */ + + srand( time( NULL ) ); /* generador de la semilla de números aleatorios */ + + printf("\n\n LANZAMIENTO DE DADO \n\n"); + + /* tira el dado 6000 veces */ + for ( tiro = 1; tiro <= 6000; tiro++ ) + { + cara = 1 + rand() % 6; + ++frecuencia[ cara ]; + } /* fin de for */ + + printf( "%s%17s\n", "Cara", "Frecuencia" ); + + /* muestra los elementos 1-6 de frecuencia en forma tabular */ + for ( cara = 1; cara < TAMANIO; cara++ ) + { + printf( "%4d%17d\n", cara, frecuencia[ cara ] ); + } /* fin de for */ + + return 0; /* indica terminación exitosa */ +} /* fin de main */ diff --git a/lanzamiento de dado/obj/Debug/main.o b/lanzamiento de dado/obj/Debug/main.o new file mode 100644 index 0000000..e2b4c90 Binary files /dev/null and b/lanzamiento de dado/obj/Debug/main.o differ diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/bin/Debug/macros y funciones_redondeo, menor, mayor, intercambio.exe b/macros y funciones_redondeo, menor, mayor, intercambio/bin/Debug/macros y funciones_redondeo, menor, mayor, intercambio.exe new file mode 100644 index 0000000..54c7afe Binary files /dev/null and b/macros y funciones_redondeo, menor, mayor, intercambio/bin/Debug/macros y funciones_redondeo, menor, mayor, intercambio.exe differ diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/functions.c b/macros y funciones_redondeo, menor, mayor, intercambio/functions.c new file mode 100644 index 0000000..d84d245 --- /dev/null +++ b/macros y funciones_redondeo, menor, mayor, intercambio/functions.c @@ -0,0 +1,14 @@ +#include "header.h" + +int menor(int *x,int *y) + { + return (*x<*y)?*x:*y; + } + +void intercambio(int *x,int *y) + { + int aux; + aux=*x; + *x=*y; + *y=aux; + } diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/header.h b/macros y funciones_redondeo, menor, mayor, intercambio/header.h new file mode 100644 index 0000000..dd7f2a0 --- /dev/null +++ b/macros y funciones_redondeo, menor, mayor, intercambio/header.h @@ -0,0 +1,21 @@ +#include +#include +#include +#include + +#define REDONDEO_1(x) ((((x)-0.5)<(int)(x))?(int)(x):(int)((x)+1)) + +#define REDONDEO_2(x) (((x)-(int)(x))>=0.5?((int)(x)+1):((int)(x))) + +#define REDONDEO_3(x) ((int)((x) + 0.5)) + +int menor(int*,int*); + +#define MENOR(x,y) ((*(x)<*(y))?*(x):*(y)) + +void intercambio(int*,int*); + +#define INTERCAMBIO(x,y) int aux; \ + aux=*x; \ + *x=*y; \ + *y=aux; diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.cbp b/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.cbp new file mode 100644 index 0000000..463c2a8 --- /dev/null +++ b/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.depend b/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.depend new file mode 100644 index 0000000..4d334ad --- /dev/null +++ b/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473702888 source:d:\unlam\programaciÓn\fabian 2\macros y funciones_redondeo, menor, mayor, intercambio\functions.c + "header.h" + +1473703035 d:\unlam\programaciÓn\fabian 2\macros y funciones_redondeo, menor, mayor, intercambio\header.h + + + + + +1473702099 source:d:\unlam\programaciÓn\fabian 2\macros y funciones_redondeo, menor, mayor, intercambio\main.c + "header.h" + diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.layout b/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.layout new file mode 100644 index 0000000..1458590 --- /dev/null +++ b/macros y funciones_redondeo, menor, mayor, intercambio/macros y funciones_redondeo, menor, mayor, intercambio.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/main.c b/macros y funciones_redondeo, menor, mayor, intercambio/main.c new file mode 100644 index 0000000..170ff36 --- /dev/null +++ b/macros y funciones_redondeo, menor, mayor, intercambio/main.c @@ -0,0 +1,29 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n Redondear flotante con 3 macros diferentes \n"); + printf("\n REDONDEO de (%.2f): \t %d",5.25,REDONDEO_1(5.25)); + printf("\n REDONDEO de (%.2f): \t %d",5.5,REDONDEO_2(5.5)); + printf("\n REDONDEO de (%.2f): \t %d",5.75,REDONDEO_3(5.75)); + + int x=5,y=3; + printf("\n\n Menor entre dos números enteros, pasándolos como argumento de fn \n"); + printf("\n 1er núnero: %d \t 2do número: %d \t Menor: %d \n",x,y,menor(&x,&y)); + printf("\n\n Menor entre dos números enteros, usando una macro \n"); + printf("\n 1er núnero: %d \t 2do número: %d \t Menor: %d \n",x,y,MENOR(&x,&y)); + + printf("\n\n Intercambiar dos enteros con una función que los recibe como punteros \n"); + printf("\n Antes del intercambio: \t 1er núnero: %d \t 2do número: %d \n",x,y); + intercambio(&x,&y); + printf("\n Después del intercambio: \t 1er núnero: %d \t 2do número: %d \n",x,y); + + printf("\n\n Intercambiar dos enteros con una macro que los recibe como punteros \n"); + printf("\n Antes del intercambio: \t 1er núnero: %d \t 2do número: %d \n",x,y); + INTERCAMBIO(&x,&y); + printf("\n Después del intercambio: \t 1er núnero: %d \t 2do número: %d \n",x,y); + + getch(); + return 0; + } diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/obj/Debug/functions.o b/macros y funciones_redondeo, menor, mayor, intercambio/obj/Debug/functions.o new file mode 100644 index 0000000..26964a2 Binary files /dev/null and b/macros y funciones_redondeo, menor, mayor, intercambio/obj/Debug/functions.o differ diff --git a/macros y funciones_redondeo, menor, mayor, intercambio/obj/Debug/main.o b/macros y funciones_redondeo, menor, mayor, intercambio/obj/Debug/main.o new file mode 100644 index 0000000..1d4af81 Binary files /dev/null and b/macros y funciones_redondeo, menor, mayor, intercambio/obj/Debug/main.o differ diff --git a/matrices cuadradas_todas las funciones/bin/Debug/matrices cuadradas_todas las funciones.exe b/matrices cuadradas_todas las funciones/bin/Debug/matrices cuadradas_todas las funciones.exe new file mode 100644 index 0000000..9c1c47c Binary files /dev/null and b/matrices cuadradas_todas las funciones/bin/Debug/matrices cuadradas_todas las funciones.exe differ diff --git a/matrices cuadradas_todas las funciones/functions.c b/matrices cuadradas_todas las funciones/functions.c new file mode 100644 index 0000000..7e967c4 --- /dev/null +++ b/matrices cuadradas_todas las funciones/functions.c @@ -0,0 +1,564 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;ic-1-i) + printf(" %d",m[i][j]); + else + printf(" "); + } + } + } +void mostrar_triang_sup_diag_pral_con_diag(int m[][COL],int f,int c) + { + int i,j; + for(i=0;i=c-1-i) + printf(" %d",m[i][j]); + else + printf(" "); + } + } + } +void mostrar_triang_arriba_diagonales_sin_diag(int m[][COL],int f,int c) + { + int i,j; + for(i=0;ic-1-i) + printf(" %d",m[i][j]); + else + printf(" "); + } + } + } +void mostrar_triang_izquierda_diagonales_sin_diag(int m[][COL],int f,int c) + { + int i,j; + for(i=0;ic-1-i) + printf(" %d",m[i][j]); + else + printf(" "); + } + } + } +void mostrar_triang_arriba_diagonales_con_diag(int m[][COL],int f,int c) + { + int i,j; + for(i=0;i=c-1-i) + printf(" %d",m[i][j]); + else + printf(" "); + } + } + } +void mostrar_triang_izquierda_diagonales_con_diag(int m[][COL],int f,int c) + { + int i,j; + for(i=0;i=c-1-i) + printf(" %d",m[i][j]); + else + printf(" "); + } + } + } +void mostrar_transpuesta(int m[][COL],int f,int c) + { + int i,j,n[c][f]; + for(i=0;i=a;j--,n++) + aux[n]=m[i][j]; + for(j++,i--;i>a;i--,n++) + aux[n]=m[i][j]; + } + array_a_matriz(aux,aux2,f,c); + mostrar_matriz(aux2,f,c); + } +void mostrar_en_zigzag_horizontal(int m[][COL],int f,int c) + { + int aux[f*c],aux2[f][c],i,j,t; + t=0; + for(i=0;i=0;j--,t++) + aux[t]=m[i][j]; + } + array_a_matriz(aux,aux2,f,c); + mostrar_matriz(aux2,f,c); + } +void mostrar_en_lluvia_desde_ultima_fila(int m[][COL],int f,int c) + { + int aux[f*c],aux2[f][c],i,j,k,t,p; + i=0; + t=0; + for(j=c-1;j>=0;j--) + { + for(k=j,i=0;k +#include +#include +#include + +#define FIL 5 +#define COL 5 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); + +void mostrar_elementos_diagonal_principal(int[][COL],int,int); +void mostrar_elementos_diagonal_secundaria(int[][COL],int,int); + +void mostrar_elementos_triang_sup_diag_pral_sin_diag(int[][COL],int,int); +void mostrar_elementos_triang_inf_diag_pral_sin_diag(int[][COL],int,int); +void mostrar_elementos_triang_sup_diag_sec_sin_diag(int[][COL],int,int); +void mostrar_elementos_triang_inf_diag_sec_sin_diag(int[][COL],int,int); + +void mostrar_elementos_triang_sup_diag_pral_con_diag(int[][COL],int,int); +void mostrar_elementos_triang_inf_diag_pral_con_diag(int[][COL],int,int); +void mostrar_elementos_triang_sup_diag_sec_con_diag(int[][COL],int,int); +void mostrar_elementos_triang_inf_diag_sec_con_diag(int[][COL],int,int); + +void mostrar_diagonal_principal(int[][COL],int,int); +void mostrar_diagonal_secundaria(int[][COL],int,int); + +void mostrar_triang_sup_diag_pral_sin_diag(int[][COL],int,int); +void mostrar_triang_inf_diag_pral_sin_diag(int[][COL],int,int); +void mostrar_triang_sup_diag_sec_sin_diag(int[][COL],int,int); +void mostrar_triang_inf_diag_sec_sin_diag(int[][COL],int,int); + +void mostrar_triang_sup_diag_pral_con_diag(int[][COL],int,int); +void mostrar_triang_inf_diag_pral_con_diag(int[][COL],int,int); +void mostrar_triang_sup_diag_sec_con_diag(int[][COL],int,int); +void mostrar_triang_inf_diag_sec_con_diag(int[][COL],int,int); + +void mostrar_triang_arriba_diagonales_sin_diag(int[][COL],int,int); +void mostrar_triang_abajo_diagonales_sin_diag(int[][COL],int,int); +void mostrar_triang_izquierda_diagonales_sin_diag(int[][COL],int,int); +void mostrar_triang_derecha_diagonales_sin_diag(int[][COL],int,int); + +void mostrar_triang_arriba_diagonales_con_diag(int[][COL],int,int); +void mostrar_triang_abajo_diagonales_con_diag(int[][COL],int,int); +void mostrar_triang_izquierda_diagonales_con_diag(int[][COL],int,int); +void mostrar_triang_derecha_diagonales_con_diag(int[][COL],int,int); + +void mostrar_transpuesta(int[][COL],int,int); +void mostrar_opuesta(int m[][COL],int,int); +void array_a_matriz(int v[],int m[][COL],int,int); +void mostrar_en_espiral(int[][COL],int,int); +void mostrar_en_zigzag_horizontal(int[][COL],int,int); +void mostrar_en_lluvia_desde_ultima_fila(int[][COL],int,int); + +int traza_diag_pral(int[][COL],int,int); +int traza_diag_sec(int[][COL],int,int); + +int es_matriz_nula(int[][COL],int,int); +int es_matriz_diagonal(int[][COL],int,int); +int es_matriz_identidad(int[][COL],int,int); +int es_matriz_escalar(int[][COL],int,int); + +int es_antisimetrica(int[][COL],int,int); +int es_simetrica_respecto_diag_pral(int[][COL],int,int); +int es_simetrica_respecto_diag_secund(int[][COL],int,int); +int es_simetrica_horizontalmente(int[][COL],int,int); +int es_simetrica_verticalmente(int[][COL],int,int); diff --git a/matrices cuadradas_todas las funciones/main.c b/matrices cuadradas_todas las funciones/main.c new file mode 100644 index 0000000..519c4d7 --- /dev/null +++ b/matrices cuadradas_todas las funciones/main.c @@ -0,0 +1,116 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 0E"); + int mat[FIL][COL]; + + printf("\a\a"); + printf("\n\t\t **********************"); + printf("\n\t\t * MATRICES CUADRADAS *"); + printf("\n\t\t **********************"); + + cargar_matriz(mat,FIL,COL); + system("cls"); + + printf("\a\a"); + printf("\n\t\t **********************"); + printf("\n\t\t * MATRICES CUADRADAS *"); + printf("\n\t\t **********************"); + + printf("\n\n Matriz cargada \n"); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n Elementos de la diagonal principal \n\n"); + mostrar_elementos_diagonal_principal(mat,FIL,COL); + printf("\n\n Elementos de la diagonal secundaria \n\n"); + mostrar_elementos_diagonal_secundaria(mat,FIL,COL); + + printf("\n\n Elementos del triángulo superior a la diagonal principal sin la diagonal \n\n"); + mostrar_elementos_triang_sup_diag_pral_sin_diag(mat,FIL,COL); + printf("\n\n Elementos del triángulo inferior a la diagonal principal sin la diagonal \n\n"); + mostrar_elementos_triang_inf_diag_pral_sin_diag(mat,FIL,COL); + printf("\n\n Elementos del triángulo superior a la diagonal secundaria sin la diagonal \n\n"); + mostrar_elementos_triang_sup_diag_sec_sin_diag(mat,FIL,COL); + printf("\n\n Elementos del triángulo inferior a la diagonal secundaria sin la diagonal \n\n"); + mostrar_elementos_triang_inf_diag_sec_sin_diag(mat,FIL,COL); + + printf("\n\n Elementos del triángulo superior a la diagonal principal con la diagonal \n\n"); + mostrar_elementos_triang_sup_diag_pral_con_diag(mat,FIL,COL); + printf("\n\n Elementos del triángulo inferior a la diagonal principal con la diagonal \n\n"); + mostrar_elementos_triang_inf_diag_pral_con_diag(mat,FIL,COL); + printf("\n\n Elementos del triángulo superior a la diagonal secundaria con la diagonal \n\n"); + mostrar_elementos_triang_sup_diag_sec_con_diag(mat,FIL,COL); + printf("\n\n Elementos del triángulo inferior a la diagonal secundaria con la diagonal \n\n"); + mostrar_elementos_triang_inf_diag_sec_con_diag(mat,FIL,COL); + + printf("\n\n Diagonal principal \n"); + mostrar_diagonal_principal(mat,FIL,COL); + printf("\n\n Diagonal secundaria \n"); + mostrar_diagonal_secundaria(mat,FIL,COL); + + printf("\n\n Triángulo superior a la diagonal principal (sin la diagonal) \n"); + mostrar_triang_sup_diag_pral_sin_diag(mat,FIL,COL); + printf("\n\n Triángulo inferior a la diagonal principal (sin la diagonal) \n"); + mostrar_triang_inf_diag_pral_sin_diag(mat,FIL,COL); + printf("\n\n Triángulo superior a la diagonal secundaria (sin la diagonal) \n"); + mostrar_triang_sup_diag_sec_sin_diag(mat,FIL,COL); + printf("\n\n Triángulo inferior a la diagonal secundaria (sin la diagonal) \n"); + mostrar_triang_inf_diag_sec_sin_diag(mat,FIL,COL); + + printf("\n\n Triángulo superior a la diagonal principal (con la diagonal) \n"); + mostrar_triang_sup_diag_pral_con_diag(mat,FIL,COL); + printf("\n\n Triángulo inferior a la diagonal principal (con la diagonal) \n"); + mostrar_triang_inf_diag_pral_con_diag(mat,FIL,COL); + printf("\n\n Triángulo superior a la diagonal secundaria (con la diagonal) \n"); + mostrar_triang_sup_diag_sec_con_diag(mat,FIL,COL); + printf("\n\n Triángulo inferior a la diagonal secundaria (con la diagonal) \n"); + mostrar_triang_inf_diag_sec_con_diag(mat,FIL,COL); + + printf("\n\n Triángulo arriba de las diagonales (sin las diagonales) \n"); + mostrar_triang_arriba_diagonales_sin_diag(mat,FIL,COL); + printf("\n\n Triángulo abajo de las diagonales (sin las diagonales) \n"); + mostrar_triang_abajo_diagonales_sin_diag(mat,FIL,COL); + printf("\n\n Triángulo a la izquierda de las diagonales (sin las diagonales) \n"); + mostrar_triang_izquierda_diagonales_sin_diag(mat,FIL,COL); + printf("\n\n Triángulo a la derecha de las diagonales (sin las diagonales) \n"); + mostrar_triang_derecha_diagonales_sin_diag(mat,FIL,COL); + + printf("\n\n Triángulo arriba de las diagonales (con las diagonales) \n"); + mostrar_triang_arriba_diagonales_con_diag(mat,FIL,COL); + printf("\n\n Triángulo abajo de las diagonales (con las diagonales) \n"); + mostrar_triang_abajo_diagonales_con_diag(mat,FIL,COL); + printf("\n\n Triángulo a la izquierda de las diagonales (con las diagonales) \n"); + mostrar_triang_izquierda_diagonales_con_diag(mat,FIL,COL); + printf("\n\n Triángulo a la derecha de las diagonales (con las diagonales) \n"); + mostrar_triang_derecha_diagonales_con_diag(mat,FIL,COL); + + printf("\n\n Matriz transpuesta \n"); + mostrar_transpuesta(mat,FIL,COL); + printf("\n\n Matriz opuesta \n"); + mostrar_opuesta(mat,FIL,COL); + printf("\n\n Matriz mostrada en espiral \n"); + mostrar_en_espiral(mat,FIL,COL); + printf("\n\n Matriz mostrada en zigzag horizontal \n"); + mostrar_en_zigzag_horizontal(mat,FIL,COL); + printf("\n\n Matriz en lluvia desde el primer elemento de la última fila \n"); + mostrar_en_lluvia_desde_ultima_fila(mat,FIL,COL); + + printf("\n\n Traza principal de la matriz = %d \n",traza_diag_pral(mat,FIL,COL)); + printf("\n\n Traza secundaria de la matriz = %d \n",traza_diag_sec(mat,FIL,COL)); + + printf("\n\n La matriz %s nula \n",es_matriz_nula(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s diagonal \n",es_matriz_diagonal(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s identidad \n",es_matriz_identidad(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s escalar \n",es_matriz_escalar(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s antisimétrica \n",es_antisimetrica(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s simétrica respecto a la diagonal principal \n",es_simetrica_respecto_diag_pral(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s simétrica respecto a la diagonal secundaria \n",es_simetrica_respecto_diag_secund(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s simétrica horizontalmente \n",es_simetrica_horizontalmente(mat,FIL,COL)?"es":"no es"); + printf("\n\n La matriz %s simétrica verticalmente \n",es_simetrica_verticalmente(mat,FIL,COL)?"es":"no es"); + + printf("\n\n\t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } diff --git a/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.cbp b/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.cbp new file mode 100644 index 0000000..d7006d3 --- /dev/null +++ b/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.depend b/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.depend new file mode 100644 index 0000000..101b4ca --- /dev/null +++ b/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473028061 source:d:\unlam\programaciÓn\fabian 2\matrices cuadradas_todas las funciones\functions.c + "header.h" + +1473023086 d:\unlam\programaciÓn\fabian 2\matrices cuadradas_todas las funciones\header.h + + + + + +1473021624 source:d:\unlam\programaciÓn\fabian 2\matrices cuadradas_todas las funciones\main.c + "header.h" + diff --git a/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.layout b/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.layout new file mode 100644 index 0000000..8c4776f --- /dev/null +++ b/matrices cuadradas_todas las funciones/matrices cuadradas_todas las funciones.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices cuadradas_todas las funciones/obj/Debug/functions.o b/matrices cuadradas_todas las funciones/obj/Debug/functions.o new file mode 100644 index 0000000..9968ee6 Binary files /dev/null and b/matrices cuadradas_todas las funciones/obj/Debug/functions.o differ diff --git a/matrices cuadradas_todas las funciones/obj/Debug/main.o b/matrices cuadradas_todas las funciones/obj/Debug/main.o new file mode 100644 index 0000000..9a52729 Binary files /dev/null and b/matrices cuadradas_todas las funciones/obj/Debug/main.o differ diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/bin/Debug/matrices_cargar y mostrar con aritm\303\251tica de punteros.exe" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/bin/Debug/matrices_cargar y mostrar con aritm\303\251tica de punteros.exe" new file mode 100644 index 0000000..9024c0f Binary files /dev/null and "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/bin/Debug/matrices_cargar y mostrar con aritm\303\251tica de punteros.exe" differ diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/functions.c" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/functions.c" new file mode 100644 index 0000000..d80255c --- /dev/null +++ "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/functions.c" @@ -0,0 +1,31 @@ +#include "header.h" + +void cargar_matriz_con_aritmetica(int *m,int f,int c) + { + int i,j; + printf("\n Cargue los datos de la matriz \n"); + for(i=0;i +#include +#include +#define FIL 10 +#define COL 10 +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_matriz_con_aritmetica(int*,int,int); +void mostrar_matriz(int*,int,int); + diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/main.c" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/main.c" new file mode 100644 index 0000000..788d146 --- /dev/null +++ "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/main.c" @@ -0,0 +1,36 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int f,c,band; + printf("\n CARGAR Y MOSTRAR MATRIZ USANDO ARITMÉTICA DE PUNTEROS \n"); + printf("\n Ingrese los datos de la matriz que desea cargar \n (orden máximo: %d*%d) \n",FIL,COL); + band=0; + do + { + if(band==1) + printf("\n No es posible que esta matriz tenga esa cantidad de filas. \n Reingrese el dato: \n"); + printf("\n FILAS: \n\n\t\t"); + scanf("%d",&f); + band=1; + } + while(!DATO_VALIDO(f,1,FIL)); + band=0; + do + { + if(band==1) + printf("\n No es posible que esta matriz tenga esa cantidad de columnas. \n Reingrese el dato: \n"); + printf("\n COLUMNAS: \n\n\t\t"); + scanf("%d",&c); + band=1; + } + while(!DATO_VALIDO(c,1,COL)); + int mat[f][c]; + cargar_matriz_con_aritmetica(&mat,f,c); + mostrar_matriz(&mat,f,c); + printf("\n\n"); + getch(); + return 0; + } + diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.cbp" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.cbp" new file mode 100644 index 0000000..8de910a --- /dev/null +++ "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.depend" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.depend" new file mode 100644 index 0000000..831dcf6 --- /dev/null +++ "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.depend" @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1473006282 source:d:\unlam\programaciÓn\fabian 2\matrices_cargar y mostrar con aritmética de punteros\main.c + "header.h" + +1473006236 d:\unlam\programaciÓn\fabian 2\matrices_cargar y mostrar con aritmética de punteros\header.h + + + + diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.layout" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.layout" new file mode 100644 index 0000000..2e089a3 --- /dev/null +++ "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/matrices_cargar y mostrar con aritm\303\251tica de punteros.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/obj/Debug/functions.o" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/obj/Debug/functions.o" new file mode 100644 index 0000000..217e015 Binary files /dev/null and "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/obj/Debug/functions.o" differ diff --git "a/matrices_cargar y mostrar con aritm\303\251tica de punteros/obj/Debug/main.o" "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/obj/Debug/main.o" new file mode 100644 index 0000000..45ae718 Binary files /dev/null and "b/matrices_cargar y mostrar con aritm\303\251tica de punteros/obj/Debug/main.o" differ diff --git a/matrices_es diagonal/bin/Debug/matrices_es diagonal.exe b/matrices_es diagonal/bin/Debug/matrices_es diagonal.exe new file mode 100644 index 0000000..45d1469 Binary files /dev/null and b/matrices_es diagonal/bin/Debug/matrices_es diagonal.exe differ diff --git a/matrices_es diagonal/functions.c b/matrices_es diagonal/functions.c new file mode 100644 index 0000000..24931c8 --- /dev/null +++ b/matrices_es diagonal/functions.c @@ -0,0 +1,36 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +int es_matriz_diagonal(int[][COL],int,int); diff --git a/matrices_es diagonal/main.c b/matrices_es diagonal/main.c new file mode 100644 index 0000000..68e5ace --- /dev/null +++ b/matrices_es diagonal/main.c @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t *******************"); + printf("\n\t * MATRIZ DIAGONAL *"); + printf("\n\t *******************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n La matriz %s diagonal \n",es_matriz_diagonal(mat,FIL,COL)?"es":"no es"); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_es diagonal/matrices_es diagonal.cbp b/matrices_es diagonal/matrices_es diagonal.cbp new file mode 100644 index 0000000..9101ff4 --- /dev/null +++ b/matrices_es diagonal/matrices_es diagonal.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_es diagonal/matrices_es diagonal.layout b/matrices_es diagonal/matrices_es diagonal.layout new file mode 100644 index 0000000..3f02d48 --- /dev/null +++ b/matrices_es diagonal/matrices_es diagonal.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_es diagonal/obj/Debug/functions.o b/matrices_es diagonal/obj/Debug/functions.o new file mode 100644 index 0000000..08b6d75 Binary files /dev/null and b/matrices_es diagonal/obj/Debug/functions.o differ diff --git a/matrices_es diagonal/obj/Debug/main.o b/matrices_es diagonal/obj/Debug/main.o new file mode 100644 index 0000000..0fe8df3 Binary files /dev/null and b/matrices_es diagonal/obj/Debug/main.o differ diff --git a/matrices_es identidad/bin/Debug/matrices_es identidad.exe b/matrices_es identidad/bin/Debug/matrices_es identidad.exe new file mode 100644 index 0000000..82a683a Binary files /dev/null and b/matrices_es identidad/bin/Debug/matrices_es identidad.exe differ diff --git a/matrices_es identidad/functions.c b/matrices_es identidad/functions.c new file mode 100644 index 0000000..9c40489 --- /dev/null +++ b/matrices_es identidad/functions.c @@ -0,0 +1,40 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +int es_matriz_identidad(int[][COL],int,int); diff --git a/matrices_es identidad/main.c b/matrices_es identidad/main.c new file mode 100644 index 0000000..304cbb4 --- /dev/null +++ b/matrices_es identidad/main.c @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t *******************"); + printf("\n\t * MATRIZ DIAGONAL *"); + printf("\n\t *******************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n La matriz %s identidad \n",es_matriz_identidad(mat,FIL,COL)?"es":"no es"); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_es identidad/matrices_es identidad.cbp b/matrices_es identidad/matrices_es identidad.cbp new file mode 100644 index 0000000..358f0cc --- /dev/null +++ b/matrices_es identidad/matrices_es identidad.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_es identidad/matrices_es identidad.depend b/matrices_es identidad/matrices_es identidad.depend new file mode 100644 index 0000000..f5d5c54 --- /dev/null +++ b/matrices_es identidad/matrices_es identidad.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473032435 source:d:\unlam\programaciÓn\fabian 2\matrices_es identidad\functions.c + "header.h" + +1473032382 d:\unlam\programaciÓn\fabian 2\matrices_es identidad\header.h + + + + +1473032504 source:d:\unlam\programaciÓn\fabian 2\matrices_es identidad\main.c + "header.h" + diff --git a/matrices_es identidad/matrices_es identidad.layout b/matrices_es identidad/matrices_es identidad.layout new file mode 100644 index 0000000..f41843f --- /dev/null +++ b/matrices_es identidad/matrices_es identidad.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_es identidad/obj/Debug/functions.o b/matrices_es identidad/obj/Debug/functions.o new file mode 100644 index 0000000..26574c2 Binary files /dev/null and b/matrices_es identidad/obj/Debug/functions.o differ diff --git a/matrices_es identidad/obj/Debug/main.o b/matrices_es identidad/obj/Debug/main.o new file mode 100644 index 0000000..efb09a1 Binary files /dev/null and b/matrices_es identidad/obj/Debug/main.o differ diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/bin/Debug/matrices_es sim\303\251trica respecto diagonal principal.exe" "b/matrices_es sim\303\251trica respecto diagonal principal/bin/Debug/matrices_es sim\303\251trica respecto diagonal principal.exe" new file mode 100644 index 0000000..bf4f2a4 Binary files /dev/null and "b/matrices_es sim\303\251trica respecto diagonal principal/bin/Debug/matrices_es sim\303\251trica respecto diagonal principal.exe" differ diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/functions.c" "b/matrices_es sim\303\251trica respecto diagonal principal/functions.c" new file mode 100644 index 0000000..ef35edd --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal principal/functions.c" @@ -0,0 +1,36 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +int es_simetrica_respecto_diag_pral(int[][COL],int,int); diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/main.c" "b/matrices_es sim\303\251trica respecto diagonal principal/main.c" new file mode 100644 index 0000000..69c2d0d --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal principal/main.c" @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ********************"); + printf("\n\t * MATRIZ SIMÉTRICA *"); + printf("\n\t ********************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n La matriz %s simétrica respecto a la diagonal principal \n",es_simetrica_respecto_diag_pral(mat,FIL,COL)?"es":"no es"); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.cbp" "b/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.cbp" new file mode 100644 index 0000000..79a714e --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.depend" "b/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.depend" new file mode 100644 index 0000000..4b77b7c --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.depend" @@ -0,0 +1,17 @@ +# depslib dependency file v1.0 +1473032830 source:d:\unlam\programaciÓn\fabian 2\matrices_es simétrica respecto diagonal principal\main.c + "header.h" + +1473032721 d:\unlam\programaciÓn\fabian 2\matrices_es simétrica respecto diagonal principal\header.h + + + + +1473032860 source:d:\unlam\programaciÓn\fabian\matrices_es simétrica respecto diagonal principal\functions.c + "header.h" + +1473032721 d:\unlam\programaciÓn\fabian\matrices_es simétrica respecto diagonal principal\header.h + + + + diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.layout" "b/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.layout" new file mode 100644 index 0000000..2d5a48a --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal principal/matrices_es sim\303\251trica respecto diagonal principal.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/obj/Debug/functions.o" "b/matrices_es sim\303\251trica respecto diagonal principal/obj/Debug/functions.o" new file mode 100644 index 0000000..4e9fe63 Binary files /dev/null and "b/matrices_es sim\303\251trica respecto diagonal principal/obj/Debug/functions.o" differ diff --git "a/matrices_es sim\303\251trica respecto diagonal principal/obj/Debug/main.o" "b/matrices_es sim\303\251trica respecto diagonal principal/obj/Debug/main.o" new file mode 100644 index 0000000..c84985e Binary files /dev/null and "b/matrices_es sim\303\251trica respecto diagonal principal/obj/Debug/main.o" differ diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/bin/Debug/matrices_es sim\303\251trica respecto diagonal secundaria.exe" "b/matrices_es sim\303\251trica respecto diagonal secundaria/bin/Debug/matrices_es sim\303\251trica respecto diagonal secundaria.exe" new file mode 100644 index 0000000..9cb8b34 Binary files /dev/null and "b/matrices_es sim\303\251trica respecto diagonal secundaria/bin/Debug/matrices_es sim\303\251trica respecto diagonal secundaria.exe" differ diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/functions.c" "b/matrices_es sim\303\251trica respecto diagonal secundaria/functions.c" new file mode 100644 index 0000000..9ec3ffc --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal secundaria/functions.c" @@ -0,0 +1,36 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +int es_simetrica_respecto_diag_secund(int[][COL],int,int); + diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/main.c" "b/matrices_es sim\303\251trica respecto diagonal secundaria/main.c" new file mode 100644 index 0000000..7cb4225 --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal secundaria/main.c" @@ -0,0 +1,18 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ********************"); + printf("\n\t * MATRIZ SIMÉTRICA *"); + printf("\n\t ********************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n La matriz %s simétrica respecto a la diagonal secundaria \n",es_simetrica_respecto_diag_secund(mat,FIL,COL)?"es":"no es"); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } + diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.cbp" "b/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.cbp" new file mode 100644 index 0000000..4da98d0 --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.depend" "b/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.depend" new file mode 100644 index 0000000..0901588 --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1476049596 source:d:\unlam\programaciÓn\fabian\matrices_es simétrica respecto diagonal secundaria\functions.c + "header.h" + +1476049366 d:\unlam\programaciÓn\fabian\matrices_es simétrica respecto diagonal secundaria\header.h + + + + +1476049358 source:d:\unlam\programaciÓn\fabian\matrices_es simétrica respecto diagonal secundaria\main.c + "header.h" + diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.layout" "b/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.layout" new file mode 100644 index 0000000..2ca3fd8 --- /dev/null +++ "b/matrices_es sim\303\251trica respecto diagonal secundaria/matrices_es sim\303\251trica respecto diagonal secundaria.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/obj/Debug/functions.o" "b/matrices_es sim\303\251trica respecto diagonal secundaria/obj/Debug/functions.o" new file mode 100644 index 0000000..37acf8e Binary files /dev/null and "b/matrices_es sim\303\251trica respecto diagonal secundaria/obj/Debug/functions.o" differ diff --git "a/matrices_es sim\303\251trica respecto diagonal secundaria/obj/Debug/main.o" "b/matrices_es sim\303\251trica respecto diagonal secundaria/obj/Debug/main.o" new file mode 100644 index 0000000..f959a8e Binary files /dev/null and "b/matrices_es sim\303\251trica respecto diagonal secundaria/obj/Debug/main.o" differ diff --git a/matrices_mostrar transpuesta/bin/Debug/matrices_mostrar transpuesta.exe b/matrices_mostrar transpuesta/bin/Debug/matrices_mostrar transpuesta.exe new file mode 100644 index 0000000..c8a1c45 Binary files /dev/null and b/matrices_mostrar transpuesta/bin/Debug/matrices_mostrar transpuesta.exe differ diff --git a/matrices_mostrar transpuesta/functions.c b/matrices_mostrar transpuesta/functions.c new file mode 100644 index 0000000..ac33c08 --- /dev/null +++ b/matrices_mostrar transpuesta/functions.c @@ -0,0 +1,41 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +void mostrar_transpuesta(int[][COL],int,int); diff --git a/matrices_mostrar transpuesta/main.c b/matrices_mostrar transpuesta/main.c new file mode 100644 index 0000000..43c2160 --- /dev/null +++ b/matrices_mostrar transpuesta/main.c @@ -0,0 +1,18 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ***********************"); + printf("\n\t * MATRIZ TRANSPUESTA *"); + printf("\n\t ***********************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n Matriz transpuesta \n"); + mostrar_transpuesta(mat,FIL,COL); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_mostrar transpuesta/matrices_mostrar transpuesta.cbp b/matrices_mostrar transpuesta/matrices_mostrar transpuesta.cbp new file mode 100644 index 0000000..5e667ef --- /dev/null +++ b/matrices_mostrar transpuesta/matrices_mostrar transpuesta.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_mostrar transpuesta/matrices_mostrar transpuesta.layout b/matrices_mostrar transpuesta/matrices_mostrar transpuesta.layout new file mode 100644 index 0000000..adb4013 --- /dev/null +++ b/matrices_mostrar transpuesta/matrices_mostrar transpuesta.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_mostrar transpuesta/obj/Debug/functions.o b/matrices_mostrar transpuesta/obj/Debug/functions.o new file mode 100644 index 0000000..a521a32 Binary files /dev/null and b/matrices_mostrar transpuesta/obj/Debug/functions.o differ diff --git a/matrices_mostrar transpuesta/obj/Debug/main.o b/matrices_mostrar transpuesta/obj/Debug/main.o new file mode 100644 index 0000000..e67e9ad Binary files /dev/null and b/matrices_mostrar transpuesta/obj/Debug/main.o differ diff --git a/matrices_producto entre matrices cuadradas de mismo orden/bin/Debug/matrices_producto entre matrices cuadradas de mismo orden.exe b/matrices_producto entre matrices cuadradas de mismo orden/bin/Debug/matrices_producto entre matrices cuadradas de mismo orden.exe new file mode 100644 index 0000000..02ddc69 Binary files /dev/null and b/matrices_producto entre matrices cuadradas de mismo orden/bin/Debug/matrices_producto entre matrices cuadradas de mismo orden.exe differ diff --git a/matrices_producto entre matrices cuadradas de mismo orden/functions.c b/matrices_producto entre matrices cuadradas de mismo orden/functions.c new file mode 100644 index 0000000..67cd25f --- /dev/null +++ b/matrices_producto entre matrices cuadradas de mismo orden/functions.c @@ -0,0 +1,38 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +void producto_matricial_cuadradas(int[][COL],int[][COL],int[][COL],int,int); diff --git a/matrices_producto entre matrices cuadradas de mismo orden/main.c b/matrices_producto entre matrices cuadradas de mismo orden/main.c new file mode 100644 index 0000000..4b7c6bf --- /dev/null +++ b/matrices_producto entre matrices cuadradas de mismo orden/main.c @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat1[FIL][COL],mat2[FIL][COL],mat3[FIL][COL]; + printf("\a\a\a"); + printf("\n\t *************************************************"); + printf("\n\t * MULTIPLICAR MATRICES CUADRADAS DE MISMO ORDEN *"); + printf("\n\t *************************************************"); + printf("\n Se le pedirá que ingrese dos matrices para luego multiplicarlas \n"); + cargar_matriz(mat1,FIL,COL); + cargar_matriz(mat2,FIL,COL); + printf("\n\n Matriz 1 \n"); + mostrar_matriz(mat1,FIL,COL); + printf("\n\n Matriz 2 \n"); + mostrar_matriz(mat2,FIL,COL); + producto_matricial_cuadradas(mat1,mat2,mat3,FIL,COL); + printf("\n\n Producto entre las matrices 1 y 2 \n"); + mostrar_matriz(mat3,FIL,COL); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_producto entre matrices cuadradas de mismo orden/matrices_producto entre matrices cuadradas de mismo orden.cbp b/matrices_producto entre matrices cuadradas de mismo orden/matrices_producto entre matrices cuadradas de mismo orden.cbp new file mode 100644 index 0000000..ee5fdf8 --- /dev/null +++ b/matrices_producto entre matrices cuadradas de mismo orden/matrices_producto entre matrices cuadradas de mismo orden.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_producto entre matrices cuadradas de mismo orden/matrices_producto entre matrices cuadradas de mismo orden.layout b/matrices_producto entre matrices cuadradas de mismo orden/matrices_producto entre matrices cuadradas de mismo orden.layout new file mode 100644 index 0000000..6132d1e --- /dev/null +++ b/matrices_producto entre matrices cuadradas de mismo orden/matrices_producto entre matrices cuadradas de mismo orden.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_producto entre matrices cuadradas de mismo orden/obj/Debug/functions.o b/matrices_producto entre matrices cuadradas de mismo orden/obj/Debug/functions.o new file mode 100644 index 0000000..c8efdef Binary files /dev/null and b/matrices_producto entre matrices cuadradas de mismo orden/obj/Debug/functions.o differ diff --git a/matrices_producto entre matrices cuadradas de mismo orden/obj/Debug/main.o b/matrices_producto entre matrices cuadradas de mismo orden/obj/Debug/main.o new file mode 100644 index 0000000..1f6c4b5 Binary files /dev/null and b/matrices_producto entre matrices cuadradas de mismo orden/obj/Debug/main.o differ diff --git a/matrices_producto matricial para cualesquiera dos matrices/bin/Debug/matrices_producto matricial para cualesquiera dos matrices.exe b/matrices_producto matricial para cualesquiera dos matrices/bin/Debug/matrices_producto matricial para cualesquiera dos matrices.exe new file mode 100644 index 0000000..cad4c80 Binary files /dev/null and b/matrices_producto matricial para cualesquiera dos matrices/bin/Debug/matrices_producto matricial para cualesquiera dos matrices.exe differ diff --git a/matrices_producto matricial para cualesquiera dos matrices/functions.c b/matrices_producto matricial para cualesquiera dos matrices/functions.c new file mode 100644 index 0000000..46eda78 --- /dev/null +++ b/matrices_producto matricial para cualesquiera dos matrices/functions.c @@ -0,0 +1,38 @@ +#include "header.h" +void cargar_matriz(int m[][TOPE],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define TOPE 10 +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_matriz(int[][TOPE],int,int); +void mostrar_matriz(int[][TOPE],int,int); +void producto_matricial(int[][TOPE],int[][TOPE],int[][TOPE],int,int,int,int); diff --git a/matrices_producto matricial para cualesquiera dos matrices/main.c b/matrices_producto matricial para cualesquiera dos matrices/main.c new file mode 100644 index 0000000..34113a6 --- /dev/null +++ b/matrices_producto matricial para cualesquiera dos matrices/main.c @@ -0,0 +1,73 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int f1,c1,f2,c2,band; + printf("\a\a\a"); + printf("\n\t ************************"); + printf("\n\t * MULTIPLICAR MATRICES *"); + printf("\n\t ************************"); + printf("\n Ingrese los datos de la primera matriz que desea cargar \n (orden máximo: %d*%d) \n",TOPE,TOPE); + band=0; + do + { + if(band==1) + printf("\n No es posible que una matriz tenga esa cantidad de filas. \n Reingrese el dato: \n"); + printf("\n FILAS: \n\n\t\t"); + scanf("%d",&f1); + band=1; + } + while(!DATO_VALIDO(f1,1,10)); + band=0; + do + { + if(band==1) + printf("\n No es posible que una matriz tenga esa cantidad de columnas. \n Reingrese el dato: \n"); + printf("\n COLUMNAS: \n\n\t\t"); + scanf("%d",&c1); + band=1; + } + while(!DATO_VALIDO(c1,1,10)); + printf("\n Ingrese los datos de la segunda matriz que desea cargar \n (orden máximo: %d*%d) \n",TOPE,TOPE); + band=0; + do + { + if(band==1) + printf("\n No es posible que una matriz tenga esa cantidad de filas. \n Reingrese el dato: \n"); + printf("\n FILAS: \n\n\t\t"); + scanf("%d",&f2); + band=1; + } + while(!DATO_VALIDO(f2,1,10)); + band=0; + do + { + if(band==1) + printf("\n No es posible que una matriz tenga esa cantidad de columnas. \n Reingrese el dato: \n"); + printf("\n COLUMNAS: \n\n\t\t"); + scanf("%d",&c2); + band=1; + } + while(!DATO_VALIDO(c2,1,10)); + if(c1==f2) + { + int mat1[f1][c1]; + cargar_matriz(mat1,f1,c1); + int mat2[f2][c2]; + cargar_matriz(mat2,f2,c2); + printf("\n\n Matriz 1 \n"); + mostrar_matriz(mat1,f1,c1); + printf("\n\n Matriz 2 \n"); + mostrar_matriz(mat2,f2,c2); + int mat3[f1][c2]; + producto_matricial(mat1,mat2,mat3,f1,c1,f2,c2); + printf("\n\n Matriz resultante del producto matricial \n\n"); + mostrar_matriz(mat3,f1,c2); + } + else + printf("\n\n Matrices con esas dimensiones no se pueden mulitiplicar porque la cantidad \n de columnas de la primera matriz es diferente a la cantidad \n de filas de la segunda matriz \n\n"); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } + diff --git a/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.cbp b/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.cbp new file mode 100644 index 0000000..7320b02 --- /dev/null +++ b/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.depend b/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.depend new file mode 100644 index 0000000..17aa647 --- /dev/null +++ b/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473035142 source:d:\unlam\programaciÓn\fabian 2\matrices_producto matricial para cualesquiera dos matrices\functions.c + "header.h" + +1473035239 d:\unlam\programaciÓn\fabian 2\matrices_producto matricial para cualesquiera dos matrices\header.h + + + + +1473035166 source:d:\unlam\programaciÓn\fabian 2\matrices_producto matricial para cualesquiera dos matrices\main.c + "header.h" + diff --git a/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.layout b/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.layout new file mode 100644 index 0000000..4b8d50f --- /dev/null +++ b/matrices_producto matricial para cualesquiera dos matrices/matrices_producto matricial para cualesquiera dos matrices.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_producto matricial para cualesquiera dos matrices/obj/Debug/functions.o b/matrices_producto matricial para cualesquiera dos matrices/obj/Debug/functions.o new file mode 100644 index 0000000..accc9ce Binary files /dev/null and b/matrices_producto matricial para cualesquiera dos matrices/obj/Debug/functions.o differ diff --git a/matrices_producto matricial para cualesquiera dos matrices/obj/Debug/main.o b/matrices_producto matricial para cualesquiera dos matrices/obj/Debug/main.o new file mode 100644 index 0000000..33cc991 Binary files /dev/null and b/matrices_producto matricial para cualesquiera dos matrices/obj/Debug/main.o differ diff --git a/matrices_sumar y restar dos matrices/bin/Debug/matrices_sumar y restar dos matrices.exe b/matrices_sumar y restar dos matrices/bin/Debug/matrices_sumar y restar dos matrices.exe new file mode 100644 index 0000000..109cdc2 Binary files /dev/null and b/matrices_sumar y restar dos matrices/bin/Debug/matrices_sumar y restar dos matrices.exe differ diff --git a/matrices_sumar y restar dos matrices/functions.c b/matrices_sumar y restar dos matrices/functions.c new file mode 100644 index 0000000..21620d1 --- /dev/null +++ b/matrices_sumar y restar dos matrices/functions.c @@ -0,0 +1,41 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +void sumar_matrices(int[][COL],int[][COL],int[][COL],int,int); +void restar_matrices(int[][COL],int[][COL],int[][COL],int,int); + diff --git a/matrices_sumar y restar dos matrices/main.c b/matrices_sumar y restar dos matrices/main.c new file mode 100644 index 0000000..d6d4aef --- /dev/null +++ b/matrices_sumar y restar dos matrices/main.c @@ -0,0 +1,26 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat1[FIL][COL],mat2[FIL][COL],mat3[FIL][COL],mat4[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ***************************"); + printf("\n\t * SUMAR Y RESTAR MATRICES *"); + printf("\n\t ***************************"); + printf("\n Se le pedirá que ingrese dos matrices para luego operarlas entre sí \n"); + cargar_matriz(mat1,FIL,COL); + cargar_matriz(mat2,FIL,COL); + printf("\n\n Matriz 1 \n"); + mostrar_matriz(mat1,FIL,COL); + printf("\n\n Matriz 2 \n"); + mostrar_matriz(mat2,FIL,COL); + sumar_matrices(mat1,mat2,mat3,FIL,COL); + printf("\n\n Suma entre las matrices 1 y 2 \n"); + mostrar_matriz(mat3,FIL,COL); + restar_matrices(mat1,mat2,mat4,FIL,COL); + printf("\n\n Resta entre las matrices 1 y 2 \n"); + mostrar_matriz(mat4,FIL,COL); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.cbp b/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.cbp new file mode 100644 index 0000000..0c2f862 --- /dev/null +++ b/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.depend b/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.depend new file mode 100644 index 0000000..22d199e --- /dev/null +++ b/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473035550 source:d:\unlam\programaciÓn\fabian 2\matrices_sumar y restar dos matrices\functions.c + "header.h" + +1473035470 d:\unlam\programaciÓn\fabian 2\matrices_sumar y restar dos matrices\header.h + + + + +1473035683 source:d:\unlam\programaciÓn\fabian 2\matrices_sumar y restar dos matrices\main.c + "header.h" + diff --git a/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.layout b/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.layout new file mode 100644 index 0000000..b76f640 --- /dev/null +++ b/matrices_sumar y restar dos matrices/matrices_sumar y restar dos matrices.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_sumar y restar dos matrices/obj/Debug/functions.o b/matrices_sumar y restar dos matrices/obj/Debug/functions.o new file mode 100644 index 0000000..c6ca411 Binary files /dev/null and b/matrices_sumar y restar dos matrices/obj/Debug/functions.o differ diff --git a/matrices_sumar y restar dos matrices/obj/Debug/main.o b/matrices_sumar y restar dos matrices/obj/Debug/main.o new file mode 100644 index 0000000..b979f38 Binary files /dev/null and b/matrices_sumar y restar dos matrices/obj/Debug/main.o differ diff --git "a/matrices_sumatorias de los tri\303\241ngulos/bin/Debug/matrices_sumatorias de los tri\303\241ngulos.exe" "b/matrices_sumatorias de los tri\303\241ngulos/bin/Debug/matrices_sumatorias de los tri\303\241ngulos.exe" new file mode 100644 index 0000000..a7a6ab3 Binary files /dev/null and "b/matrices_sumatorias de los tri\303\241ngulos/bin/Debug/matrices_sumatorias de los tri\303\241ngulos.exe" differ diff --git "a/matrices_sumatorias de los tri\303\241ngulos/functions.c" "b/matrices_sumatorias de los tri\303\241ngulos/functions.c" new file mode 100644 index 0000000..978f75e --- /dev/null +++ "b/matrices_sumatorias de los tri\303\241ngulos/functions.c" @@ -0,0 +1,91 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); + +int sumar_elementos_triang_sup_diag_pral_sin_diag(int[][COL],int,int); +int sumar_elementos_triang_inf_diag_pral_sin_diag(int[][COL],int,int); +int sumar_elementos_triang_sup_diag_sec_sin_diag(int[][COL],int,int); +int sumar_elementos_triang_inf_diag_sec_sin_diag(int[][COL],int,int); + +int sumar_elementos_triang_sup_diag_pral_con_diag(int[][COL],int,int); +int sumar_elementos_triang_inf_diag_pral_con_diag(int[][COL],int,int); +int sumar_elementos_triang_sup_diag_sec_con_diag(int[][COL],int,int); +int sumar_elementos_triang_inf_diag_sec_con_diag(int[][COL],int,int); diff --git "a/matrices_sumatorias de los tri\303\241ngulos/main.c" "b/matrices_sumatorias de los tri\303\241ngulos/main.c" new file mode 100644 index 0000000..0bd8e34 --- /dev/null +++ "b/matrices_sumatorias de los tri\303\241ngulos/main.c" @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ***************************************************************"); + printf("\n\t * SUMATORIAS DE LOS ELEMENTOS DE LOS TRIÁNGULOS DE UNA MATRIZ *"); + printf("\n\t ***************************************************************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n Sumatoria de los elementos del triángulo superior \n a la diagonal principal, sin incluirla: \t %d",sumar_elementos_triang_sup_diag_pral_sin_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo inferior \n a la diagonal principal, sin incluirla: \t %d",sumar_elementos_triang_inf_diag_pral_sin_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo superior \n a la diagonal secundaria, sin incluirla: \t %d",sumar_elementos_triang_sup_diag_sec_sin_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo inferior \n a la diagonal secundaria, sin incluirla: \t %d",sumar_elementos_triang_inf_diag_sec_sin_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo superior \n a la diagonal principal, incluyéndola: \t %d",sumar_elementos_triang_sup_diag_pral_con_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo inferior \n a la diagonal principal, incluyéndola: \t %d",sumar_elementos_triang_inf_diag_pral_con_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo superior \n a la diagonal secundaria, incluyéndola: \t %d",sumar_elementos_triang_sup_diag_sec_con_diag(mat,FIL,COL)); + printf("\n\n Sumatoria de los elementos del triángulo inferior \n a la diagonal secundaria, incluyéndola: \t %d",sumar_elementos_triang_inf_diag_sec_con_diag(mat,FIL,COL)); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git "a/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.cbp" "b/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.cbp" new file mode 100644 index 0000000..2baa570 --- /dev/null +++ "b/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.depend" "b/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.depend" new file mode 100644 index 0000000..b17e124 --- /dev/null +++ "b/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473030335 source:d:\unlam\programaciÓn\fabian 2\matrices_sumatorias de los triángulos\functions.c + "header.h" + +1473030801 d:\unlam\programaciÓn\fabian 2\matrices_sumatorias de los triángulos\header.h + + + + +1473031026 source:d:\unlam\programaciÓn\fabian 2\matrices_sumatorias de los triángulos\main.c + "header.h" + diff --git "a/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.layout" "b/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.layout" new file mode 100644 index 0000000..a329bad --- /dev/null +++ "b/matrices_sumatorias de los tri\303\241ngulos/matrices_sumatorias de los tri\303\241ngulos.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/matrices_sumatorias de los tri\303\241ngulos/obj/Debug/functions.o" "b/matrices_sumatorias de los tri\303\241ngulos/obj/Debug/functions.o" new file mode 100644 index 0000000..e90d2e8 Binary files /dev/null and "b/matrices_sumatorias de los tri\303\241ngulos/obj/Debug/functions.o" differ diff --git "a/matrices_sumatorias de los tri\303\241ngulos/obj/Debug/main.o" "b/matrices_sumatorias de los tri\303\241ngulos/obj/Debug/main.o" new file mode 100644 index 0000000..085cf05 Binary files /dev/null and "b/matrices_sumatorias de los tri\303\241ngulos/obj/Debug/main.o" differ diff --git a/matrices_transponer in situ/bin/Debug/matrices_transponer in situ.exe b/matrices_transponer in situ/bin/Debug/matrices_transponer in situ.exe new file mode 100644 index 0000000..6a4023d Binary files /dev/null and b/matrices_transponer in situ/bin/Debug/matrices_transponer in situ.exe differ diff --git a/matrices_transponer in situ/functions.c b/matrices_transponer in situ/functions.c new file mode 100644 index 0000000..70d6077 --- /dev/null +++ b/matrices_transponer in situ/functions.c @@ -0,0 +1,38 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +void transponer_in_situ(int[][COL],int,int); diff --git a/matrices_transponer in situ/main.c b/matrices_transponer in situ/main.c new file mode 100644 index 0000000..7f317d4 --- /dev/null +++ b/matrices_transponer in situ/main.c @@ -0,0 +1,19 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ***********************"); + printf("\n\t * MATRIZ TRANSPUESTA *"); + printf("\n\t ***********************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n Matriz transpuesta \n"); + transponer_in_situ(mat,FIL,COL); + mostrar_matriz(mat,FIL,COL); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_transponer in situ/matrices_transponer in situ.cbp b/matrices_transponer in situ/matrices_transponer in situ.cbp new file mode 100644 index 0000000..071bda3 --- /dev/null +++ b/matrices_transponer in situ/matrices_transponer in situ.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_transponer in situ/matrices_transponer in situ.layout b/matrices_transponer in situ/matrices_transponer in situ.layout new file mode 100644 index 0000000..ee2f75b --- /dev/null +++ b/matrices_transponer in situ/matrices_transponer in situ.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_transponer in situ/obj/Debug/functions.o b/matrices_transponer in situ/obj/Debug/functions.o new file mode 100644 index 0000000..bd838d1 Binary files /dev/null and b/matrices_transponer in situ/obj/Debug/functions.o differ diff --git a/matrices_transponer in situ/obj/Debug/main.o b/matrices_transponer in situ/obj/Debug/main.o new file mode 100644 index 0000000..b25aa7f Binary files /dev/null and b/matrices_transponer in situ/obj/Debug/main.o differ diff --git a/matrices_trazas de ambas diagonales/bin/Debug/matrices_trazas de ambas diagonales.exe b/matrices_trazas de ambas diagonales/bin/Debug/matrices_trazas de ambas diagonales.exe new file mode 100644 index 0000000..5b8696d Binary files /dev/null and b/matrices_trazas de ambas diagonales/bin/Debug/matrices_trazas de ambas diagonales.exe differ diff --git a/matrices_trazas de ambas diagonales/functions.c b/matrices_trazas de ambas diagonales/functions.c new file mode 100644 index 0000000..67c11dc --- /dev/null +++ b/matrices_trazas de ambas diagonales/functions.c @@ -0,0 +1,43 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); + +int traza_diag_pral(int[][COL],int,int); +int traza_diag_sec(int[][COL],int,int); diff --git a/matrices_trazas de ambas diagonales/main.c b/matrices_trazas de ambas diagonales/main.c new file mode 100644 index 0000000..2bab291 --- /dev/null +++ b/matrices_trazas de ambas diagonales/main.c @@ -0,0 +1,18 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int mat[FIL][COL]; + printf("\a\a\a"); + printf("\n\t ***********************"); + printf("\n\t * TRAZAS DE LA MATRIZ *"); + printf("\n\t ***********************"); + cargar_matriz(mat,FIL,COL); + printf("\n\n Matriz \n"); + mostrar_matriz(mat,FIL,COL); + printf("\n\n Traza principal de la matriz = %d \n",traza_diag_pral(mat,FIL,COL)); + printf("\n\n Traza secundaria de la matriz = %d \n",traza_diag_sec(mat,FIL,COL)); + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_trazas de ambas diagonales/matrices_trazas de ambas diagonales.cbp b/matrices_trazas de ambas diagonales/matrices_trazas de ambas diagonales.cbp new file mode 100644 index 0000000..36f51be --- /dev/null +++ b/matrices_trazas de ambas diagonales/matrices_trazas de ambas diagonales.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/matrices_trazas de ambas diagonales/matrices_trazas de ambas diagonales.layout b/matrices_trazas de ambas diagonales/matrices_trazas de ambas diagonales.layout new file mode 100644 index 0000000..a01b373 --- /dev/null +++ b/matrices_trazas de ambas diagonales/matrices_trazas de ambas diagonales.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_trazas de ambas diagonales/obj/Debug/functions.o b/matrices_trazas de ambas diagonales/obj/Debug/functions.o new file mode 100644 index 0000000..5fcdfd9 Binary files /dev/null and b/matrices_trazas de ambas diagonales/obj/Debug/functions.o differ diff --git a/matrices_trazas de ambas diagonales/obj/Debug/main.o b/matrices_trazas de ambas diagonales/obj/Debug/main.o new file mode 100644 index 0000000..6a922c2 Binary files /dev/null and b/matrices_trazas de ambas diagonales/obj/Debug/main.o differ diff --git a/matrices_vecinos de un elemento/bin/Debug/matrices_vecinos de un elemento.exe b/matrices_vecinos de un elemento/bin/Debug/matrices_vecinos de un elemento.exe new file mode 100644 index 0000000..c63096e Binary files /dev/null and b/matrices_vecinos de un elemento/bin/Debug/matrices_vecinos de un elemento.exe differ diff --git a/matrices_vecinos de un elemento/functions.c b/matrices_vecinos de un elemento/functions.c new file mode 100644 index 0000000..f406831 --- /dev/null +++ b/matrices_vecinos de un elemento/functions.c @@ -0,0 +1,37 @@ +#include "header.h" +void cargar_matriz(int m[][COL],int f,int c) + { + int i,j; + printf("\n\n %c Cargue los datos de la matriz de orden %dx%d \n",16,f,c); + for(i=0;i",m[x+i][y+j]); + } diff --git a/matrices_vecinos de un elemento/header.h b/matrices_vecinos de un elemento/header.h new file mode 100644 index 0000000..7f4afa6 --- /dev/null +++ b/matrices_vecinos de un elemento/header.h @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +#define FIL 5 +#define COL 5 + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); +void vecinos(int[][COL],int,int,int,int); diff --git a/matrices_vecinos de un elemento/main.c b/matrices_vecinos de un elemento/main.c new file mode 100644 index 0000000..918f453 --- /dev/null +++ b/matrices_vecinos de un elemento/main.c @@ -0,0 +1,60 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 0E"); + int mat[FIL][COL]; + + printf("\a\a\a"); + printf("\n\t\t ***************************************"); + printf("\n\t\t * VECINOS DE UN ELEMENTO DE LA MATRIZ *"); + printf("\n\t\t ***************************************"); + + printf("\n\n Complete el vecindario: \n "); + cargar_matriz(mat,FIL,COL); + int i,j,op,band; + do + { + system("cls"); + printf("\a\a\a"); + printf("\n\t\t ***************************************"); + printf("\n\t\t * VECINOS DE UN ELEMENTO DE LA MATRIZ *"); + printf("\n\t\t ***************************************"); + printf("\n\n VECINDARIO \n"); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n %c Descubra cuáles son los vecinos de alguien \n a partir de sus coordenadas en el vecindario: \n",16); + band=0; + do + { + if(band==1) + printf("\n\n Esa fila no está en el vecindario.\n\a\a"); + printf("\n Ingrese la fila (1 a %d): \t",FIL); + scanf("%d",&i); + band=1; + } + while(!DATO_VALIDO(i,1,FIL)); + band=0; + do + { + if(band==1) + printf("\n\n Esa columna no está en el vecindario.\n\a\a"); + printf("\n Ingrese la columna (1 a %d): \t",COL); + scanf("%d",&j); + band=1; + } + while(!DATO_VALIDO(j,1,COL)); + + printf("\n VECINOS: \n\n\a\a"); + vecinos(mat,FIL,COL,i-1,j-1); + + printf("\n\n ----------------------------------------------------------------------------- \n"); + printf("\n Para realizar una nueva búsqueda de vecinos, presione 1. \n\t Caso contrario, presione cualquier tecla:\t"); + scanf("%d",&op); + } + while(op==1); + + printf("\n\n\t\t\t\t Fin del programa....... \n\n\a\a\a"); + getch(); + return 0; + } diff --git a/matrices_vecinos de un elemento/matrices_vecinos de un elemento.cbp b/matrices_vecinos de un elemento/matrices_vecinos de un elemento.cbp new file mode 100644 index 0000000..de93bba --- /dev/null +++ b/matrices_vecinos de un elemento/matrices_vecinos de un elemento.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/matrices_vecinos de un elemento/matrices_vecinos de un elemento.depend b/matrices_vecinos de un elemento/matrices_vecinos de un elemento.depend new file mode 100644 index 0000000..7c4991e --- /dev/null +++ b/matrices_vecinos de un elemento/matrices_vecinos de un elemento.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1473044759 source:d:\unlam\programaciÓn\fabian 2\matrices_vecinos de un elemento\functions.c + "header.h" + +1473044893 d:\unlam\programaciÓn\fabian 2\matrices_vecinos de un elemento\header.h + + + + + +1473044529 source:d:\unlam\programaciÓn\fabian 2\matrices_vecinos de un elemento\main.c + "header.h" + diff --git a/matrices_vecinos de un elemento/matrices_vecinos de un elemento.layout b/matrices_vecinos de un elemento/matrices_vecinos de un elemento.layout new file mode 100644 index 0000000..968ab61 --- /dev/null +++ b/matrices_vecinos de un elemento/matrices_vecinos de un elemento.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/matrices_vecinos de un elemento/obj/Debug/functions.o b/matrices_vecinos de un elemento/obj/Debug/functions.o new file mode 100644 index 0000000..c5977b0 Binary files /dev/null and b/matrices_vecinos de un elemento/obj/Debug/functions.o differ diff --git a/matrices_vecinos de un elemento/obj/Debug/main.o b/matrices_vecinos de un elemento/obj/Debug/main.o new file mode 100644 index 0000000..5ae76fd Binary files /dev/null and b/matrices_vecinos de un elemento/obj/Debug/main.o differ diff --git a/merge de archivos_A - B/A - B.bin b/merge de archivos_A - B/A - B.bin new file mode 100644 index 0000000..449cd78 Binary files /dev/null and b/merge de archivos_A - B/A - B.bin differ diff --git a/merge de archivos_A - B/bin/Debug/merge de archivos_A - B.exe b/merge de archivos_A - B/bin/Debug/merge de archivos_A - B.exe new file mode 100644 index 0000000..cbde635 Binary files /dev/null and b/merge de archivos_A - B/bin/Debug/merge de archivos_A - B.exe differ diff --git a/merge de archivos_A - B/functions.c b/merge de archivos_A - B/functions.c new file mode 100644 index 0000000..b4faed3 --- /dev/null +++ b/merge de archivos_A - B/functions.c @@ -0,0 +1,82 @@ +#include "header.h" + +void A_menos_B_de_archivos_binarios(FILE *pf_A,FILE *pf_B,FILE *pf_A_menos_B) + { + int comparador; + + t_persona persona_A; + t_persona persona_B; + + rewind(pf_A); + rewind(pf_B); + rewind(pf_A_menos_B); + + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + + while(!feof(pf_A)&&!feof(pf_B)) + { + comparador=comparacion_de_registros(&persona_A,&persona_B); + + if(comparador<0) + { + fwrite(&persona_A,sizeof(t_persona),1,pf_A_menos_B); + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + else + if(comparador>0) + fread(&persona_B,sizeof(t_persona),1,pf_B); + else + { + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + + while(!feof(pf_A)) + { + fwrite(&persona_A,sizeof(t_persona),1,pf_A_menos_B); + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + } + +int comparacion_de_registros(t_persona *persona_1,t_persona *persona_2) + { + int comparador; + if((comparador=str_cmp(persona_1->apellido,persona_2->apellido))==0) + if((comparador=str_cmp(persona_1->nombre,persona_2->nombre))==0) + if(persona_1->dni==persona_2->dni) + return IGUAL; + else + if(persona_1->dni>persona_2->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } + +void mostrar_archivo_binario(FILE *pf) + { + t_persona registro; + rewind(pf); + fread(®istro,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo); + fread(®istro,sizeof(t_persona),1,pf); + } + } + diff --git a/merge de archivos_A - B/header.h b/merge de archivos_A - B/header.h new file mode 100644 index 0000000..f8ea40e --- /dev/null +++ b/merge de archivos_A - B/header.h @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + }t_persona; + +void A_menos_B_de_archivos_binarios(FILE*,FILE*,FILE*); +int comparacion_de_registros(t_persona*,t_persona*); +int str_cmp(const char*,const char*); +void mostrar_archivo_binario(FILE*); + diff --git a/merge de archivos_A - B/main.c b/merge de archivos_A - B/main.c new file mode 100644 index 0000000..d8d3ec8 --- /dev/null +++ b/merge de archivos_A - B/main.c @@ -0,0 +1,75 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 80"); + + FILE *pf_A,*pf_B; + + printf("\n\n\t\t A - B DE ARCHIVOS"); + printf("\n\t\t ================= \n\n\a\a"); + + printf("\n El archivo resultante A - B contendrá los registros \n que aparezcan en A pero no en B \n\n"); + getch(); + + pf_A=fopen("personas_A.bin","rb"); + if(!pf_A) + { + printf("\n\n No se pudo leer el archivo \"personas_A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_B=fopen("personas_B.bin","rb"); + if(!pf_B) + { + printf("\n\n No se pudo leer el archivo \"personas_B.bin\" \n\n\a\a"); + fclose(pf_A); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_A); + getch(); + + printf("\n\n\t\t ARCHIVO B \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_B); + getch(); + + FILE *pf_A_menos_B; + pf_A_menos_B=fopen("A - B.bin","wb"); + if(!pf_A_menos_B) + { + printf("\n\n No se pudo crear el archivo \"A - B.bin\" \n\n\a\a"); + fclose(pf_A); + fclose(pf_B); + exit(EXIT_FAILURE); + } + A_menos_B_de_archivos_binarios(pf_A,pf_B,pf_A_menos_B); + printf("\n\n Se he generado el archivo \"A - B.bin\" \n\n\a\a"); + getch(); + + fclose(pf_A); + fclose(pf_B); + fclose(pf_A_menos_B); + + pf_A_menos_B=fopen("A - B.bin","rb"); + if(!pf_A_menos_B) + { + printf("\n\n No se pudo abrir el archivo \"A - B.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A - B \a\a"); + printf("\n\t\t ============= \n\n"); + mostrar_archivo_binario(pf_A_menos_B); + fclose(pf_A_menos_B); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + diff --git a/merge de archivos_A - B/merge de archivos_A - B.cbp b/merge de archivos_A - B/merge de archivos_A - B.cbp new file mode 100644 index 0000000..4b1ad07 --- /dev/null +++ b/merge de archivos_A - B/merge de archivos_A - B.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/merge de archivos_A - B/merge de archivos_A - B.depend b/merge de archivos_A - B/merge de archivos_A - B.depend new file mode 100644 index 0000000..be9f24b --- /dev/null +++ b/merge de archivos_A - B/merge de archivos_A - B.depend @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1474238841 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_a - b\functions.c + "header.h" + +1474237217 d:\unlam\programaciÓn\fabian 2\merge de archivos_a - b\header.h + + + + + diff --git a/merge de archivos_A - B/merge de archivos_A - B.layout b/merge de archivos_A - B/merge de archivos_A - B.layout new file mode 100644 index 0000000..8e3a76b --- /dev/null +++ b/merge de archivos_A - B/merge de archivos_A - B.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/merge de archivos_A - B/obj/Debug/functions.o b/merge de archivos_A - B/obj/Debug/functions.o new file mode 100644 index 0000000..c5eb50e Binary files /dev/null and b/merge de archivos_A - B/obj/Debug/functions.o differ diff --git a/merge de archivos_A - B/obj/Debug/main.o b/merge de archivos_A - B/obj/Debug/main.o new file mode 100644 index 0000000..b4d3f9e Binary files /dev/null and b/merge de archivos_A - B/obj/Debug/main.o differ diff --git a/merge de archivos_A - B/personas_A.bin b/merge de archivos_A - B/personas_A.bin new file mode 100644 index 0000000..ed642f7 Binary files /dev/null and b/merge de archivos_A - B/personas_A.bin differ diff --git a/merge de archivos_A - B/personas_B.bin b/merge de archivos_A - B/personas_B.bin new file mode 100644 index 0000000..be0c7c1 Binary files /dev/null and b/merge de archivos_A - B/personas_B.bin differ diff --git "a/merge de archivos_A diferencia sim\303\251trica B/A diferencia sim\303\251trica B.bin" "b/merge de archivos_A diferencia sim\303\251trica B/A diferencia sim\303\251trica B.bin" new file mode 100644 index 0000000..febb8bd Binary files /dev/null and "b/merge de archivos_A diferencia sim\303\251trica B/A diferencia sim\303\251trica B.bin" differ diff --git "a/merge de archivos_A diferencia sim\303\251trica B/bin/Debug/merge de archivos_A diferencia sim\303\251trica B.exe" "b/merge de archivos_A diferencia sim\303\251trica B/bin/Debug/merge de archivos_A diferencia sim\303\251trica B.exe" new file mode 100644 index 0000000..546c4e5 Binary files /dev/null and "b/merge de archivos_A diferencia sim\303\251trica B/bin/Debug/merge de archivos_A diferencia sim\303\251trica B.exe" differ diff --git "a/merge de archivos_A diferencia sim\303\251trica B/functions.c" "b/merge de archivos_A diferencia sim\303\251trica B/functions.c" new file mode 100644 index 0000000..bb89e3f --- /dev/null +++ "b/merge de archivos_A diferencia sim\303\251trica B/functions.c" @@ -0,0 +1,90 @@ +#include "header.h" + +void diferencia_simetrica_de_archivos_binarios(FILE *pf_A,FILE *pf_B,FILE *pf_dif_sim) + { + int comparador; + + t_persona persona_A; + t_persona persona_B; + + rewind(pf_A); + rewind(pf_B); + rewind(pf_dif_sim); + + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + + while(!feof(pf_A)&&!feof(pf_B)) + { + comparador=comparacion_de_registros(&persona_A,&persona_B); + + if(comparador<0) + { + fwrite(&persona_A,sizeof(t_persona),1,pf_dif_sim); + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + else + if(comparador>0) + { + fwrite(&persona_B,sizeof(t_persona),1,pf_dif_sim); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + else + { + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + + while(!feof(pf_A)) + { + fwrite(&persona_A,sizeof(t_persona),1,pf_dif_sim); + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + while(!feof(pf_B)) + { + fwrite(&persona_B,sizeof(t_persona),1,pf_dif_sim); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + +int comparacion_de_registros(t_persona *persona_1,t_persona *persona_2) + { + int comparador; + if((comparador=str_cmp(persona_1->apellido,persona_2->apellido))==0) + if((comparador=str_cmp(persona_1->nombre,persona_2->nombre))==0) + if(persona_1->dni==persona_2->dni) + return IGUAL; + else + if(persona_1->dni>persona_2->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } + +void mostrar_archivo_binario(FILE *pf) + { + t_persona registro; + rewind(pf); + fread(®istro,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo); + fread(®istro,sizeof(t_persona),1,pf); + } + } + diff --git "a/merge de archivos_A diferencia sim\303\251trica B/header.h" "b/merge de archivos_A diferencia sim\303\251trica B/header.h" new file mode 100644 index 0000000..97470b2 --- /dev/null +++ "b/merge de archivos_A diferencia sim\303\251trica B/header.h" @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + }t_persona; + +void diferencia_simetrica_de_archivos_binarios(FILE*,FILE*,FILE*); +int comparacion_de_registros(t_persona*,t_persona*); +int str_cmp(const char*,const char*); +void mostrar_archivo_binario(FILE*); + diff --git "a/merge de archivos_A diferencia sim\303\251trica B/main.c" "b/merge de archivos_A diferencia sim\303\251trica B/main.c" new file mode 100644 index 0000000..3959341 --- /dev/null +++ "b/merge de archivos_A diferencia sim\303\251trica B/main.c" @@ -0,0 +1,75 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 80"); + + FILE *pf_A,*pf_B; + + printf("\n\n\t\t DIFERENCIA SIMÉTRICA DE ARCHIVOS"); + printf("\n\t\t ================================ \n\n\a\a"); + + printf("\n El archivo resultante A diferencia simétrica B contendrá los registros \n que aparezcan en A o en B, pero no en ambos \n\n"); + getch(); + + pf_A=fopen("personas_A.bin","rb"); + if(!pf_A) + { + printf("\n\n No se pudo leer el archivo \"personas_A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_B=fopen("personas_B.bin","rb"); + if(!pf_B) + { + printf("\n\n No se pudo leer el archivo \"personas_B.bin\" \n\n\a\a"); + fclose(pf_A); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_A); + getch(); + + printf("\n\n\t\t ARCHIVO B \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_B); + getch(); + + FILE *pf_dif_sim; + pf_dif_sim=fopen("A diferencia simétrica B.bin","wb"); + if(!pf_dif_sim) + { + printf("\n\n No se pudo crear el archivo \"A diferencia simétrica B.bin\" \n\n\a\a"); + fclose(pf_A); + fclose(pf_B); + exit(EXIT_FAILURE); + } + diferencia_simetrica_de_archivos_binarios(pf_A,pf_B,pf_dif_sim); + printf("\n\n Se he generado el archivo \"A diferencia simétrica B.bin\" \n\n\a\a"); + getch(); + + fclose(pf_A); + fclose(pf_B); + fclose(pf_dif_sim); + + pf_dif_sim=fopen("A diferencia simétrica B.bin","rb"); + if(!pf_dif_sim) + { + printf("\n\n No se pudo abrir el archivo \"A diferencia simétrica B.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A DIFERENCIA SIMÉTRICA B \a\a"); + printf("\n\t\t ================= \n\n"); + mostrar_archivo_binario(pf_dif_sim); + fclose(pf_dif_sim); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + diff --git "a/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.cbp" "b/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.cbp" new file mode 100644 index 0000000..18815d8 --- /dev/null +++ "b/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.depend" "b/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.depend" new file mode 100644 index 0000000..99a059a --- /dev/null +++ "b/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474236268 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_a diferencia simétrica b\functions.c + "header.h" + +1474236148 d:\unlam\programaciÓn\fabian 2\merge de archivos_a diferencia simétrica b\header.h + + + + + +1474236132 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_a diferencia simétrica b\main.c + "header.h" + diff --git "a/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.layout" "b/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.layout" new file mode 100644 index 0000000..7150e5b --- /dev/null +++ "b/merge de archivos_A diferencia sim\303\251trica B/merge de archivos_A diferencia sim\303\251trica B.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/merge de archivos_A diferencia sim\303\251trica B/obj/Debug/functions.o" "b/merge de archivos_A diferencia sim\303\251trica B/obj/Debug/functions.o" new file mode 100644 index 0000000..b6f1f83 Binary files /dev/null and "b/merge de archivos_A diferencia sim\303\251trica B/obj/Debug/functions.o" differ diff --git "a/merge de archivos_A diferencia sim\303\251trica B/obj/Debug/main.o" "b/merge de archivos_A diferencia sim\303\251trica B/obj/Debug/main.o" new file mode 100644 index 0000000..5592a4b Binary files /dev/null and "b/merge de archivos_A diferencia sim\303\251trica B/obj/Debug/main.o" differ diff --git "a/merge de archivos_A diferencia sim\303\251trica B/personas_A.bin" "b/merge de archivos_A diferencia sim\303\251trica B/personas_A.bin" new file mode 100644 index 0000000..ed642f7 Binary files /dev/null and "b/merge de archivos_A diferencia sim\303\251trica B/personas_A.bin" differ diff --git "a/merge de archivos_A diferencia sim\303\251trica B/personas_B.bin" "b/merge de archivos_A diferencia sim\303\251trica B/personas_B.bin" new file mode 100644 index 0000000..be0c7c1 Binary files /dev/null and "b/merge de archivos_A diferencia sim\303\251trica B/personas_B.bin" differ diff --git "a/merge de archivos_A intersecci\303\263n B/A intersecci\303\263n B.bin" "b/merge de archivos_A intersecci\303\263n B/A intersecci\303\263n B.bin" new file mode 100644 index 0000000..074cd4f Binary files /dev/null and "b/merge de archivos_A intersecci\303\263n B/A intersecci\303\263n B.bin" differ diff --git "a/merge de archivos_A intersecci\303\263n B/bin/Debug/merge de archivos_A intersecci\303\263n B.exe" "b/merge de archivos_A intersecci\303\263n B/bin/Debug/merge de archivos_A intersecci\303\263n B.exe" new file mode 100644 index 0000000..65bacc6 Binary files /dev/null and "b/merge de archivos_A intersecci\303\263n B/bin/Debug/merge de archivos_A intersecci\303\263n B.exe" differ diff --git "a/merge de archivos_A intersecci\303\263n B/functions.c" "b/merge de archivos_A intersecci\303\263n B/functions.c" new file mode 100644 index 0000000..116ef26 --- /dev/null +++ "b/merge de archivos_A intersecci\303\263n B/functions.c" @@ -0,0 +1,77 @@ +#include "header.h" + +void interseccion_de_archivos_binarios(FILE *pf_A,FILE *pf_B,FILE *pf_interseccion) + { + int comparador; + + t_persona persona_A; + t_persona persona_B; + + rewind(pf_A); + rewind(pf_B); + rewind(pf_interseccion); + + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + + while(!feof(pf_A)&&!feof(pf_B)) + { + comparador=comparacion_de_registros(&persona_A,&persona_B); + + if(comparador<0) + { + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + else + if(comparador>0) + { + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + else + { + fwrite(&persona_A,sizeof(t_persona),1,pf_interseccion); + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + } + +int comparacion_de_registros(t_persona *persona_1,t_persona *persona_2) + { + int comparador; + if((comparador=str_cmp(persona_1->apellido,persona_2->apellido))==0) + if((comparador=str_cmp(persona_1->nombre,persona_2->nombre))==0) + if(persona_1->dni==persona_2->dni) + return IGUAL; + else + if(persona_1->dni>persona_2->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } + +void mostrar_archivo_binario(FILE *pf) + { + t_persona registro; + rewind(pf); + fread(®istro,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo); + fread(®istro,sizeof(t_persona),1,pf); + } + } diff --git "a/merge de archivos_A intersecci\303\263n B/header.h" "b/merge de archivos_A intersecci\303\263n B/header.h" new file mode 100644 index 0000000..c66a8b1 --- /dev/null +++ "b/merge de archivos_A intersecci\303\263n B/header.h" @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + }t_persona; + +void interseccion_de_archivos_binarios(FILE*,FILE*,FILE*); +int comparacion_de_registros(t_persona*,t_persona*); +int str_cmp(const char*,const char*); +void mostrar_archivo_binario(FILE*); diff --git "a/merge de archivos_A intersecci\303\263n B/main.c" "b/merge de archivos_A intersecci\303\263n B/main.c" new file mode 100644 index 0000000..cfb88a6 --- /dev/null +++ "b/merge de archivos_A intersecci\303\263n B/main.c" @@ -0,0 +1,74 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 80"); + + FILE *pf_A,*pf_B; + + printf("\n\n\t\t INTERSECCIÓN DE ARCHIVOS"); + printf("\n\t\t ======================== \n\n\a\a"); + + printf("\n El archivo resultante A intersección B contendrá los registros \n que aparezcan en A y en B \n\n"); + getch(); + + pf_A=fopen("personas_A.bin","rb"); + if(!pf_A) + { + printf("\n\n No se pudo leer el archivo \"personas_A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_B=fopen("personas_B.bin","rb"); + if(!pf_B) + { + printf("\n\n No se pudo leer el archivo \"personas_B.bin\" \n\n\a\a"); + fclose(pf_A); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_A); + getch(); + + printf("\n\n\t\t ARCHIVO B \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_B); + getch(); + + FILE *pf_interseccion; + pf_interseccion=fopen("A intersección B.bin","wb"); + if(!pf_interseccion) + { + printf("\n\n No se pudo crear el archivo \"A intersección B.bin\" \n\n\a\a"); + fclose(pf_A); + fclose(pf_B); + exit(EXIT_FAILURE); + } + interseccion_de_archivos_binarios(pf_A,pf_B,pf_interseccion); + printf("\n\n Se he generado el archivo \"A intersección B.bin\" \n\n\a\a"); + getch(); + + fclose(pf_A); + fclose(pf_B); + fclose(pf_interseccion); + + pf_interseccion=fopen("A intersección B.bin","rb"); + if(!pf_interseccion) + { + printf("\n\n No se pudo abrir el archivo \"A intersección B.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A INTERSECCIÓN B \a\a"); + printf("\n\t\t ======================== \n\n"); + mostrar_archivo_binario(pf_interseccion); + fclose(pf_interseccion); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } diff --git "a/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.cbp" "b/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.cbp" new file mode 100644 index 0000000..b70f3d7 --- /dev/null +++ "b/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.depend" "b/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.depend" new file mode 100644 index 0000000..2f5ef0d --- /dev/null +++ "b/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.depend" @@ -0,0 +1,10 @@ +# depslib dependency file v1.0 +1474235762 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_a intersección b\functions.c + "header.h" + +1474232114 d:\unlam\programaciÓn\fabian 2\merge de archivos_a intersección b\header.h + + + + + diff --git "a/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.layout" "b/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.layout" new file mode 100644 index 0000000..f1382bb --- /dev/null +++ "b/merge de archivos_A intersecci\303\263n B/merge de archivos_A intersecci\303\263n B.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/merge de archivos_A intersecci\303\263n B/obj/Debug/functions.o" "b/merge de archivos_A intersecci\303\263n B/obj/Debug/functions.o" new file mode 100644 index 0000000..3c59b2e Binary files /dev/null and "b/merge de archivos_A intersecci\303\263n B/obj/Debug/functions.o" differ diff --git "a/merge de archivos_A intersecci\303\263n B/obj/Debug/main.o" "b/merge de archivos_A intersecci\303\263n B/obj/Debug/main.o" new file mode 100644 index 0000000..279537e Binary files /dev/null and "b/merge de archivos_A intersecci\303\263n B/obj/Debug/main.o" differ diff --git "a/merge de archivos_A intersecci\303\263n B/personas_A.bin" "b/merge de archivos_A intersecci\303\263n B/personas_A.bin" new file mode 100644 index 0000000..ed642f7 Binary files /dev/null and "b/merge de archivos_A intersecci\303\263n B/personas_A.bin" differ diff --git "a/merge de archivos_A intersecci\303\263n B/personas_B.bin" "b/merge de archivos_A intersecci\303\263n B/personas_B.bin" new file mode 100644 index 0000000..be0c7c1 Binary files /dev/null and "b/merge de archivos_A intersecci\303\263n B/personas_B.bin" differ diff --git "a/merge de archivos_A uni\303\263n B/A uni\303\263n B.bin" "b/merge de archivos_A uni\303\263n B/A uni\303\263n B.bin" new file mode 100644 index 0000000..44ec8c6 Binary files /dev/null and "b/merge de archivos_A uni\303\263n B/A uni\303\263n B.bin" differ diff --git "a/merge de archivos_A uni\303\263n B/bin/Debug/merge de archivos_A uni\303\263n B.exe" "b/merge de archivos_A uni\303\263n B/bin/Debug/merge de archivos_A uni\303\263n B.exe" new file mode 100644 index 0000000..f96e75c Binary files /dev/null and "b/merge de archivos_A uni\303\263n B/bin/Debug/merge de archivos_A uni\303\263n B.exe" differ diff --git "a/merge de archivos_A uni\303\263n B/functions.c" "b/merge de archivos_A uni\303\263n B/functions.c" new file mode 100644 index 0000000..2dc49c3 --- /dev/null +++ "b/merge de archivos_A uni\303\263n B/functions.c" @@ -0,0 +1,90 @@ +#include "header.h" + +void union_de_archivos_binarios(FILE *pf_A,FILE *pf_B,FILE *pf_union) + { + int comparador; + + t_persona persona_A; + t_persona persona_B; + + rewind(pf_A); + rewind(pf_B); + rewind(pf_union); + + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + + while(!feof(pf_A)&&!feof(pf_B)) + { + comparador=comparacion_de_registros(&persona_A,&persona_B); + + if(comparador<0) + { + fwrite(&persona_A,sizeof(t_persona),1,pf_union); + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + else + if(comparador>0) + { + fwrite(&persona_B,sizeof(t_persona),1,pf_union); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + else + { + fwrite(&persona_A,sizeof(t_persona),1,pf_union); + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + + while(!feof(pf_A)) + { + fwrite(&persona_A,sizeof(t_persona),1,pf_union); + fread(&persona_A,sizeof(t_persona),1,pf_A); + } + while(!feof(pf_B)) + { + fwrite(&persona_B,sizeof(t_persona),1,pf_union); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + +int comparacion_de_registros(t_persona *persona_1,t_persona *persona_2) + { + int comparador; + if((comparador=str_cmp(persona_1->apellido,persona_2->apellido))==0) + if((comparador=str_cmp(persona_1->nombre,persona_2->nombre))==0) + if(persona_1->dni==persona_2->dni) + return IGUAL; + else + if(persona_1->dni>persona_2->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } + +void mostrar_archivo_binario(FILE *pf) + { + t_persona registro; + rewind(pf); + fread(®istro,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo); + fread(®istro,sizeof(t_persona),1,pf); + } + } diff --git "a/merge de archivos_A uni\303\263n B/header.h" "b/merge de archivos_A uni\303\263n B/header.h" new file mode 100644 index 0000000..b40a4fd --- /dev/null +++ "b/merge de archivos_A uni\303\263n B/header.h" @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + }t_persona; + +void union_de_archivos_binarios(FILE*,FILE*,FILE*); +int comparacion_de_registros(t_persona*,t_persona*); +int str_cmp(const char*,const char*); +void mostrar_archivo_binario(FILE*); diff --git "a/merge de archivos_A uni\303\263n B/main.c" "b/merge de archivos_A uni\303\263n B/main.c" new file mode 100644 index 0000000..e720191 --- /dev/null +++ "b/merge de archivos_A uni\303\263n B/main.c" @@ -0,0 +1,74 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 80"); + + FILE *pf_A,*pf_B; + + printf("\n\n\t\t UNIÓN DE ARCHIVOS"); + printf("\n\t\t ================= \n\n\a\a"); + + printf("\n El archivo resultante A unión B contendrá los registros \n que aparezcan en A, en B, o en ambos \n\n"); + getch(); + + pf_A=fopen("personas_A.bin","rb"); + if(!pf_A) + { + printf("\n\n No se pudo leer el archivo \"personas_A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_B=fopen("personas_B.bin","rb"); + if(!pf_B) + { + printf("\n\n No se pudo leer el archivo \"personas_B.bin\" \n\n\a\a"); + fclose(pf_A); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_A); + getch(); + + printf("\n\n\t\t ARCHIVO B \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_B); + getch(); + + FILE *pf_union; + pf_union=fopen("A unión B.bin","wb"); + if(!pf_union) + { + printf("\n\n No se pudo crear el archivo \"A unión B.bin\" \n\n\a\a"); + fclose(pf_A); + fclose(pf_B); + exit(EXIT_FAILURE); + } + union_de_archivos_binarios(pf_A,pf_B,pf_union); + printf("\n\n Se he generado el archivo \"A unión B.bin\" \n\n\a\a"); + getch(); + + fclose(pf_A); + fclose(pf_B); + fclose(pf_union); + + pf_union=fopen("A unión B.bin","rb"); + if(!pf_union) + { + printf("\n\n No se pudo abrir el archivo \"A unión B.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A UNIÓN B \a\a"); + printf("\n\t\t ================= \n\n"); + mostrar_archivo_binario(pf_union); + fclose(pf_union); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } diff --git "a/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.cbp" "b/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.cbp" new file mode 100644 index 0000000..0410c9e --- /dev/null +++ "b/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.depend" "b/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.depend" new file mode 100644 index 0000000..6b02f7b --- /dev/null +++ "b/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474231444 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_a unión b\functions.c + "header.h" + +1474227511 d:\unlam\programaciÓn\fabian 2\merge de archivos_a unión b\header.h + + + + + +1474228067 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_a unión b\main.c + "header.h" + diff --git "a/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.layout" "b/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.layout" new file mode 100644 index 0000000..71d91f2 --- /dev/null +++ "b/merge de archivos_A uni\303\263n B/merge de archivos_A uni\303\263n B.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/merge de archivos_A uni\303\263n B/obj/Debug/functions.o" "b/merge de archivos_A uni\303\263n B/obj/Debug/functions.o" new file mode 100644 index 0000000..7049ffe Binary files /dev/null and "b/merge de archivos_A uni\303\263n B/obj/Debug/functions.o" differ diff --git "a/merge de archivos_A uni\303\263n B/obj/Debug/main.o" "b/merge de archivos_A uni\303\263n B/obj/Debug/main.o" new file mode 100644 index 0000000..7e1c865 Binary files /dev/null and "b/merge de archivos_A uni\303\263n B/obj/Debug/main.o" differ diff --git "a/merge de archivos_A uni\303\263n B/personas_A.bin" "b/merge de archivos_A uni\303\263n B/personas_A.bin" new file mode 100644 index 0000000..ed642f7 Binary files /dev/null and "b/merge de archivos_A uni\303\263n B/personas_A.bin" differ diff --git "a/merge de archivos_A uni\303\263n B/personas_B.bin" "b/merge de archivos_A uni\303\263n B/personas_B.bin" new file mode 100644 index 0000000..be0c7c1 Binary files /dev/null and "b/merge de archivos_A uni\303\263n B/personas_B.bin" differ diff --git a/merge de archivos_B - A/B - A.bin b/merge de archivos_B - A/B - A.bin new file mode 100644 index 0000000..84dcc39 Binary files /dev/null and b/merge de archivos_B - A/B - A.bin differ diff --git a/merge de archivos_B - A/bin/Debug/merge de archivos_B - A.exe b/merge de archivos_B - A/bin/Debug/merge de archivos_B - A.exe new file mode 100644 index 0000000..6a3ddc7 Binary files /dev/null and b/merge de archivos_B - A/bin/Debug/merge de archivos_B - A.exe differ diff --git a/merge de archivos_B - A/functions.c b/merge de archivos_B - A/functions.c new file mode 100644 index 0000000..289062a --- /dev/null +++ b/merge de archivos_B - A/functions.c @@ -0,0 +1,82 @@ +#include "header.h" + +void B_menos_A_de_archivos_binarios(FILE *pf_A,FILE *pf_B,FILE *pf_B_menos_A) + { + int comparador; + + t_persona persona_A; + t_persona persona_B; + + rewind(pf_A); + rewind(pf_B); + rewind(pf_B_menos_A); + + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + + while(!feof(pf_A)&&!feof(pf_B)) + { + comparador=comparacion_de_registros(&persona_A,&persona_B); + + if(comparador<0) + fread(&persona_A,sizeof(t_persona),1,pf_A); + else + if(comparador>0) + { + fwrite(&persona_B,sizeof(t_persona),1,pf_B_menos_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + else + { + fread(&persona_A,sizeof(t_persona),1,pf_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + + while(!feof(pf_B)) + { + fwrite(&persona_B,sizeof(t_persona),1,pf_B_menos_A); + fread(&persona_B,sizeof(t_persona),1,pf_B); + } + } + +int comparacion_de_registros(t_persona *persona_1,t_persona *persona_2) + { + int comparador; + if((comparador=str_cmp(persona_1->apellido,persona_2->apellido))==0) + if((comparador=str_cmp(persona_1->nombre,persona_2->nombre))==0) + if(persona_1->dni==persona_2->dni) + return IGUAL; + else + if(persona_1->dni>persona_2->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } + +void mostrar_archivo_binario(FILE *pf) + { + t_persona registro; + rewind(pf); + fread(®istro,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo); + fread(®istro,sizeof(t_persona),1,pf); + } + } + diff --git a/merge de archivos_B - A/header.h b/merge de archivos_B - A/header.h new file mode 100644 index 0000000..e236c04 --- /dev/null +++ b/merge de archivos_B - A/header.h @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + }t_persona; + +void B_menos_A_de_archivos_binarios(FILE*,FILE*,FILE*); +int comparacion_de_registros(t_persona*,t_persona*); +int str_cmp(const char*,const char*); +void mostrar_archivo_binario(FILE*); + diff --git a/merge de archivos_B - A/main.c b/merge de archivos_B - A/main.c new file mode 100644 index 0000000..01f5d7d --- /dev/null +++ b/merge de archivos_B - A/main.c @@ -0,0 +1,75 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 80"); + + FILE *pf_A,*pf_B; + + printf("\n\n\t\t B - A DE ARCHIVOS"); + printf("\n\t\t ================= \n\n\a\a"); + + printf("\n El archivo resultante B - A contendrá los registros \n que aparezcan en B pero no en A \n\n"); + getch(); + + pf_A=fopen("personas_A.bin","rb"); + if(!pf_A) + { + printf("\n\n No se pudo leer el archivo \"personas_A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_B=fopen("personas_B.bin","rb"); + if(!pf_B) + { + printf("\n\n No se pudo leer el archivo \"personas_B.bin\" \n\n\a\a"); + fclose(pf_A); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO A \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_A); + getch(); + + printf("\n\n\t\t ARCHIVO B \a\a"); + printf("\n\t\t ========= \n\n"); + mostrar_archivo_binario(pf_B); + getch(); + + FILE *pf_B_menos_A; + pf_B_menos_A=fopen("B - A.bin","wb"); + if(!pf_B_menos_A) + { + printf("\n\n No se pudo crear el archivo \"B - A.bin\" \n\n\a\a"); + fclose(pf_A); + fclose(pf_B); + exit(EXIT_FAILURE); + } + B_menos_A_de_archivos_binarios(pf_A,pf_B,pf_B_menos_A); + printf("\n\n Se he generado el archivo \"B - A.bin\" \n\n\a\a"); + getch(); + + fclose(pf_A); + fclose(pf_B); + fclose(pf_B_menos_A); + + pf_B_menos_A=fopen("B - A.bin","rb"); + if(!pf_B_menos_A) + { + printf("\n\n No se pudo abrir el archivo \"B - A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO B - A \a\a"); + printf("\n\t\t ============= \n\n"); + mostrar_archivo_binario(pf_B_menos_A); + fclose(pf_B_menos_A); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + diff --git a/merge de archivos_B - A/merge de archivos_B - A.cbp b/merge de archivos_B - A/merge de archivos_B - A.cbp new file mode 100644 index 0000000..abade27 --- /dev/null +++ b/merge de archivos_B - A/merge de archivos_B - A.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/merge de archivos_B - A/merge de archivos_B - A.depend b/merge de archivos_B - A/merge de archivos_B - A.depend new file mode 100644 index 0000000..6f3a4b6 --- /dev/null +++ b/merge de archivos_B - A/merge de archivos_B - A.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474239479 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_b - a\functions.c + "header.h" + +1474239072 d:\unlam\programaciÓn\fabian 2\merge de archivos_b - a\header.h + + + + + +1474239355 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_b - a\main.c + "header.h" + diff --git a/merge de archivos_B - A/merge de archivos_B - A.layout b/merge de archivos_B - A/merge de archivos_B - A.layout new file mode 100644 index 0000000..d7a6fbf --- /dev/null +++ b/merge de archivos_B - A/merge de archivos_B - A.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/merge de archivos_B - A/obj/Debug/functions.o b/merge de archivos_B - A/obj/Debug/functions.o new file mode 100644 index 0000000..888e848 Binary files /dev/null and b/merge de archivos_B - A/obj/Debug/functions.o differ diff --git a/merge de archivos_B - A/obj/Debug/main.o b/merge de archivos_B - A/obj/Debug/main.o new file mode 100644 index 0000000..5fabc9c Binary files /dev/null and b/merge de archivos_B - A/obj/Debug/main.o differ diff --git a/merge de archivos_B - A/personas_A.bin b/merge de archivos_B - A/personas_A.bin new file mode 100644 index 0000000..ed642f7 Binary files /dev/null and b/merge de archivos_B - A/personas_A.bin differ diff --git a/merge de archivos_B - A/personas_B.bin b/merge de archivos_B - A/personas_B.bin new file mode 100644 index 0000000..be0c7c1 Binary files /dev/null and b/merge de archivos_B - A/personas_B.bin differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/bin/Debug/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.exe b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/bin/Debug/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.exe new file mode 100644 index 0000000..2b3b55d Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/bin/Debug/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.exe differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia maestro actualizado_antes de ser renombrado maestro.bin b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia maestro actualizado_antes de ser renombrado maestro.bin new file mode 100644 index 0000000..a4159da Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia maestro actualizado_antes de ser renombrado maestro.bin differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia maestro_original antes de actualizar y ser descartado.bin b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia maestro_original antes de actualizar y ser descartado.bin new file mode 100644 index 0000000..e706184 Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia maestro_original antes de actualizar y ser descartado.bin differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia novedades_antes de ser vaciado porque ya fueron implementadas.bin b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia novedades_antes de ser vaciado porque ya fueron implementadas.bin new file mode 100644 index 0000000..9787f23 Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/copia novedades_antes de ser vaciado porque ya fueron implementadas.bin differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/errores exportado a txt long fija.txt b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/errores exportado a txt long fija.txt new file mode 100644 index 0000000..e512e7e --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/errores exportado a txt long fija.txt @@ -0,0 +1,16 @@ + + ARCHIVO ERRORES + =============== +DNI APELLIDO/s NOMBRE/s EDAD SUELDO CÓDIGO + +13259961 Donastero Edmundo Pedro 58 447500.00 A +31548454 Figueroa Ricardo Paulo 28 18500.00 A +18564966 Gutierrez Enrique Luis 50 16640.00 B +23487488 Montero Romualdo Humberto 26 16590.00 B +32659449 Ortúzar Oriana Lucía 27 32000.00 A +19648754 Pereyra Oscar Darío 43 34656.00 B +12514142 Pontesa Jose María 62 354000.00 M +25648754 Roberto Sergio 31 14500.00 A +36494948 Segobia Laura Daiana 25 14750.00 A +13648754 Torres Rojas Gilberto Pancracio 56 29850.00 B +29135796 Valente Loana Elene 34 29500.00 A diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/errores.bin b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/errores.bin new file mode 100644 index 0000000..80f4ef1 Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/errores.bin differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/functions.c b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/functions.c new file mode 100644 index 0000000..9c0da02 --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/functions.c @@ -0,0 +1,183 @@ +#include "header.h" + +void grabar_archivo_maestro(char *ruta,t_maestro registros[],int tam) + { + FILE *pf; + pf=fopen(ruta,"wb"); + if(!pf) + { + printf("\n\n No se pudo crear el archivo %s \n\n",ruta); + exit(EXIT_FAILURE); + } + fwrite(registros,sizeof(t_maestro),tam,pf); + fclose(pf); + } + +void grabar_archivo_novedades(char *ruta,t_novedades registros[],int tam) + { + FILE *pf; + pf=fopen(ruta,"wb"); + if(!pf) + { + printf("\n\n No se pudo crear el archivo %s \n\n",ruta); + exit(EXIT_FAILURE); + } + fwrite(registros,sizeof(t_novedades),tam,pf); + fclose(pf); + } + +void mostrar_archivo_maestro(FILE *pf) + { + t_maestro registro; + rewind(pf); + fread(®istro,sizeof(t_maestro),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n\t\t ESTADO: \t %c \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo,registro.estado); + fread(®istro,sizeof(t_maestro),1,pf); + } + } + +void mostrar_archivo_novedades(FILE *pf) + { + t_novedades registro; + rewind(pf); + fread(®istro,sizeof(t_novedades),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n\t\t CÓDIGO: \t %c \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo,registro.codigo); + fread(®istro,sizeof(t_novedades),1,pf); + } + } + +void actualizar_archivo_maestro(FILE *pf_maestro,FILE *pf_novedades,FILE *pf_maestro_actualizado,FILE *pf_errores) + { + int comparador; + + t_maestro registro_maestro; + t_novedades registro_novedades; + + rewind(pf_maestro); + rewind(pf_novedades); + rewind(pf_maestro_actualizado); + rewind(pf_errores); + + fread(®istro_maestro,sizeof(t_maestro),1,pf_maestro); + fread(®istro_novedades,sizeof(t_novedades),1,pf_novedades); + + while(!feof(pf_maestro)&&!feof(pf_novedades)) + { + comparador=comparacion_de_registros(®istro_maestro,®istro_novedades); + + if(comparador<0) + { + fwrite(®istro_maestro,sizeof(t_maestro),1,pf_maestro_actualizado); + fread(®istro_maestro,sizeof(t_maestro),1,pf_maestro); + } + else + if(comparador>0) + { + if(registro_novedades.codigo=='B'||registro_novedades.codigo=='M') + fwrite(®istro_novedades,sizeof(t_novedades),1,pf_errores); + else + fwrite(®istro_novedades,sizeof(t_maestro),1,pf_maestro_actualizado); + fread(®istro_novedades,sizeof(t_novedades),1,pf_novedades); + } + else + { + if(registro_novedades.codigo=='M') + { + registro_novedades.codigo=registro_maestro.estado; + fwrite(®istro_novedades,sizeof(t_maestro),1,pf_maestro_actualizado); + } + else + if(registro_maestro.estado!=registro_novedades.codigo) + { + registro_maestro.estado=registro_novedades.codigo; + fwrite(®istro_maestro,sizeof(t_maestro),1,pf_maestro_actualizado); + } + else + { + fwrite(®istro_novedades,sizeof(t_novedades),1,pf_errores); + fwrite(®istro_maestro,sizeof(t_maestro),1,pf_maestro_actualizado); + } + + fread(®istro_maestro,sizeof(t_maestro),1,pf_maestro); + fread(®istro_novedades,sizeof(t_novedades),1,pf_novedades); + } + } + + while(!feof(pf_maestro)) + { + fwrite(®istro_maestro,sizeof(t_maestro),1,pf_maestro_actualizado); + fread(®istro_maestro,sizeof(t_maestro),1,pf_maestro); + } + while(!feof(pf_novedades)) + { + if(registro_novedades.codigo=='B'||registro_novedades.codigo=='M') + fwrite(®istro_novedades,sizeof(t_novedades),1,pf_errores); + else + fwrite(®istro_novedades,sizeof(t_maestro),1,pf_maestro_actualizado); + fread(®istro_novedades,sizeof(t_novedades),1,pf_novedades); + } + } + +int comparacion_de_registros(t_maestro *registro_maestro,t_novedades *registro_novedades) + { + int comparador; + if((comparador=str_cmp(registro_maestro->apellido,registro_novedades->apellido))==0) + if((comparador=str_cmp(registro_maestro->nombre,registro_novedades->nombre))==0) + if(registro_maestro->dni==registro_novedades->dni) + return IGUAL; + else + if(registro_maestro->dni>registro_novedades->dni) + return MAYOR; + else + return MENOR; + else + return comparador; + else + return comparador; + } + +int str_cmp(const char *s1,const char *s2) + { + while(*s1==*s2&&*s1&&*s2) + { + s1++; + s2++; + } + return *s1-*s2; + } + +void exportar_maestro_a_txt_longitud_fija(FILE *pf_bin,FILE *pf_txt) + { + t_maestro registro; + rewind(pf_bin); + rewind(pf_txt); + fprintf(pf_txt,"\n\t\t\t ARCHIVO MAESTRO"); + fprintf(pf_txt,"\n\t\t\t =============== \n"); + fprintf(pf_txt,"DNI \t APELLIDO/s \t\t NOMBRE/s \t\t\t EDAD SUELDO ESTADO \n\n"); + fread(®istro,sizeof(t_maestro),1,pf_bin); + while(!feof(pf_bin)) + { + fprintf(pf_txt,"%8d %-25s%-30s%2d %.2lf %c\n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo,registro.estado); + fread(®istro,sizeof(t_maestro),1,pf_bin); + } + } + +void exportar_errores_a_txt_longitud_fija(FILE *pf_bin,FILE *pf_txt) + { + t_novedades registro; + rewind(pf_bin); + rewind(pf_txt); + fprintf(pf_txt,"\n\t\t\t ARCHIVO ERRORES"); + fprintf(pf_txt,"\n\t\t\t =============== \n"); + fprintf(pf_txt,"DNI \t APELLIDO/s \t\t NOMBRE/s \t\t\t EDAD SUELDO CÓDIGO \n\n"); + fread(®istro,sizeof(t_maestro),1,pf_bin); + while(!feof(pf_bin)) + { + fprintf(pf_txt,"%8d %-25s%-30s%2d %.2lf %c\n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo,registro.codigo); + fread(®istro,sizeof(t_maestro),1,pf_bin); + } + } diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/header.h b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/header.h new file mode 100644 index 0000000..7a2a1e7 --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/header.h @@ -0,0 +1,41 @@ +#include +#include +#include +#include + +#define TAM_MAESTRO 20 +#define TAM_NOVEDADES 18 + +#define MENOR -1 +#define IGUAL 0 +#define MAYOR 1 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + char estado; + }t_maestro; + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + char codigo; + }t_novedades; + +void grabar_archivo_maestro(char*,t_maestro[],int); +void grabar_archivo_novedades(char*,t_novedades[],int); +void mostrar_archivo_maestro(FILE*); +void mostrar_archivo_novedades(FILE*); +void actualizar_archivo_maestro(FILE*,FILE*,FILE*,FILE*); +int comparacion_de_registros(t_maestro*,t_novedades*); +int str_cmp(const char*,const char*); +void exportar_maestro_a_txt_longitud_fija(FILE*,FILE*); +void exportar_errores_a_txt_longitud_fija(FILE*,FILE*); diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/maestro exportado a txt long fija.txt b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/maestro exportado a txt long fija.txt new file mode 100644 index 0000000..5a9e9bd --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/maestro exportado a txt long fija.txt @@ -0,0 +1,27 @@ + + ARCHIVO MAESTRO + =============== +DNI APELLIDO/s NOMBRE/s EDAD SUELDO ESTADO + +25494177 Andrada Sofía 31 34000.00 A +30135949 Aranibar Johanna Luna 29 26450.00 A +25648754 Ascacibar Andrea Julieta 35 32000.00 B +16514142 Borrato Jorge Esteban 54 24000.00 B +36916554 Cancarro Matías Ignacio 25 37870.00 A +13259961 Donastero Edmundo Pedro 58 447500.00 A +26489494 Echegaray Malena Romina 33 17470.00 A +31548454 Figueroa Ricardo Paulo 28 18500.00 A +18564966 Gutierrez Enrique Luis 50 16640.00 B +36514142 Miranda Milena Lena 26 26500.00 A +23487487 Montero Patricio Humberto 26 23350.00 A +28946356 Oberto Jorge Ignacio 35 17000.00 B +32659449 Ortúzar Oriana Lucía 27 32000.00 A +19648754 Pereyra Oscar Darío 43 34656.00 B +25648754 Roberto Sergio 31 14500.00 A +26496135 Sánchez Tamara 25 16700.00 A +36494948 Segobia Laura Daiana 25 14750.00 A +20161131 Serrano Omar Ricardo 35 26400.00 A +13648754 Torres Rojas Gilberto Pancracio 56 29850.00 B +25648754 Ulisotta Juan Edgardo 34 16200.00 B +29135796 Valente Loana Elene 34 29500.00 A +23648754 Zuñiga Pedro Iván 42 14750.00 B diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/maestro.bin b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/maestro.bin new file mode 100644 index 0000000..a4159da Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/maestro.bin differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/main.c b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/main.c new file mode 100644 index 0000000..cec2c0d --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/main.c @@ -0,0 +1,227 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5E"); + + printf("\n\t\t\t *********************"); + printf("\n\t\t\t * MERGE DE ARCHIVOS * \a\a"); + printf("\n\t\t\t *********************\n"); + + printf("\n El archivo maestro contiene un campo de estado que indica \n si sus registros están dados de alta o de baja. \n"); + printf("\n Este archivo no se modifica permanentemente, sino que es actualizado \n cada cierto tiempo, para no manosearlo tan a menudo, ya que"); + printf("\n contiene datos importantes. Lo que se hace es actualizar lo que sea \n necesario a partir de un archivo que contiene las novedades. "); + printf("\n Este archivo de novedades cuenta con los registros intervinientes y un \n código de operación en el que figura lo que debe hacerse en cada caso. \n"); + getch(); + printf("\n Luego de hacer las modificaciones correspondientes, el archivo de novedades \n vuelve a cero para seguir siendo cargado cuando sea necesario.\n"); + printf("\n El archivo maestro es descartado ya que es obsoleto cuando rige el archivo \n maestro actualizado, quien luego se convierte en el archivo maestro. \n"); + printf("\n Los registros con errores que pudiera haber traído el archivo de novedades \n serán volcados en un archivo de errores"); + printf("\n para poder ser revisados luego. Por supuesto que no son tenidos en cuenta \n a la hora de actualizar el archivo maestro. \n\n"); + getch(); + + t_maestro personas_maestro[TAM_MAESTRO]= { {30135949,"Aranibar","Johanna Luna",29,26450.00,'A'}, + {25648754,"Ascacibar","Andrea Julieta",35,32000.00,'A'}, + {16514142,"Borrato","Jorge Esteban",54,24000.00,'A'}, + {36916554,"Cancarro","Matías Ignacio",25,37870.00,'A'}, + {13259961,"Donastero","Edmundo Pedro",58,447500,'A'}, + {26489494,"Echegaray","Malena Romina",33,17470.00,'B'}, + {31548454,"Figueroa","Ricardo Paulo",28,18500.00,'A'}, + {18564966,"Gutierrez","Enrique Luis",50,16640.00,'B'}, + {23487487,"Montero","Patricio Humberto",26,23350.00,'A'}, + {28946356,"Oberto","Jorge Ignacio",35,17000.00,'A'}, + {32659449,"Ortúzar","Oriana Lucía",27,32000.00,'A'}, + {19648754,"Pereyra","Oscar Darío",43,34656.00,'B'}, + {25648754,"Roberto","Sergio",31,14500.00,'A'}, + {26496135,"Sánchez","Tamara",25,16700.00,'A'}, + {36494948,"Segobia","Laura Daiana",25,14750.00,'A'}, + {20161131,"Serrano","Omar Ricardo",35,16400.00,'A'}, + {13648754,"Torres Rojas","Gilberto Pancracio",56,29850.00,'B'}, + {25648754,"Ulisotta","Juan Edgardo",34,16200.00,'B'}, + {29135796,"Valente","Loana Elene",34,29500.00,'A'}, + {23648754,"Zuñiga","Pedro Iván",42,14750.00,'B'} }; + + t_novedades personas_novedades[TAM_NOVEDADES]= { {25494177,"Andrada","Sofía",31,34000.00,'A'}, + {25648754,"Ascacibar","Andrea Julieta",35,32000.00,'B'}, + {16514142,"Borrato","Jorge Esteban",54,24000.00,'B'}, + {13259961,"Donastero","Edmundo Pedro",58,447500,'A'}, + {26489494,"Echegaray","Malena Romina",33,17470.00,'A'}, + {31548454,"Figueroa","Ricardo Paulo",28,18500.00,'A'}, + {18564966,"Gutierrez","Enrique Luis",50,16640.00,'B'}, + {36514142,"Miranda","Milena Lena",26,26500.00,'A'}, + {23487488,"Montero","Romualdo Humberto",26,16590.00,'B'}, + {28946356,"Oberto","Jorge Ignacio",35,17000.00,'B'}, + {32659449,"Ortúzar","Oriana Lucía",27,32000.00,'A'}, + {19648754,"Pereyra","Oscar Darío",43,34656.00,'B'}, + {12514142,"Pontesa","Jose María",62,354000.00,'M'}, + {25648754,"Roberto","Sergio",31,14500.00,'A'}, + {36494948,"Segobia","Laura Daiana",25,14750.00,'A'}, + {20161131,"Serrano","Omar Ricardo",35,26400.00,'M'}, + {13648754,"Torres Rojas","Gilberto Pancracio",56,29850.00,'B'}, + {29135796,"Valente","Loana Elene",34,29500.00,'A'} }; + + grabar_archivo_maestro("maestro.bin",personas_maestro,TAM_MAESTRO); + grabar_archivo_novedades("novedades.bin",personas_novedades,TAM_NOVEDADES); + + //--------------------------------------------------------------------------------------------------------------------- + + FILE *pf_maestro,*pf_novedades; + + pf_maestro=fopen("maestro.bin","rb"); + if(!pf_maestro) + { + printf("\n\n No se pudo leer el archivo \"maestro.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_novedades=fopen("novedades.bin","rb"); + if(!pf_novedades) + { + printf("\n\n No se pudo leer el archivo \"novedades.bin\" \n\n\a\a"); + fclose(pf_maestro); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO MAESTRO"); + printf("\n\t\t ***************\n\n\a\a"); + mostrar_archivo_maestro(pf_maestro); + getch(); + + printf("\n\n\t\t ARCHIVO NOVEDADES"); + printf("\n\t\t *****************\n\n\a\a"); + mostrar_archivo_novedades(pf_novedades); + getch(); + + //------------------------------------------------------------------------------------------------------------------------- + + printf("\n\n Presione cualquier tecla para comenzar con la actualización del archivo maestro \n\n\a\a"); + getch(); + + FILE *pf_maestro_actualizado,*pf_errores; + + pf_maestro_actualizado=fopen("maestro actualizado.bin","wb"); + if(!pf_maestro_actualizado) + { + printf("\n\n No se pudo crear el archivo \"maestro actualizado.bin\" \n\n\a\a"); + fclose(pf_maestro); + fclose(pf_novedades); + exit(EXIT_FAILURE); + } + + pf_errores=fopen("errores.bin","wb"); + if(!pf_errores) + { + printf("\n\n No se pudo crear el archivo \"errores.bin\" \n\n\a\a"); + fclose(pf_maestro); + fclose(pf_novedades); + fclose(pf_maestro_actualizado); + exit(EXIT_FAILURE); + } + + actualizar_archivo_maestro(pf_maestro,pf_novedades,pf_maestro_actualizado,pf_errores); + printf("\n\n La actualización del archivo maestro ha finalizado exitosamente \a\a"); + printf("\n\n Se han generado los archivos \"maestro actualizado.bin\" y \"errores.bin\""); + + fclose(pf_maestro_actualizado); + fclose(pf_errores); + + //--------------------------------------------------------------------------------------------------------- + + printf("\n\n Presione cualquier tecla para ver los resultados \n\n"); + getch(); + + pf_maestro_actualizado=fopen("maestro actualizado.bin","rb"); + if(!pf_maestro_actualizado) + { + printf("\n\n No se pudo leer el archivo \"maestro actualizado.bin\" \n\n\a\a"); + fclose(pf_maestro); + fclose(pf_novedades); + exit(EXIT_FAILURE); + } + + pf_errores=fopen("errores.bin","rb"); + if(!pf_errores) + { + printf("\n\n No se pudo leer el archivo \"errores.bin\" \n\n\a\a"); + fclose(pf_maestro); + fclose(pf_novedades); + fclose(pf_maestro_actualizado); + exit(EXIT_FAILURE); + } + + printf("\n\n\t\t ARCHIVO MAESTRO ACTUALIZADO"); + printf("\n\t\t *************************** \n\n\a\a"); + mostrar_archivo_maestro(pf_maestro_actualizado); + getch(); + + printf("\n\n\t\t ARCHIVO ERRORES"); + printf("\n\t\t ***************\n\n\a\a"); + mostrar_archivo_novedades(pf_errores); + getch(); + + //---------------------------------------------------------------------------------------------------------------------- + + fclose(pf_novedades); + pf_novedades=fopen("novedades.bin","wb"); + if(!pf_novedades) + { + printf("\n\n No se ha podido vaciar el archivo \"novedades.bin\" \n\n\a\a"); + fclose(pf_maestro); + fclose(pf_maestro_actualizado); + fclose(pf_errores); + exit(EXIT_FAILURE); + } + + FILE *pf_errores_txt; + pf_errores_txt=fopen("errores exportado a txt long fija.txt","wt"); + if(!pf_errores_txt) + { + printf("\n\n No se ha podido exportar el archivo errores a \n archivo de texto de longitud fija \n\n\a\a"); + fclose(pf_errores); + fclose(pf_maestro); + fclose(pf_novedades); + fclose(pf_maestro_actualizado); + exit(EXIT_FAILURE); + } + exportar_errores_a_txt_longitud_fija(pf_errores,pf_errores_txt); + fclose(pf_errores_txt); + + printf("\n\n El archivo \"errores.bin\" ha sido exportado al archivo \n \"errores exportado a txt long fija.txt\" \n\n\a\a"); + getch(); + + fclose(pf_errores); + printf("\n\n El archivo \"errores.bin\" ha sido cerrado, y espera a revisión \n\n\a\a"); + getch(); + + fclose(pf_novedades); + printf("\n\n El archivo \"novedades.bin\" ha sido vaciado ya que ya se ha implementado \n\n\a\a"); + getch(); + + fclose(pf_maestro); + remove("maestro.bin"); + printf("\n\n El archivo \"maestro.bin\" ha sido descartado \n\n\a\a"); + getch(); + + FILE *pf_maestro_txt; + pf_maestro_txt=fopen("maestro exportado a txt long fija.txt","wt"); + if(!pf_maestro_txt) + { + printf("\n\n No se ha podido exportar el archivo maestro a \n archivo de texto de longitud fija \n\n\a\a"); + fclose(pf_maestro_actualizado); + exit(EXIT_FAILURE); + } + exportar_maestro_a_txt_longitud_fija(pf_maestro_actualizado,pf_maestro_txt); + fclose(pf_maestro_txt); + + fclose(pf_maestro_actualizado); + rename("maestro actualizado.bin","maestro.bin"); + printf("\n\n El archivo \"maestro actualizado.bin\" ahora es el nuevo archivo \"maestro.bin\" \n\n\a\a"); + getch(); + + printf("\n\n El archivo \"maestro.bin\" ha sido exportado al archivo \n \"maestro exportado a txt long fija.txt\" \n\n\a\a"); + getch(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.cbp b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.cbp new file mode 100644 index 0000000..35670bc --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.depend b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.depend new file mode 100644 index 0000000..9a7ef44 --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474260102 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_archivo maestro, novedades, maestro actualizado y errores\functions.c + "header.h" + +1474260506 d:\unlam\programaciÓn\fabian 2\merge de archivos_archivo maestro, novedades, maestro actualizado y errores\header.h + + + + + +1474260469 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_archivo maestro, novedades, maestro actualizado y errores\main.c + "header.h" + diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.layout b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.layout new file mode 100644 index 0000000..43548a5 --- /dev/null +++ b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/merge de archivos_archivo maestro, novedades, maestro actualizado y errores.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/novedades.bin b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/novedades.bin new file mode 100644 index 0000000..e69de29 diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/obj/Debug/functions.o b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/obj/Debug/functions.o new file mode 100644 index 0000000..46fcbe0 Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/obj/Debug/functions.o differ diff --git a/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/obj/Debug/main.o b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/obj/Debug/main.o new file mode 100644 index 0000000..e70118e Binary files /dev/null and b/merge de archivos_archivo maestro, novedades, maestro actualizado y errores/obj/Debug/main.o differ diff --git a/merge de archivos_hardcodeo archivos A y B/bin/Debug/merge de archivos_hardcodeo archivos A y B.exe b/merge de archivos_hardcodeo archivos A y B/bin/Debug/merge de archivos_hardcodeo archivos A y B.exe new file mode 100644 index 0000000..998bf1b Binary files /dev/null and b/merge de archivos_hardcodeo archivos A y B/bin/Debug/merge de archivos_hardcodeo archivos A y B.exe differ diff --git a/merge de archivos_hardcodeo archivos A y B/functions.c b/merge de archivos_hardcodeo archivos A y B/functions.c new file mode 100644 index 0000000..d414b7f --- /dev/null +++ b/merge de archivos_hardcodeo archivos A y B/functions.c @@ -0,0 +1,26 @@ +#include "header.h" + +void grabar_en_binario(char *ruta,t_persona registros[],int tam) + { + FILE *pf; + pf=fopen(ruta,"wb"); + if(!pf) + { + printf("\n\n No se pudo crear el archivo %s \n\n",ruta); + exit(EXIT_FAILURE); + } + fwrite(registros,sizeof(t_persona),tam,pf); + fclose(pf); + } + +void mostrar_archivo_binario(FILE *pf) + { + t_persona registro; + rewind(pf); + fread(®istro,sizeof(t_persona),1,pf); + while(!feof(pf)) + { + printf("\n DNI: %d \t Apellido/s: \t %s \n\t\t Nombre/s: \t %s \n\t\t Edad: \t\t %d \n\t\t Sueldo: \t %.2lf \n",registro.dni,registro.apellido,registro.nombre,registro.edad,registro.sueldo); + fread(®istro,sizeof(t_persona),1,pf); + } + } diff --git a/merge de archivos_hardcodeo archivos A y B/header.h b/merge de archivos_hardcodeo archivos A y B/header.h new file mode 100644 index 0000000..2d6d18c --- /dev/null +++ b/merge de archivos_hardcodeo archivos A y B/header.h @@ -0,0 +1,19 @@ +#include +#include +#include +#include + +#define TAM 10 + +typedef struct + { + int dni; + char apellido[25]; + char nombre[30]; + int edad; + double sueldo; + }t_persona; + +void grabar_en_binario(char*,t_persona[],int); +void grabar_en_binario(char*,t_persona[],int); +void mostrar_archivo_binario(FILE*); diff --git a/merge de archivos_hardcodeo archivos A y B/main.c b/merge de archivos_hardcodeo archivos A y B/main.c new file mode 100644 index 0000000..968e943 --- /dev/null +++ b/merge de archivos_hardcodeo archivos A y B/main.c @@ -0,0 +1,62 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n MERGE DE ARCHIVOS: HARDCODEO ARCHIVOS A Y B \n\n"); + + t_persona personas_A[TAM]={ {25648754,"Ascacibar","Andrea Julieta",35,32000.00}, + {16514142,"Borrato","Jorge Esteban",54,24000.00}, + {36916554,"Cancarro","Matías Ignacio",25,37870.00}, + {26489494,"Echegaray","Malena Romina",33,17470.00}, + {18564966,"Gutierrez","Enrique Luis",50,16640.00}, + {28946356,"Oberto","Jorge Ignacio",35,17000.00}, + {32659449,"Ortúzar","Oriana Lucía",27,32000.00}, + {25648754,"Roberto","Sergio",31,14500.00}, + {13648754,"Torres Rojas","Gilberto Pancracio",56,29850.00}, + {25648754,"Ulisotta","Juan Edgardo",34,16200.00} }; + + t_persona personas_B[TAM]={ {30135949,"Aranibar","Johanna Luna",29,26450.00}, + {26489494,"Echegaray","Malena Romina",33,17470.00}, + {18564966,"Gutierrez","Enrique Luis",50,16640.00}, + {23487487,"Montero","Patricio Humberto",26,23350.00}, + {19648754,"Pereyra","Oscar Darío",43,34656.00}, + {25648754,"Roberto","Sergio",31,14500.00}, + {26496135,"Sánchez","Tamara",25,16700.00}, + {20161131,"Serrano","Omar Ricardo",35,16400.00}, + {25648754,"Ulisotta","Juan Edgardo",34,16200.00}, + {23648754,"Zuñiga","Pedro Iván",42,147500} }; + + grabar_en_binario("personas_A.bin",personas_A,TAM); + grabar_en_binario("personas_B.bin",personas_B,TAM); + + //---------------------------------------------------------------------------------------------------- + + FILE *pf_A,*pf_B; + pf_A=fopen("personas_A.bin","rb"); + if(!pf_A) + { + printf("\n\n No se pudo leer el archivo \"personas_A.bin\" \n\n\a\a"); + exit(EXIT_FAILURE); + } + pf_B=fopen("personas_B.bin","rb"); + if(!pf_B) + { + printf("\n\n No se pudo leer el archivo \"personas_B.bin\" \n\n\a\a"); + fclose(pf_A); + exit(EXIT_FAILURE); + } + + printf("\n\n ARCHIVO A \n\n"); + mostrar_archivo_binario(pf_A); + printf("\n\n ARCHIVO B \n\n"); + mostrar_archivo_binario(pf_B); + + fclose(pf_A); + fclose(pf_B); + + printf("\n\n Se han generado los archivos \"personas_A.bin\" y \"personas_B.bin\" \n\a\a"); + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.cbp b/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.cbp new file mode 100644 index 0000000..6bceee0 --- /dev/null +++ b/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.depend b/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.depend new file mode 100644 index 0000000..47412df --- /dev/null +++ b/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474224573 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_hardcodeo archivos a y b\functions.c + "header.h" + +1474223987 d:\unlam\programaciÓn\fabian 2\merge de archivos_hardcodeo archivos a y b\header.h + + + + + +1474223949 source:d:\unlam\programaciÓn\fabian 2\merge de archivos_hardcodeo archivos a y b\main.c + "header.h" + diff --git a/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.layout b/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.layout new file mode 100644 index 0000000..c40ddd2 --- /dev/null +++ b/merge de archivos_hardcodeo archivos A y B/merge de archivos_hardcodeo archivos A y B.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/merge de archivos_hardcodeo archivos A y B/obj/Debug/functions.o b/merge de archivos_hardcodeo archivos A y B/obj/Debug/functions.o new file mode 100644 index 0000000..0de52c7 Binary files /dev/null and b/merge de archivos_hardcodeo archivos A y B/obj/Debug/functions.o differ diff --git a/merge de archivos_hardcodeo archivos A y B/obj/Debug/main.o b/merge de archivos_hardcodeo archivos A y B/obj/Debug/main.o new file mode 100644 index 0000000..fb65c39 Binary files /dev/null and b/merge de archivos_hardcodeo archivos A y B/obj/Debug/main.o differ diff --git a/merge de archivos_hardcodeo archivos A y B/personas_A.bin b/merge de archivos_hardcodeo archivos A y B/personas_A.bin new file mode 100644 index 0000000..ed642f7 Binary files /dev/null and b/merge de archivos_hardcodeo archivos A y B/personas_A.bin differ diff --git a/merge de archivos_hardcodeo archivos A y B/personas_B.bin b/merge de archivos_hardcodeo archivos A y B/personas_B.bin new file mode 100644 index 0000000..be0c7c1 Binary files /dev/null and b/merge de archivos_hardcodeo archivos A y B/personas_B.bin differ diff --git "a/multiplicaci\303\263n rusa/bin/Debug/multiplicaci\303\263n rusa.exe" "b/multiplicaci\303\263n rusa/bin/Debug/multiplicaci\303\263n rusa.exe" new file mode 100644 index 0000000..8e519db Binary files /dev/null and "b/multiplicaci\303\263n rusa/bin/Debug/multiplicaci\303\263n rusa.exe" differ diff --git "a/multiplicaci\303\263n rusa/encabezados.h" "b/multiplicaci\303\263n rusa/encabezados.h" new file mode 100644 index 0000000..9d57118 --- /dev/null +++ "b/multiplicaci\303\263n rusa/encabezados.h" @@ -0,0 +1,5 @@ +#include +#include +#include +int multiplicacion_rusa(int,int); + diff --git "a/multiplicaci\303\263n rusa/funciones.c" "b/multiplicaci\303\263n rusa/funciones.c" new file mode 100644 index 0000000..3e1607b --- /dev/null +++ "b/multiplicaci\303\263n rusa/funciones.c" @@ -0,0 +1,13 @@ +#include "encabezados.h" +int multiplicacion_rusa(int n1,int n2) + { + int y=0; + while(n1>=1)//hasta cociente 1 + { + if(n1%2!=0)//si el primero es impar, acumulo el segundo + y+=n2; + n1/=2;//divido al primero y multiplico al segundo + n2*=2; + } + return y; + } diff --git "a/multiplicaci\303\263n rusa/main.c" "b/multiplicaci\303\263n rusa/main.c" new file mode 100644 index 0000000..12b6775 --- /dev/null +++ "b/multiplicaci\303\263n rusa/main.c" @@ -0,0 +1,24 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int factor1,factor2,prod; + printf("\n MULTIPLICACIÓN RUSA \n"); + printf("\n Ingrese dos números enteros positivos para calcular su producto \n mediante el método de multiplicación rusa \n"); + do + { + printf("\n Factor 1: \t\t"); + scanf("%d",&factor1); + } + while(factor1<0); + do + { + printf("\n Factor 2: \t\t"); + scanf("%d",&factor2); + } + while(factor2<0); + prod=multiplicacion_rusa(factor1,factor2); + printf("\n El producto es %d \n\n",prod); + getch(); + return 0; + } diff --git "a/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.cbp" "b/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.cbp" new file mode 100644 index 0000000..84fae5e --- /dev/null +++ "b/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.depend" "b/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.depend" new file mode 100644 index 0000000..8cd30ad --- /dev/null +++ "b/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471574059 source:d:\unlam\programaciÓn\fabian 2da\multiplicación rusa\funciones.c + "encabezados.h" + +1471573708 d:\unlam\programaciÓn\fabian 2da\multiplicación rusa\encabezados.h + + + + +1471573739 source:d:\unlam\programaciÓn\fabian 2da\multiplicación rusa\main.c + "encabezados.h" + diff --git "a/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.layout" "b/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.layout" new file mode 100644 index 0000000..3f2810d --- /dev/null +++ "b/multiplicaci\303\263n rusa/multiplicaci\303\263n rusa.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/multiplicaci\303\263n rusa/obj/Debug/funciones.o" "b/multiplicaci\303\263n rusa/obj/Debug/funciones.o" new file mode 100644 index 0000000..8198d68 Binary files /dev/null and "b/multiplicaci\303\263n rusa/obj/Debug/funciones.o" differ diff --git "a/multiplicaci\303\263n rusa/obj/Debug/main.o" "b/multiplicaci\303\263n rusa/obj/Debug/main.o" new file mode 100644 index 0000000..23758e1 Binary files /dev/null and "b/multiplicaci\303\263n rusa/obj/Debug/main.o" differ diff --git a/normalizar_apellido_nombre/bin/Debug/normalizar_apellido_nombre.exe b/normalizar_apellido_nombre/bin/Debug/normalizar_apellido_nombre.exe new file mode 100644 index 0000000..b58ca22 Binary files /dev/null and b/normalizar_apellido_nombre/bin/Debug/normalizar_apellido_nombre.exe differ diff --git a/normalizar_apellido_nombre/functions.c b/normalizar_apellido_nombre/functions.c new file mode 100644 index 0000000..2840fd4 --- /dev/null +++ b/normalizar_apellido_nombre/functions.c @@ -0,0 +1,64 @@ +#include "header.h" + +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } + +void normalizar_apellido_nombre(char *s) +{ + char cadena[40],*aux=cadena,*inicio_s=s; + + while(ES_BLANCO(*s)) + s++; + + *aux=A_MAYUSCULA(*s); + aux++; + s++; + + while(ES_LETRA(*s)) + { + *aux=A_MINUSCULA(*s); + aux++; + s++; + } + + while(!ES_LETRA(*s)) + s++; + + *aux=','; + aux++; + + while(*s) + { + *aux=' '; + aux++; + + *aux=A_MAYUSCULA(*s); + aux++; + s++; + + while(ES_LETRA(*s)) + { + *aux=A_MINUSCULA(*s); + aux++; + s++; + } + + while(*s && ES_BLANCO(*s)) + s++; + } + + *aux='\0'; + + s=inicio_s; + str_cpy(s,cadena); +} diff --git a/normalizar_apellido_nombre/header.h b/normalizar_apellido_nombre/header.h new file mode 100644 index 0000000..dac879e --- /dev/null +++ b/normalizar_apellido_nombre/header.h @@ -0,0 +1,18 @@ +#include +#include +#include +#include + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +#define ES_BLANCO(x) ((x)==32) +#define ES_COMA(x) ((x)==',') +#define ES_LETRA(x) (((x)>='A'&&(x)<='Z')||((x)>='a'&&(x)<='z')) +#define ES_MAYUSCULA(x) ((x)>='A'&&(x)<='Z') +#define ES_MINUSCULA(x) ((x)>='a'&&(x)<='z') + +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) +#define A_MINUSCULA(x) (((x)>='A'&&(x)<='Z')?((x)+32):(x)) + +char *str_cpy(char*,const char*); +void normalizar_apellido_nombre(char*); diff --git a/normalizar_apellido_nombre/main.c b/normalizar_apellido_nombre/main.c new file mode 100644 index 0000000..68cbe50 --- /dev/null +++ b/normalizar_apellido_nombre/main.c @@ -0,0 +1,22 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n Normalización de cadena tipo \"apellido, nombre/s\" \n\a\a"); + printf("\n Ingrese la cadena de caracteres a normalizar: \n\n\t"); + + char cadena[50]; + fflush(stdin); + + gets(cadena); + printf("\n\n Cadena ingresada: \t \"%s\"",cadena); + + normalizar_apellido_nombre(cadena); + printf("\n\n Cadena normalizada: \t \"%s\"",cadena); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/normalizar_apellido_nombre/normalizar_apellido_nombre.cbp b/normalizar_apellido_nombre/normalizar_apellido_nombre.cbp new file mode 100644 index 0000000..5a3cda8 --- /dev/null +++ b/normalizar_apellido_nombre/normalizar_apellido_nombre.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/normalizar_apellido_nombre/normalizar_apellido_nombre.depend b/normalizar_apellido_nombre/normalizar_apellido_nombre.depend new file mode 100644 index 0000000..9693ba3 --- /dev/null +++ b/normalizar_apellido_nombre/normalizar_apellido_nombre.depend @@ -0,0 +1,25 @@ +# depslib dependency file v1.0 +1475444040 source:d:\unlam\programaciÓn\fabian 2\normalizar_apellido_nombre\functions.c + "header.h" + +1475444019 d:\unlam\programaciÓn\fabian 2\normalizar_apellido_nombre\header.h + + + + + +1475193588 source:d:\unlam\programaciÓn\fabian 2\normalizar_apellido_nombre\main.c + "header.h" + +1480560012 source:d:\unlam\programaciÓn\fabian\normalizar_apellido_nombre\functions.c + "header.h" + +1480557268 d:\unlam\programaciÓn\fabian\normalizar_apellido_nombre\header.h + + + + + +1480555865 source:d:\unlam\programaciÓn\fabian\normalizar_apellido_nombre\main.c + "header.h" + diff --git a/normalizar_apellido_nombre/normalizar_apellido_nombre.layout b/normalizar_apellido_nombre/normalizar_apellido_nombre.layout new file mode 100644 index 0000000..d2178f5 --- /dev/null +++ b/normalizar_apellido_nombre/normalizar_apellido_nombre.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/normalizar_apellido_nombre/obj/Debug/functions.o b/normalizar_apellido_nombre/obj/Debug/functions.o new file mode 100644 index 0000000..3a27708 Binary files /dev/null and b/normalizar_apellido_nombre/obj/Debug/functions.o differ diff --git a/normalizar_apellido_nombre/obj/Debug/main.o b/normalizar_apellido_nombre/obj/Debug/main.o new file mode 100644 index 0000000..a56506b Binary files /dev/null and b/normalizar_apellido_nombre/obj/Debug/main.o differ diff --git "a/n\303\272mero combinatorio/bin/Debug/n\303\272mero combinatorio.exe" "b/n\303\272mero combinatorio/bin/Debug/n\303\272mero combinatorio.exe" new file mode 100644 index 0000000..8829673 Binary files /dev/null and "b/n\303\272mero combinatorio/bin/Debug/n\303\272mero combinatorio.exe" differ diff --git "a/n\303\272mero combinatorio/encabezados.h" "b/n\303\272mero combinatorio/encabezados.h" new file mode 100644 index 0000000..7f20258 --- /dev/null +++ "b/n\303\272mero combinatorio/encabezados.h" @@ -0,0 +1,5 @@ +#include +#include +#include +int factorial(int); +int combinatorio(int,int); diff --git "a/n\303\272mero combinatorio/funciones.c" "b/n\303\272mero combinatorio/funciones.c" new file mode 100644 index 0000000..98affd6 --- /dev/null +++ "b/n\303\272mero combinatorio/funciones.c" @@ -0,0 +1,25 @@ +#include "encabezados.h" +int factorial(int n) + { + if(n<=1) + return 1; + else + return n*factorial(n-1); + } +/* +ésta función funciona, pero es más eficiente la suguiente porque no guarda los cálculos en variables, ya que no es necesario + +int combinatorio(int m,int n) + { + int fm,fn,fmn,comb; + fm=factorial(m); + fn=factorial(n); + fmn=factorial(m-n); + comb=fm/(fn*fmn); + return comb; + } +*/ +int combinatorio(int m,int n) + { + return factorial(m)/(factorial(n)*factorial(m-n)); + } diff --git "a/n\303\272mero combinatorio/main.c" "b/n\303\272mero combinatorio/main.c" new file mode 100644 index 0000000..4661da5 --- /dev/null +++ "b/n\303\272mero combinatorio/main.c" @@ -0,0 +1,31 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int m,n,comb; + printf("\n \t\t CÁLCULO DEL NÚMERO COMBINATORIO C ( m ; n )\n"); + printf("\n m debe ser mayor o igual a n por definición del número combinatorio \n"); + printf("\n (si los números m y n ingresados no cumplen ésta condición, \n deberán volver a ser ingresados) \n\n"); + do + { + do + { + printf("\n\n Ingrese el número m entero no negativo:\n\n\t\t"); + scanf("%d",&m); + } + while(m<0); + do + { + printf("\n\n Ingrese el número n entero no negativo:\n\n\t\t"); + scanf("%d",&n); + } + while(n<0); + if(m + + + + + diff --git "a/n\303\272mero combinatorio/n\303\272mero combinatorio.depend" "b/n\303\272mero combinatorio/n\303\272mero combinatorio.depend" new file mode 100644 index 0000000..71fb58d --- /dev/null +++ "b/n\303\272mero combinatorio/n\303\272mero combinatorio.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471480623 source:d:\unlam\programaciÓn\fabian 2da\número combinatorio\funciones.c + "encabezados.h" + +1471480002 d:\unlam\programaciÓn\fabian 2da\número combinatorio\encabezados.h + + + + +1471481776 source:d:\unlam\programaciÓn\fabian 2da\número combinatorio\main.c + "encabezados.h" + diff --git "a/n\303\272mero combinatorio/n\303\272mero combinatorio.layout" "b/n\303\272mero combinatorio/n\303\272mero combinatorio.layout" new file mode 100644 index 0000000..8173cef --- /dev/null +++ "b/n\303\272mero combinatorio/n\303\272mero combinatorio.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/n\303\272mero combinatorio/obj/Debug/funciones.o" "b/n\303\272mero combinatorio/obj/Debug/funciones.o" new file mode 100644 index 0000000..36449fa Binary files /dev/null and "b/n\303\272mero combinatorio/obj/Debug/funciones.o" differ diff --git "a/n\303\272mero combinatorio/obj/Debug/main.o" "b/n\303\272mero combinatorio/obj/Debug/main.o" new file mode 100644 index 0000000..f783258 Binary files /dev/null and "b/n\303\272mero combinatorio/obj/Debug/main.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.exe" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.exe" new file mode 100644 index 0000000..95253a2 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.exe" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/funciones.c" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/funciones.c" new file mode 100644 index 0000000..44ba8fe --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/funciones.c" @@ -0,0 +1,123 @@ +#include "header.h" +void cargar_vector(int *pv,int ce) + { + int i; + for(i=0;i*pv) + { + aux=*pv; + *pv=*comp; + *comp=aux; + hubo_cambio=1; + } + comp++; + } + j++; + pv++; + } + while(hubo_cambio==1); + } +void seleccion_orden_ascendente(int *pv,int ce) + { + int j,i,*comp,*min,aux; + for(j=0;j*max) + max=comp; + comp++; + } + if(max!=pv) + { + aux=*pv; + *pv=*max; + *max=aux; + } + pv++; + } + } diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/header.h" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/header.h" new file mode 100644 index 0000000..aba9a5b --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#define TAM 10 +void cargar_vector(int*,int); +void copiar_vector(int*,int*,int); +void mostrar_vector(int*,int); +void burbujeo_orden_ascendente(int*,int); +void burbujeo_orden_descendente(int*,int); +void seleccion_orden_ascendente(int*,int); +void seleccion_orden_descendente(int*,int); diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/main.c" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/main.c" new file mode 100644 index 0000000..3b8baaf --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/main.c" @@ -0,0 +1,34 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\t ORDENAMIENTO DE VECTOR, CON ARITMÉTICA DE PUNTEROS \n"); + int a[TAM],b[TAM],c[TAM],d[TAM]; + printf("\n %c Cargar vector: \n",16); + cargar_vector(a,TAM); + printf("\n\n El vector cargado es: \n\n"); + mostrar_vector(a,TAM); + //copio el vector para tener cuatro copias + //cada copia la envío a una función diferente para corroborar que todas las funciones ordenan completamente desde cero + copiar_vector(a,b,TAM); + copiar_vector(a,c,TAM); + copiar_vector(a,d,TAM); + //burbujeo + printf("\n\n\t Burbujeo orden ascendente: \n\n"); + burbujeo_orden_ascendente(a,TAM); + mostrar_vector(a,TAM); + printf("\n\n\t Burbujeo orden descendente: \n\n"); + burbujeo_orden_descendente(b,TAM); + mostrar_vector(b,TAM); + //selección + printf("\n\n\t Selección orden ascendente: \n\n"); + seleccion_orden_ascendente(c,TAM); + mostrar_vector(c,TAM); + printf("\n\n\t Selección orden descendente: \n\n"); + seleccion_orden_descendente(d,TAM); + mostrar_vector(d,TAM); + printf("\n\n"); + getch(); + return 0; + } + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/obj/Debug/funciones.o" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/obj/Debug/funciones.o" new file mode 100644 index 0000000..9a6e2c3 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/obj/Debug/funciones.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/obj/Debug/main.o" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/obj/Debug/main.o" new file mode 100644 index 0000000..9beb907 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/obj/Debug/main.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.cbp" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.cbp" new file mode 100644 index 0000000..4becc2e --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.depend" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.depend" new file mode 100644 index 0000000..c63af78 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472094168 source:d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con aritmética de punteros\main.c + "header.h" + +1472086914 d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con aritmética de punteros\header.h + + + + +1472094145 source:d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con aritmética de punteros\funciones.c + "header.h" + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.layout" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.layout" new file mode 100644 index 0000000..69b9823 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.exe" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.exe" new file mode 100644 index 0000000..9a6faa3 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.exe" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/functions.c" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/functions.c" new file mode 100644 index 0000000..9768d26 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/functions.c" @@ -0,0 +1,136 @@ +#include "header.h" +void cargar_vector(int *v,int ce) + { + int *fin=v+ce; + while(v*sig) + { + aux=*v; + *v=*sig; + *sig=aux; + hubo_cambio=1; + } + v++; + sig++; + } + v=inicio; + sig=v+1; + fin--; + } + while(hubo_cambio==1&&sig*comp) + { + menor=comp; + band=1; + } + comp++; + } + if(band==1) + { + aux=*v; + *v=*menor; + *menor=aux; + } + v++; + } + } +void seleccion_orden_descendente(int *v,int ce) + { + if(ce==1||ce==0) + return; + int aux,band=0,*fin=v+ce,*mayor,*comp=v; + while(v +#include +#include +#define TAM 10 +void cargar_vector(int*,int); +void copiar_vector(int*,int*,int); +void mostrar_vector(int*,int); +void burbujeo_orden_ascendente(int*,int); +void burbujeo_orden_descendente(int*,int); +void seleccion_orden_ascendente(int*,int); +void seleccion_orden_descendente(int*,int); diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/main.c" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/main.c" new file mode 100644 index 0000000..258981d --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/main.c" @@ -0,0 +1,33 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\t ORDENAMIENTO DE VECTOR, CON ARITMÉTICA DE PUNTEROS \n"); + int a[TAM],b[TAM],c[TAM],d[TAM]; + printf("\n %c Cargar vector: \n",16); + cargar_vector(a,TAM); + printf("\n\n El vector cargado es: \n\n"); + mostrar_vector(a,TAM); + //copio el vector para tener cuatro copias + //cada copia la envío a una función diferente para corroborar que todas las funciones ordenan completamente desde cero + copiar_vector(a,b,TAM); + copiar_vector(a,c,TAM); + copiar_vector(a,d,TAM); + //burbujeo + printf("\n\n\t Burbujeo orden ascendente: \n\n"); + burbujeo_orden_ascendente(a,TAM); + mostrar_vector(a,TAM); + printf("\n\n\t Burbujeo orden descendente: \n\n"); + burbujeo_orden_descendente(b,TAM); + mostrar_vector(b,TAM); + //selección + printf("\n\n\t Selección orden ascendente: \n\n"); + seleccion_orden_ascendente(c,TAM); + mostrar_vector(c,TAM); + printf("\n\n\t Selección orden descendente: \n\n"); + seleccion_orden_descendente(d,TAM); + mostrar_vector(d,TAM); + printf("\n\n"); + getch(); + return 0; + } diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/obj/Debug/functions.o" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/obj/Debug/functions.o" new file mode 100644 index 0000000..0646f52 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/obj/Debug/functions.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/obj/Debug/main.o" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/obj/Debug/main.o" new file mode 100644 index 0000000..8045011 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/obj/Debug/main.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.cbp" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.cbp" new file mode 100644 index 0000000..013052a --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.depend" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.depend" new file mode 100644 index 0000000..5730d76 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472488845 source:d:\unlam\programaciÓn\fabian 2\ordenamiento_burbujeo y selección_con aritmética de punteros_con while\main.c + "header.h" + +1472488872 d:\unlam\programaciÓn\fabian 2\ordenamiento_burbujeo y selección_con aritmética de punteros_con while\header.h + + + + +1472489893 source:d:\unlam\programaciÓn\fabian 2\ordenamiento_burbujeo y selección_con aritmética de punteros_con while\functions.c + "header.h" + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.layout" "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.layout" new file mode 100644 index 0000000..9bf7219 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while/ordenamiento_burbujeo y selecci\303\263n_con aritm\303\251tica de punteros_con while.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.exe" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.exe" new file mode 100644 index 0000000..c792a39 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.exe" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/funciones.c" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/funciones.c" new file mode 100644 index 0000000..35c20b8 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/funciones.c" @@ -0,0 +1,92 @@ +#include "header.h" +void cargar_vector(int *v,int ce) + { + int i; + for(i=0;i*(v+i+1)) + { + aux=*(v+i+1); + *(v+i+1)=*(v+i); + *(v+i)=aux; + hubo_cambio=1; + } + } + while(hubo_cambio==1); + } +void burbujeo_orden_descendente(int *v,int ce) + { + int i,j,hubo_cambio,aux; + j=0; + do + { + hubo_cambio=0; + j++; + for(i=0;i*(v+pos_mayor)) + pos_mayor=i; + } + aux=*(v+pos_mayor); + *(v+pos_mayor)=*(v+j-1); + *(v+j-1)=aux; + } + } diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/header.h" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/header.h" new file mode 100644 index 0000000..aba9a5b --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#define TAM 10 +void cargar_vector(int*,int); +void copiar_vector(int*,int*,int); +void mostrar_vector(int*,int); +void burbujeo_orden_ascendente(int*,int); +void burbujeo_orden_descendente(int*,int); +void seleccion_orden_ascendente(int*,int); +void seleccion_orden_descendente(int*,int); diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/main.c" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/main.c" new file mode 100644 index 0000000..3624a56 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/main.c" @@ -0,0 +1,34 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\t ORDENAMIENTO DE VECTOR, CON INDIRECCIONES \n"); + int a[TAM],b[TAM],c[TAM],d[TAM]; + printf("\n %c Cargar vector: \n",16); + cargar_vector(a,TAM); + printf("\n\n El vector cargado es: \n\n"); + mostrar_vector(a,TAM); + //copio el vector para tener cuatro copias + //cada copia la envío a una función diferente para corroborar que todas las funciones ordenan completamente desde cero + copiar_vector(a,b,TAM); + copiar_vector(a,c,TAM); + copiar_vector(a,d,TAM); + //burbujeo + printf("\n\n\t Burbujeo orden ascendente: \n\n"); + burbujeo_orden_ascendente(a,TAM); + mostrar_vector(a,TAM); + printf("\n\n\t Burbujeo orden descendente: \n\n"); + burbujeo_orden_descendente(b,TAM); + mostrar_vector(b,TAM); + //selección + printf("\n\n\t Selección orden ascendente: \n\n"); + seleccion_orden_ascendente(c,TAM); + mostrar_vector(c,TAM); + printf("\n\n\t Selección orden descendente: \n\n"); + seleccion_orden_descendente(d,TAM); + mostrar_vector(d,TAM); + printf("\n\n"); + getch(); + return 0; + } + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/obj/Debug/funciones.o" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/obj/Debug/funciones.o" new file mode 100644 index 0000000..78fb2ac Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/obj/Debug/funciones.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/obj/Debug/main.o" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/obj/Debug/main.o" new file mode 100644 index 0000000..f97ec26 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/obj/Debug/main.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.cbp" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.cbp" new file mode 100644 index 0000000..e6c15fa --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.depend" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.depend" new file mode 100644 index 0000000..b254a4b --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472081608 source:d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con indirecciones\funciones.c + "header.h" + +1472080673 d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con indirecciones\header.h + + + + +1472080441 source:d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con indirecciones\main.c + "header.h" + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.layout" "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.layout" new file mode 100644 index 0000000..642fcf3 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con indirecciones/ordenamiento_burbujeo y selecci\303\263n_con indirecciones.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.exe" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.exe" new file mode 100644 index 0000000..f77c97f Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/bin/Debug/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.exe" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/funciones.c" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/funciones.c" new file mode 100644 index 0000000..39034de --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/funciones.c" @@ -0,0 +1,92 @@ +#include "header.h" +void cargar_vector(int v[],int ce) + { + int i; + for(i=0;iv[i+1]) + { + aux=v[i+1]; + v[i+1]=v[i]; + v[i]=aux; + hubo_cambio=1; + } + } + while(hubo_cambio==1); + } +void burbujeo_orden_descendente(int v[],int ce) + { + int i,j,hubo_cambio,aux; + j=0; + do + { + hubo_cambio=0; + j++; + for(i=0;iv[pos_mayor]) + pos_mayor=i; + } + aux=v[pos_mayor]; + v[pos_mayor]=v[j-1]; + v[j-1]=aux; + } + } diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/header.h" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/header.h" new file mode 100644 index 0000000..8e5a9c5 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#define TAM 10 +void cargar_vector(int[],int); +void copiar_vector(int[],int[],int); +void mostrar_vector(int[],int); +void burbujeo_orden_ascendente(int[],int); +void burbujeo_orden_descendente(int[],int); +void seleccion_orden_ascendente(int[],int); +void seleccion_orden_descendente(int[],int); diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/main.c" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/main.c" new file mode 100644 index 0000000..76c70a5 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/main.c" @@ -0,0 +1,33 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\t ORDENAMIENTO DE VECTOR, CON SUBÍNDICES \n"); + int a[TAM],b[TAM],c[TAM],d[TAM]; + printf("\n %c Cargar vector: \n",16); + cargar_vector(a,TAM); + printf("\n\n El vector cargado es: \n\n"); + mostrar_vector(a,TAM); + //copio el vector para tener cuatro copias + //cada copia la envío a una función diferente para corroborar que todas las funciones ordenan completamente desde cero + copiar_vector(a,b,TAM); + copiar_vector(a,c,TAM); + copiar_vector(a,d,TAM); + //burbujeo + printf("\n\n\t Burbujeo orden ascendente: \n\n"); + burbujeo_orden_ascendente(a,TAM); + mostrar_vector(a,TAM); + printf("\n\n\t Burbujeo orden descendente: \n\n"); + burbujeo_orden_descendente(b,TAM); + mostrar_vector(b,TAM); + //selección + printf("\n\n\t Selección orden ascendente: \n\n"); + seleccion_orden_ascendente(c,TAM); + mostrar_vector(c,TAM); + printf("\n\n\t Selección orden descendente: \n\n"); + seleccion_orden_descendente(d,TAM); + mostrar_vector(d,TAM); + printf("\n\n"); + getch(); + return 0; + } diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/obj/Debug/funciones.o" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/obj/Debug/funciones.o" new file mode 100644 index 0000000..7244418 Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/obj/Debug/funciones.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/obj/Debug/main.o" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/obj/Debug/main.o" new file mode 100644 index 0000000..631efda Binary files /dev/null and "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/obj/Debug/main.o" differ diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.cbp" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.cbp" new file mode 100644 index 0000000..474c451 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.depend" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.depend" new file mode 100644 index 0000000..e294911 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472076280 source:d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con subíndices\main.c + "header.h" + +1472073691 d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con subíndices\header.h + + + + +1472076092 source:d:\unlam\programaciÓn\fabian 2da\ordenamiento_burbujeo y selección_con subíndices\funciones.c + "header.h" + diff --git "a/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.layout" "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.layout" new file mode 100644 index 0000000..152ee07 --- /dev/null +++ "b/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices/ordenamiento_burbujeo y selecci\303\263n_con sub\303\255ndices.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/palabras de un texto/bin/Debug/palabras de un texto.exe b/palabras de un texto/bin/Debug/palabras de un texto.exe new file mode 100644 index 0000000..c9542a7 Binary files /dev/null and b/palabras de un texto/bin/Debug/palabras de un texto.exe differ diff --git a/palabras de un texto/functions.c b/palabras de un texto/functions.c new file mode 100644 index 0000000..4817f83 --- /dev/null +++ b/palabras de un texto/functions.c @@ -0,0 +1,35 @@ +#include "header.h" + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +int str_icmp(const char *s1,const char *s2) + { + while(A_MAYUSCULA(*s1)==A_MAYUSCULA(*s2)&&*s1&&*s2) + { + s1++; + s2++; + } + return A_MAYUSCULA(*s1)-A_MAYUSCULA(*s2); + } + +char *str_cpy(char *destino,const char *origen) + { + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; + } diff --git a/palabras de un texto/header.h b/palabras de un texto/header.h new file mode 100644 index 0000000..1fd1dcb --- /dev/null +++ b/palabras de un texto/header.h @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +#define TAM 500 + +#define A_MAYUSCULA(x) (((x)>='a'&&(x)<='z')?((x)-32):(x)) + +size_t str_len(const char*); +int str_icmp(const char*,const char*); +char *str_cpy(char*,const char*); diff --git a/palabras de un texto/main.c b/palabras de un texto/main.c new file mode 100644 index 0000000..8f19ab0 --- /dev/null +++ b/palabras de un texto/main.c @@ -0,0 +1,56 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 0B"); + + char texto[TAM]="",primera_palabra[TAM]="",palabra[TAM]="",*lector=texto; + int cuenta_palabras=0,cuenta_primera_palabra=0,mayor_long_palabra=0,long_palabra; + + printf("\n\n PALABRAS DE UN TEXTO \n\n\a\a"); + printf("\n\n Ingrese un texto u oración (si se encuentra un punto o se agotan %d caracteres \n se considera terminada la cadena de caracteres): \n\n\t ",TAM); + + fflush(stdin); + gets(texto); + + while(*lector&&*lector!='.') + { + while(*lector==' ') + lector++; + if(*lector=='.'||!lector) + break; + + sscanf(lector,"%[^. ]",palabra); + long_palabra=str_len(palabra); + + cuenta_palabras++; + if(cuenta_palabras==1) + { + str_cpy(primera_palabra,palabra); + mayor_long_palabra=long_palabra; + lector+=long_palabra; + continue; + } + + if(str_icmp(palabra,primera_palabra)==0) + cuenta_primera_palabra++; + else + { + if(long_palabra>mayor_long_palabra) + mayor_long_palabra=long_palabra; + } + + lector+=long_palabra; + } + + printf("\n\n RESULTADO"); + printf("\n\n Primera palabra: \t %s",primera_palabra); + printf("\n\n Repeticiones de la primera palabra en el texto: \t %d",cuenta_primera_palabra); + printf("\n\n Cantidad de palabras del texto: \t %d",cuenta_palabras); + printf("\n\n Longitud de la palabra más larga: \t %d",mayor_long_palabra); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git a/palabras de un texto/obj/Debug/functions.o b/palabras de un texto/obj/Debug/functions.o new file mode 100644 index 0000000..7f610ef Binary files /dev/null and b/palabras de un texto/obj/Debug/functions.o differ diff --git a/palabras de un texto/obj/Debug/main.o b/palabras de un texto/obj/Debug/main.o new file mode 100644 index 0000000..7f73ceb Binary files /dev/null and b/palabras de un texto/obj/Debug/main.o differ diff --git a/palabras de un texto/palabras de un texto.cbp b/palabras de un texto/palabras de un texto.cbp new file mode 100644 index 0000000..56d58a4 --- /dev/null +++ b/palabras de un texto/palabras de un texto.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/palabras de un texto/palabras de un texto.depend b/palabras de un texto/palabras de un texto.depend new file mode 100644 index 0000000..a3c8489 --- /dev/null +++ b/palabras de un texto/palabras de un texto.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1474333326 source:d:\unlam\programaciÓn\fabian 2\palabras de un texto\functions.c + "header.h" + +1474333331 d:\unlam\programaciÓn\fabian 2\palabras de un texto\header.h + + + + + +1474334884 source:d:\unlam\programaciÓn\fabian 2\palabras de un texto\main.c + "header.h" + diff --git a/palabras de un texto/palabras de un texto.layout b/palabras de un texto/palabras de un texto.layout new file mode 100644 index 0000000..83f5872 --- /dev/null +++ b/palabras de un texto/palabras de un texto.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/pal\303\255ndromo/bin/Debug/pal\303\255ndromo.exe" "b/pal\303\255ndromo/bin/Debug/pal\303\255ndromo.exe" new file mode 100644 index 0000000..3fcc1ff Binary files /dev/null and "b/pal\303\255ndromo/bin/Debug/pal\303\255ndromo.exe" differ diff --git "a/pal\303\255ndromo/functions.c" "b/pal\303\255ndromo/functions.c" new file mode 100644 index 0000000..b1c4ce6 --- /dev/null +++ "b/pal\303\255ndromo/functions.c" @@ -0,0 +1,33 @@ +#include "header.h" +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } +int es_palindromo(char *c) + { + char *cadena=c,cad[TOPE]; + int i,j=0,longitud=str_len(cadena); + for(i=0;i<=longitud;i++) + { + if(ES_MAYUSCULA(cadena[i])) + cadena[i]=A_MINUSCULA(cadena[i]); + if(cadena[i]!=' ') + { + cad[j]=cadena[i]; + j++; + } + } + longitud=str_len(cad); + for(i=0;i<=longitud/2;i++) + if(cad[i]!=cad[longitud-1-i]) + { + return 0; + } + return 1; + } diff --git "a/pal\303\255ndromo/header.h" "b/pal\303\255ndromo/header.h" new file mode 100644 index 0000000..02dfbf9 --- /dev/null +++ "b/pal\303\255ndromo/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#define TOPE 50 +#define ES_MAYUSCULA(x) ((x)>='A'&&(x)<='Z') +#define A_MINUSCULA(x) (((x)>='A'&&(x)<='Z')?((x)+32):(x)) +size_t str_len(const char*); +int es_palindromo(char*); + diff --git "a/pal\303\255ndromo/main.c" "b/pal\303\255ndromo/main.c" new file mode 100644 index 0000000..24a51ff --- /dev/null +++ "b/pal\303\255ndromo/main.c" @@ -0,0 +1,17 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[TOPE]; + printf("\n\n PALÍNDROMO \n"); + printf("\n Una palabra o frase es un palíndromo si se lee \n de igual manera en ambos sentidos \n"); + printf("\n Ingrese una cadena de caracteres para ver si es palíndrome \n\n\t"); + gets(cadena); + if(es_palindromo(cadena)) + printf("\n \"%s\" es un palíndromo",cadena); + else + printf("\n \"%s\" no es un palíndromo",cadena); + printf("\n\n"); + getch(); + return 0; + } diff --git "a/pal\303\255ndromo/obj/Debug/functions.o" "b/pal\303\255ndromo/obj/Debug/functions.o" new file mode 100644 index 0000000..86d506c Binary files /dev/null and "b/pal\303\255ndromo/obj/Debug/functions.o" differ diff --git "a/pal\303\255ndromo/obj/Debug/main.o" "b/pal\303\255ndromo/obj/Debug/main.o" new file mode 100644 index 0000000..6f00325 Binary files /dev/null and "b/pal\303\255ndromo/obj/Debug/main.o" differ diff --git "a/pal\303\255ndromo/pal\303\255ndromo.cbp" "b/pal\303\255ndromo/pal\303\255ndromo.cbp" new file mode 100644 index 0000000..d611ca5 --- /dev/null +++ "b/pal\303\255ndromo/pal\303\255ndromo.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/pal\303\255ndromo/pal\303\255ndromo.depend" "b/pal\303\255ndromo/pal\303\255ndromo.depend" new file mode 100644 index 0000000..5c83e82 --- /dev/null +++ "b/pal\303\255ndromo/pal\303\255ndromo.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473365614 source:d:\unlam\programaciÓn\fabian 2\palíndromo\functions.c + "header.h" + +1473365675 d:\unlam\programaciÓn\fabian 2\palíndromo\header.h + + + + +1473361496 source:d:\unlam\programaciÓn\fabian 2\palíndromo\main.c + "header.h" + diff --git "a/pal\303\255ndromo/pal\303\255ndromo.layout" "b/pal\303\255ndromo/pal\303\255ndromo.layout" new file mode 100644 index 0000000..e303f63 --- /dev/null +++ "b/pal\303\255ndromo/pal\303\255ndromo.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/archivos/actual.dat" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/archivos/actual.dat" new file mode 100644 index 0000000..aac2f95 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/archivos/actual.dat" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/archivos/histor.dat" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/archivos/histor.dat" new file mode 100644 index 0000000..aac2f95 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/archivos/histor.dat" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/bin/Debug/parcial1Modelo.exe" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/bin/Debug/parcial1Modelo.exe" new file mode 100644 index 0000000..123d382 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/bin/Debug/parcial1Modelo.exe" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/funciones/cola.c" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/funciones/cola.c" new file mode 100644 index 0000000..35d2957 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/funciones/cola.c" @@ -0,0 +1,74 @@ +#include +#include +#include + +void crearCola(t_cola *cola) +{ + cola->frente=NULL; + cola->fondo=NULL; +} + +int colaVacia(const t_cola *cola) +{ + if(cola->frente!=NULL) + return 0; + return 1; +} + +int colaLLena(const t_cola *cola) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + if(aux==NULL) + return 0; + return 1; +} + +int ponerEnCola(t_cola *cola, const t_info *info) +{ + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return 0; + nuevo->info=*info; + nuevo->sig=NULL; + if(cola->fondo==NULL) + cola->frente=nuevo; + else + cola->fondo->sig=nuevo; + cola->fondo=nuevo; + return 1; +} + +int sacarDeCola(t_cola *cola, t_info *info) +{ + if(cola->frente==NULL) + return 0; + t_nodo *aux=cola->frente; + *info=aux->info; + cola->frente=aux->sig; + if(cola->frente==NULL) + cola->fondo==NULL; + free(aux); + return 1; +} + +int primeroEnCola(const t_cola *cola, t_info *info) +{ + if(cola->frente==NULL) + return 0; + *info=cola->frente->info; + return 1; +} + +void vaciarCola(t_cola *cola) +{ + t_nodo *aux; + while(cola->frente!=NULL) + { + aux=cola->frente; + cola->frente=aux->sig; + free(aux); + } + cola->fondo=NULL; +} + diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/funciones/funciones.c" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/funciones/funciones.c" new file mode 100644 index 0000000..a6d56f7 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/funciones/funciones.c" @@ -0,0 +1,133 @@ +#include +#include +#include +#include + +void crearArchivo() + { + FILE *pf=fopen("archivos/histor.dat","wb"); + if(!pf) + { + printf("\n No se pudo crear el archivo binario \"archivos/histor.dat\" \n\n\a\a"); + printf("\n Programa evacuado \n"); + exit(EXIT_FAILURE); + } + + t_historial hist[15]={ {123456789,"soy una descripción",123,1,2}, + {123456789,"soy otra descripción",123,1,2}, + {123456789,"soy descripción",123,1,2}, + {123456789,"soy la descripción",123,1,2}, + {123456789,"soy descripción",123,1,2}, + {123456789,"soy la descripción",123,1,2}, + {123456789,"soy una descripción",123,1,2}, + {123456789,"soy otra descripción",123,1,2}, + {123456789,"soy una descripción",123,1,2}, + {123456789,"soy otra descripción",123,1,2}, + {123456789,"soy la descripción",123,1,2}, + {123456789,"soy la descripción",123,1,2}, + {123456789,"soy la descripción",123,1,2}, + {123456789,"soy una descripción",123,1,2}, + {123456789,"soy una descripción",123,1,2} }; + + fwrite(hist,sizeof(t_historial),15,pf); + fclose(pf); + } + +int aperturaDeArchivos(FILE **archivo, const char *ruta, const char *modo) + { + *archivo=fopen(ruta,modo); + if(!*archivo) + return 0; + return 1; + } + +int es_vocal(char s) +{ + if(s!='A'&&s!='E'&&s!='I'&&s!='O'&&s!='U'&&s!='a'&&s!='e'&&s!='i'&&s!='o'&&s!='u') + return 0; + return 1; +} + +int cantVocalesIni(char *s) +{ + int vocales=0; + while(*s) + { + if(es_vocal(*s)) + vocales=1; + while(*s&&!ES_BLANCO(*s)) + s++; + if(ES_BLANCO(*s)) + s++; + } + if(vocales==0) + return 0; + return 1; +} + +char *str_cpy(char *destino,const char *origen) +{ + char *inicio=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return inicio; +} + +void cargaInfoDeArchivo(FILE *entrada,t_historial *his,t_cola *cola,char descripcion[][46], long valores[][4], int *fila) +{ + t_info info; + rewind(entrada); + + fread(his,sizeof(t_historial),1,entrada); + while(!feof(entrada)) + { + if(cantVocalesIni(his->desc)) + { + str_cpy(descripcion[*fila],his->desc); + valores[*fila][0]=his->clave; + valores[*fila][1]=his->prepo; + valores[*fila][2]=his->exist; + valores[*fila][3]=his->pengr; + (*fila)++; + } + else + { + info=his->clave; + ponerEnCola(cola,&info); + } + fread(his,sizeof(t_historial),1,entrada); + } +} + + +void crearArchivoActual(FILE *entrada, FILE *salida, t_historial *his,t_cola *cola) +{ + t_info info; + rewind(entrada); + rewind(salida); + + fread(his,sizeof(t_historial),1,entrada); + while(!feof(entrada)) + { + primeroEnCola(cola,&info); + if(his->clave==info) + { + sacarDeCola(cola,&info); + fwrite(his,sizeof(t_historial),1,salida); + } + fread(his,sizeof(t_historial),1,entrada); + } +} + +void mostrarInfo(char descripcion[][46], long valores[][4], int *cant) +{ + int i; + printf("\n CLAVE \t\t DESC \t\t\t\t PREPO \t EXIST \t PENGR \n"); + for(i=0;i<*cant;i++) + printf("\n %ld \t %s \t\t %ld \t %ld \t %ld",valores[i][0],descripcion[i],valores[i][1],valores[i][2],valores[i][3]); +} diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/cola.h" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/cola.h" new file mode 100644 index 0000000..1fc6585 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/cola.h" @@ -0,0 +1,24 @@ +#ifndef COLA_H_INCLUDED +#define COLA_H_INCLUDED + +typedef long t_info; + +typedef struct s_nodo{ + struct s_nodo *sig; + t_info info; +}t_nodo; + +typedef struct { + t_nodo * frente; + t_nodo * fondo; +}t_cola; + +void crearCola(t_cola *cola); +int colaVacia(const t_cola *cola); +int colaLLena(const t_cola *cola); +int ponerEnCola(t_cola *cola, const t_info *info); +int sacarDeCola(t_cola *cola, t_info *info); +int primeroEnCola(const t_cola *cola, t_info *info); +void vaciarCola(t_cola *cola); + +#endif // COLA_H_INCLUDED diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/funciones.h" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/funciones.h" new file mode 100644 index 0000000..9532434 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/funciones.h" @@ -0,0 +1,20 @@ +#ifndef FUNCIONES_H_INCLUDED +#define FUNCIONES_H_INCLUDED + +#include +#include + +#define TAM 50 +#define ES_BLANCO(x) ((x)==' ') + +void crearArchivo(); +int aperturaDeArchivos(FILE **archivo, const char *ruta, const char *modo); + +void cargaInfoDeArchivo(FILE *entrada,t_historial *his,t_cola *cola,char descripcion[][46], long valores[][4], int *fila); +void crearArchivoActual(FILE *entrada, FILE *salida, t_historial *his,t_cola *cola); +void mostrarInfo(char descripcion[][46], long valores[][4], int *cant); +int cantVocalesIni(char *s); +int es_vocal(char c); +char *str_cpy(char*,const char*); + +#endif // FUNCIONES_H_INCLUDED diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/tipo.h" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/tipo.h" new file mode 100644 index 0000000..f7a1f45 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/include/tipo.h" @@ -0,0 +1,12 @@ +#ifndef TIPO_H_INCLUDED +#define TIPO_H_INCLUDED + +typedef struct{ + long clave; + char desc[46]; + long prepo, + exist, + pengr; +}t_historial; + +#endif // TIPO_H_INCLUDED diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/libreria/libParcial1.a" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/libreria/libParcial1.a" new file mode 100644 index 0000000..860d0f1 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/libreria/libParcial1.a" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/main.c" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/main.c" new file mode 100644 index 0000000..8efd35d --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/main.c" @@ -0,0 +1,60 @@ +///ESCOBAR, FABIÁN NORBERTO DNI: 39210915 + +#include +#include +#include +#include +#include + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + + FILE *entrada; + FILE *salida; + + t_historial his; + t_cola cola; + + int fila = 0; + char descripcion[TAM][46]; + long valores[TAM][4]; + + printf("\n\n\t PARCIAL 1 \n"); + + crearCola(&cola); + printf("\n Se ha creado una cola \n\a\a"); + + crearArchivo(); + printf("\n Se ha generado el archivo \"histor.dat\" \n"); + + if(!aperturaDeArchivos(&entrada, "archivos/histor.dat", "rb")) + return 5; + if(!aperturaDeArchivos(&salida, "archivos/actual.dat", "wb")) + return 5; + + printf("\n Se ha leído el archivo \"histor.dat\" correctamente \n"); + + cargaInfoDeArchivo(entrada, &his, &cola, descripcion, valores, &fila); + printf("\n Se han cargado los arrays bidimensionales y la cola \n"); + printf("\n En los arrays, están los registros que tienen alguna palabra \n que empieza con vocal en su descripción \n"); + printf("\n En la cola, están las claves de los registros restantes \n"); + + crearArchivoActual(entrada, salida, &his, &cola); + printf("\n Los registros del archivo de entrada que figuraban en la cola \n fueron grabados en el archivo de salida \n"); + + printf("\n Los registros de los arrays son los siguientes \n"); + puts("\n\n *** ARRAYS *** \n"); + mostrarInfo(descripcion, valores, &fila); + + fclose(entrada); + fclose(salida); + printf("\n\n\n Los archivos fueron cerrados exitosamente \n"); + + vaciarCola(&cola); + printf("\n La cola fue vaciada \n"); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + return 0; + getch(); +} diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/funciones/cola.o" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/funciones/cola.o" new file mode 100644 index 0000000..6ac6ba7 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/funciones/cola.o" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/funciones/funciones.o" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/funciones/funciones.o" new file mode 100644 index 0000000..c73e05a Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/funciones/funciones.o" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/main.o" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/main.o" new file mode 100644 index 0000000..755a390 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/obj/Debug/main.o" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial.png" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial.png" new file mode 100644 index 0000000..fdf4753 Binary files /dev/null and "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial.png" differ diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.cbp" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.cbp" new file mode 100644 index 0000000..1a6ae14 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.cbp" @@ -0,0 +1,60 @@ + + + + + + diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.depend" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.depend" new file mode 100644 index 0000000..34e5c68 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.depend" @@ -0,0 +1,27 @@ +# depslib dependency file v1.0 +1475694821 source:d:\unlam\programaciÓn\fabian\parcial01\funciones\cola.c + + + + +1475687773 d:\unlam\programaciÓn\fabian\parcial01\include\cola.h + +1475697253 source:d:\unlam\programaciÓn\fabian\parcial01\funciones\funciones.c + + + + + +1475691847 d:\unlam\programaciÓn\fabian\parcial01\include\funciones.h + + + +1475686578 d:\unlam\programaciÓn\fabian\parcial01\include\tipo.h + +1475695109 source:d:\unlam\programaciÓn\fabian\parcial01\main.c + + + + + + diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.layout" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.layout" new file mode 100644 index 0000000..529aaa6 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial01.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial1Modelo.depend" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial1Modelo.depend" new file mode 100644 index 0000000..f2da226 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial1Modelo.depend" @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1475437656 source:c:\users\federico\desktop\parcial1modelo\funciones\cola.c + + + + +1475437656 c:\users\federico\desktop\parcial1modelo\include\cola.h + +1475437863 source:c:\users\federico\desktop\parcial1modelo\funciones\funciones.c + + + + + + +1475437940 c:\users\federico\desktop\parcial1modelo\include\funciones.h + + + +1475435461 c:\users\federico\desktop\parcial1modelo\include\tipo.h + +1475436973 source:c:\users\federico\desktop\parcial1modelo\main.c + + + + diff --git "a/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial1Modelo.layout" "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial1Modelo.layout" new file mode 100644 index 0000000..d55c161 --- /dev/null +++ "b/parcial 1_archivos binarios y cola din\303\241mica/parcial01/parcial1Modelo.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ERRORES b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ERRORES new file mode 100644 index 0000000..9758702 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ERRORES @@ -0,0 +1,3 @@ +999999-9 E 2500.00 +111111-6 E 2000.00 +333333-3 E 1500.00 diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ERRORES.txt b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ERRORES.txt new file mode 100644 index 0000000..9758702 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ERRORES.txt @@ -0,0 +1,3 @@ +999999-9 E 2500.00 +111111-6 E 2000.00 +333333-3 E 1500.00 diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/bin/Debug/ejercicio 1_movimientos bancarios_archivos y lista.exe b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/bin/Debug/ejercicio 1_movimientos bancarios_archivos y lista.exe new file mode 100644 index 0000000..d118da3 Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/bin/Debug/ejercicio 1_movimientos bancarios_archivos y lista.exe differ diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo mayor a 1000 b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo mayor a 1000 new file mode 100644 index 0000000..5e67434 Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo mayor a 1000 differ diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo mayor a 1000.dat b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo mayor a 1000.dat new file mode 100644 index 0000000..5e67434 Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo mayor a 1000.dat differ diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo menor a 1000 b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo menor a 1000 new file mode 100644 index 0000000..e69de29 diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo menor a 1000.dat b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/cuentas con saldo menor a 1000.dat new file mode 100644 index 0000000..e69de29 diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/dato.h b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/dato.h new file mode 100644 index 0000000..d82e2f9 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/dato.h @@ -0,0 +1,6 @@ +typedef struct + { + char cuenta[9]; + char movimiento; + float importe; + }t_dato; diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.cbp b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.cbp new file mode 100644 index 0000000..d5bab03 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.depend b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.depend new file mode 100644 index 0000000..47f6937 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.depend @@ -0,0 +1,21 @@ +# depslib dependency file v1.0 +1476552993 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 1_movimientos bancarios_archivos y lista\funciones.c + "header.h" + +1476553193 d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 1_movimientos bancarios_archivos y lista\header.h + + + + + "lista_simplemente_enlazada.h" + +1476554969 d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 1_movimientos bancarios_archivos y lista\lista_simplemente_enlazada.h + "dato.h" + +1476554984 d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 1_movimientos bancarios_archivos y lista\dato.h + +1476554636 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 1_movimientos bancarios_archivos y lista\lista_simplemente_enlazada.c + + + "lista_simplemente_enlazada.h" + diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.layout b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.layout new file mode 100644 index 0000000..42d9d38 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/ejercicio 1_movimientos bancarios_archivos y lista.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/funciones.c b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/funciones.c new file mode 100644 index 0000000..8fb0b5f --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/funciones.c @@ -0,0 +1,49 @@ +#include "header.h" + +int cuenta_valida(const char *s) +{ + unsigned acum=0; + + while(*s&&*s!='-') + { + acum+=A_NUMERO(*s); + s++; + } + s++; + + while(acum/10!=0) + acum=acum%10+acum/10; + + return acum==A_NUMERO(*s); +} + +char *str_cpy(char *destino,const char *origen) +{ + char *s=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return s; +} + +int str_cmp(const char *s1,const char *s2) +{ + while(*s1&&*s2&&*s1==*s2) + { + s1++; + s2++; + } + return *s1-*s2; +} + +int comparar_movimiento_e_importe(const void *v1,const void *v2) +{ + t_registro *e1=(t_registro*)v1,*e2=(t_registro*)v2; + if(e1->movimiento==e2->movimiento) + return e1->importe-e2->importe; + return e1->movimiento-e2->movimiento; +} diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/header.h b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/header.h new file mode 100644 index 0000000..a72aba7 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/header.h @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +#include "lista_simplemente_enlazada.h" + +#define A_NUMERO(x) ((x)-'0') + +typedef struct + { + char cuenta[9]; + char movimiento; + float importe; + }t_registro; + +int cuenta_valida(const char*); +char *str_cpy(char*,const char*); +int str_cmp(const char*,const char*); +int comparar_movimiento_e_importe(const void*,const void*); diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/lista_simplemente_enlazada.c b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/lista_simplemente_enlazada.c new file mode 100644 index 0000000..bc3bc39 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/lista_simplemente_enlazada.c @@ -0,0 +1,39 @@ +#include +#include + +#include "lista_simplemente_enlazada.h" + +void crear_lista(t_lista *l) + { + *l=NULL; + } + +int lista_vacia(const t_lista *l) + { + return *l==NULL; + } + +int sacar_de_lista_primero(t_lista *l,t_dato *d) + { + if(!*l) + return LISTA_VACIA; + t_nodo *aux=*l; + *d=aux->dato; + *l=aux->sig; + free(aux); + return OK; + } + +int insertar_en_lista_ordenado_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) + { + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->dato,(void*)d)<=0)) + l=&(*l)->sig; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; + } diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/lista_simplemente_enlazada.h b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/lista_simplemente_enlazada.h new file mode 100644 index 0000000..5750004 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/lista_simplemente_enlazada.h @@ -0,0 +1,20 @@ +#include "dato.h" + +#define MEMORIA_LLENA 0 +#define LISTA_VACIA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int sacar_de_lista_primero(t_lista*,t_dato*); +int insertar_en_lista_ordenado_con_duplicado(t_lista*,const t_dato*,t_cmp); diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/main.c b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/main.c new file mode 100644 index 0000000..2c82485 --- /dev/null +++ b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/main.c @@ -0,0 +1,152 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n\t\t ***** MOVIMIENTOS BANCARIOS ***** \n"); + + t_registro registro; + float saldo; + char cuenta[9]; + + FILE *pf_movimientos,*pf_saldo_menor,*pf_saldo_mayor,*pf_errores; + + pf_movimientos=fopen("movimientos.dat","wb"); + if(!pf_movimientos) + { + printf("\n\n No se ha podido crear el archivo lote de prueba \n\n\t Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + t_registro registros[17]={ {"999999-9",'D',1500}, + {"999999-9",'D',3000}, + {"999999-9",'E',2500}, + {"999999-9",'D',7500}, + {"111111-6",'D',1000}, + {"111111-6",'E',2000}, + {"333333-3",'E',1500}, + {"121212-9",'D',3000}, + {"242421-9",'E',2000}, + {"242521-9",'D',1000}, + {"222222-3",'D',3500}, + {"222222-2",'E',4000}, + {"222222-2",'E',5000}, + {"789787-6",'D',1000}, + {"147147-6",'E',9000}, + {"147147-6",'E',2500}, + {"111112-3",'E',1000} }; + + fwrite(registros,sizeof(t_registro),17,pf_movimientos); + + fclose(pf_movimientos); + printf("\n\n El lote de prueba \"movimientos.dat\" ha sido generado exitosamente \n"); + + //----------------------------------------------------------------------------------------------------------------------------------------------- + + pf_movimientos=fopen("movimientos.dat","rb"); + if(!pf_movimientos) + { + printf("\n\n No se ha podido leer el archivo lote de prueba \n\n\t Programa evacuado \n\n\a\a"); + exit(EXIT_FAILURE); + } + + pf_saldo_menor=fopen("cuentas con saldo menor a 1000.dat","wb"); + if(!pf_saldo_menor) + { + printf("\n\n No se ha podido crear el archivo de cuentas con saldo menor a 1000 \n\n\t Programa evacuado \n\n\a\a"); + fclose(pf_movimientos); + exit(EXIT_FAILURE); + } + + pf_saldo_mayor=fopen("cuentas con saldo mayor a 1000.dat","wb"); + if(!pf_saldo_mayor) + { + printf("\n\n No se ha podido crear el archivo de cuentas con saldo mayor a 1000 \n\n\t Programa evacuado \n\n\a\a"); + fclose(pf_movimientos); + fclose(pf_saldo_menor); + exit(EXIT_FAILURE); + } + + pf_errores=fopen("ERRORES.txt","wt"); + if(!pf_errores) + { + printf("\n\n No se ha pododo crear el archivo de errores \n\n\t Programa evacuado \n\n\a\a"); + fclose(pf_movimientos); + fclose(pf_saldo_menor); + fclose(pf_saldo_mayor); + exit(EXIT_FAILURE); + } + + //-------------------------------------------------------------------------------------------------------------------------------------------------- + + t_lista lista; + crear_lista(&lista); + + fread(®istro,sizeof(t_registro),1,pf_movimientos); + + while(!feof(pf_movimientos)) + { + if(cuenta_valida(registro.cuenta)) + { + saldo=0; + str_cpy(cuenta,registro.cuenta); + while(!feof(pf_movimientos)&&!str_cmp(cuenta,registro.cuenta)) + { + if(registro.movimiento=='D') + saldo+=registro.importe; + else + saldo-=registro.importe; + + insertar_en_lista_ordenado_con_duplicado(&lista,(t_dato*)®istro,comparar_movimiento_e_importe); + + if(saldo<0) + { + while(!lista_vacia(&lista)) + { + sacar_de_lista_primero(&lista,(t_dato*)®istro); + fprintf(pf_errores,"%-8s %c %.2f\n",registro.cuenta,registro.movimiento,registro.importe); + } + + fread(®istro,sizeof(t_registro),1,pf_movimientos); + break; + } + + + fread(®istro,sizeof(t_registro),1,pf_movimientos); + } + if(str_cmp(cuenta,registro.cuenta)) + { + if(saldo<1000) + while(!lista_vacia(&lista)) + { + sacar_de_lista_primero(&lista,(t_dato*)®istro); + fwrite(®istro,sizeof(t_registro),1,pf_saldo_menor); + } + else + while(!lista_vacia(&lista)) + { + sacar_de_lista_primero(&lista,(t_dato*)®istro); + fwrite(®istro,sizeof(t_registro),1,pf_saldo_mayor); + } + } + } + else + { + fprintf(pf_errores,"%-8s %c %.2f\n",registro.cuenta,registro.movimiento,registro.importe); + fread(®istro,sizeof(t_registro),1,pf_movimientos); + } + str_cpy(cuenta,registro.cuenta); + } + + printf("\n\n Se han generado exitosamente los archivos binarios \n \"cuentas con saldo mayor a 1000.dat\" y \"cuentas con saldo menor a 1000.dat\""); + printf("\n y el archivo de texto \"ERRORES.txt\" \n\n"); + + fclose(pf_movimientos); + fclose(pf_saldo_menor); + fclose(pf_saldo_mayor); + fclose(pf_errores); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n \a\a"); + getch(); + return 0; +} diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/movimientos.dat b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/movimientos.dat new file mode 100644 index 0000000..f3cc0b8 Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/movimientos.dat differ diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/funciones.o b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/funciones.o new file mode 100644 index 0000000..1bdbb28 Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/funciones.o differ diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/lista_simplemente_enlazada.o b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/lista_simplemente_enlazada.o new file mode 100644 index 0000000..7ef4bde Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/lista_simplemente_enlazada.o differ diff --git a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/main.o b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/main.o new file mode 100644 index 0000000..87a4d30 Binary files /dev/null and b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 1_movimientos bancarios_archivos y lista/obj/Debug/main.o differ diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/bin/Debug/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.exe" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/bin/Debug/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.exe" new file mode 100644 index 0000000..2b6d2aa Binary files /dev/null and "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/bin/Debug/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.exe" differ diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.cbp" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.cbp" new file mode 100644 index 0000000..9e6ba6f --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.depend" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.depend" new file mode 100644 index 0000000..7bcd7eb --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1476409542 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos de texto, matrices y cadenas\ejercicio 2_matrices_simetría diagonal secundaria\funciones.c + "header.h" + +1476409460 d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos de texto, matrices y cadenas\ejercicio 2_matrices_simetría diagonal secundaria\header.h + + + + + +1476409606 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos de texto, matrices y cadenas\ejercicio 2_matrices_simetría diagonal secundaria\main.c + "header.h" + diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.layout" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.layout" new file mode 100644 index 0000000..b142c82 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/ejercicio 2_matrices_simetr\303\255a diagonal secundaria.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/funciones.c" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/funciones.c" new file mode 100644 index 0000000..5ce8ecf --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/funciones.c" @@ -0,0 +1,38 @@ +#include "header.h" + +void cargar_matriz(int m[][COL],int f,int c) +{ + int i,j; + for(i=0;i +#include +#include +#include + +#define FIL 4 +#define COL 4 + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); + +int matriz_simetrica_respecto_diagonal_secundaria(int[][COL],int,int); diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/main.c" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/main.c" new file mode 100644 index 0000000..c821e54 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/main.c" @@ -0,0 +1,23 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n SIMETRÍA DE MATRIZ CUADRADA RESPECTO DIAGONAL SECUNDARIA \n\a\a"); + + int mat[FIL][COL]; + + printf("\n\n Ingrese una matriz de %dx%d \n",FIL,COL); + cargar_matriz(mat,FIL,COL); + + printf("\n\n\t\t\t MATRIZ \n"); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n La matriz %s simétrica respecto la diagonal secundaria \n",\ + matriz_simetrica_respecto_diagonal_secundaria(mat,FIL,COL)?"es":"no es"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/obj/Debug/funciones.o" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/obj/Debug/funciones.o" new file mode 100644 index 0000000..35c7d05 Binary files /dev/null and "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/obj/Debug/funciones.o" differ diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/obj/Debug/main.o" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/obj/Debug/main.o" new file mode 100644 index 0000000..6281e0c Binary files /dev/null and "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 2_matrices_simetr\303\255a diagonal secundaria/obj/Debug/main.o" differ diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/bin/Debug/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.exe" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/bin/Debug/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.exe" new file mode 100644 index 0000000..d3d5747 Binary files /dev/null and "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/bin/Debug/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.exe" differ diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.cbp" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.cbp" new file mode 100644 index 0000000..f079396 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.depend" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.depend" new file mode 100644 index 0000000..b0e2619 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.depend" @@ -0,0 +1,25 @@ +# depslib dependency file v1.0 +1476411529 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos de texto, matrices y cadenas\ejercicio 3_cadenas_buscar aparición de subcadena en cadena\funciones.c + "header.h" + +1476410988 d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos de texto, matrices y cadenas\ejercicio 3_cadenas_buscar aparición de subcadena en cadena\header.h + + + + + +1476411529 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos de texto, matrices y cadenas\ejercicio 3_cadenas_buscar aparición de subcadena en cadena\main.c + "header.h" + +1476570247 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 3_cadenas_buscar aparición de subcadena en cadena\main.c + "header.h" + +1476569703 d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 3_cadenas_buscar aparición de subcadena en cadena\header.h + + + + + +1476570299 source:d:\unlam\programaciÓn\fabian\parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas\ejercicio 3_cadenas_buscar aparición de subcadena en cadena\funciones.c + "header.h" + diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.layout" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.layout" new file mode 100644 index 0000000..fdf4885 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/funciones.c" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/funciones.c" new file mode 100644 index 0000000..5a7a3c4 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/funciones.c" @@ -0,0 +1,62 @@ +#include "header.h" + +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } + +int str_ncmpi(const char *s1,const char *s2,size_t cant) + { + while(*s1&&*s2&&A_MINUSCULA(*s1)==A_MINUSCULA(*s2)&&--cant) + { + s1++; + s2++; + } + return A_MINUSCULA(*s1)-A_MINUSCULA(*s2); + } + +int ocurrencia_de_subcadena_en_cadena(const char *s1,const char *s2) +{ + size_t tam=str_len(s2); + int cont=0; + while(*s1&&str_ncmpi(s1,s2,tam)) + { + s1++; + cont++; + } + return(*s1)?cont:-1; +} + +int ocurrencia_de_subcadena_en_cadena_optimizada(const char *s1,const char *s2) +{ + char *lector_s1=s1; + char *inicio_s2=s2; + int pos=0; + + while(*s1) + { + if(A_MINUSCULA(*s1)==A_MINUSCULA(*s2)) + { + lector_s1=s1; + while(*lector_s1&&*s2&&A_MINUSCULA(*lector_s1)==A_MINUSCULA(*s2)) + { + lector_s1++; + s2++; + } + + if(!*s2) + return pos; + else + s2=inicio_s2; + } + pos++; + s1++; + } + return -1; +} diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/header.h" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/header.h" new file mode 100644 index 0000000..090c252 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +#define A_MINUSCULA(x) (((x)>='A'&&(x)<='Z')?((x)+' '):(x)) + +size_t str_len(const char*); +int str_ncmpi(const char*,const char*,size_t); +int ocurrencia_de_subcadena_en_cadena(const char*,const char*); +int ocurrencia_de_subcadena_en_cadena_optimizada(const char*,const char*); diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/main.c" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/main.c" new file mode 100644 index 0000000..b0b80f1 --- /dev/null +++ "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/main.c" @@ -0,0 +1,41 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n \t\t *** OCURRENCIA DE UNA CADENA EN OTRA *** \n\a\a"); + + printf("\n A partir de 2 cadenas, comprueba si la segunda es subcadena de la primera. \n"); + + char cadena_1[20],cadena_2[20]; + + printf("\n Ingrese una cadena: \n\n\t"); + fflush(stdin); + gets(cadena_1); + + printf("\n Ingrese otra cadena: \n\n\t"); + fflush(stdin); + gets(cadena_2); + + int retorno; + + //USANDO LA FUNCIÓN QUE LLAMA A STRLEN Y A STRNCMPI + retorno=ocurrencia_de_subcadena_en_cadena(cadena_1,cadena_2); + printf("\n\n Usando la primera función: \n"); + if(retorno==-1) + printf("\n\n No hay ocurrencia de la subcadena en la cadena \n\n"); + else + printf("\n\n La segunda cadena es subcadena del la primera cadena \n y su ocurrencia se da en la posición %d \n\n",retorno); + + //USANDO UNA ÚNICA FUNCIÓN--> VERSIÓN OPTIMIZADA OPTIMIZADA + retorno=ocurrencia_de_subcadena_en_cadena_optimizada(cadena_1,cadena_2); + printf("\n\n Usando la segunda función: \n"); + if(retorno==-1) + printf("\n\n No hay ocurrencia de la subcadena en la cadena \n\n"); + else + printf("\n\n La segunda cadena es subcadena del la primera cadena \n y su ocurrencia se da en la posición %d \n\n",retorno); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/obj/Debug/funciones.o" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/obj/Debug/funciones.o" new file mode 100644 index 0000000..211d0d6 Binary files /dev/null and "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/obj/Debug/funciones.o" differ diff --git "a/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/obj/Debug/main.o" "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/obj/Debug/main.o" new file mode 100644 index 0000000..9e63d70 Binary files /dev/null and "b/parcial 1_movimientos bancarios_archivos y lista, matrices y cadenas/ejercicio 3_cadenas_buscar aparici\303\263n de subcadena en cadena/obj/Debug/main.o" differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/11717019_10206904931243915_407733251_n.jpg b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/11717019_10206904931243915_407733251_n.jpg new file mode 100644 index 0000000..459bb67 Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/11717019_10206904931243915_407733251_n.jpg differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/PRODUCTO.dat b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/PRODUCTO.dat new file mode 100644 index 0000000..f42212d Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/PRODUCTO.dat differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/arbol_binario_de_busqueda.c b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/arbol_binario_de_busqueda.c new file mode 100644 index 0000000..5243f68 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/arbol_binario_de_busqueda.c @@ -0,0 +1,70 @@ +#include "arbol_binario_de_busqueda.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +int arbol_vacio(const t_arbol *a) +{ + return *a==NULL; +} + +int arbol_lleno(const t_arbol *a) +{ + void *aux=malloc(sizeof(t_nodo_arbol)); + free(aux); + return aux==NULL; +} + +int insertar_en_arbol(t_arbol *a,const t_dato_arbol *d,t_cmp comparar) +{ + int cmp; + + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return DUPLICADO; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + + *a=(t_nodo_arbol*)malloc(sizeof(t_nodo_arbol)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int buscar_en_arbol_y_retornar_dato(const t_arbol *a,t_dato_arbol *d,void *clave,t_cmp comparar) +{ + int cmp; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,clave))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NO_ENCONTRADO; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + free(*a); + *a=NULL; + } +} diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/arbol_binario_de_busqueda.h b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/arbol_binario_de_busqueda.h new file mode 100644 index 0000000..d5a447c --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/arbol_binario_de_busqueda.h @@ -0,0 +1,33 @@ +#include +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +typedef struct +{ + int posicion_en_archivo; + char codigo_producto[6]; +}t_dato_arbol; + +typedef struct s_nodo_arbol +{ + t_dato_arbol dato; + struct s_nodo_arbol *izq; + struct s_nodo_arbol *der; +}t_nodo_arbol; + +typedef t_nodo_arbol* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol*); +int arbol_vacio(const t_arbol*); +int arbol_lleno(const t_arbol*); +int insertar_en_arbol(t_arbol*,const t_dato_arbol*,t_cmp); +int buscar_en_arbol_y_retornar_dato(const t_arbol*,t_dato_arbol*,void *clave,t_cmp); +void vaciar_arbol(t_arbol*); diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/bin/Debug/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).exe b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/bin/Debug/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).exe new file mode 100644 index 0000000..56c41a6 Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/bin/Debug/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).exe differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/funciones.c b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/funciones.c new file mode 100644 index 0000000..c8450c7 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/funciones.c @@ -0,0 +1,176 @@ +#include "header.h" + +char *str_cpy(char *destino,const char *origen) +{ + char *inicio=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return inicio; +} + +int str_cmp(const char *s1,const char *s2) +{ + while(*s1&&*s2&&*s1==*s2) + { + s1++; + s2++; + } + return *s1-*s2; +} + +int comparar_dato_contra_dato(const void *v1,const void *v2) +{ + t_dato_lista *dato1=(t_dato_lista*)v1; + t_dato_lista *dato2=(t_dato_lista*)v2; + return str_cmp(dato1->codigo_producto,dato2->codigo_producto); +} + +int comparar_dato_contra_clave(const void *v,const void *c) +{ + t_dato_arbol *dato=(t_dato_arbol*)v; + char *clave=(char*)c; + return str_cmp(dato->codigo_producto,clave); +} + +void generar_archivo_de_productos(FILE *pf) +{ + t_registro registros[10]= { {"Caramelos","asd15",500}, + {"Alfajores","erg54",920}, + {"Barritas de cereal","nbm78",460}, + {"Galletitas","ret36",100}, + {"Botellitas de licor","aqw33",300}, + {"Gomitas","oiu87",130}, + {"Gaseosa","zas23",250}, + {"Agua","hgf22",250}, + {"Energizante","dde58",300}, + {"Cigarrillos","rte60",700} + }; + + pf=fopen("PRODUCTO.dat","wb"); + if(!pf) + exit(EXIT_FAILURE); + + fwrite(registros,sizeof(t_registro),10,pf); + fclose(pf); + +} + +void generar_indice_del_archivo_en_el_arbol(FILE *pf,t_arbol *a,t_cmp comparar) +{ + t_registro registro; + t_dato_arbol dato; + int i=1; + + pf=fopen("PRODUCTO.dat","rb"); + if(!pf) + exit(EXIT_FAILURE); + + fread(®istro,sizeof(t_registro),1,pf); + while(!feof(pf)) + { + str_cpy(dato.codigo_producto,registro.codigo_producto); + dato.posicion_en_archivo=i; + + insertar_en_arbol(a,&dato,comparar_dato_contra_clave); + fread(®istro,sizeof(t_registro),1,pf); + i++; + } + + fclose(pf); +} + +void generar_lista_de_pedidos(t_lista *l) +{ + int i=0; + t_dato_lista registros[35]= { {"asd15",50}, + {"zas23",250}, + {"asd15",150}, + {"erg54",920}, + {"ret36",100}, + {"zas23",200}, + {"dde58",300}, + {"erg54",290}, + {"asd15",50}, + {"zas23",250}, + {"rte60",70}, + {"nbm78",46}, + {"ret36",100}, + {"erg54",920}, + {"hgf22",250}, + {"aqw33",30}, + {"nbm78",460}, + {"oiu87",130}, + {"rte60",70}, + {"erg54",92}, + {"nbm78",460}, + {"rte60",70}, + {"ret36",100}, + {"oiu87",130}, + {"erg54",92}, + {"oiu87",100}, + {"hgf22",25}, + {"hgf22",200}, + {"dde58",300}, + {"aqw33",300}, + {"nbm78",46}, + {"aqw33",300}, + {"dde58",30}, + {"asd15",500}, + {"rte60",700} }; + + for(i=0;i<35;i++) + insertar_en_lista_doble_ordenada_con_duplicado(l,®istros[i],comparar_dato_contra_dato); +} + +void procesar_pedido_completo(FILE *pf,const t_arbol *arbol,t_pila *pila,t_dato_lista *dato_lista,int cantidad_pedida) +{ + t_registro registro; + t_dato_arbol dato_arbol; + t_dato_pila dato_pila; + + // con el código de producto, busco en el árbol el registro en el archivo + buscar_en_arbol_y_retornar_dato(arbol,&dato_arbol,(void*)dato_lista->codigo_producto,comparar_dato_contra_clave); + + // me posiciono en ese registro y lo leo + fseek(pf,(dato_arbol.posicion_en_archivo-1)*sizeof(t_registro),SEEK_SET); + fread(®istro,sizeof(t_registro),1,pf); + + // me fijo se el stock me alcanza para concretar el pedido + if(cantidad_pedida<=registro.stock) + { + registro.stock-=cantidad_pedida; // si alcanza, lo concreto y actualizo el registro en el archivo + + fseek(pf,-sizeof(t_registro),SEEK_CUR); + fwrite(®istro,sizeof(t_registro),1,pf); + } + else + { + if(!pila_llena(pila)) // si no alcanza, apilo el pedido sin stock en una pila circular + { + str_cpy(dato_pila.codigo_producto,dato_lista->codigo_producto); + dato_pila.cantidad_pedida=dato_lista->cantidad_pedida; + + apilar(pila,&dato_pila); + } + else + printf("\n\n PILA LLENA: No se puede apilar pedido sin stock \n\n"); + } +} + +void mostrar_pedidos_sin_stock(t_pila *pila) +{ + t_dato_pila dato; + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + + printf("\n\n Código de producto: \t %s",dato.codigo_producto); + printf("\n Cantidad pedida: \t %d \n",dato.cantidad_pedida); + } +} diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/header.h b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/header.h new file mode 100644 index 0000000..7564d46 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/header.h @@ -0,0 +1,28 @@ +#include +#include +#include +#include + +#include "lista_doblemente_enlazada.h" +#include "arbol_binario_de_busqueda.h" +#include "pila_circular.h" + +typedef struct +{ + char nombre_producto[36]; + char codigo_producto[6]; + int stock; +}t_registro; + +char *str_cpy(char*,const char*); +int str_cmp(const char*,const char*); + +int comparar_dato_contra_dato(const void*,const void*); // usada en la lista +int comparar_dato_contra_clave(const void*,const void*); // usada en el arbol + +void generar_archivo_de_productos(FILE*); +void generar_indice_del_archivo_en_el_arbol(FILE*,t_arbol*,t_cmp); +void generar_lista_de_pedidos(t_lista*); + +void procesar_pedido_completo(FILE*,const t_arbol*,t_pila*,t_dato_lista*,int); +void mostrar_pedidos_sin_stock(t_pila*); diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/lista_doblemente_enlazada.c b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/lista_doblemente_enlazada.c new file mode 100644 index 0000000..43c1606 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/lista_doblemente_enlazada.c @@ -0,0 +1,91 @@ +#include "lista_doblemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo_lista)); + free(aux); + return aux==NULL; +} + +int insertar_en_lista_doble_ordenada_con_duplicado(t_lista *l,const t_dato_lista *d,t_cmp comparar) +{ + t_nodo_lista *act=*l; + t_nodo_lista *ant=NULL; + t_nodo_lista *sig=NULL; + + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(comparar((void*)&act->dato,(void*)d)>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + + act=(t_nodo_lista*)malloc(sizeof(t_nodo_lista)); + if(!act) + return MEMORIA_LLENA; + + act->dato=*d; + act->ant=ant; + act->sig=sig; + + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + + *l=act; + return OK; +} + +int sacar_primero_de_la_lista(t_lista *l,t_dato_lista *d) +{ + t_nodo_lista *aux; + + if(!*l) + return LISTA_VACIA; + + while((*l)->ant) + l=&(*l)->ant; + + aux=*l; + *d=aux->dato; + *l=aux->sig; + if(*l) + (*l)->ant=NULL; + + free(aux); + return OK; +} + +int ver_primero_de_lista(const t_lista *l,t_dato_lista *d) +{ + if(!*l) + return LISTA_VACIA; + + while((*l)->ant) + l=&(*l)->ant; + + *d=(*l)->dato; + return OK; +} diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/lista_doblemente_enlazada.h b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/lista_doblemente_enlazada.h new file mode 100644 index 0000000..75d691d --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/lista_doblemente_enlazada.h @@ -0,0 +1,30 @@ +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct +{ + char codigo_producto[6];//clave + int cantidad_pedida; +}t_dato_lista; + +typedef struct s_nodo_lista +{ + t_dato_lista dato; + struct s_nodo_lista *ant; + struct s_nodo_lista *sig; +}t_nodo_lista; + +typedef t_nodo_lista* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int insertar_en_lista_doble_ordenada_con_duplicado(t_lista*,const t_dato_lista*,t_cmp); +int sacar_primero_de_la_lista(t_lista*,t_dato_lista*); +int ver_primero_de_lista(const t_lista*,t_dato_lista*); diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/main.c b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/main.c new file mode 100644 index 0000000..8791425 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/main.c @@ -0,0 +1,80 @@ +#include "header.h" + +int main() +{ + FILE *pf=NULL; + t_arbol arbol; + t_lista lista; + t_pila pila; + + t_dato_lista dato_anterior; + t_dato_lista dato_lista; + int cantidad_pedida=0; + + crear_arbol(&arbol); + crear_lista(&lista); + crear_pila(&pila); + + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + printf("\n\n\t\t ENCARGO DE PRODUCTOS \a\a\n\n"); + + //--------------------------------------------------------------------------------------------------------------------------------------------------- + + generar_archivo_de_productos(pf); + printf("\n\n Se generó el archivo de productos \n"); + + generar_indice_del_archivo_en_el_arbol(pf,&arbol,comparar_dato_contra_dato); + printf("\n\n Se generó el árbol binario de búsqueda, índice del archivo \n"); + + generar_lista_de_pedidos(&lista); + printf("\n\n Se generó la lista de pedidos \n"); + + //--------------------------------------------------------------------------------------------------------------------------------------------------- + + pf=fopen("PRODUCTO.dat","ab"); + if(!pf) + exit(EXIT_FAILURE); + + //veo el primer pedido + ver_primero_de_lista(&lista,&dato_anterior); + + while(!lista_vacia(&lista)) + { + //leo un pedido + sacar_primero_de_la_lista(&lista,&dato_lista); + + //comparo el código de producto del pedido actual con el anterior + if(!comparar_dato_contra_dato(&dato_anterior,&dato_lista)) + cantidad_pedida+=dato_lista.cantidad_pedida; //si no cambia, sigo acumulando la cantidad pedida + else + { + procesar_pedido_completo(pf,&arbol,&pila,&dato_lista,cantidad_pedida); // si cambia, entonces proceso el pedido + + //trato al último pedido que fue ingresadop + dato_anterior=dato_lista; + cantidad_pedida=dato_lista.cantidad_pedida; + } + } + + //proceso el último pedido + + procesar_pedido_completo(pf,&arbol,&pila,&dato_lista,cantidad_pedida); + + //-------------------------------------------------------------------------------------------------------------------------------------------------- + + printf("\n\n --->>> Los pedidos fueron realizados exitosamente \n"); + + vaciar_arbol(&arbol); + printf("\n\n El árbol fue vaciado \n"); + + printf("\n\n Se ha vaciado la lista de pedidos sin stock \n"); + + fclose(pf); + printf("\n Se ha actualizado el archivo de productos \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \a\a \n\n"); + getch(); + return 0; +} diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/arbol_binario_de_busqueda.o b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/arbol_binario_de_busqueda.o new file mode 100644 index 0000000..7020cb1 Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/arbol_binario_de_busqueda.o differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/funciones.o b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/funciones.o new file mode 100644 index 0000000..881eb3f Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/funciones.o differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/lista_doblemente_enlazada.o b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/lista_doblemente_enlazada.o new file mode 100644 index 0000000..773ef56 Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/lista_doblemente_enlazada.o differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/main.o b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/main.o new file mode 100644 index 0000000..d9190ed Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/main.o differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/pila_circular.o b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/pila_circular.o new file mode 100644 index 0000000..17efc76 Binary files /dev/null and b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/obj/Debug/pila_circular.o differ diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).cbp b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).cbp new file mode 100644 index 0000000..7c64a08 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).cbp @@ -0,0 +1,59 @@ + + + + + + diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).depend b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).depend new file mode 100644 index 0000000..2ca62bf --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).depend @@ -0,0 +1,37 @@ +# depslib dependency file v1.0 +1479688428 source:d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\arbol_binario_de_busqueda.c + "arbol_binario_de_busqueda.h" + +1479423291 d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\arbol_binario_de_busqueda.h + + + +1479688327 source:d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\funciones.c + "header.h" + +1479683393 d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\header.h + + + + + "lista_doblemente_enlazada.h" + "arbol_binario_de_busqueda.h" + "pila_circular.h" + +1479432655 d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\lista_doblemente_enlazada.h + + + +1479432442 d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\pila_circular.h + + + +1479685573 source:d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\lista_doblemente_enlazada.c + "lista_doblemente_enlazada.h" + +1479688363 source:d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\main.c + "header.h" + +1479432721 source:d:\unlam\programaciÓn\fabian\parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)\pila_circular.c + "pila_circular.h" + diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).layout b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).layout new file mode 100644 index 0000000..da9539d --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock).layout @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/pila_circular.c b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/pila_circular.c new file mode 100644 index 0000000..568e10c --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/pila_circular.c @@ -0,0 +1,54 @@ +#include "pila_circular.h" + +void crear_pila(t_pila *p) +{ + *p=NULL; +} + +int pila_vacia(const t_pila *p) +{ + return *p==NULL; +} + +int pila_llena(const t_pila *p) +{ + void *aux=malloc(sizeof(t_nodo_pila)); + free(aux); + return aux==NULL; +} + +int apilar(t_pila *p,const t_dato_pila *d) +{ + t_nodo_pila *nuevo=(t_nodo_pila*)malloc(sizeof(t_nodo_pila)); + + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + + if(!*p) + *p=nuevo; + else + nuevo->sig=(*p)->sig; + + (*p)->sig=nuevo; + return OK; +} + +int desapilar(t_pila *p,t_dato_pila *d) +{ + t_nodo_pila *aux; + + if(!*p) + return PILA_VACIA; + + aux=(*p)->sig; + *d=aux->dato; + + if(*p==aux) + *p=NULL; + else + (*p)->sig=aux->sig; + + free(aux); + return OK; +} diff --git a/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/pila_circular.h b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/pila_circular.h new file mode 100644 index 0000000..51b8d11 --- /dev/null +++ b/parcial 2 (lista doble pedidos, arch stock,arbol ind arch,pila circ sin stock)/pila_circular.h @@ -0,0 +1,26 @@ +#include +#include + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct +{ + char codigo_producto[6]; + int cantidad_pedida; +}t_dato_pila; + +typedef struct s_nodo_pila +{ + t_dato_pila dato; + struct s_nodo_pila *sig; +}t_nodo_pila; + +typedef t_nodo_pila* t_pila; + +void crear_pila(t_pila*); +int pila_vacia(const t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato_pila*); +int desapilar(t_pila*,t_dato_pila*); diff --git a/parte entera de un flotante/bin/Debug/parte entera de un flotante.exe b/parte entera de un flotante/bin/Debug/parte entera de un flotante.exe new file mode 100644 index 0000000..1719af8 Binary files /dev/null and b/parte entera de un flotante/bin/Debug/parte entera de un flotante.exe differ diff --git a/parte entera de un flotante/encabezados.h b/parte entera de un flotante/encabezados.h new file mode 100644 index 0000000..25de9f9 --- /dev/null +++ b/parte entera de un flotante/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +int parte_entera(float); + diff --git a/parte entera de un flotante/funciones.c b/parte entera de un flotante/funciones.c new file mode 100644 index 0000000..5e4d371 --- /dev/null +++ b/parte entera de un flotante/funciones.c @@ -0,0 +1,5 @@ +#include "encabezados.h" +int parte_entera(float x) + { + return (int)x; + } diff --git a/parte entera de un flotante/main.c b/parte entera de un flotante/main.c new file mode 100644 index 0000000..238956f --- /dev/null +++ b/parte entera de un flotante/main.c @@ -0,0 +1,14 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + float num; + int redondeo; + printf("\n\t PARTE ENTERA \n"); + printf("\n Ingrese un número real: \n\n\t\t"); + scanf("%f",&num); + redondeo=parte_entera(num); + printf("\n La parte entera de %.2f es %d \n\n",num,redondeo); + getch(); + return 0; + } diff --git a/parte entera de un flotante/obj/Debug/funciones.o b/parte entera de un flotante/obj/Debug/funciones.o new file mode 100644 index 0000000..3b6c53c Binary files /dev/null and b/parte entera de un flotante/obj/Debug/funciones.o differ diff --git a/parte entera de un flotante/obj/Debug/main.o b/parte entera de un flotante/obj/Debug/main.o new file mode 100644 index 0000000..317067e Binary files /dev/null and b/parte entera de un flotante/obj/Debug/main.o differ diff --git a/parte entera de un flotante/parte entera de un flotante.cbp b/parte entera de un flotante/parte entera de un flotante.cbp new file mode 100644 index 0000000..5a72e45 --- /dev/null +++ b/parte entera de un flotante/parte entera de un flotante.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/parte entera de un flotante/parte entera de un flotante.depend b/parte entera de un flotante/parte entera de un flotante.depend new file mode 100644 index 0000000..48a913f --- /dev/null +++ b/parte entera de un flotante/parte entera de un flotante.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471575044 source:d:\unlam\programaciÓn\fabian 2da\parte entera de un flotante\funciones.c + "encabezados.h" + +1471574929 d:\unlam\programaciÓn\fabian 2da\parte entera de un flotante\encabezados.h + + + + +1471574960 source:d:\unlam\programaciÓn\fabian 2da\parte entera de un flotante\main.c + "encabezados.h" + diff --git a/parte entera de un flotante/parte entera de un flotante.layout b/parte entera de un flotante/parte entera de un flotante.layout new file mode 100644 index 0000000..472f46f --- /dev/null +++ b/parte entera de un flotante/parte entera de un flotante.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/perfecto deficiente abundante/bin/Debug/perfecto deficiente abundante.exe b/perfecto deficiente abundante/bin/Debug/perfecto deficiente abundante.exe new file mode 100644 index 0000000..12685eb Binary files /dev/null and b/perfecto deficiente abundante/bin/Debug/perfecto deficiente abundante.exe differ diff --git a/perfecto deficiente abundante/encabezados.h b/perfecto deficiente abundante/encabezados.h new file mode 100644 index 0000000..1259559 --- /dev/null +++ b/perfecto deficiente abundante/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +int suma_de_divisores(int); +void perfecto_deficiente_abundante(int); diff --git a/perfecto deficiente abundante/funciones.c b/perfecto deficiente abundante/funciones.c new file mode 100644 index 0000000..9cbd968 --- /dev/null +++ b/perfecto deficiente abundante/funciones.c @@ -0,0 +1,23 @@ +#include "encabezados.h" +int suma_de_divisores(int n) + { + int i,sumdiv; + sumdiv=0; + for(i=1;isumdiv) + printf("\n El número %d es deficiente \n\n",n); + else + printf("\n El número %d es abundante \n\n",n); + } + diff --git a/perfecto deficiente abundante/main.c b/perfecto deficiente abundante/main.c new file mode 100644 index 0000000..2b5c2f1 --- /dev/null +++ b/perfecto deficiente abundante/main.c @@ -0,0 +1,16 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n; + printf("\n NÚMEROS PERFECTOS, DEFICIENTES Y ABUNDANTES \n"); + do + { + printf("\n Ingrese un número natural para conocer su tipo de acuerdo \n a la sumatoria de sus divisores: \n\n\t"); + scanf("%d",&n); + } + while(n<=0); + perfecto_deficiente_abundante(n); + getch(); + return 0; + } diff --git a/perfecto deficiente abundante/obj/Debug/funciones.o b/perfecto deficiente abundante/obj/Debug/funciones.o new file mode 100644 index 0000000..69b864a Binary files /dev/null and b/perfecto deficiente abundante/obj/Debug/funciones.o differ diff --git a/perfecto deficiente abundante/obj/Debug/main.o b/perfecto deficiente abundante/obj/Debug/main.o new file mode 100644 index 0000000..d3441ac Binary files /dev/null and b/perfecto deficiente abundante/obj/Debug/main.o differ diff --git a/perfecto deficiente abundante/perfecto deficiente abundante.cbp b/perfecto deficiente abundante/perfecto deficiente abundante.cbp new file mode 100644 index 0000000..5f3ab2c --- /dev/null +++ b/perfecto deficiente abundante/perfecto deficiente abundante.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/perfecto deficiente abundante/perfecto deficiente abundante.depend b/perfecto deficiente abundante/perfecto deficiente abundante.depend new file mode 100644 index 0000000..4a78cd7 --- /dev/null +++ b/perfecto deficiente abundante/perfecto deficiente abundante.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471569938 source:d:\unlam\programaciÓn\fabian 2da\perfecto deficiente abundante\funciones.c + "encabezados.h" + +1471569848 d:\unlam\programaciÓn\fabian 2da\perfecto deficiente abundante\encabezados.h + + + + +1471569879 source:d:\unlam\programaciÓn\fabian 2da\perfecto deficiente abundante\main.c + "encabezados.h" + diff --git a/perfecto deficiente abundante/perfecto deficiente abundante.layout b/perfecto deficiente abundante/perfecto deficiente abundante.layout new file mode 100644 index 0000000..b42a374 --- /dev/null +++ b/perfecto deficiente abundante/perfecto deficiente abundante.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/bin/Debug/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.exe" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/bin/Debug/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.exe" new file mode 100644 index 0000000..fbe426b Binary files /dev/null and "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/bin/Debug/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.exe" differ diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/dato.h" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/dato.h" new file mode 100644 index 0000000..e4d142e --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/functions.c" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/functions.c" new file mode 100644 index 0000000..ba318e0 --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/functions.c" @@ -0,0 +1,148 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato a apilar (número): \t\a\a"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato desapilado: \t %d \n",d->numero); + } + +int menu(void) + { + int op,bandera; + bandera=0; + do + { + if(bandera==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe \a\a"); + getch(); + system("cls"); + } + + printf("\n\t\t ************************"); + printf("\n\t\t * MENÚ - PILA DINÁMICA *\a\a"); + printf("\n\t\t ************************"); + + printf("\n\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Crear pila"); + printf("\n 2- Apilar"); + printf("\n 3- Desapilar"); + printf("\n 4- ¿Pila llena?"); + printf("\n 5- ¿Pila vacía?"); + printf("\n 6- Ver tope"); + printf("\n 7- Vaciar pila"); + printf("\n 8- Borrar pila"); + printf("\n 9- Exportar pila a archivo binario"); + printf("\n 10- Exportar pila a archivo de texto"); + printf("\n 11- Cargar pila desde archivo binario"); + printf("\n 12- Cargar pila desde archivo de texto"); + printf("\n\n 0- SALIR"); + + printf("\n\n \t\t\t\t Opción: \t"); + scanf("%d",&op); + bandera=1; + } + while(!DATO_VALIDO(op,0,12)); + + return op; + } + +int exportar_pila_a_archivo_bin(t_pila *pila) + { + FILE *pf; + pf=fopen("pila.bin","wb"); + if(!pf) + return 0; + + t_dato dato; + t_pila pila_inversa; + crear_pila(&pila_inversa); + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + apilar(&pila_inversa,&dato); + } + + while(!pila_vacia(&pila_inversa)) + { + desapilar(&pila_inversa,&dato); + fwrite(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int exportar_pila_a_archivo_txt(t_pila *pila) + { + FILE *pf; + pf=fopen("pila.txt","wt"); + if(!pf) + return 0; + + t_dato dato; + t_pila pila_inversa; + crear_pila(&pila_inversa); + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + apilar(&pila_inversa,&dato); + } + + while(!pila_vacia(&pila_inversa)) + { + desapilar(&pila_inversa,&dato); + fprintf(pf,"%d|",dato.numero); + } + + fclose(pf); + return 1; + } + +int cargar_pila_desde_archivo_bin(t_pila *pila) + { + t_dato dato; + FILE *pf; + pf=fopen("pila.bin","rb"); + if(!pf) + return 0; + + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + apilar(pila,&dato); + fread(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int cargar_pila_desde_archivo_txt(t_pila *pila) + { + t_dato dato; + + FILE *pf; + pf=fopen("pila.txt","rt"); + if(!pf) + return 0; + + fscanf(pf,"%d|",&dato.numero); + while(!feof(pf)) + { + apilar(pila,&dato); + fscanf(pf,"%d|",&dato.numero); + } + + fclose(pf); + return 1; + } diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/header.h" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/header.h" new file mode 100644 index 0000000..ee4895e --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/header.h" @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +#include "primitivas_pila_dinámica.h" + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); +int menu(void); +int exportar_pila_a_archivo_bin(t_pila*); +int exportar_pila_a_archivo_txt(t_pila*); +int cargar_pila_desde_archivo_bin(t_pila*); +int cargar_pila_desde_archivo_txt(t_pila*); diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/main.c" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/main.c" new file mode 100644 index 0000000..1212207 --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/main.c" @@ -0,0 +1,242 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 8B"); + + t_pila pila; + t_dato dato; + int op,respuesta,bandera,existe_pila=0; + + op=menu(); + system("cls"); + while(op!=0) + { + switch(op) + { + + case 1: if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Creación de pila cancelada \a\a"); + break; + } + } + crear_pila(&pila); + existe_pila=1; + printf("\n\n Se ha creado una pila \n\a\a"); + break; + + case 2: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede apilar.\n\a\a"); + break; + } + if(pila_llena(&pila)) + { + printf("\n\n La pila está llena. No puede apilar \n\a\a"); + break; + } + cargar_dato(&dato); + system("cls"); + apilar(&pila,&dato); + printf("\n\n El dato ha sido apilado exitosamente \n\a\a"); + break; + + case 3: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede desapilar.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No puede desapilar. \n\a\a"); + break; + } + desapilar(&pila,&dato); + printf("\n\n El dato fue desapilado exitosamente \n\a\a"); + mostrar_dato(&dato); + break; + + case 4: if(!existe_pila) + { + printf("\n\n No se ha creado una pila \n\a\a"); + break; + } + printf("\n La pila %s está llena \n\a\a",pila_llena(&pila)?"":"no"); + break; + + case 5: if(!existe_pila) + { + printf("\n\n No se ha creado una pila.\n\a\a"); + break; + } + printf("\n La pila %s está vacía \n\a\a",pila_vacia(&pila)?"":"no"); + break; + + case 6: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede ver el tope.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido ver el tope. \a\a"); + break; + } + ver_tope(&pila,&dato); + printf("\n\n El tope de la pila es: \t %d \n\a\a",dato.numero); + break; + + case 7: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede vaciar la pila.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido vaciarla. \a\a"); + break; + } + vaciar_pila(&pila); + printf("\n\n La pila ha sido vaciado exitosamente \n\a\a"); + break; + + case 8: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede borrar. \a\a"); + break; + } + existe_pila=0; + printf("\n\n La pila fue borrada exitosamente \a\a"); + break; + + case 9: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede exportar. \a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_pila_a_archivo_bin(&pila)) + { + printf("\n\n Falló la exportación de la pila a archivo binario \a\a"); + break; + } + printf("\n\n La pila ha sido exportada a archivo binario exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La pila quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 10:if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede exportar. \a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_pila_a_archivo_txt(&pila)) + { + printf("\n\n Falló la exportación de la pila a archivo de texto \a\a"); + break; + } + printf("\n\n La pila ha sido exportada a archivo de texto exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La pila quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 11:if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de pila cancelada \a\a"); + break; + } + existe_pila=0; + } + system("cls"); + if(!cargar_pila_desde_archivo_bin(&pila)) + { + printf("\n\n Falló la carga de la pila desde archivo binario \a\a"); + break; + } + existe_pila=1; + printf("\n\n Se ha cargado una pila desde archivo binario exitosamente \n\a\a"); + break; + + case 12:if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de pila cancelada \a\a"); + break; + } + existe_pila=0; + } + system("cls"); + if(!cargar_pila_desde_archivo_bin(&pila)) + { + printf("\n\n Falló la carga de la pila desde archivo de texto \a\a"); + break; + } + existe_pila=1; + printf("\n\n Se ha cargado una pila desde archivo de texto exitosamente \n\a\a"); + break; + } + + getch(); + system("cls"); + op=menu(); + system("cls"); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" new file mode 100644 index 0000000..3db0ca9 Binary files /dev/null and "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" differ diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" new file mode 100644 index 0000000..ecc08d4 Binary files /dev/null and "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" differ diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_pila_din\303\241mica.o" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_pila_din\303\241mica.o" new file mode 100644 index 0000000..9d16033 Binary files /dev/null and "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_pila_din\303\241mica.o" differ diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.cbp" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.cbp" new file mode 100644 index 0000000..d1f201c --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.depend" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.depend" new file mode 100644 index 0000000..8b97113 --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.depend" @@ -0,0 +1,24 @@ +# depslib dependency file v1.0 +1475429864 source:d:\unlam\programaciÓn\fabian 2\pila dinámica_menú_primitivas y pasaje a archivos\functions.c + "header.h" + +1475429804 d:\unlam\programaciÓn\fabian 2\pila dinámica_menú_primitivas y pasaje a archivos\header.h + + + + + "primitivas_pila_dinámica.h" + +1475429263 d:\unlam\programaciÓn\fabian 2\pila dinámica_menú_primitivas y pasaje a archivos\primitivas_pila_dinámica.h + "dato.h" + +1474765137 d:\unlam\programaciÓn\fabian 2\pila dinámica_menú_primitivas y pasaje a archivos\dato.h + +1475019065 source:d:\unlam\programaciÓn\fabian 2\pila dinámica_menú_primitivas y pasaje a archivos\main.c + "header.h" + +1475429511 source:d:\unlam\programaciÓn\fabian 2\pila dinámica_menú_primitivas y pasaje a archivos\primitivas_pila_dinámica.c + "primitivas_pila_dinámica.h" + + + diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.layout" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.layout" new file mode 100644 index 0000000..db88b25 --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila.bin" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/pila.bin" new file mode 100644 index 0000000..e69de29 diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_din\303\241mica.c" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..0d475e8 --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_din\303\241mica.h" "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..90e4155 --- /dev/null +++ "b/pila din\303\241mica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,22 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo + { + t_dato dato; + struct s_nodo *sig; + }t_nodo; + +typedef t_nodo* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); + diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/bin/Debug/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.exe" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/bin/Debug/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.exe" new file mode 100644 index 0000000..0811543 Binary files /dev/null and "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/bin/Debug/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.exe" differ diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/dato.h" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/dato.h" new file mode 100644 index 0000000..e4d142e --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct + { + int numero; + }t_dato; diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/functions.c" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/functions.c" new file mode 100644 index 0000000..c5da1a1 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/functions.c" @@ -0,0 +1,148 @@ +#include "header.h" + +void cargar_dato(t_dato *d) + { + printf("\n Ingrese dato a apilar (número): \t\a\a"); + scanf("%d",&d->numero); + } + +void mostrar_dato(t_dato *d) + { + printf("\n Dato desapilado: \t %d \n",d->numero); + } + +int menu(void) + { + int op,bandera; + bandera=0; + do + { + if(bandera==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe \a\a"); + getch(); + system("cls"); + } + + printf("\n\t\t ************************"); + printf("\n\t\t * MENÚ - PILA ESTÁTICA *\a\a"); + printf("\n\t\t ************************"); + + printf("\n\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Crear pila"); + printf("\n 2- Apilar"); + printf("\n 3- Desapilar"); + printf("\n 4- ¿Pila llena?"); + printf("\n 5- ¿Pila vacía?"); + printf("\n 6- Ver tope"); + printf("\n 7- Vaciar pila"); + printf("\n 8- Borrar pila"); + printf("\n 9- Exportar pila a archivo binario"); + printf("\n 10- Exportar pila a archivo de texto"); + printf("\n 11- Cargar pila desde archivo binario"); + printf("\n 12- Cargar pila desde archivo de texto"); + printf("\n\n 0- SALIR"); + + printf("\n\n \t\t\t\t Opción: \t"); + scanf("%d",&op); + bandera=1; + } + while(!DATO_VALIDO(op,0,12)); + + return op; + } + +int exportar_pila_a_archivo_bin(t_pila *pila) + { + FILE *pf; + pf=fopen("pila.bin","wb"); + if(!pf) + return 0; + + t_dato dato; + t_pila pila_inversa; + crear_pila(&pila_inversa); + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + apilar(&pila_inversa,&dato); + } + + while(!pila_vacia(&pila_inversa)) + { + desapilar(&pila_inversa,&dato); + fwrite(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int exportar_pila_a_archivo_txt(t_pila *pila) + { + FILE *pf; + pf=fopen("pila.txt","wt"); + if(!pf) + return 0; + + t_dato dato; + t_pila pila_inversa; + crear_pila(&pila_inversa); + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + apilar(&pila_inversa,&dato); + } + + while(!pila_vacia(&pila_inversa)) + { + desapilar(&pila_inversa,&dato); + fprintf(pf,"%d|",dato.numero); + } + + fclose(pf); + return 1; + } + +int cargar_pila_desde_archivo_bin(t_pila *pila) + { + t_dato dato; + FILE *pf; + pf=fopen("pila.bin","rb"); + if(!pf) + return 0; + + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + apilar(pila,&dato); + fread(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int cargar_pila_desde_archivo_txt(t_pila *pila) + { + t_dato dato; + + FILE *pf; + pf=fopen("pila.txt","rt"); + if(!pf) + return 0; + + fscanf(pf,"%d|",&dato.numero); + while(!feof(pf)) + { + apilar(pila,&dato); + fscanf(pf,"%d|",&dato.numero); + } + + fclose(pf); + return 1; + } diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/header.h" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/header.h" new file mode 100644 index 0000000..dbd4e5b --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/header.h" @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +#include "primitivas_pila_estática.h" + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); +int menu(void); +int exportar_pila_a_archivo_bin(t_pila*); +int exportar_pila_a_archivo_txt(t_pila*); +int cargar_pila_desde_archivo_bin(t_pila*); +int cargar_pila_desde_archivo_txt(t_pila*); diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/main.c" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/main.c" new file mode 100644 index 0000000..1212207 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/main.c" @@ -0,0 +1,242 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 8B"); + + t_pila pila; + t_dato dato; + int op,respuesta,bandera,existe_pila=0; + + op=menu(); + system("cls"); + while(op!=0) + { + switch(op) + { + + case 1: if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Creación de pila cancelada \a\a"); + break; + } + } + crear_pila(&pila); + existe_pila=1; + printf("\n\n Se ha creado una pila \n\a\a"); + break; + + case 2: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede apilar.\n\a\a"); + break; + } + if(pila_llena(&pila)) + { + printf("\n\n La pila está llena. No puede apilar \n\a\a"); + break; + } + cargar_dato(&dato); + system("cls"); + apilar(&pila,&dato); + printf("\n\n El dato ha sido apilado exitosamente \n\a\a"); + break; + + case 3: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede desapilar.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No puede desapilar. \n\a\a"); + break; + } + desapilar(&pila,&dato); + printf("\n\n El dato fue desapilado exitosamente \n\a\a"); + mostrar_dato(&dato); + break; + + case 4: if(!existe_pila) + { + printf("\n\n No se ha creado una pila \n\a\a"); + break; + } + printf("\n La pila %s está llena \n\a\a",pila_llena(&pila)?"":"no"); + break; + + case 5: if(!existe_pila) + { + printf("\n\n No se ha creado una pila.\n\a\a"); + break; + } + printf("\n La pila %s está vacía \n\a\a",pila_vacia(&pila)?"":"no"); + break; + + case 6: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede ver el tope.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido ver el tope. \a\a"); + break; + } + ver_tope(&pila,&dato); + printf("\n\n El tope de la pila es: \t %d \n\a\a",dato.numero); + break; + + case 7: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede vaciar la pila.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido vaciarla. \a\a"); + break; + } + vaciar_pila(&pila); + printf("\n\n La pila ha sido vaciado exitosamente \n\a\a"); + break; + + case 8: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede borrar. \a\a"); + break; + } + existe_pila=0; + printf("\n\n La pila fue borrada exitosamente \a\a"); + break; + + case 9: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede exportar. \a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_pila_a_archivo_bin(&pila)) + { + printf("\n\n Falló la exportación de la pila a archivo binario \a\a"); + break; + } + printf("\n\n La pila ha sido exportada a archivo binario exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La pila quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 10:if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede exportar. \a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_pila_a_archivo_txt(&pila)) + { + printf("\n\n Falló la exportación de la pila a archivo de texto \a\a"); + break; + } + printf("\n\n La pila ha sido exportada a archivo de texto exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La pila quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 11:if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de pila cancelada \a\a"); + break; + } + existe_pila=0; + } + system("cls"); + if(!cargar_pila_desde_archivo_bin(&pila)) + { + printf("\n\n Falló la carga de la pila desde archivo binario \a\a"); + break; + } + existe_pila=1; + printf("\n\n Se ha cargado una pila desde archivo binario exitosamente \n\a\a"); + break; + + case 12:if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de pila cancelada \a\a"); + break; + } + existe_pila=0; + } + system("cls"); + if(!cargar_pila_desde_archivo_bin(&pila)) + { + printf("\n\n Falló la carga de la pila desde archivo de texto \a\a"); + break; + } + existe_pila=1; + printf("\n\n Se ha cargado una pila desde archivo de texto exitosamente \n\a\a"); + break; + } + + getch(); + system("cls"); + op=menu(); + system("cls"); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" new file mode 100644 index 0000000..2fd4f9c Binary files /dev/null and "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/functions.o" differ diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" new file mode 100644 index 0000000..ba04264 Binary files /dev/null and "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/main.o" differ diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_pila_est\303\241tica.o" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_pila_est\303\241tica.o" new file mode 100644 index 0000000..b6de89d Binary files /dev/null and "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/obj/Debug/primitivas_pila_est\303\241tica.o" differ diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.cbp" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.cbp" new file mode 100644 index 0000000..b7b4ea3 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.depend" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.depend" new file mode 100644 index 0000000..fc400cf --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1475019581 source:d:\unlam\programaciÓn\fabian 2\pila estática_menú_primitivas y pasaje a archivos\functions.c + "header.h" + +1474824450 d:\unlam\programaciÓn\fabian 2\pila estática_menú_primitivas y pasaje a archivos\header.h + + + + + "primitivas_pila_estática.h" + +1474755851 d:\unlam\programaciÓn\fabian 2\pila estática_menú_primitivas y pasaje a archivos\primitivas_pila_estática.h + "dato.h" + +1474765137 d:\unlam\programaciÓn\fabian 2\pila estática_menú_primitivas y pasaje a archivos\dato.h + +1474754039 source:d:\unlam\programaciÓn\fabian 2\pila estática_menú_primitivas y pasaje a archivos\primitivas_pila_estática.c + "primitivas_pila_estática.h" + +1475019065 source:d:\unlam\programaciÓn\fabian 2\pila estática_menú_primitivas y pasaje a archivos\main.c + "header.h" + diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.layout" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.layout" new file mode 100644 index 0000000..94a6bf8 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila.bin" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila.bin" new file mode 100644 index 0000000..5c9a726 Binary files /dev/null and "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila.bin" differ diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila.txt" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila.txt" new file mode 100644 index 0000000..fa0aca9 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/pila.txt" @@ -0,0 +1 @@ +7|5|3| \ No newline at end of file diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_est\303\241tica.c" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..c1da8f4 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,48 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) + { + p->tope=0; + } + +int pila_llena(const t_pila *p) + { + return p->tope==TAM; + } + +int apilar(t_pila *p,const t_dato *d) + { + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return p->tope==0; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; + } + +void vaciar_pila(t_pila *p) + { + p->tope=0; + } + diff --git "a/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_est\303\241tica.h" "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..b227de3 --- /dev/null +++ "b/pila est\303\241tica_men\303\272_primitivas y pasaje a archivos/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 1 +#define OK 1 + +typedef struct + { + t_dato pila[TAM]; + int tope;//primera libre + }t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/TDA_\303\255ndice_est\303\241tico.c" "b/primitivas TDA \303\255ndice est\303\241tico con cola/TDA_\303\255ndice_est\303\241tico.c" new file mode 100644 index 0000000..2b9cc18 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/TDA_\303\255ndice_est\303\241tico.c" @@ -0,0 +1,159 @@ +#include "TDA_índice_estático.h" + +#include +#include + +void ind_crear(t_indice *ind) + { + ind->tope=0; + ind->hay_cola=0; + } + +int ind_insertar(t_indice *ind,const t_reg_indice *reg_ind) + { + if(ind->tope==TAM) + return INDICE_LLENO; + if(ind->tope!=0) + { + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(ind->registro[pos].dni==reg_ind->dni) + return DUPLICADO; + t_reg_indice aux1,aux2; + aux1=ind->registro[pos]; + ind->registro[pos]=*reg_ind; + pos++; + while(postope) + { + aux2=ind->registro[pos]; + ind->registro[pos]=aux1; + aux1=aux2; + pos++; + } + ind->registro[pos]=aux1; + } + else + ind->registro[ind->tope]=*reg_ind; + ind->tope++; + return OK; + } + +int ind_eliminar(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(pos==ind->tope||ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + while(postope) + { + ind->registro[pos]=ind->registro[pos+1]; + pos++; + } + ind->tope--; + return OK; + } + +int ind_buscar(const t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(postope&&ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + *reg_ind=ind->registro[pos]; + return OK; + } + +int ind_cargar(t_indice *ind,const char *path) + { + FILE *pf; + pf=fopen(path,"rb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + while(!feof(pf)) + { + pos++; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + } + fclose(pf); + ind->tope=pos; + return OK; + } + +int ind_grabar(const t_indice *ind,const char *path) + { + if(ind->tope==0) + return INDICE_VACIO; + FILE *pf; + pf=fopen(path,"wb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + while(postope) + { + fwrite(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + pos++; + } + fclose(pf); + return OK; + } + +void ind_vaciar(t_indice *ind) + { + ind->tope=0; + ind->hay_cola=0; + } + +int ind_primero(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + if(ind->hay_cola==1) + vaciar_cola(&ind->cola); + crear_cola(&ind->cola); + ind->hay_cola=1; + int i=0; + while(itope) + { + if(cola_llena(&ind->cola)) + return COLA_LLENA; + acolar(&ind->cola,(t_dato*)&ind->registro[i]); + i++; + } + desacolar(&ind->cola,(t_dato*)reg_ind); + return OK; + } + +int ind_siguiente(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + if(ind->hay_cola==0) + return COLA_VACIA; + desacolar(&ind->cola,(t_dato*)reg_ind); + if(cola_vacia(&ind->cola)) + ind->hay_cola=0; + return OK; + } + +int ind_fin(t_indice *ind) + { + if(ind->tope==0) + return INDICE_VACIO; + if(ind->hay_cola==1) + return COLA_LLENA; + return OK; + } + +void ind_liberar(t_indice *indice) + { + ///Esta primitiva no aplica a la implementación estática del TDA índice + } diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/TDA_\303\255ndice_est\303\241tico.h" "b/primitivas TDA \303\255ndice est\303\241tico con cola/TDA_\303\255ndice_est\303\241tico.h" new file mode 100644 index 0000000..a98d2fb --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/TDA_\303\255ndice_est\303\241tico.h" @@ -0,0 +1,29 @@ +#include "registro.h" +#include "primitivas_cola_estática.h" + +#define INDICE_VACIO 0 +#define INDICE_LLENO 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define ARCHIVO_CORRUPTO 0 +#define OK 1 + +typedef struct + { + t_cola cola; + unsigned hay_cola; + t_reg_indice registro[TAM]; + unsigned tope;//primera posición libre + }t_indice; + +void ind_crear(t_indice*); +int ind_insertar(t_indice*,const t_reg_indice*); +int ind_eliminar(t_indice*,t_reg_indice*); +int ind_buscar(const t_indice*,t_reg_indice*); +int ind_cargar(t_indice*,const char*); +int ind_grabar(const t_indice*,const char*); +void ind_vaciar(t_indice*); +int ind_primero(t_indice*,t_reg_indice*); +int ind_siguiente(t_indice*,t_reg_indice*); +int ind_fin(t_indice*); +void ind_liberar(t_indice*); diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/bin/Debug/primitivas TDA \303\255ndice est\303\241tico con cola.exe" "b/primitivas TDA \303\255ndice est\303\241tico con cola/bin/Debug/primitivas TDA \303\255ndice est\303\241tico con cola.exe" new file mode 100644 index 0000000..0a53fe3 Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico con cola/bin/Debug/primitivas TDA \303\255ndice est\303\241tico con cola.exe" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/dato.h" "b/primitivas TDA \303\255ndice est\303\241tico con cola/dato.h" new file mode 100644 index 0000000..ca44547 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/dato.h" @@ -0,0 +1,8 @@ +#define TAM 100 + +typedef struct + { + long dni; + unsigned nro_reg; + }t_dato; + diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/funciones.c" "b/primitivas TDA \303\255ndice est\303\241tico con cola/funciones.c" new file mode 100644 index 0000000..4f170a6 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/funciones.c" @@ -0,0 +1,17 @@ +#include "header.h" + +void cargar_registro(t_reg_indice *reg_ind) + { + printf("\n\n NUEVO REGISTRO \n"); + printf("\n Ingrese el dni: \t"); + scanf("%ld",®_ind->dni); + printf("\n Ingrese el número de registro: \t"); + scanf("%u",®_ind->nro_reg); + } + +void mostrar_registro(t_reg_indice *reg_ind) + { + printf("\n\n REGISTRO \n"); + printf("\n DNI: \t %ld \n",reg_ind->dni); + printf("\n Número de registro: \t %u \n",reg_ind->nro_reg); + } diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/header.h" "b/primitivas TDA \303\255ndice est\303\241tico con cola/header.h" new file mode 100644 index 0000000..0d91de7 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "TDA_índice_estático.h" + +void cargar_registro(t_reg_indice*); +void mostrar_registro(t_reg_indice*); diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/indice.dat" "b/primitivas TDA \303\255ndice est\303\241tico con cola/indice.dat" new file mode 100644 index 0000000..c8caccf Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico con cola/indice.dat" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/main.c" "b/primitivas TDA \303\255ndice est\303\241tico con cola/main.c" new file mode 100644 index 0000000..b63b726 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/main.c" @@ -0,0 +1,123 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PRIMITIVAS DE TDA ÍNDICE ESTÁTICO \n\n\a\a"); + + t_indice indice; + t_reg_indice registro; + char ruta[50]; + + ind_crear(&indice); + printf("\n\n Se ha creado un índice \n"); + + int i; + for(i=0;i<5;i++) + { + printf("\n\n Ingrese registro a insertar: \n"); + cargar_registro(®istro); + if(ind_insertar(&indice,®istro)) + printf("\n\n Registro insertado en orden \n"); + else + printf("\n\n No se ha podido insertar el registro en orden \n"); + } + + printf("\n\n Ingrese registro a eliminar: \n"); + cargar_registro(®istro); + if(ind_eliminar(&indice,®istro)) + printf("\n\n Registro eliminado exitosamente \n"); + else + printf("\n\n No se ha podido eliminar el registro \n"); + + printf("\n\n Ingrese registro a buscar: \n"); + cargar_registro(®istro); + if(ind_buscar(&indice,®istro)) + { + printf("\n\n Se ha encontrado el registro \n"); + mostrar_registro(®istro); + } + else + printf("\n\n No se ha encontrado el registro \n"); + + printf("\n\n Cargar índice desde archivo ordenado \n"); + printf("\n\n Ingrese la ruta del archivo: \n\n\t"); + fflush(stdin); + gets(ruta); + if(ind_cargar(&indice,ruta)) + printf("\n\n Se ha cargado el índice desde el archivo exitosamente \n"); + else + printf("\n\n No se ha podido cargar el índice desde el archivo \n"); + + printf("\n\n Grabar registro en archivo binario \n"); + printf("\n\n Ingrese la ruta del archivo: \n\n\t"); + fflush(stdin); + gets(ruta); + if(ind_grabar(&indice,ruta)) + printf("\n\n Se ha grabado el índice desde el archivo exitosamente \n"); + else + printf("\n\n No se ha podido grabar el índice desde el archivo \n"); + + printf("\n\n Cargar índice desde archivo ordenado \n"); + printf("\n\n Ingrese la ruta del archivo: \n\n\t"); + fflush(stdin); + gets(ruta); + if(ind_cargar(&indice,ruta)) + printf("\n\n Se ha cargado el índice desde el archivo exitosamente \n"); + else + printf("\n\n No se ha podido cargar el índice desde el archivo \n"); + + printf("\n\n Siguiente del índice \n"); + if(ind_siguiente(&indice,®istro)) + { + printf("\n\n Se ha podido acceder al siguiente del índice \n"); + mostrar_registro(®istro); + } + else + { + if(ind_fin(&indice)) + printf("\n\n Se ha llegado al fin del índice. \n Para volver a recorrerlo, invoque a la función primero \n"); + else + printf("\n\n No se ha invocado a la función primero \n"); + } + getch(); + + printf("\n\n Primero del índice \n"); + if(ind_primero(&indice,®istro)) + { + printf("\n\n Se ha podido acceder al primero del índice \n"); + mostrar_registro(®istro); + } + else + printf("\n\n El índice está vacío \n"); + getch(); + + for(i=0;i<6;i++) + { + printf("\n\n Siguiente del índice \n"); + if(ind_siguiente(&indice,®istro)) + { + printf("\n\n Se ha podido acceder al siguiente del índice \n"); + mostrar_registro(®istro); + } + else + { + if(ind_fin(&indice)) + printf("\n\n Se ha llegado al fin del índice. \n Para volver a recorrerlo, invoque a la función primero \n"); + else + printf("\n\n No se ha invocado a la función primero \n"); + } + getch(); + } + + ind_vaciar(&indice); + printf("\n\n Se ha vaciado el indice \n"); + + ind_liberar(&indice); + printf("\n\n Se ha liberado el índice \n"); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/TDA_\303\255ndice_est\303\241tico.o" "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/TDA_\303\255ndice_est\303\241tico.o" new file mode 100644 index 0000000..908bb95 Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/TDA_\303\255ndice_est\303\241tico.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/funciones.o" "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/funciones.o" new file mode 100644 index 0000000..3058754 Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/funciones.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/main.o" "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/main.o" new file mode 100644 index 0000000..749d77f Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/main.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/primitivas_cola_est\303\241tica.o" "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/primitivas_cola_est\303\241tica.o" new file mode 100644 index 0000000..9c2d52d Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico con cola/obj/Debug/primitivas_cola_est\303\241tica.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.cbp" "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.cbp" new file mode 100644 index 0000000..b593d35 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.cbp" @@ -0,0 +1,57 @@ + + + + + + diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.depend" "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.depend" new file mode 100644 index 0000000..d8a64f0 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.depend" @@ -0,0 +1,33 @@ +# depslib dependency file v1.0 +1476143962 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\funciones.c + "header.h" + +1476142377 d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\header.h + + + + + "TDA_índice_estático.h" + +1477174094 d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\tda_índice_estático.h + "registro.h" + "primitivas_cola_estática.h" + +1476140485 d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\registro.h + +1476148827 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\main.c + "header.h" + +1477173814 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\tda_índice_estático.c + "TDA_índice_estático.h" + + + +1475433603 d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\primitivas_cola_estática.h + "dato.h" + +1477172010 d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\dato.h + +1475434668 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático con cola\primitivas_cola_estática.c + "primitivas_cola_estática.h" + diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.layout" "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.layout" new file mode 100644 index 0000000..5e9449c --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas TDA \303\255ndice est\303\241tico con cola.layout" @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas_cola_est\303\241tica.c" "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas_cola_est\303\241tica.c" new file mode 100644 index 0000000..111cbe5 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas_cola_est\303\241tica.c" @@ -0,0 +1,63 @@ +#include "primitivas_cola_estática.h" + +void crear_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } + +int cola_llena(const t_cola *c) + { + return (c->ult+1)%TAM==c->pri&&c->ult!=-1; + } + +int acolar(t_cola *c,const t_dato *d) + { + if((c->ult+1)%TAM==c->pri&&c->ult!=-1) + return COLA_LLENA; + c->ult=(c->ult+1)%TAM; + c->cola[c->ult]=*d; + return OK; + } + +int cola_vacia(const t_cola *c) + { + return c->ult==-1; + } + +int desacolar(t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + if(c->pri==c->ult) + { + c->pri=0; + c->ult=-1; + } + else + c->pri=(c->pri+1)%TAM; + return OK; + } + +int ver_primero_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + return OK; + } + +int ver_ultimo_en_cola(const t_cola *c,t_dato *d) + { + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->ult]; + return OK; + } + +void vaciar_cola(t_cola *c) + { + c->pri=0; + c->ult=-1; + } diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas_cola_est\303\241tica.h" "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas_cola_est\303\241tica.h" new file mode 100644 index 0000000..54c94d6 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/primitivas_cola_est\303\241tica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define COLA_LLENA 0 +#define COLA_VACIA 0 +#define OK 1 + +typedef struct + { + t_dato cola[TAM]; + int pri; + int ult; + }t_cola; + +void crear_cola(t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int cola_vacia(const t_cola*); +int desacolar(t_cola*,t_dato*); +int ver_primero_en_cola(const t_cola*,t_dato*); +int ver_ultimo_en_cola(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/primitivas TDA \303\255ndice est\303\241tico con cola/registro.h" "b/primitivas TDA \303\255ndice est\303\241tico con cola/registro.h" new file mode 100644 index 0000000..ce83e65 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico con cola/registro.h" @@ -0,0 +1,7 @@ +#define TAM 100 + +typedef struct + { + long dni; + unsigned nro_reg; + }t_reg_indice; diff --git "a/primitivas TDA \303\255ndice est\303\241tico/TDA_\303\255ndice_est\303\241tico.c" "b/primitivas TDA \303\255ndice est\303\241tico/TDA_\303\255ndice_est\303\241tico.c" new file mode 100644 index 0000000..336c3ff --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/TDA_\303\255ndice_est\303\241tico.c" @@ -0,0 +1,150 @@ +#include "TDA_índice_estático.h" + +#include +#include + +unsigned indicador=TAM; + +void ind_crear(t_indice *ind) + { + ind->tope=0; + } + +int ind_insertar(t_indice *ind,const t_reg_indice *reg_ind) + { + if(ind->tope==TAM) + return INDICE_LLENO; + if(ind->tope!=0) + { + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(ind->registro[pos].dni==reg_ind->dni) + return DUPLICADO; + t_reg_indice aux1,aux2; + aux1=ind->registro[pos]; + ind->registro[pos]=*reg_ind; + pos++; + while(postope) + { + aux2=ind->registro[pos]; + ind->registro[pos]=aux1; + aux1=aux2; + pos++; + } + ind->registro[pos]=aux1; + } + else + ind->registro[ind->tope]=*reg_ind; + ind->tope++; + return OK; + } + +int ind_eliminar(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(pos==ind->tope||ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + while(postope) + { + ind->registro[pos]=ind->registro[pos+1]; + pos++; + } + ind->tope--; + return OK; + } + +int ind_buscar(const t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + unsigned pos=0; + while(postope&&ind->registro[pos].dnidni) + pos++; + if(postope&&ind->registro[pos].dni!=reg_ind->dni) + return NO_ENCONTRADO; + *reg_ind=ind->registro[pos]; + return OK; + } + +int ind_cargar(t_indice *ind,const char *path) + { + FILE *pf; + pf=fopen(path,"rb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + while(!feof(pf)) + { + pos++; + fread(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + } + fclose(pf); + ind->tope=pos; + return OK; + } + +int ind_grabar(const t_indice *ind,const char *path) + { + if(ind->tope==0) + return INDICE_VACIO; + FILE *pf; + pf=fopen(path,"wb"); + if(!pf) + return ARCHIVO_CORRUPTO; + unsigned pos=0; + while(postope) + { + fwrite(&ind->registro[pos],sizeof(t_reg_indice),1,pf); + pos++; + } + fclose(pf); + return OK; + } + +void ind_vaciar(t_indice *ind) + { + ind->tope=0; + } + +int ind_primero(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + extern unsigned indicador; + indicador=0; + *reg_ind=ind->registro[indicador]; + return OK; + } + +int ind_siguiente(t_indice *ind,t_reg_indice *reg_ind) + { + if(ind->tope==0) + return INDICE_VACIO; + extern unsigned indicador; + if(indicador==TAM) + return NO_ENCONTRADO; + if(indicador+1==ind->tope) + return NO_ENCONTRADO; + indicador++; + *reg_ind=ind->registro[indicador]; + return OK; + } + +int ind_fin(t_indice *ind) + { + extern unsigned indicador; + if(indicador+1==ind->tope) + return OK; + return NO_ENCONTRADO; + } + +void ind_liberar(t_indice *indice) + { + ///Esta primitiva no aplica a la implementación estática del TDA índice + } diff --git "a/primitivas TDA \303\255ndice est\303\241tico/TDA_\303\255ndice_est\303\241tico.h" "b/primitivas TDA \303\255ndice est\303\241tico/TDA_\303\255ndice_est\303\241tico.h" new file mode 100644 index 0000000..e63f43a --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/TDA_\303\255ndice_est\303\241tico.h" @@ -0,0 +1,26 @@ +#include "registro.h" + +#define INDICE_VACIO 0 +#define INDICE_LLENO 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define ARCHIVO_CORRUPTO 0 +#define OK 1 + +typedef struct + { + t_reg_indice registro[TAM]; + unsigned tope;//primera posición libre + }t_indice; + +void ind_crear(t_indice*); +int ind_insertar(t_indice*,const t_reg_indice*); +int ind_eliminar(t_indice*,t_reg_indice*); +int ind_buscar(const t_indice*,t_reg_indice*); +int ind_cargar(t_indice*,const char*); +int ind_grabar(const t_indice*,const char*); +void ind_vaciar(t_indice*); +int ind_primero(t_indice*,t_reg_indice*); +int ind_siguiente(t_indice*,t_reg_indice*); +int ind_fin(t_indice*); +void ind_liberar(t_indice*); diff --git "a/primitivas TDA \303\255ndice est\303\241tico/bin/Debug/primitivas TDA \303\255ndice est\303\241tico.exe" "b/primitivas TDA \303\255ndice est\303\241tico/bin/Debug/primitivas TDA \303\255ndice est\303\241tico.exe" new file mode 100644 index 0000000..bee4cf4 Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico/bin/Debug/primitivas TDA \303\255ndice est\303\241tico.exe" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico/funciones.c" "b/primitivas TDA \303\255ndice est\303\241tico/funciones.c" new file mode 100644 index 0000000..4f170a6 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/funciones.c" @@ -0,0 +1,17 @@ +#include "header.h" + +void cargar_registro(t_reg_indice *reg_ind) + { + printf("\n\n NUEVO REGISTRO \n"); + printf("\n Ingrese el dni: \t"); + scanf("%ld",®_ind->dni); + printf("\n Ingrese el número de registro: \t"); + scanf("%u",®_ind->nro_reg); + } + +void mostrar_registro(t_reg_indice *reg_ind) + { + printf("\n\n REGISTRO \n"); + printf("\n DNI: \t %ld \n",reg_ind->dni); + printf("\n Número de registro: \t %u \n",reg_ind->nro_reg); + } diff --git "a/primitivas TDA \303\255ndice est\303\241tico/header.h" "b/primitivas TDA \303\255ndice est\303\241tico/header.h" new file mode 100644 index 0000000..0d91de7 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "TDA_índice_estático.h" + +void cargar_registro(t_reg_indice*); +void mostrar_registro(t_reg_indice*); diff --git "a/primitivas TDA \303\255ndice est\303\241tico/indice.bin" "b/primitivas TDA \303\255ndice est\303\241tico/indice.bin" new file mode 100644 index 0000000..c8caccf Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico/indice.bin" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico/main.c" "b/primitivas TDA \303\255ndice est\303\241tico/main.c" new file mode 100644 index 0000000..b63b726 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/main.c" @@ -0,0 +1,123 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PRIMITIVAS DE TDA ÍNDICE ESTÁTICO \n\n\a\a"); + + t_indice indice; + t_reg_indice registro; + char ruta[50]; + + ind_crear(&indice); + printf("\n\n Se ha creado un índice \n"); + + int i; + for(i=0;i<5;i++) + { + printf("\n\n Ingrese registro a insertar: \n"); + cargar_registro(®istro); + if(ind_insertar(&indice,®istro)) + printf("\n\n Registro insertado en orden \n"); + else + printf("\n\n No se ha podido insertar el registro en orden \n"); + } + + printf("\n\n Ingrese registro a eliminar: \n"); + cargar_registro(®istro); + if(ind_eliminar(&indice,®istro)) + printf("\n\n Registro eliminado exitosamente \n"); + else + printf("\n\n No se ha podido eliminar el registro \n"); + + printf("\n\n Ingrese registro a buscar: \n"); + cargar_registro(®istro); + if(ind_buscar(&indice,®istro)) + { + printf("\n\n Se ha encontrado el registro \n"); + mostrar_registro(®istro); + } + else + printf("\n\n No se ha encontrado el registro \n"); + + printf("\n\n Cargar índice desde archivo ordenado \n"); + printf("\n\n Ingrese la ruta del archivo: \n\n\t"); + fflush(stdin); + gets(ruta); + if(ind_cargar(&indice,ruta)) + printf("\n\n Se ha cargado el índice desde el archivo exitosamente \n"); + else + printf("\n\n No se ha podido cargar el índice desde el archivo \n"); + + printf("\n\n Grabar registro en archivo binario \n"); + printf("\n\n Ingrese la ruta del archivo: \n\n\t"); + fflush(stdin); + gets(ruta); + if(ind_grabar(&indice,ruta)) + printf("\n\n Se ha grabado el índice desde el archivo exitosamente \n"); + else + printf("\n\n No se ha podido grabar el índice desde el archivo \n"); + + printf("\n\n Cargar índice desde archivo ordenado \n"); + printf("\n\n Ingrese la ruta del archivo: \n\n\t"); + fflush(stdin); + gets(ruta); + if(ind_cargar(&indice,ruta)) + printf("\n\n Se ha cargado el índice desde el archivo exitosamente \n"); + else + printf("\n\n No se ha podido cargar el índice desde el archivo \n"); + + printf("\n\n Siguiente del índice \n"); + if(ind_siguiente(&indice,®istro)) + { + printf("\n\n Se ha podido acceder al siguiente del índice \n"); + mostrar_registro(®istro); + } + else + { + if(ind_fin(&indice)) + printf("\n\n Se ha llegado al fin del índice. \n Para volver a recorrerlo, invoque a la función primero \n"); + else + printf("\n\n No se ha invocado a la función primero \n"); + } + getch(); + + printf("\n\n Primero del índice \n"); + if(ind_primero(&indice,®istro)) + { + printf("\n\n Se ha podido acceder al primero del índice \n"); + mostrar_registro(®istro); + } + else + printf("\n\n El índice está vacío \n"); + getch(); + + for(i=0;i<6;i++) + { + printf("\n\n Siguiente del índice \n"); + if(ind_siguiente(&indice,®istro)) + { + printf("\n\n Se ha podido acceder al siguiente del índice \n"); + mostrar_registro(®istro); + } + else + { + if(ind_fin(&indice)) + printf("\n\n Se ha llegado al fin del índice. \n Para volver a recorrerlo, invoque a la función primero \n"); + else + printf("\n\n No se ha invocado a la función primero \n"); + } + getch(); + } + + ind_vaciar(&indice); + printf("\n\n Se ha vaciado el indice \n"); + + ind_liberar(&indice); + printf("\n\n Se ha liberado el índice \n"); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; + } + diff --git "a/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/TDA_\303\255ndice_est\303\241tico.o" "b/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/TDA_\303\255ndice_est\303\241tico.o" new file mode 100644 index 0000000..4607e34 Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/TDA_\303\255ndice_est\303\241tico.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/funciones.o" "b/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/funciones.o" new file mode 100644 index 0000000..25e118a Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/funciones.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/main.o" "b/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/main.o" new file mode 100644 index 0000000..ae35803 Binary files /dev/null and "b/primitivas TDA \303\255ndice est\303\241tico/obj/Debug/main.o" differ diff --git "a/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.cbp" "b/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.cbp" new file mode 100644 index 0000000..c91fb02 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.cbp" @@ -0,0 +1,53 @@ + + + + + + diff --git "a/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.depend" "b/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.depend" new file mode 100644 index 0000000..4deaffc --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.depend" @@ -0,0 +1,29 @@ +# depslib dependency file v1.0 +1476143962 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático\funciones.c + "header.h" + +1476142377 d:\unlam\programaciÓn\fabian\primitivas tda índice estático\header.h + + + + + "TDA_índice_estático.h" + +1476142627 d:\unlam\programaciÓn\fabian\primitivas tda índice estático\tda_índice_estático.h + "registro.h" + +1476140485 d:\unlam\programaciÓn\fabian\primitivas tda índice estático\registro.h + +1476148827 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático\main.c + "header.h" + +1476148676 source:d:\unlam\programaciÓn\fabian\primitivas tda índice estático\tda_índice_estático.c + "TDA_índice_estático.h" + + + +1476142315 d:\unlam\programaciÓn\fabian\primitivas tda índice estático\tda_índice_estático.c + "TDA_índice_estático.h" + + + diff --git "a/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.layout" "b/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.layout" new file mode 100644 index 0000000..25196c4 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/primitivas TDA \303\255ndice est\303\241tico.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/primitivas TDA \303\255ndice est\303\241tico/registro.h" "b/primitivas TDA \303\255ndice est\303\241tico/registro.h" new file mode 100644 index 0000000..ce83e65 --- /dev/null +++ "b/primitivas TDA \303\255ndice est\303\241tico/registro.h" @@ -0,0 +1,7 @@ +#define TAM 100 + +typedef struct + { + long dni; + unsigned nro_reg; + }t_reg_indice; diff --git a/primo o no primo/bin/Debug/primo o no primo.exe b/primo o no primo/bin/Debug/primo o no primo.exe new file mode 100644 index 0000000..c550629 Binary files /dev/null and b/primo o no primo/bin/Debug/primo o no primo.exe differ diff --git a/primo o no primo/encabezados.h b/primo o no primo/encabezados.h new file mode 100644 index 0000000..0eba550 --- /dev/null +++ b/primo o no primo/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +int primo_o_no_primo(int); + diff --git a/primo o no primo/funciones.c b/primo o no primo/funciones.c new file mode 100644 index 0000000..5a2948a --- /dev/null +++ b/primo o no primo/funciones.c @@ -0,0 +1,14 @@ +#include "encabezados.h" +int primo_o_no_primo(int n) + { + int i,j; + i=2; + do + { + j=n%i; + i++; + } + while(j!=0&&i + + + + + diff --git a/primo o no primo/primo o no primo.depend b/primo o no primo/primo o no primo.depend new file mode 100644 index 0000000..0562f87 --- /dev/null +++ b/primo o no primo/primo o no primo.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472317596 source:d:\unlam\programaciÓn\fabian 2da\primo o no primo\funciones.c + "encabezados.h" + +1471572624 d:\unlam\programaciÓn\fabian 2da\primo o no primo\encabezados.h + + + + +1471572716 source:d:\unlam\programaciÓn\fabian 2da\primo o no primo\main.c + "encabezados.h" + diff --git a/primo o no primo/primo o no primo.layout b/primo o no primo/primo o no primo.layout new file mode 100644 index 0000000..aef9b6d --- /dev/null +++ b/primo o no primo/primo o no primo.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/producto mediante sumas sucesivas/bin/Debug/producto mediante sumas sucesivas.exe b/producto mediante sumas sucesivas/bin/Debug/producto mediante sumas sucesivas.exe new file mode 100644 index 0000000..6502759 Binary files /dev/null and b/producto mediante sumas sucesivas/bin/Debug/producto mediante sumas sucesivas.exe differ diff --git a/producto mediante sumas sucesivas/encabezados.h b/producto mediante sumas sucesivas/encabezados.h new file mode 100644 index 0000000..0181d74 --- /dev/null +++ b/producto mediante sumas sucesivas/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +int producto(int,int); + diff --git a/producto mediante sumas sucesivas/funciones.c b/producto mediante sumas sucesivas/funciones.c new file mode 100644 index 0000000..9665a8e --- /dev/null +++ b/producto mediante sumas sucesivas/funciones.c @@ -0,0 +1,10 @@ +#include "encabezados.h" +int producto(int n1,int n2) + { + int prod,i; + prod=0; + for(i=0;i + + + + + diff --git a/producto mediante sumas sucesivas/producto mediante sumas sucesivas.depend b/producto mediante sumas sucesivas/producto mediante sumas sucesivas.depend new file mode 100644 index 0000000..3610a18 --- /dev/null +++ b/producto mediante sumas sucesivas/producto mediante sumas sucesivas.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471570827 source:d:\unlam\programaciÓn\fabian 2da\producto mediante sumas sucesivas\funciones.c + "encabezados.h" + +1471570535 d:\unlam\programaciÓn\fabian 2da\producto mediante sumas sucesivas\encabezados.h + + + + +1471570607 source:d:\unlam\programaciÓn\fabian 2da\producto mediante sumas sucesivas\main.c + "encabezados.h" + diff --git a/producto mediante sumas sucesivas/producto mediante sumas sucesivas.layout b/producto mediante sumas sucesivas/producto mediante sumas sucesivas.layout new file mode 100644 index 0000000..4b39e20 --- /dev/null +++ b/producto mediante sumas sucesivas/producto mediante sumas sucesivas.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/promedio_lista de argumentos de longitud variable/bin/Debug/promedio_lista de argumentos de longitud variable.exe b/promedio_lista de argumentos de longitud variable/bin/Debug/promedio_lista de argumentos de longitud variable.exe new file mode 100644 index 0000000..22b6c5f Binary files /dev/null and b/promedio_lista de argumentos de longitud variable/bin/Debug/promedio_lista de argumentos de longitud variable.exe differ diff --git a/promedio_lista de argumentos de longitud variable/main.c b/promedio_lista de argumentos de longitud variable/main.c new file mode 100644 index 0000000..9edf228 --- /dev/null +++ b/promedio_lista de argumentos de longitud variable/main.c @@ -0,0 +1,42 @@ +#include +#include +#include + +double promedio(int i,...); + +int main() +{ + // variables + double w,x,y,z; + w=37.5; + x=22.5; + y=1.7; + z=10.2; + printf("\n PROMEDIO_lista de argumentos de longitud variable \n"); + printf("\n\n w: %.2f x: %.2f y: %.2f z: %.2f \n",w,x,y,z); + + // promedios + printf("\n promedio(2,w,x): %.2f \n",promedio(2,w,x)); + printf("\n promedio(3,w,x,y): %.2f \n",promedio(3,w,x,y)); + printf("\n promedio(4,w,x,y,z): %.2f \n",promedio(4,w,x,y,z)); + + return 0; +} + +double promedio(int i,...) +{ + double suma=0; // inicializo la sumatoria de los argumentos + int j; // contador para seleccionar argumentos + + va_list puntero; // almacena la información necesaria para va_start y para va_end + va_start(puntero,i); // inicializa el objeto de tipo va_list + // va_start utiliza el objeto puntero del tipo va_list para saber dónde comienza la lista de argumentos de longitud variable + + //procesa la lista de argumentos de longitud variable + for(j=1;j<=i;j++) + suma+=va_arg(puntero,double); + + va_end(puntero); // limpia la lista de argumentos de longitud variable + + return suma/i; // retorna el promedio +} diff --git a/promedio_lista de argumentos de longitud variable/obj/Debug/main.o b/promedio_lista de argumentos de longitud variable/obj/Debug/main.o new file mode 100644 index 0000000..1a9aa16 Binary files /dev/null and b/promedio_lista de argumentos de longitud variable/obj/Debug/main.o differ diff --git a/promedio_lista de argumentos de longitud variable/promedio_lista de argumentos de longitud variable.cbp b/promedio_lista de argumentos de longitud variable/promedio_lista de argumentos de longitud variable.cbp new file mode 100644 index 0000000..12f9394 --- /dev/null +++ b/promedio_lista de argumentos de longitud variable/promedio_lista de argumentos de longitud variable.cbp @@ -0,0 +1,44 @@ + + + + + + diff --git a/promedio_lista de argumentos de longitud variable/promedio_lista de argumentos de longitud variable.layout b/promedio_lista de argumentos de longitud variable/promedio_lista de argumentos de longitud variable.layout new file mode 100644 index 0000000..a3cf191 --- /dev/null +++ b/promedio_lista de argumentos de longitud variable/promedio_lista de argumentos de longitud variable.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/proveedor de productos/bin/Debug/proveedor de productos.exe b/proveedor de productos/bin/Debug/proveedor de productos.exe new file mode 100644 index 0000000..9613810 Binary files /dev/null and b/proveedor de productos/bin/Debug/proveedor de productos.exe differ diff --git a/proveedor de productos/dato.h b/proveedor de productos/dato.h new file mode 100644 index 0000000..6b84933 --- /dev/null +++ b/proveedor de productos/dato.h @@ -0,0 +1,20 @@ +#define TAM 10 + +typedef struct + { + int d, + m, + a; + }t_fecha; + +typedef struct + { + char cod[8]; + char desc[16]; + char prov[16]; + t_fecha f_comp; + t_fecha f_venc; + int cant; + float prec_comp; + float prec_vent; + }t_dato; diff --git a/proveedor de productos/datos.bin b/proveedor de productos/datos.bin new file mode 100644 index 0000000..a925f84 Binary files /dev/null and b/proveedor de productos/datos.bin differ diff --git a/proveedor de productos/datos.txt b/proveedor de productos/datos.txt new file mode 100644 index 0000000..1694d72 --- /dev/null +++ b/proveedor de productos/datos.txt @@ -0,0 +1,2 @@ +1256499|Alfajores|Cachafaz|2/8/2016|16/9/2016|500|23.990000|28.990000 +3625481|Bocaditos|Bonafide|2/8/2016|24/6/2017|300|6.990000|12.990000 diff --git a/proveedor de productos/functions.c b/proveedor de productos/functions.c new file mode 100644 index 0000000..a7be483 --- /dev/null +++ b/proveedor de productos/functions.c @@ -0,0 +1,244 @@ +#include "header.h" + +int fecha_valida(t_fecha *f) + { + return (f->a>=1600&&f->m>=1&&f->m<=12&&f->d>=1&&f->d<=cant_dias_mes(f->m,f->a))?1:0; + } + +int cant_dias_mes(int m,int a) + { + int dias[]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; + } + +int bisiesto(int a) + { + return ((a%4==0&&a%100!=0)||a%400==0)?1:0; + } + +void ingresa_fecha(t_fecha *f) + { + int bandera=0; + printf("\n Ingrese la fecha en formato dd/mm/aaaa: \t"); + do + { + if(bandera==1) + printf("\n La fecha ingresada no existe. Reingrésela: \t\a\a"); + scanf("%d/%d/%d",&f->d,&f->m,&f->a); + bandera=1; + } + while(!fecha_valida(f)); + } + +void cargar_dato(t_dato *d) + { + int bandera; + + printf("\n DATO A APILAR: \a\a"); + + printf("\n\n Ingrese el código de producto (7 caracteres): \n\n\t"); + fflush(stdin); + gets(d->cod); + + printf("\n\n Ingrese la descripción del producto (15 caracteres): \n\n\t"); + fflush(stdin); + gets(d->desc); + + printf("\n\n Ingrese el proveedor del producto (15 caracteres): \n\n\t"); + fflush(stdin); + gets(d->prov); + + printf("\n\n Fecha de compra \n"); + fflush(stdin); + ingresa_fecha(&d->f_comp); + + printf("\n\n Fecha de vencimiento \n"); + fflush(stdin); + ingresa_fecha(&d->f_venc); + + printf("\n Ingrese la cantidad de productos: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n La cantidad ingresada es incorrecta. Ingrese cantidad válida: \a\a\n\n\t"); + fflush(stdin); + scanf("%d",&d->cant); + bandera=1; + } + while(d->cant<=0); + + printf("\n Ingrese el precio de compra: \t\t"); + bandera=0; + do + { + if(bandera==1) + printf("\n El precio ingresado es inválido. Ingrese un precio válido: \a\a\n\n\t"); + fflush(stdin); + scanf("%f",&d->prec_comp); + bandera=1; + } + while(d->prec_comp<=0); + + printf("\n Ingrese el precio de venta: \t\t"); + bandera=0; + do + { + if(bandera==1) + printf("\n El precio ingresado es inválido. Ingrese un precio válido: \a\a\n\n\t"); + fflush(stdin); + scanf("%f",&d->prec_vent); + bandera=1; + } + while(d->prec_vent<=0); + } + +void mostrar_dato(t_dato *d) + { + printf("\n DATO: \n\a\a"); + printf("\n Código de producto: \t %s",d->cod); + printf("\n Descripción del producto: \t %s",d->desc); + printf("\n Proveedor del producto: \t %s",d->prov); + printf("\n Fecha de compra: \t %d/%d/%d",d->f_comp.d,d->f_comp.m,d->f_comp.a); + printf("\n Fecha de vencimiento: \t %d/%d/%d",d->f_venc.d,d->f_venc.m,d->f_venc.a); + printf("\n Cantidad de productos: \t %d",d->cant); + printf("\n Precio de compra: \t %.2f",d->prec_comp); + printf("\n Precio de venta: \t %.2f\n\n",d->prec_vent); + } + +int menu(void) + { + int op,bandera; + bandera=0; + do + { + if(bandera==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe \a\a"); + getch(); + system("cls"); + } + + printf("\n\t\t *********************************"); + printf("\n\t\t * MENÚ - PROVEEDOR DE PRODUCTOS *\a\a"); + printf("\n\t\t *********************************"); + + printf("\n\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Crear pila de productos"); + printf("\n 2- Apilar un nuevo producto"); + printf("\n 3- Desapilar un producto"); + printf("\n 4- ¿Pila de productos llena?"); + printf("\n 5- ¿Pila de productos vacía?"); + printf("\n 6- Ver tope de la pila de productos"); + printf("\n 7- Vaciar pila de productos"); + printf("\n 8- Borrar pila de productos"); + printf("\n 9- Exportar pila de productos a archivo binario"); + printf("\n 10- Exportar pila de productos a archivo de texto"); + printf("\n 11- Cargar pila de productos desde archivo binario"); + printf("\n 12- Cargar pila de productos desde archivo de texto"); + printf("\n\n 0- SALIR"); + + printf("\n\n \t\t\t\t Opción: \t"); + scanf("%d",&op); + bandera=1; + } + while(!DATO_VALIDO(op,0,12)); + + return op; + } + +int exportar_pila_a_archivo_bin(t_pila *pila) + { + FILE *pf; + pf=fopen("datos.bin","wb"); + if(!pf) + return 0; + + t_dato dato; + t_pila pila_inversa; + crear_pila(&pila_inversa); + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + apilar(&pila_inversa,&dato); + } + + while(!pila_vacia(&pila_inversa)) + { + desapilar(&pila_inversa,&dato); + fwrite(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int exportar_pila_a_archivo_txt(t_pila *pila) + { + FILE *pf; + pf=fopen("datos.txt","wt"); + if(!pf) + return 0; + + t_dato dato; + t_pila pila_inversa; + crear_pila(&pila_inversa); + + while(!pila_vacia(pila)) + { + desapilar(pila,&dato); + apilar(&pila_inversa,&dato); + } + + while(!pila_vacia(&pila_inversa)) + { + desapilar(&pila_inversa,&dato); + fprintf(pf,"%s|%s|%s|%d/%d/%d|%d/%d/%d|%d|%f|%f\n",dato.cod,dato.desc,dato.prov,dato.f_comp.d,dato.f_comp.m,dato.f_comp.a,dato.f_venc.d,dato.f_venc.m,dato.f_venc.a,dato.cant,dato.prec_comp,dato.prec_vent); + } + + fclose(pf); + return 1; + } + +int cargar_pila_desde_archivo_bin(t_pila *pila) + { + t_dato dato; + FILE *pf; + pf=fopen("datos.bin","rb"); + if(!pf) + return 0; + + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + apilar(pila,&dato); + fread(&dato,sizeof(t_dato),1,pf); + } + + fclose(pf); + return 1; + } + +int cargar_pila_desde_archivo_txt(t_pila *pila) + { + t_dato dato; + + FILE *pf; + pf=fopen("datos.txt","rt"); + if(!pf) + return 0; + + fscanf(pf,"%[^|]|%[^|]|%[^|]|%d/%d/%d|%d/%d/%d|%d|%f|%f\n",dato.cod,dato.desc,dato.prov,&dato.f_comp.d,&dato.f_comp.m,&dato.f_comp.a,&dato.f_venc.d,&dato.f_venc.m,&dato.f_venc.a,&dato.cant,&dato.prec_comp,&dato.prec_vent); + while(!feof(pf)) + { + apilar(pila,&dato); + fscanf(pf,"%s|%s|%s|%d/%d/%d|%d/%d/%d|%d|%f|%f\n",dato.cod,dato.desc,dato.prov,&dato.f_comp.d,&dato.f_comp.m,&dato.f_comp.a,&dato.f_venc.d,&dato.f_venc.m,&dato.f_venc.a,&dato.cant,&dato.prec_comp,&dato.prec_vent); + } + + fclose(pf); + return 1; + } + diff --git a/proveedor de productos/header.h b/proveedor de productos/header.h new file mode 100644 index 0000000..60b8a7d --- /dev/null +++ b/proveedor de productos/header.h @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +#include "primitivas_pila_estática.h" + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +int fecha_valida(t_fecha*); +int cant_dias_mes(int,int); +int bisiesto(int); +void ingresa_fecha(t_fecha*); +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); +int menu(void); +int exportar_pila_a_archivo_bin(t_pila*); +int exportar_pila_a_archivo_txt(t_pila*); +int cargar_pila_desde_archivo_bin(t_pila*); +int cargar_pila_desde_archivo_txt(t_pila*); diff --git a/proveedor de productos/main.c b/proveedor de productos/main.c new file mode 100644 index 0000000..40583b2 --- /dev/null +++ b/proveedor de productos/main.c @@ -0,0 +1,243 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 8B"); + + t_pila pila; + t_dato dato; + int op,respuesta,bandera,existe_pila=0; + + op=menu(); + system("cls"); + while(op!=0) + { + switch(op) + { + + case 1: if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Creación de pila cancelada \a\a"); + break; + } + } + crear_pila(&pila); + existe_pila=1; + printf("\n\n Se ha creado una pila \n\a\a"); + break; + + case 2: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede apilar.\n\a\a"); + break; + } + if(pila_llena(&pila)) + { + printf("\n\n La pila está llena. No puede apilar \n\a\a"); + break; + } + cargar_dato(&dato); + system("cls"); + apilar(&pila,&dato); + printf("\n\n El dato ha sido apilado exitosamente \n\a\a"); + break; + + case 3: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede desapilar.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No puede desapilar. \n\a\a"); + break; + } + desapilar(&pila,&dato); + printf("\n\n El dato fue desapilado exitosamente \n\a\a"); + mostrar_dato(&dato); + break; + + case 4: if(!existe_pila) + { + printf("\n\n No se ha creado una pila \n\a\a"); + break; + } + printf("\n La pila %s está llena \n\a\a",pila_llena(&pila)?"":"no"); + break; + + case 5: if(!existe_pila) + { + printf("\n\n No se ha creado una pila.\n\a\a"); + break; + } + printf("\n La pila %s está vacía \n\a\a",pila_vacia(&pila)?"":"no"); + break; + + case 6: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede ver el tope.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido ver el tope. \a\a"); + break; + } + ver_tope(&pila,&dato); + printf("\n\n TOPE DE LA PILA \n"); + mostrar_dato(&dato); + break; + + case 7: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No puede vaciar la pila.\n\a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido vaciarla. \a\a"); + break; + } + vaciar_pila(&pila); + printf("\n\n La pila ha sido vaciado exitosamente \n\a\a"); + break; + + case 8: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede borrar. \a\a"); + break; + } + existe_pila=0; + printf("\n\n La pila fue borrada exitosamente \a\a"); + break; + + case 9: if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede exportar. \a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_pila_a_archivo_bin(&pila)) + { + printf("\n\n Falló la exportación de la pila a archivo binario \a\a"); + break; + } + printf("\n\n La pila ha sido exportada a archivo binario exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La pila quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 10:if(!existe_pila) + { + printf("\n\n No se ha creado una pila. No se la puede exportar. \a\a"); + break; + } + if(pila_vacia(&pila)) + { + printf("\n\n La pila está vacía. No tiene sentido exportarla. \a\a"); + break; + } + if(!exportar_pila_a_archivo_txt(&pila)) + { + printf("\n\n Falló la exportación de la pila a archivo de texto \a\a"); + break; + } + printf("\n\n La pila ha sido exportada a archivo de texto exitosamente \a\a"); + getch(); + system("cls"); + printf("\n\n La pila quedó vacía. Si quiere recuperarla puede cargarla desde el archivo. \a\a"); + break; + + case 11:if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de pila cancelada \a\a"); + break; + } + existe_pila=0; + } + system("cls"); + if(!cargar_pila_desde_archivo_bin(&pila)) + { + printf("\n\n Falló la carga de la pila desde archivo binario \a\a"); + break; + } + existe_pila=1; + printf("\n\n Se ha cargado una pila desde archivo binario exitosamente \n\a\a"); + break; + + case 12:if(existe_pila) + { + printf("\n\n Ya se ha creado una pila. ¿Desea reemplazarla? \a\a"); + printf("\n 1- SI \t 2- NO \t\t Opción: \t"); + bandera=0; + do + { + if(bandera==1) + printf("\n\n La opción ingresada es incorrecta. Ingrese una opción válida: \t\a\a"); + scanf("%d",&respuesta); + bandera=1; + } + while(!DATO_VALIDO(respuesta,1,2)); + if(respuesta==2) + { + system("cls"); + printf("\n\n Carga de pila cancelada \a\a"); + break; + } + existe_pila=0; + } + system("cls"); + if(!cargar_pila_desde_archivo_bin(&pila)) + { + printf("\n\n Falló la carga de la pila desde archivo de texto \a\a"); + break; + } + existe_pila=1; + printf("\n\n Se ha cargado una pila desde archivo de texto exitosamente \n\a\a"); + break; + } + + getch(); + system("cls"); + op=menu(); + system("cls"); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git a/proveedor de productos/obj/Debug/functions.o b/proveedor de productos/obj/Debug/functions.o new file mode 100644 index 0000000..3e716f9 Binary files /dev/null and b/proveedor de productos/obj/Debug/functions.o differ diff --git a/proveedor de productos/obj/Debug/main.o b/proveedor de productos/obj/Debug/main.o new file mode 100644 index 0000000..9d6ff7f Binary files /dev/null and b/proveedor de productos/obj/Debug/main.o differ diff --git "a/proveedor de productos/obj/Debug/primitivas_pila_est\303\241tica.o" "b/proveedor de productos/obj/Debug/primitivas_pila_est\303\241tica.o" new file mode 100644 index 0000000..b2e8413 Binary files /dev/null and "b/proveedor de productos/obj/Debug/primitivas_pila_est\303\241tica.o" differ diff --git "a/proveedor de productos/primitivas_pila_est\303\241tica.c" "b/proveedor de productos/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..c1da8f4 --- /dev/null +++ "b/proveedor de productos/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,48 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) + { + p->tope=0; + } + +int pila_llena(const t_pila *p) + { + return p->tope==TAM; + } + +int apilar(t_pila *p,const t_dato *d) + { + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return p->tope==0; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; + } + +void vaciar_pila(t_pila *p) + { + p->tope=0; + } + diff --git "a/proveedor de productos/primitivas_pila_est\303\241tica.h" "b/proveedor de productos/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..b227de3 --- /dev/null +++ "b/proveedor de productos/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 1 +#define OK 1 + +typedef struct + { + t_dato pila[TAM]; + int tope;//primera libre + }t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git a/proveedor de productos/proveedor de productos.cbp b/proveedor de productos/proveedor de productos.cbp new file mode 100644 index 0000000..d553041 --- /dev/null +++ b/proveedor de productos/proveedor de productos.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/proveedor de productos/proveedor de productos.depend b/proveedor de productos/proveedor de productos.depend new file mode 100644 index 0000000..1ec2d77 --- /dev/null +++ b/proveedor de productos/proveedor de productos.depend @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1475449826 source:d:\unlam\programaciÓn\fabian 2\proveedor de productos\main.c + "header.h" + +1475449642 d:\unlam\programaciÓn\fabian 2\proveedor de productos\header.h + + + + + "primitivas_pila_estática.h" + +1474755851 d:\unlam\programaciÓn\fabian 2\proveedor de productos\primitivas_pila_estática.h + "dato.h" + +1475449648 d:\unlam\programaciÓn\fabian 2\proveedor de productos\dato.h + +1474754039 source:d:\unlam\programaciÓn\fabian 2\proveedor de productos\primitivas_pila_estática.c + "primitivas_pila_estática.h" + +1475450207 source:d:\unlam\programaciÓn\fabian 2\proveedor de productos\functions.c + "header.h" + diff --git a/proveedor de productos/proveedor de productos.layout b/proveedor de productos/proveedor de productos.layout new file mode 100644 index 0000000..5ddd127 --- /dev/null +++ b/proveedor de productos/proveedor de productos.layout @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/rand y srand/bin/Debug/rand y srand.exe b/rand y srand/bin/Debug/rand y srand.exe new file mode 100644 index 0000000..6e88c25 Binary files /dev/null and b/rand y srand/bin/Debug/rand y srand.exe differ diff --git a/rand y srand/main.c b/rand y srand/main.c new file mode 100644 index 0000000..32d2491 --- /dev/null +++ b/rand y srand/main.c @@ -0,0 +1,71 @@ +#include +#include +#include +#include + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n \t RAND Y SRAND \n"); + printf("\n Estas funciones de stdlib.h generan números pseudo aleatorios \n (srand cambia la semilla, porque sino rand siempre genera la misma secuencia de números) \n"); + + int i; + printf("\n\n Con la semilla por defecto \n"); + for(i=0;i<50;i++) + printf("%d ",rand()); + + srand(2); + printf("\n\n Con semilla 2 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()); + + srand(50); + printf("\n\n Con semilla 5 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()); + + srand(200); + printf("\n\n Con semilla 500 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()); + + srand(1000); + printf("\n\n Con semilla 1000 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()); + + srand(0); + + printf("\n\n Solo números entre 0 y 6 \n");//siempre se genera a partir del cero + for(i=0;i<50;i++) + printf("%d ",rand()%7); + + printf("\n\n Solo números entre 1 y 7 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()%7+1); + + printf("\n\n Solo números entre 1 y 100 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()%100+1); + + printf("\n\n Solo números entre -100 y 0 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()%100-100); + + printf("\n\n Solo números entre 0 y 999 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()%1000); + + printf("\n\n Solo números entre 1000 y 1999 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()%1000+1000); + + printf("\n\n Solo números entre -128 y 805 \n"); + for(i=0;i<50;i++) + printf("%d ",rand()%928-123);//se suman 128 y 805 para saber cuántos númerps deseo generar y luego los acomodo en el rango que desee + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/rand y srand/obj/Debug/main.o b/rand y srand/obj/Debug/main.o new file mode 100644 index 0000000..cd91f7c Binary files /dev/null and b/rand y srand/obj/Debug/main.o differ diff --git a/rand y srand/rand y srand.cbp b/rand y srand/rand y srand.cbp new file mode 100644 index 0000000..b4cdb74 --- /dev/null +++ b/rand y srand/rand y srand.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/rand y srand/rand y srand.layout b/rand y srand/rand y srand.layout new file mode 100644 index 0000000..c93c4ac --- /dev/null +++ b/rand y srand/rand y srand.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/randomizaci\303\263n y escalamiento/bin/Debug/randomizaci\303\263n y escalamiento.exe" "b/randomizaci\303\263n y escalamiento/bin/Debug/randomizaci\303\263n y escalamiento.exe" new file mode 100644 index 0000000..d1aceda Binary files /dev/null and "b/randomizaci\303\263n y escalamiento/bin/Debug/randomizaci\303\263n y escalamiento.exe" differ diff --git "a/randomizaci\303\263n y escalamiento/main.c" "b/randomizaci\303\263n y escalamiento/main.c" new file mode 100644 index 0000000..ba79841 --- /dev/null +++ "b/randomizaci\303\263n y escalamiento/main.c" @@ -0,0 +1,25 @@ +#include +#include +#include +#include + +int main() +{ + int i; + setlocale(LC_CTYPE,"Spanish"); + + printf("\n\n RANDOMIZACIÓN Y ESCALAMIENTO \n\n"); + + srand(time(NULL)); + //la función srand randomiza la función rand usando como semilla los segundos relativos indicados por el reloj del sistema + + //la función rand genera números pseudoaleatorios de acuerdo a una semilla + + for(i=0;i<50;i++) + printf("%d \t",2+rand()%6); + //el escalamiento es la modificación de la generación de los números pseudoaleatorios + //su ecuación es a+rand()%b siendo a el valor de cambio que indica el primer valor del rango de números pseudoaleatorios + //y siendo b el factor de escalamiento que indica la longitud del rango de números generados + + return 0; +} diff --git "a/randomizaci\303\263n y escalamiento/obj/Debug/main.o" "b/randomizaci\303\263n y escalamiento/obj/Debug/main.o" new file mode 100644 index 0000000..10e6c44 Binary files /dev/null and "b/randomizaci\303\263n y escalamiento/obj/Debug/main.o" differ diff --git "a/randomizaci\303\263n y escalamiento/randomizaci\303\263n y escalamiento.cbp" "b/randomizaci\303\263n y escalamiento/randomizaci\303\263n y escalamiento.cbp" new file mode 100644 index 0000000..b2557b3 --- /dev/null +++ "b/randomizaci\303\263n y escalamiento/randomizaci\303\263n y escalamiento.cbp" @@ -0,0 +1,44 @@ + + + + + + diff --git "a/randomizaci\303\263n y escalamiento/randomizaci\303\263n y escalamiento.layout" "b/randomizaci\303\263n y escalamiento/randomizaci\303\263n y escalamiento.layout" new file mode 100644 index 0000000..d1be839 --- /dev/null +++ "b/randomizaci\303\263n y escalamiento/randomizaci\303\263n y escalamiento.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/repaso arbol/arbol en inorden.bin b/repaso arbol/arbol en inorden.bin new file mode 100644 index 0000000..a00df38 Binary files /dev/null and b/repaso arbol/arbol en inorden.bin differ diff --git a/repaso arbol/arbol en inorden.txt b/repaso arbol/arbol en inorden.txt new file mode 100644 index 0000000..b32191d --- /dev/null +++ b/repaso arbol/arbol en inorden.txt @@ -0,0 +1 @@ +12|25|40|50|55|60|65|70|75|80|85|86|87|90|95|100| \ No newline at end of file diff --git a/repaso arbol/arbol en posorden.bin b/repaso arbol/arbol en posorden.bin new file mode 100644 index 0000000..95131c7 Binary files /dev/null and b/repaso arbol/arbol en posorden.bin differ diff --git a/repaso arbol/arbol en posorden.txt b/repaso arbol/arbol en posorden.txt new file mode 100644 index 0000000..d7b4372 --- /dev/null +++ b/repaso arbol/arbol en posorden.txt @@ -0,0 +1 @@ +12|40|25|55|65|60|75|70|86|87|85|95|90|100|80|50| \ No newline at end of file diff --git a/repaso arbol/arbol en preorden.bin b/repaso arbol/arbol en preorden.bin new file mode 100644 index 0000000..bd66ea4 Binary files /dev/null and b/repaso arbol/arbol en preorden.bin differ diff --git a/repaso arbol/arbol en preorden.txt b/repaso arbol/arbol en preorden.txt new file mode 100644 index 0000000..bef68dd --- /dev/null +++ b/repaso arbol/arbol en preorden.txt @@ -0,0 +1 @@ +50|25|12|40|80|70|60|55|65|75|100|90|85|87|86|95| \ No newline at end of file diff --git a/repaso arbol/arbol.png b/repaso arbol/arbol.png new file mode 100644 index 0000000..beb620e Binary files /dev/null and b/repaso arbol/arbol.png differ diff --git a/repaso arbol/bin/Debug/repaso arbol.exe b/repaso arbol/bin/Debug/repaso arbol.exe new file mode 100644 index 0000000..9e4de5d Binary files /dev/null and b/repaso arbol/bin/Debug/repaso arbol.exe differ diff --git a/repaso arbol/dato.h b/repaso arbol/dato.h new file mode 100644 index 0000000..a50c8c3 --- /dev/null +++ b/repaso arbol/dato.h @@ -0,0 +1,5 @@ +typedef struct +{ + int numero; +}t_dato; + diff --git a/repaso arbol/funciones.c b/repaso arbol/funciones.c new file mode 100644 index 0000000..79f27a2 --- /dev/null +++ b/repaso arbol/funciones.c @@ -0,0 +1,24 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n DATO: \n %d \n",d->numero); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} + +void mostrar_nodo(const void *v) +{ + t_dato *d=(t_dato*)v; + printf("\t %d",d->numero); +} diff --git a/repaso arbol/header.h b/repaso arbol/header.h new file mode 100644 index 0000000..f8e823e --- /dev/null +++ b/repaso arbol/header.h @@ -0,0 +1,11 @@ +#include "primitivas_arbol.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); +int comparar_enteros(const void*,const void*); +void mostrar_nodo(const void*); diff --git a/repaso arbol/main.c b/repaso arbol/main.c new file mode 100644 index 0000000..e2f06e4 --- /dev/null +++ b/repaso arbol/main.c @@ -0,0 +1,210 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n ÁRBOL \n\a\a"); + + t_arbol arbol; + //t_dato dato; + + crear_arbol(&arbol); + printf("\n Se ha creado un árbol \n"); + +/* + if(arbol_vacio(&arbol)) + printf("\n El árbol está vacío \n"); + + printf("\n\n Cargar un árbol \n"); + int i; + for(i=0;i<16;i++) + { + cargar_dato(&dato); + if(!insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros)) + printf("\n No se pudo insertar el nodo \n"); + } + printf("\n El árbol fue cargado \n"); + + if(arbol_lleno(&arbol)) + printf("\n El árbol no está lleno \n"); + + if(!es_hoja(&arbol)) + printf("\n El árbol no es hoja \n"); + + printf("\n El árbol %s semibalanceado \n",arbol_semibalanceado(&arbol)?"es":"no es"); + printf("\n El árbol %s balanceado \n",arbol_balanceado(&arbol)?"es":"no es"); + + printf("\n\n RECORRER EN INORDEN \n\n Notación Infija Usual: \n"); + recorrer_arbol_en_inorden(&arbol,mostrar_nodo); + + printf("\n\n RECORRER EN PREORDEN \n\n Notación Polaca: \n"); + recorrer_arbol_en_preorden(&arbol,mostrar_nodo); + + printf("\n\n RECORRER EN POSORDEN \n\n Notación Polaca Inversa \n"); + recorrer_arbol_en_posorden(&arbol,mostrar_nodo); + + printf("\n Raíz del árbol \n"); + ver_raiz(&arbol,&dato); + mostrar_dato(&dato); + + FILE *pf_bin_inorden,*pf_bin_preorden,*pf_bin_posorden; + FILE *pf_txt_inorden,*pf_txt_preorden,*pf_txt_posorden; + + pf_bin_inorden=fopen("arbol en inorden.bin","wb"); + if(!pf_bin_inorden) + { + printf("\n\n No se pudo crear el archivo binario en inorden \n"); + exit(EXIT_FAILURE); + } + + pf_bin_preorden=fopen("arbol en preorden.bin","wb"); + if(!pf_bin_preorden) + { + printf("\n\n No se pudo crear el archivo binario en preorden \n"); + fclose(pf_bin_inorden); + remove("arbol en inorden.bin"); + exit(EXIT_FAILURE); + } + + pf_bin_posorden=fopen("arbol en posorden.bin","wb"); + if(!pf_bin_posorden) + { + printf("\n\n No se pudo crear el archivo binario en posorden \n"); + fclose(pf_bin_inorden); + remove("arbol en inorden.bin"); + fclose(pf_bin_preorden); + remove("arbol en preorden.bin"); + exit(EXIT_FAILURE); + } + + pf_txt_inorden=fopen("arbol en inorden.txt","wt"); + if(!pf_txt_inorden) + { + printf("\n\n No se pudo crear el archivo de texto en inorden \n"); + fclose(pf_bin_inorden); + remove("arbol en inorden.bin"); + fclose(pf_bin_preorden); + remove("arbol en preorden.bin"); + fclose(pf_bin_posorden); + remove("arbol en posorden.bin"); + exit(EXIT_FAILURE); + } + + pf_txt_preorden=fopen("arbol en preorden.txt","wt"); + if(!pf_txt_preorden) + { + printf("\n\n No se pudo crear el archivo de texto en preorden \n"); + fclose(pf_bin_inorden); + remove("arbol en inorden.bin"); + fclose(pf_bin_preorden); + remove("arbol en preorden.bin"); + fclose(pf_bin_posorden); + remove("arbol en posorden.bin"); + fclose(pf_txt_inorden); + remove("arbol en inorden.txt"); + exit(EXIT_FAILURE); + } + + pf_txt_posorden=fopen("arbol en posorden.txt","wt"); + if(!pf_txt_posorden) + { + printf("\n\n No se pudo crear el archivo de texto en posorden \n"); + fclose(pf_bin_inorden); + remove("arbol en inorden.bin"); + fclose(pf_bin_preorden); + remove("arbol en preorden.bin"); + fclose(pf_bin_posorden); + remove("arbol en posorden.bin"); + fclose(pf_txt_inorden); + remove("arbol en inorden.txt"); + fclose(pf_txt_preorden); + remove("arbol en preorden.txt"); + exit(EXIT_FAILURE); + } + + grabar_arbol_en_inorden_en_archivo_binario(&arbol,pf_bin_inorden); + printf("\n\n Se ha grabado el árbol en inorden en archivo binario \n"); + grabar_arbol_en_preorden_en_archivo_binario(&arbol,pf_bin_preorden); + printf("\n\n Se ha grabado el árbol en preorden en archivo binario \n"); + grabar_arbol_en_posorden_en_archivo_binario(&arbol,pf_bin_posorden); + printf("\n\n Se ha grabado el árbol en posorden en archivo binario \n"); + grabar_arbol_en_inorden_en_archivo_de_texto(&arbol,pf_txt_inorden); + printf("\n\n Se ha grabado el árbol en inorden en archivo de texto \n"); + grabar_arbol_en_preorden_en_archivo_de_texto(&arbol,pf_txt_preorden); + printf("\n\n Se ha grabado el árbol en preorden en archivo de texto \n"); + grabar_arbol_en_posorden_en_archivo_de_texto(&arbol,pf_txt_posorden); + printf("\n\n Se ha grabado el árbol en posorden en archivo de texto \n"); + + fclose(pf_bin_inorden); + fclose(pf_bin_preorden); + fclose(pf_bin_posorden); + fclose(pf_txt_inorden); + fclose(pf_txt_preorden); + fclose(pf_txt_posorden); + + //-------------------------------------------------------------------------------------------------------------------------------------------------- +*/ + + FILE *pf; + pf=fopen("arbol en preorden.bin","rb"); + if(!pf) + { + printf("\n\n No se pudo leer el archivo \n"); + exit(EXIT_FAILURE); + } + if(cargar_arbol_con_archivo_binario_en_preorden(&arbol,pf,comparar_enteros)) + { + printf("\n\n Se ha cargado el árbol con el archivo binario en preorden \n"); + fclose(pf); + } + else + { + printf("\n\n No se pudo cargar el árbol con el archivo \n\n"); + fclose(pf); + exit(EXIT_FAILURE); + } + + printf("\n\n RECORRER EN INORDEN \n\n Notación Infija Usual: \n"); + recorrer_arbol_en_inorden(&arbol,mostrar_nodo); + + printf("\n\n RECORRER EN PREORDEN \n\n Notación Polaca: \n"); + recorrer_arbol_en_preorden(&arbol,mostrar_nodo); + + printf("\n\n RECORRER EN POSORDEN \n\n Notación Polaca Inversa \n"); + recorrer_arbol_en_posorden(&arbol,mostrar_nodo); + + vaciar_arbol(&arbol); + printf("\n\n El árbol fue vaciado \n"); +/* + pf=fopen("arbol en inorden.bin","rb"); + if(!pf) + { + printf("\n\n No se pudo leer el archivo \n"); + exit(EXIT_FAILURE); + } + if(cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible(&arbol,pf,comparar_enteros)) + { + printf("\n\n Se ha cargado el árbol con el archivo binario en inorden \n lo más balanceado posible \n"); + fclose(pf); + } + else + { + printf("\n\n No se pudo cargar el árbol con el archivo \n\n"); + fclose(pf); + exit(EXIT_FAILURE); + } + + printf("\n\n RECORRER EN INORDEN \n\n Notación Infija Usual: \n"); + recorrer_arbol_en_inorden(&arbol,mostrar_nodo); + + printf("\n\n RECORRER EN PREORDEN \n\n Notación Polaca: \n"); + recorrer_arbol_en_preorden(&arbol,mostrar_nodo); + + printf("\n\n RECORRER EN POSORDEN \n\n Notación Polaca Inversa \n"); + recorrer_arbol_en_posorden(&arbol,mostrar_nodo); +*/ + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n \a\a"); + getch(); + return 0; +} diff --git a/repaso arbol/obj/Debug/funciones.o b/repaso arbol/obj/Debug/funciones.o new file mode 100644 index 0000000..a34837d Binary files /dev/null and b/repaso arbol/obj/Debug/funciones.o differ diff --git a/repaso arbol/obj/Debug/main.o b/repaso arbol/obj/Debug/main.o new file mode 100644 index 0000000..5d3ac6f Binary files /dev/null and b/repaso arbol/obj/Debug/main.o differ diff --git a/repaso arbol/obj/Debug/primitivas_arbol.o b/repaso arbol/obj/Debug/primitivas_arbol.o new file mode 100644 index 0000000..689b99a Binary files /dev/null and b/repaso arbol/obj/Debug/primitivas_arbol.o differ diff --git a/repaso arbol/orden de ingreso del arbol.txt b/repaso arbol/orden de ingreso del arbol.txt new file mode 100644 index 0000000..d8f9cd7 --- /dev/null +++ b/repaso arbol/orden de ingreso del arbol.txt @@ -0,0 +1 @@ +50 25 80 12 40 70 100 60 75 90 55 65 85 95 87 86 \ No newline at end of file diff --git a/repaso arbol/primitivas_arbol.c b/repaso arbol/primitivas_arbol.c new file mode 100644 index 0000000..cbe8238 --- /dev/null +++ b/repaso arbol/primitivas_arbol.c @@ -0,0 +1,559 @@ +#include "primitivas_arbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +void talar_arbol(t_arbol *a) +{ + *a=NULL; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + free(*a); + *a=NULL; + } +} + +int arbol_vacio(const t_arbol *a) +{ + return *a==NULL; +} + +int arbol_lleno(const t_arbol *a) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int ver_raiz(const t_arbol *a,t_dato *d) +{ + if(!*a) + return ARBOL_VACIO; + *d=(*a)->dato; + return OK; +} + +int es_hoja(const t_arbol *a) +{ + return *a&&!(*a)->izq&&!(*a)->der; +} + +void recorrer_arbol_en_inorden(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_en_inorden(&(*a)->izq,mostrar); + mostrar((void*)&(*a)->dato); + recorrer_arbol_en_inorden(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_en_preorden(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar((void*)&(*a)->dato); + recorrer_arbol_en_preorden(&(*a)->izq,mostrar); + recorrer_arbol_en_preorden(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_en_posorden(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_en_posorden(&(*a)->izq,mostrar); + recorrer_arbol_en_posorden(&(*a)->der,mostrar); + mostrar((void*)&(*a)->dato); + } +} + +int insertar_en_arbol_recursiva(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + if(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + return insertar_en_arbol_recursiva(&(*a)->izq,d,comparar); + if(comparar((void*)&(*a)->dato,(void*)d)<0) + return insertar_en_arbol_recursiva(&(*a)->der,d,comparar); + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int buscar_en_arbol_recursiva(const t_arbol *a,const t_dato *d,t_cmp comparar) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return OK; + if(cmp>0) + return buscar_en_arbol_recursiva(&(*a)->izq,d,comparar); + else + return buscar_en_arbol_recursiva(&(*a)->der,d,comparar); + } + return NO_ENCONTRADO; +} + +int buscar_en_arbol_iterativa(const t_arbol *a,const t_dato *d,t_cmp comparar) +{ + int cmp; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return OK; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NO_ENCONTRADO; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_del_padre_recursiva(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo **padre=a; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return NULL; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_del_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_del_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_del_padre_recursiva_interna(t_arbol *a,const t_dato *d,t_cmp comparar,t_arbol *padre) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return padre; + *padre=*a; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_del_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_del_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_del_padre_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo **padre=a; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return (a==padre)?NULL:padre; + *padre=*a; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NULL; +} + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->izq,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->der,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + } +} + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->izq,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->der,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + } +} + +int cargar_arbol_con_archivo_binario_en_preorden(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + return 0; + fread(&dato,sizeof(t_dato),1,pf); + } + return OK; +} + +int cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible(t_arbol *a,FILE *pf,t_cmp comparar) +{ + fseek(pf,0L,SEEK_END); + return cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible_interna(a,pf,comparar,1,ftell(pf)/sizeof(t_dato)); +} + +int cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible_interna(t_arbol *a,FILE *pf,t_cmp comparar,int pri,int ult) +{ + t_dato dato; + if(pri<=ult) + { + int medio=(ult-pri)/2; + fseek(pf,(medio-1)*sizeof(t_dato),SEEK_SET); + fread(&dato,sizeof(t_dato),1,pf); + if(!feof(pf)) + { + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible_interna(a,pf,comparar,pri,medio-1); + cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible_interna(a,pf,comparar,medio+1,ult); + } + } + return OK; +} + +int calcular_altura(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (alt_izq>=alt_der)?alt_izq+1:alt_der+1; + } + return 0; +} + +int calcular_nivel(const t_arbol *a) +{ + if(*a) + { + int niv_izq=calcular_altura(&(*a)->izq); + int niv_der=calcular_altura(&(*a)->der); + return (niv_izq>=niv_der)?niv_izq+1:niv_der+1; + } + return -1; +} + +int arbol_balanceado(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (alt_izq!=alt_der)?0:arbol_balanceado(&(*a)->izq)&&arbol_balanceado(&(*a)->der); + } + return 1; +} + +int arbol_semibalanceado(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (ABS(alt_izq-alt_der)>1)?0:arbol_semibalanceado(&(*a)->izq)&&arbol_semibalanceado(&(*a)->der); + } + return 1; +} + +int mostrar_y_contar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_nodos(&(*a)->izq,mostrar)+mostrar_y_contar_nodos(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(es_hoja(a)) + { + mostrar((void*)&(*a)->dato); + return 1; + } + return mostrar_y_contar_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_nodos(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + if(!es_hoja(a)) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_nodos(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&!((*a)->izq&&(*a)->der)) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + return mostrar_y_contar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar((void*)&(*a)->dato); + return 1; + } + return 0; +} + +int mostrar_y_contar_hasta_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + if(nivel) + { + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_hasta_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_hasta_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_hasta_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar((void*)&(*a)->dato); + if(nivel>=0) + return mostrar_y_contar_hasta_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_hasta_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + return 1; + } + return 0; +} + +int mostrar_y_contar_desde_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=0) + return mostrar_y_contar_desde_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_desde_nivel(&(*a)->der,nivel-1,mostrar); + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_desde_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_desde_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_desde_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=1) + return mostrar_y_contar_desde_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_desde_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + mostrar((void*)&(*a)->dato); + return mostrar_y_contar_desde_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_desde_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +void podar_hojas(t_arbol *a) +{ + if(*a) + { + if(es_hoja(a)) + { + free(*a); + *a=NULL; + } + else + { + podar_hojas(&(*a)->izq); + podar_hojas(&(*a)->der); + } + } +} + +t_nodo **buscar_nodo_menor(t_arbol *a) +{ + if(!*a) + return NULL; + while((*a)->izq) + a=&(*a)->izq; + return a; +} + +t_nodo **buscar_nodo_mayor(t_arbol *a) +{ + if(!*a) + return NULL; + while((*a)->der) + a=&(*a)->der; + return a; +} + +int eliminar_nodo_y_acomodar_ramas(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + t_arbol *sub_arbol; + a=buscar_en_arbol_y_retornar_direccion_del_padre_iterativa(a,d,comparar); + if(!a) + return NO_ENCONTRADO; + while(!es_hoja(a)) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + sub_arbol=(alt_izq<=alt_der)?buscar_nodo_menor(&(*a)->izq):buscar_nodo_mayor(&(*a)->der); + (*a)->dato=(*sub_arbol)->dato; + a=sub_arbol; + } + free(*a); + *a=NULL; + return OK; +} diff --git a/repaso arbol/primitivas_arbol.h b/repaso arbol/primitivas_arbol.h new file mode 100644 index 0000000..cdc7b6b --- /dev/null +++ b/repaso arbol/primitivas_arbol.h @@ -0,0 +1,92 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +#define ABS(x) (((x)>=0)?(x):(-(x))) + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *izq; + struct s_nodo *der; +}t_nodo; + +typedef t_nodo* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol*); + +void talar_arbol(t_arbol*); +void vaciar_arbol(t_arbol*); + +int arbol_vacio(const t_arbol*); +int arbol_lleno(const t_arbol*); + +int ver_raiz(const t_arbol*,t_dato*); +int es_hoja(const t_arbol*); + +void recorrer_arbol_en_inorden(const t_arbol*,t_mst); +void recorrer_arbol_en_preorden(const t_arbol*,t_mst); +void recorrer_arbol_en_posorden(const t_arbol*,t_mst); + +int insertar_en_arbol_recursiva(t_arbol*,const t_dato*,t_cmp); +int insertar_en_arbol_iterativa(t_arbol*,const t_dato*,t_cmp); + +int buscar_en_arbol_recursiva(const t_arbol*,const t_dato*,t_cmp); +int buscar_en_arbol_iterativa(const t_arbol*,const t_dato*,t_cmp); + +t_nodo **buscar_en_arbol_y_retornar_direccion_del_padre_recursiva(t_arbol*,const t_dato*,t_cmp); +t_nodo **buscar_en_arbol_y_retornar_direccion_del_padre_recursiva_interna(t_arbol*,const t_dato*,t_cmp,t_arbol*); +t_nodo **buscar_en_arbol_y_retornar_direccion_del_padre_iterativa(t_arbol*,const t_dato*,t_cmp); + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol*,FILE*); + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol*,FILE*); + +int cargar_arbol_con_archivo_binario_en_preorden(t_arbol*,FILE*,t_cmp); +int cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible(t_arbol*,FILE*,t_cmp); +int cargar_arbol_con_archivo_binario_en_inorden_lo_mas_balanceado_posible_interna(t_arbol*,FILE*,t_cmp,int,int); + +int calcular_altura(const t_arbol*); +int calcular_nivel(const t_arbol*); + +int arbol_balanceado(const t_arbol*); +int arbol_semibalanceado(const t_arbol*); + +int mostrar_y_contar_nodos(const t_arbol*,t_mst); +int mostrar_y_contar_hojas(const t_arbol*,t_mst); +int mostrar_y_contar_no_hojas(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_hasta_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_hasta_nivel_inclusive(const t_arbol*,int,t_mst); +int mostrar_y_contar_desde_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_desde_nivel_inclusive(const t_arbol*,int,t_mst); + +void podar_hojas(t_arbol*); + +t_nodo **buscar_nodo_menor(t_arbol*); +t_nodo **buscar_nodo_mayor(t_arbol*); + +int eliminar_nodo_y_acomodar_ramas(t_arbol*,const t_dato*,t_cmp); diff --git a/repaso arbol/repaso arbol.cbp b/repaso arbol/repaso arbol.cbp new file mode 100644 index 0000000..81b1753 --- /dev/null +++ b/repaso arbol/repaso arbol.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso arbol/repaso arbol.depend b/repaso arbol/repaso arbol.depend new file mode 100644 index 0000000..57bc45e --- /dev/null +++ b/repaso arbol/repaso arbol.depend @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1479079953 source:d:\unlam\programaciÓn\fabian\repaso arbol\funciones.c + "header.h" + +1479058626 d:\unlam\programaciÓn\fabian\repaso arbol\header.h + "primitivas_arbol.h" + + + + + +1479079893 d:\unlam\programaciÓn\fabian\repaso arbol\primitivas_arbol.h + "dato.h" + + + + + +1479058363 d:\unlam\programaciÓn\fabian\repaso arbol\dato.h + +1479094494 source:d:\unlam\programaciÓn\fabian\repaso arbol\main.c + "header.h" + +1479094110 source:d:\unlam\programaciÓn\fabian\repaso arbol\primitivas_arbol.c + "primitivas_arbol.h" + diff --git a/repaso arbol/repaso arbol.layout b/repaso arbol/repaso arbol.layout new file mode 100644 index 0000000..3d9b899 --- /dev/null +++ b/repaso arbol/repaso arbol.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso arbol_nuevo/arbol.c b/repaso arbol_nuevo/arbol.c new file mode 100644 index 0000000..d67ec09 --- /dev/null +++ b/repaso arbol_nuevo/arbol.c @@ -0,0 +1,122 @@ +#include "arbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + + free(*a); + *a=NULL; + } +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return FALSO; + } + + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return FALSO; + + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + + return VERDADERO; +} + +int calcular_altura(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + + return (alt_izq>=alt_der)?alt_izq+1:alt_der+1; + } + + return 0; +} + +int es_arbol_AVL(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + + return (ABS(alt_izq-alt_der)>1)?FALSO:es_arbol_AVL(&(*a)->izq)&&es_arbol_AVL(&(*a)->der); + } + + return VERDADERO; +} + +int es_arbol_balanceado(const t_arbol *a) +{ + int h=calcular_altura(a); + return es_arbol_balanceado_interna(a,h); +} + +int es_arbol_balanceado_interna(const t_arbol *a,int altura) +{ + if(*a) + return es_arbol_balanceado_interna(&(*a)->izq,altura-1)&&es_arbol_balanceado_interna(&(*a)->der,altura-1); + + return altura<=1; +} + +int es_arbol_completo(const t_arbol *a) +{ + return es_arbol_completo_interna(a,calcular_altura(a)); +} + +int es_arbol_completo_interna(const t_arbol *a,int altura) +{ + if(*a) + return es_arbol_completo_interna(&(*a)->izq,altura-1)&&es_arbol_completo_interna(&(*a)->der,altura-1); + + return altura==0; +} + +void graficar_arbol(const t_arbol *a,t_mst mostrar) +{ + graficar_arbol_interna(a,0,mostrar); +} + +void graficar_arbol_interna(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + graficar_arbol_interna(&(*a)->der,nivel+1,mostrar); + + tab(nivel); + mostrar((void*)&(*a)->dato); + printf("\n\n"); + + graficar_arbol_interna(&(*a)->izq,nivel+1,mostrar); + } +} + +void tab(int nivel) +{ + int i; + + for(i=0;i +#include + +#define ARBOL_VACIO 0 +#define ARBOL_LLENO 0 + +#define FALSO 0 +#define VERDADERO 1 + +#define ABS(x) (((x)<0)?(-x):(x)) + +typedef struct +{ + int numero; +}t_dato; + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *izq; + struct s_nodo *der; +}t_nodo; + +typedef t_nodo* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol *a); +void vaciar_arbol(t_arbol *a); + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar); + +int calcular_altura(const t_arbol *a); + +int es_arbol_AVL(const t_arbol *a); + +int es_arbol_balanceado(const t_arbol *a); +int es_arbol_balanceado_interna(const t_arbol *a,int altura); + +int es_arbol_completo(const t_arbol *a); +int es_arbol_completo_interna(const t_arbol *a,int altura); + +void graficar_arbol(const t_arbol *a,t_mst mostrar); +void graficar_arbol_interna(const t_arbol *a,int nivel,t_mst mostrar); + +void tab(int nivel); diff --git a/repaso arbol_nuevo/bin/Debug/repaso arbol_nuevo.exe b/repaso arbol_nuevo/bin/Debug/repaso arbol_nuevo.exe new file mode 100644 index 0000000..5c5928f Binary files /dev/null and b/repaso arbol_nuevo/bin/Debug/repaso arbol_nuevo.exe differ diff --git a/repaso arbol_nuevo/funciones.c b/repaso arbol_nuevo/funciones.c new file mode 100644 index 0000000..8ab4b68 --- /dev/null +++ b/repaso arbol_nuevo/funciones.c @@ -0,0 +1,14 @@ +#include "header.h" + +void mostrar_nodo(const void *v) +{ + t_dato *dato=(t_dato*)v; + printf("%d",dato->numero); +} + +int comparar_enteros(const void *void1,const void *void2) +{ + t_dato *dato1=(t_dato*)void1; + t_dato *dato2=(t_dato*)void2; + return dato1->numero-dato2->numero; +} diff --git a/repaso arbol_nuevo/header.h b/repaso arbol_nuevo/header.h new file mode 100644 index 0000000..8f57454 --- /dev/null +++ b/repaso arbol_nuevo/header.h @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "arbol.h" + +void mostrar_nodo(const void *v); + +int comparar_enteros(const void *void1,const void *void2); diff --git a/repaso arbol_nuevo/main.c b/repaso arbol_nuevo/main.c new file mode 100644 index 0000000..c78b010 --- /dev/null +++ b/repaso arbol_nuevo/main.c @@ -0,0 +1,44 @@ +#include "header.h" + +int main() +{ + t_arbol arbol; + t_dato dato; + + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 6B"); + + printf("\n\n \t\t ÁRBOL \n"); + + crear_arbol(&arbol); + + dato.numero=50; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=75; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=25; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=12; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=38; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=62; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=88; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + dato.numero=6; + insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros); + + printf("\n Altura del árbol: \t %d \n",calcular_altura(&arbol)); + + printf("\n El árbol %s AVL \n",(es_arbol_AVL(&arbol))?"ES":"NO ES"); + printf("\n El árbol %s balanceado \n",(es_arbol_balanceado(&arbol))?"ES":"NO ES"); + printf("\n El árbol %s completo \n",(es_arbol_completo(&arbol))?"ES":"NO ES"); + + printf("\n Gráfico del árbol \n\n"); + graficar_arbol(&arbol,mostrar_nodo); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n \a\a"); + getch(); + return 0; +} diff --git a/repaso arbol_nuevo/obj/Debug/arbol.o b/repaso arbol_nuevo/obj/Debug/arbol.o new file mode 100644 index 0000000..f288c14 Binary files /dev/null and b/repaso arbol_nuevo/obj/Debug/arbol.o differ diff --git a/repaso arbol_nuevo/obj/Debug/funciones.o b/repaso arbol_nuevo/obj/Debug/funciones.o new file mode 100644 index 0000000..ae79ff5 Binary files /dev/null and b/repaso arbol_nuevo/obj/Debug/funciones.o differ diff --git a/repaso arbol_nuevo/obj/Debug/main.o b/repaso arbol_nuevo/obj/Debug/main.o new file mode 100644 index 0000000..6772731 Binary files /dev/null and b/repaso arbol_nuevo/obj/Debug/main.o differ diff --git a/repaso arbol_nuevo/repaso arbol_nuevo.cbp b/repaso arbol_nuevo/repaso arbol_nuevo.cbp new file mode 100644 index 0000000..d9d8cf2 --- /dev/null +++ b/repaso arbol_nuevo/repaso arbol_nuevo.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso arbol_nuevo/repaso arbol_nuevo.depend b/repaso arbol_nuevo/repaso arbol_nuevo.depend new file mode 100644 index 0000000..f59000e --- /dev/null +++ b/repaso arbol_nuevo/repaso arbol_nuevo.depend @@ -0,0 +1,21 @@ +# depslib dependency file v1.0 +1480364051 source:d:\unlam\programaciÓn\fabian\repaso arbol_nuevo\funciones.c + "header.h" + +1480364034 d:\unlam\programaciÓn\fabian\repaso arbol_nuevo\header.h + + + + + "arbol.h" + +1480953721 d:\unlam\programaciÓn\fabian\repaso arbol_nuevo\arbol.h + + + +1480367745 source:d:\unlam\programaciÓn\fabian\repaso arbol_nuevo\arbol.c + "arbol.h" + +1480367729 source:d:\unlam\programaciÓn\fabian\repaso arbol_nuevo\main.c + "header.h" + diff --git a/repaso arbol_nuevo/repaso arbol_nuevo.layout b/repaso arbol_nuevo/repaso arbol_nuevo.layout new file mode 100644 index 0000000..a99c3c8 --- /dev/null +++ b/repaso arbol_nuevo/repaso arbol_nuevo.layout @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso cadenas de caracteres/bin/Debug/repaso cadenas de caracteres.exe b/repaso cadenas de caracteres/bin/Debug/repaso cadenas de caracteres.exe new file mode 100644 index 0000000..1bbbb83 Binary files /dev/null and b/repaso cadenas de caracteres/bin/Debug/repaso cadenas de caracteres.exe differ diff --git a/repaso cadenas de caracteres/functions.c b/repaso cadenas de caracteres/functions.c new file mode 100644 index 0000000..a52ce77 --- /dev/null +++ b/repaso cadenas de caracteres/functions.c @@ -0,0 +1,156 @@ +#include "header.h" + +char *str_cpy(char *destino,const char *origen) +{ + char *inicio=destino; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return inicio; +} + +size_t str_len(const char *s) +{ + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; +} + +char *str_cat(char *destino,const char *origen) +{ + char *inicio=destino; + while(*destino) + destino++; + while(*origen) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return inicio; +} + +int str_cmp(const char *s1,const char *s2) +{ + while(*s1&&*s2&&*s1==*s2) + { + s1++; + s2++; + } + return *s1-*s2; +} + +int str_icmp(const char *s1,const char *s2) +{ + while(*s1&&*s2&&A_MAYUSCULA(*s1)==A_MAYUSCULA(*s2)) + { + s1++; + s2++; + } + return A_MAYUSCULA(*s1)-A_MAYUSCULA(*s2); +} +/* +int str_icmp(const char *s1,const char *s2) +{ + while(*s1&&*s2&&A_MINUSCULA(*s1)==A_MINUSCULA(*s2)) + { + s1++; + s2++; + } + return A_MINUSCULA(*s1)-A_MINUSCULA(*s2); +} +*/ + +char *str_ncpy(char *destino,const char *origen,int cant) +{ + char *inicio=destino; + while(*origen&&cant--) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return inicio; +} + +char *str_ncat(char *destino,const char *origen,int cant) +{ + char *inicio=destino; + while(*destino) + destino++; + while(*origen&&cant--) + { + *destino=*origen; + destino++; + origen++; + } + *destino='\0'; + return inicio; +} + +int str_ncmp(const char *s1,const char *s2,int cant) +{ + while(*s1&&*s2&&*s1==*s2&&cant--) + { + s1++; + s2++; + } + return *s1-*s2; +} + +char *str_chr(const char *s,int c) +{ + while(*s&&*s!=c) + s++; + return (*s)?s:NULL; +} + +char *str_rchr(const char *s,int c) +{ + char *inicio=s; + while(*s) + s++; + while(s>inicio&&*s!=c) + s--; + return (*s==c)?s:NULL; +} + +char *str_str(const char *s1,const char *s2) +{ + size_t tam=str_len(s2); + while(*s1&&str_ncmp(s1,s2,tam)) + s1++; + return (*s1)?s1:NULL; +} + +char *str_upr(char *s) +{ + char *inicio=s; + while(*s) + { + *s=A_MAYUSCULA(*s); + s++; + } + return inicio; +} + +char *str_lwr(char *s) +{ + char *inicio=s; + while(*s) + { + *s=A_MINUSCULA(*s); + s++; + } + return inicio; +} diff --git a/repaso cadenas de caracteres/header.h b/repaso cadenas de caracteres/header.h new file mode 100644 index 0000000..d4cf0e9 --- /dev/null +++ b/repaso cadenas de caracteres/header.h @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +#define A_MAYUSCULA(x) ((x)>='a'&&(x)<='z')?(x-' '):(x) +#define A_MINUSCULA(x) ((x)>='A'&&(x)<='Z')?(x+' '):(x) + +char *str_cpy(char *,const char*); +size_t str_len(const char*); +char *str_cat(char*,const char*); +int str_cmp(const char*,const char*); +int str_icmp(const char*,const char*); +char *str_ncpy(char*,const char*,int); +char *str_ncat(char*,const char*,int); +char *str_chr(const char*,int c); +char *str_rchr(const char*,int c); +char *str_str(const char*,const char*); +char *str_upr(char*); +char *str_lwr(char*); diff --git a/repaso cadenas de caracteres/main.c b/repaso cadenas de caracteres/main.c new file mode 100644 index 0000000..f873980 --- /dev/null +++ b/repaso cadenas de caracteres/main.c @@ -0,0 +1,60 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n CADENAS DE CARACTERES \n"); + + char cadena1[]="hola"; + char cadena2[20]="mundo"; + + char copia[20]; + str_cpy(copia,cadena1); + puts("\n Cadena copiada \n\t"); + puts(copia); + + printf("\n Longitud cadena copiada: \t %d",str_len(copia)); + + puts("\n\n Cadenas concatenadas \n"); + char concatenacion[40]=""; + str_cat(concatenacion,cadena1); + str_cat(concatenacion,cadena2); + puts(concatenacion); + + printf("\n Comparación: \t %d \n",str_cmp(cadena1,cadena2)); + if(str_cmp(cadena1,cadena2)>0) + printf("\n La cadena 1 es mayor \n"); + else + printf("\n La cadena 2 es mayor \n"); + + char c='a'; + char C='A'; + printf("\n %c --- a mayúscula ---> %c \n",c,A_MAYUSCULA(c)); + printf("\n %c --- a minúscula ---> %c \n",C,A_MINUSCULA(C)); + + char copia_cortada[20]; + puts("\n Cadena copiada en 3 caracteres \n"); + puts(str_ncpy(copia_cortada,cadena2,3)); + + puts("\n\n Cadenas concatenadas en 3 caracteres \n"); + char concatenacion_2[40]=""; + str_ncat(concatenacion_2,cadena1,3); + puts(concatenacion_2); + + puts("\n Cadena 1 a partir de la primera ocurrencia del caracter l \n"); + puts(str_chr(cadena1,'l')); + + puts("\n Cadena 2 a partir de la última ocurrencia del caracter n \n"); + puts(str_rchr(cadena2,'n')); + + puts("\n Cadena 1 a partir de la ocurrencia de la cadena 2 \n"); + puts(str_str(cadena1,cadena2)); + + printf("\n Cadena 1: \t %s",cadena1); + printf("\n --- a mayúscula ---> %s \n",str_upr(cadena1)); + printf("\n --- a minúscula ---> %s \n",str_lwr(cadena1)); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; + } diff --git a/repaso cadenas de caracteres/obj/Debug/functions.o b/repaso cadenas de caracteres/obj/Debug/functions.o new file mode 100644 index 0000000..732ec2f Binary files /dev/null and b/repaso cadenas de caracteres/obj/Debug/functions.o differ diff --git a/repaso cadenas de caracteres/obj/Debug/main.o b/repaso cadenas de caracteres/obj/Debug/main.o new file mode 100644 index 0000000..c75b511 Binary files /dev/null and b/repaso cadenas de caracteres/obj/Debug/main.o differ diff --git a/repaso cadenas de caracteres/repaso cadenas de caracteres.cbp b/repaso cadenas de caracteres/repaso cadenas de caracteres.cbp new file mode 100644 index 0000000..bf5f1fe --- /dev/null +++ b/repaso cadenas de caracteres/repaso cadenas de caracteres.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/repaso cadenas de caracteres/repaso cadenas de caracteres.depend b/repaso cadenas de caracteres/repaso cadenas de caracteres.depend new file mode 100644 index 0000000..5432863 --- /dev/null +++ b/repaso cadenas de caracteres/repaso cadenas de caracteres.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1476845673 source:d:\unlam\programaciÓn\fabian\repaso cadenas de caracteres\functions.c + "header.h" + +1476845557 d:\unlam\programaciÓn\fabian\repaso cadenas de caracteres\header.h + + + + + +1476845776 source:d:\unlam\programaciÓn\fabian\repaso cadenas de caracteres\main.c + "header.h" + diff --git a/repaso cadenas de caracteres/repaso cadenas de caracteres.layout b/repaso cadenas de caracteres/repaso cadenas de caracteres.layout new file mode 100644 index 0000000..77d7a7e --- /dev/null +++ b/repaso cadenas de caracteres/repaso cadenas de caracteres.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/repaso cola circular/bin/Debug/repaso cola circular.exe b/repaso cola circular/bin/Debug/repaso cola circular.exe new file mode 100644 index 0000000..d6b6159 Binary files /dev/null and b/repaso cola circular/bin/Debug/repaso cola circular.exe differ diff --git a/repaso cola circular/dato.h b/repaso cola circular/dato.h new file mode 100644 index 0000000..1334a6b --- /dev/null +++ b/repaso cola circular/dato.h @@ -0,0 +1,4 @@ +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso cola circular/funciones.c b/repaso cola circular/funciones.c new file mode 100644 index 0000000..ba31884 --- /dev/null +++ b/repaso cola circular/funciones.c @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n DATO: \t %d \n",d->numero); +} diff --git a/repaso cola circular/header.h b/repaso cola circular/header.h new file mode 100644 index 0000000..aa5082f --- /dev/null +++ b/repaso cola circular/header.h @@ -0,0 +1,9 @@ +#include "primitivas_cola_circular.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); diff --git a/repaso cola circular/main.c b/repaso cola circular/main.c new file mode 100644 index 0000000..d517186 --- /dev/null +++ b/repaso cola circular/main.c @@ -0,0 +1,49 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n COLA CIRCULAR \n"); + + t_lista cola; + t_dato dato; + + crear_cola(&cola); + printf("\n Se ha creado una cola \n"); + + printf("\n Carga de 5 elementos \n"); + int i; + for(i=0;i<5;i++) + { + cargar_dato(&dato); + acolar(&cola,&dato); + } + printf("\n Se ha cargado algo \n"); + + if(!cola_llena(&cola)) + printf("\n La cola no está llena \n"); + + ver_primero_en_cola(&cola,&dato); + printf("\n\n El primero de la cola es: \t %d \n",dato.numero); + ver_ultimo_en_cola(&cola,&dato); + printf("\n\n El último de la cola es: \t %d \n",dato.numero); + + printf("\n Desacolar todo \n"); + while(!cola_vacia(&cola)) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + } + printf("\n Se ha desacolado todo \n"); + + printf("\n Ingreso algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + + vaciar_cola(&cola); + printf("\n La cola fue vaciada \n"); + + printf("\n\n\t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso cola circular/obj/Debug/funciones.o b/repaso cola circular/obj/Debug/funciones.o new file mode 100644 index 0000000..f95c65e Binary files /dev/null and b/repaso cola circular/obj/Debug/funciones.o differ diff --git a/repaso cola circular/obj/Debug/main.o b/repaso cola circular/obj/Debug/main.o new file mode 100644 index 0000000..bbc0cff Binary files /dev/null and b/repaso cola circular/obj/Debug/main.o differ diff --git a/repaso cola circular/obj/Debug/primitivas_cola_circular.o b/repaso cola circular/obj/Debug/primitivas_cola_circular.o new file mode 100644 index 0000000..ce036d7 Binary files /dev/null and b/repaso cola circular/obj/Debug/primitivas_cola_circular.o differ diff --git a/repaso cola circular/primitivas_cola_circular.c b/repaso cola circular/primitivas_cola_circular.c new file mode 100644 index 0000000..a977474 --- /dev/null +++ b/repaso cola circular/primitivas_cola_circular.c @@ -0,0 +1,80 @@ +#include "primitivas_cola_circular.h" + +void crear_cola(t_lista *c) +{ + *c=NULL; +} + +int cola_vacia(const t_lista *c) +{ + return *c==NULL; +} + +int cola_llena(const t_lista *c) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int acolar(t_lista *c,const t_dato *d) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*c) + nue->sig=nue; + else + { + nue->sig=(*c)->sig; + (*c)->sig=nue; + } + *c=nue; + return OK; +} + +int desacolar(t_lista *c,t_dato *d) +{ + t_nodo *aux; + if(!*c) + return COLA_VACIA; + aux=(*c)->sig; + *d=aux->dato; + if(*c==aux) + *c=NULL; + else + (*c)->sig=aux->sig; + free(aux); + return OK; +} + +int ver_primero_en_cola(const t_lista *c,t_dato *d) +{ + if(!*c) + return COLA_VACIA; + *d=(*c)->sig->dato; + return OK; +} + +int ver_ultimo_en_cola(const t_lista *c,t_dato *d) +{ + if(!*c) + return COLA_VACIA; + *d=(*c)->dato; + return OK; +} + +void vaciar_cola(t_lista *c) +{ + t_nodo *aux,*ult=*c; + *c=(*c)->sig; + while(*c&&*c!=ult) + { + aux=*c; + *c=aux->sig; + free(aux); + } + free(*c); + *c=NULL; +} diff --git a/repaso cola circular/primitivas_cola_circular.h b/repaso cola circular/primitivas_cola_circular.h new file mode 100644 index 0000000..10a0a23 --- /dev/null +++ b/repaso cola circular/primitivas_cola_circular.h @@ -0,0 +1,27 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define COLA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +void crear_cola(t_lista*); +int cola_vacia(const t_lista*); +int cola_llena(const t_lista*); +int acolar(t_lista*,const t_dato*); +int desacolar(t_lista*,t_dato*); +int ver_primero_en_cola(const t_lista*,t_dato*); +int ver_ultimo_en_cola(const t_lista*,t_dato*); +void vaciar_cola(t_lista*); diff --git a/repaso cola circular/repaso cola circular.cbp b/repaso cola circular/repaso cola circular.cbp new file mode 100644 index 0000000..bc6a581 --- /dev/null +++ b/repaso cola circular/repaso cola circular.cbp @@ -0,0 +1,53 @@ + + + + + + diff --git a/repaso cola circular/repaso cola circular.depend b/repaso cola circular/repaso cola circular.depend new file mode 100644 index 0000000..02fe62c --- /dev/null +++ b/repaso cola circular/repaso cola circular.depend @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1478993987 source:d:\unlam\programaciÓn\fabian\repaso cola circular\funciones.c + "header.h" + +1478990569 d:\unlam\programaciÓn\fabian\repaso cola circular\header.h + "primitivas_cola_circular.h" + + + + + +1478994080 d:\unlam\programaciÓn\fabian\repaso cola circular\primitivas_cola_circular.h + "dato.h" + + + + + +1478990432 d:\unlam\programaciÓn\fabian\repaso cola circular\dato.h + +1478994454 source:d:\unlam\programaciÓn\fabian\repaso cola circular\main.c + "header.h" + +1478994460 source:d:\unlam\programaciÓn\fabian\repaso cola circular\primitivas_cola_circular.c + "primitivas_cola_circular.h" + diff --git a/repaso cola circular/repaso cola circular.layout b/repaso cola circular/repaso cola circular.layout new file mode 100644 index 0000000..9e89e27 --- /dev/null +++ b/repaso cola circular/repaso cola circular.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso cola circular_nuevo/bin/Debug/repaso cola circular_nuevo.exe b/repaso cola circular_nuevo/bin/Debug/repaso cola circular_nuevo.exe new file mode 100644 index 0000000..26dccf5 Binary files /dev/null and b/repaso cola circular_nuevo/bin/Debug/repaso cola circular_nuevo.exe differ diff --git a/repaso cola circular_nuevo/cola circular.c b/repaso cola circular_nuevo/cola circular.c new file mode 100644 index 0000000..5e14243 --- /dev/null +++ b/repaso cola circular_nuevo/cola circular.c @@ -0,0 +1,80 @@ +#include "cola circular.h" + +void crear_cola(t_lista *c) +{ + *c=NULL; +} + +int cola_vacia(const t_lista *c) +{ + return *c==NULL; +} + +int cola_llena(const t_lista *c) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int acolar(t_lista *c,const t_dato *d) +{ + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + if(!*c) + nuevo->sig=nuevo; + else + { + nuevo->sig=(*c)->sig; + (*c)->sig=nuevo; + } + *c=nuevo; + return OK; +} + +int desacolar(t_lista *c,t_dato *d) +{ + t_nodo *aux; + if(!*c) + return COLA_VACIA; + aux=(*c)->sig; + *d=aux->dato; + if(aux==*c) + *c=NULL; + else + (*c)->sig=aux->sig; + free(aux); + return OK; +} + +int ver_primero_de_cola(const t_lista *c,t_dato *d) +{ + if(!*c) + return COLA_VACIA; + *d=(*c)->sig->dato; + return OK; +} + +int ver_ultimo_de_cola(const t_lista *c,t_dato *d) +{ + if(!*c) + return COLA_VACIA; + *d=(*c)->dato; + return OK; +} + +void vaciar_cola(t_lista *c) +{ + t_nodo *aux,*ult=*c; + *c=(*c)->sig; + while(*c&&*c!=ult) + { + aux=*c; + *c=aux->sig; + free(aux); + } + free(*c); + return OK; +} diff --git a/repaso cola circular_nuevo/cola circular.h b/repaso cola circular_nuevo/cola circular.h new file mode 100644 index 0000000..6d0da58 --- /dev/null +++ b/repaso cola circular_nuevo/cola circular.h @@ -0,0 +1,27 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define COLA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +void crear_cola(t_lista*); +int cola_vacia(const t_lista*); +int cola_llena(const t_lista*); +int acolar(t_lista*,const t_dato*); +int desacolar(t_lista*,t_dato*); +int ver_primero_de_cola(const t_lista*,t_dato*); +int ver_ultimo_de_cola(const t_lista*,t_dato*); +void vaciar_cola(t_lista*); diff --git a/repaso cola circular_nuevo/dato.h b/repaso cola circular_nuevo/dato.h new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ b/repaso cola circular_nuevo/dato.h @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso cola circular_nuevo/funciones.c b/repaso cola circular_nuevo/funciones.c new file mode 100644 index 0000000..6383757 --- /dev/null +++ b/repaso cola circular_nuevo/funciones.c @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} diff --git a/repaso cola circular_nuevo/header.h b/repaso cola circular_nuevo/header.h new file mode 100644 index 0000000..0fdc7a7 --- /dev/null +++ b/repaso cola circular_nuevo/header.h @@ -0,0 +1,9 @@ +#include "cola circular.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); diff --git a/repaso cola circular_nuevo/main.c b/repaso cola circular_nuevo/main.c new file mode 100644 index 0000000..796a593 --- /dev/null +++ b/repaso cola circular_nuevo/main.c @@ -0,0 +1,59 @@ +#include "header.h" + +int main() +{ + t_lista cola; + t_dato dato; + + int i; + + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + printf("\n\n \t\t COLA CIRCULAR \n"); + + crear_cola(&cola); + printf("\n\n Se ha creado una cola \n"); + + if(cola_vacia(&cola)) + printf("\n\n La cola está vacía \n"); + + printf("\n\n Carga de 5 datos \n"); + for(i=0;i<5;i++) + { + cargar_dato(&dato); + acolar(&cola,&dato); + } + printf("\n\n Se han cargado 5 datos \n"); + + if(!cola_llena(&cola)) + printf("\n\n La cola no está llena \n"); + + printf("\n\n Primero de la cola \n"); + ver_primero_de_cola(&cola,&dato); + mostrar_dato(&dato); + + printf("\n\n Último de la cola \n"); + ver_ultimo_de_cola(&cola,&dato); + mostrar_dato(&dato); + + printf("\n\n Desacolamos todo \n"); + while(!cola_vacia(&cola)) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desacolado todo \n"); + + printf("\n\n Acolar algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + printf("\n\n Se acoló algo \n"); + + vaciar_cola(&cola); + printf("\n\n Se ha vaciado la cola \n"); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso cola circular_nuevo/obj/Debug/cola circular.o b/repaso cola circular_nuevo/obj/Debug/cola circular.o new file mode 100644 index 0000000..f138c11 Binary files /dev/null and b/repaso cola circular_nuevo/obj/Debug/cola circular.o differ diff --git a/repaso cola circular_nuevo/obj/Debug/funciones.o b/repaso cola circular_nuevo/obj/Debug/funciones.o new file mode 100644 index 0000000..7b2e47b Binary files /dev/null and b/repaso cola circular_nuevo/obj/Debug/funciones.o differ diff --git a/repaso cola circular_nuevo/obj/Debug/main.o b/repaso cola circular_nuevo/obj/Debug/main.o new file mode 100644 index 0000000..634df5d Binary files /dev/null and b/repaso cola circular_nuevo/obj/Debug/main.o differ diff --git a/repaso cola circular_nuevo/repaso cola circular_nuevo.cbp b/repaso cola circular_nuevo/repaso cola circular_nuevo.cbp new file mode 100644 index 0000000..ecff070 --- /dev/null +++ b/repaso cola circular_nuevo/repaso cola circular_nuevo.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso cola circular_nuevo/repaso cola circular_nuevo.depend b/repaso cola circular_nuevo/repaso cola circular_nuevo.depend new file mode 100644 index 0000000..84668e9 --- /dev/null +++ b/repaso cola circular_nuevo/repaso cola circular_nuevo.depend @@ -0,0 +1,23 @@ +# depslib dependency file v1.0 +1480033553 source:d:\unlam\programaciÓn\fabian\repaso cola circular_nuevo\cola circular.c + "cola circular.h" + +1480033491 d:\unlam\programaciÓn\fabian\repaso cola circular_nuevo\cola circular.h + "dato.h" + + + + + +1480030305 d:\unlam\programaciÓn\fabian\repaso cola circular_nuevo\dato.h + +1480033559 source:d:\unlam\programaciÓn\fabian\repaso cola circular_nuevo\funciones.c + "header.h" + +1480030511 d:\unlam\programaciÓn\fabian\repaso cola circular_nuevo\header.h + "cola circular.h" + + + + + diff --git a/repaso cola circular_nuevo/repaso cola circular_nuevo.layout b/repaso cola circular_nuevo/repaso cola circular_nuevo.layout new file mode 100644 index 0000000..cfbe24e --- /dev/null +++ b/repaso cola circular_nuevo/repaso cola circular_nuevo.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/repaso cola din\303\241mica/bin/Debug/repaso cola din\303\241mica.exe" "b/repaso cola din\303\241mica/bin/Debug/repaso cola din\303\241mica.exe" new file mode 100644 index 0000000..0523415 Binary files /dev/null and "b/repaso cola din\303\241mica/bin/Debug/repaso cola din\303\241mica.exe" differ diff --git "a/repaso cola din\303\241mica/dato.h" "b/repaso cola din\303\241mica/dato.h" new file mode 100644 index 0000000..ce4f252 --- /dev/null +++ "b/repaso cola din\303\241mica/dato.h" @@ -0,0 +1,6 @@ + +typedef struct +{ + int numero; +}t_dato; + diff --git "a/repaso cola din\303\241mica/functions.c" "b/repaso cola din\303\241mica/functions.c" new file mode 100644 index 0000000..a5a9732 --- /dev/null +++ "b/repaso cola din\303\241mica/functions.c" @@ -0,0 +1,14 @@ +#include "header.h" + +void cargar_dato(t_dato *dato) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&dato->numero); +} + +void mostrar_dato(t_dato *dato) +{ + printf("\n DATO: \t %d",dato->numero); +} + + diff --git "a/repaso cola din\303\241mica/header.h" "b/repaso cola din\303\241mica/header.h" new file mode 100644 index 0000000..9f79895 --- /dev/null +++ "b/repaso cola din\303\241mica/header.h" @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +#include "primitivas_cola_dinámica.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); + + diff --git "a/repaso cola din\303\241mica/main.c" "b/repaso cola din\303\241mica/main.c" new file mode 100644 index 0000000..e327a5d --- /dev/null +++ "b/repaso cola din\303\241mica/main.c" @@ -0,0 +1,54 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n COLA DINÁMICA \n\a\a"); + + t_cola cola; + t_dato dato; + + crear_cola(&cola); + printf("\n\n Se ha creado una cola \n"); + + if(cola_vacia(&cola)) + printf("\n\n La cola está vacía \n\n"); + + printf("\n\n Acolar \n"); + int i; + for(i=0;i<5;i++) + { + cargar_dato(&dato); + acolar(&cola,&dato); + } + printf("\n\n Se ha cargado la cola \n"); + + printf("\n\n Ver primero en cola \n"); + ver_primero(&cola,&dato); + mostrar_dato(&dato); + + printf("\n\n Ver último en cola \n"); + ver_ultimo(&cola,&dato); + mostrar_dato(&dato); + + printf("\n\n Desacolar \n"); + while(!cola_vacia(&cola)) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desacolado todo \n"); + + printf("\n\n Ingresar algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + printf("\n\n Se ha cargado algo \n"); + + vaciar_cola(&cola); + printf("\n\n Se ha vaciado la cola \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} + diff --git "a/repaso cola din\303\241mica/obj/Debug/functions.o" "b/repaso cola din\303\241mica/obj/Debug/functions.o" new file mode 100644 index 0000000..25aaecc Binary files /dev/null and "b/repaso cola din\303\241mica/obj/Debug/functions.o" differ diff --git "a/repaso cola din\303\241mica/obj/Debug/main.o" "b/repaso cola din\303\241mica/obj/Debug/main.o" new file mode 100644 index 0000000..cd3f115 Binary files /dev/null and "b/repaso cola din\303\241mica/obj/Debug/main.o" differ diff --git "a/repaso cola din\303\241mica/obj/Debug/primitivas_cola_din\303\241mica.o" "b/repaso cola din\303\241mica/obj/Debug/primitivas_cola_din\303\241mica.o" new file mode 100644 index 0000000..4ac5bd4 Binary files /dev/null and "b/repaso cola din\303\241mica/obj/Debug/primitivas_cola_din\303\241mica.o" differ diff --git "a/repaso cola din\303\241mica/primitivas_cola_din\303\241mica.c" "b/repaso cola din\303\241mica/primitivas_cola_din\303\241mica.c" new file mode 100644 index 0000000..075231a --- /dev/null +++ "b/repaso cola din\303\241mica/primitivas_cola_din\303\241mica.c" @@ -0,0 +1,76 @@ +#include "primitivas_cola_dinámica.h" + +void crear_cola(t_cola *c) +{ + c->pri=NULL; + c->ult=NULL; +} + +int cola_vacia(const t_cola *c) +{ + return c->pri==NULL; +} + +int cola_llena(const t_cola *c) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int acolar(t_cola *c,const t_dato *d) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=NULL; + if(c->ult==NULL) + c->pri=nue; + else + c->ult->sig=nue; + c->ult=nue; + return OK; +} + +int desacolar(t_cola *c,t_dato *d) +{ + t_nodo *aux; + if(c->pri==NULL) + return COLA_VACIA; + aux=c->pri; + *d=aux->dato; + c->pri=aux->sig; + if(c->pri==NULL) + c->ult=NULL; + free(aux); + return OK; +} + +int ver_primero(const t_cola *c,t_dato *d) +{ + if(c->pri==NULL) + return COLA_VACIA; + *d=c->pri->dato; + return OK; +} + +int ver_ultimo(const t_cola *c,t_dato *d) +{ + if(c->pri==NULL) + return COLA_VACIA; + *d=c->ult->dato; + return OK; +} + +void vaciar_cola(t_cola *c) +{ + t_nodo *aux; + while(c->pri) + { + aux=c->pri; + c->pri=aux->sig; + free(aux); + } + c->ult=NULL; +} diff --git "a/repaso cola din\303\241mica/primitivas_cola_din\303\241mica.h" "b/repaso cola din\303\241mica/primitivas_cola_din\303\241mica.h" new file mode 100644 index 0000000..e9d12af --- /dev/null +++ "b/repaso cola din\303\241mica/primitivas_cola_din\303\241mica.h" @@ -0,0 +1,29 @@ +#include "dato.h" + +#include +#include + +#define COLA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef struct +{ + t_nodo *pri; + t_nodo *ult; +}t_cola; + +void crear_cola(t_cola*); +int cola_vacia(const t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int desacolar(t_cola*,t_dato*); +int ver_primero(const t_cola*,t_dato*); +int ver_ultimo(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/repaso cola din\303\241mica/repaso cola din\303\241mica.cbp" "b/repaso cola din\303\241mica/repaso cola din\303\241mica.cbp" new file mode 100644 index 0000000..86f50c8 --- /dev/null +++ "b/repaso cola din\303\241mica/repaso cola din\303\241mica.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/repaso cola din\303\241mica/repaso cola din\303\241mica.depend" "b/repaso cola din\303\241mica/repaso cola din\303\241mica.depend" new file mode 100644 index 0000000..731933e --- /dev/null +++ "b/repaso cola din\303\241mica/repaso cola din\303\241mica.depend" @@ -0,0 +1,21 @@ +# depslib dependency file v1.0 +1476997868 source:d:\unlam\programaciÓn\fabian\repaso cola dinámica\functions.c + "header.h" + +1476997768 d:\unlam\programaciÓn\fabian\repaso cola dinámica\header.h + + + + + "primitivas_cola_dinámica.h" + +1477002624 d:\unlam\programaciÓn\fabian\repaso cola dinámica\primitivas_cola_dinámica.h + "dato.h" + + + +1476997572 d:\unlam\programaciÓn\fabian\repaso cola dinámica\dato.h + +1476998068 source:d:\unlam\programaciÓn\fabian\repaso cola dinámica\main.c + "header.h" + diff --git "a/repaso cola din\303\241mica/repaso cola din\303\241mica.layout" "b/repaso cola din\303\241mica/repaso cola din\303\241mica.layout" new file mode 100644 index 0000000..ee93722 --- /dev/null +++ "b/repaso cola din\303\241mica/repaso cola din\303\241mica.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/repaso cola est\303\241tica/bin/Debug/repaso cola est\303\241tica.exe" "b/repaso cola est\303\241tica/bin/Debug/repaso cola est\303\241tica.exe" new file mode 100644 index 0000000..6f60dc1 Binary files /dev/null and "b/repaso cola est\303\241tica/bin/Debug/repaso cola est\303\241tica.exe" differ diff --git "a/repaso cola est\303\241tica/dato.h" "b/repaso cola est\303\241tica/dato.h" new file mode 100644 index 0000000..1da8c18 --- /dev/null +++ "b/repaso cola est\303\241tica/dato.h" @@ -0,0 +1,7 @@ +#define TAM 10 + +typedef struct +{ + int numero; +}t_dato; + diff --git "a/repaso cola est\303\241tica/functions.c" "b/repaso cola est\303\241tica/functions.c" new file mode 100644 index 0000000..8eee6f6 --- /dev/null +++ "b/repaso cola est\303\241tica/functions.c" @@ -0,0 +1,13 @@ +#include "header.h" + +void cargar_dato(t_dato *dato) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&dato->numero); +} + +void mostrar_dato(t_dato *dato) +{ + printf("\n DATO: \t %d",dato->numero); +} + diff --git "a/repaso cola est\303\241tica/header.h" "b/repaso cola est\303\241tica/header.h" new file mode 100644 index 0000000..edc7a50 --- /dev/null +++ "b/repaso cola est\303\241tica/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "primitivas_cola_estática.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); + diff --git "a/repaso cola est\303\241tica/main.c" "b/repaso cola est\303\241tica/main.c" new file mode 100644 index 0000000..61e6ed0 --- /dev/null +++ "b/repaso cola est\303\241tica/main.c" @@ -0,0 +1,53 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n COLA ESTÁTICA \n\a\a"); + + t_cola cola; + t_dato dato; + + crear_cola(&cola); + printf("\n\n Se ha creado una cola \n"); + + if(cola_vacia(&cola)) + printf("\n\n La cola está vacía \n\n"); + + printf("\n\n Acolar \n"); + while(!cola_llena(&cola)) + { + cargar_dato(&dato); + acolar(&cola,&dato); + } + printf("\n\n Se ha cargado la cola \n"); + + printf("\n\n Ver primero en cola \n"); + ver_primero(&cola,&dato); + mostrar_dato(&dato); + + printf("\n\n Ver último en cola \n"); + ver_ultimo(&cola,&dato); + mostrar_dato(&dato); + + printf("\n\n Desacolar \n"); + while(!cola_vacia(&cola)) + { + desacolar(&cola,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desacolado todo \n"); + + printf("\n\n Ingresar algo \n"); + cargar_dato(&dato); + acolar(&cola,&dato); + printf("\n\n Se ha cargado algo \n"); + + vaciar_cola(&cola); + printf("\n\n Se ha vaciado la cola \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} + diff --git "a/repaso cola est\303\241tica/obj/Debug/functions.o" "b/repaso cola est\303\241tica/obj/Debug/functions.o" new file mode 100644 index 0000000..e705656 Binary files /dev/null and "b/repaso cola est\303\241tica/obj/Debug/functions.o" differ diff --git "a/repaso cola est\303\241tica/obj/Debug/main.o" "b/repaso cola est\303\241tica/obj/Debug/main.o" new file mode 100644 index 0000000..d91797f Binary files /dev/null and "b/repaso cola est\303\241tica/obj/Debug/main.o" differ diff --git "a/repaso cola est\303\241tica/obj/Debug/primitivas_cola_est\303\241tica.o" "b/repaso cola est\303\241tica/obj/Debug/primitivas_cola_est\303\241tica.o" new file mode 100644 index 0000000..2c48854 Binary files /dev/null and "b/repaso cola est\303\241tica/obj/Debug/primitivas_cola_est\303\241tica.o" differ diff --git "a/repaso cola est\303\241tica/primitivas_cola_est\303\241tica.c" "b/repaso cola est\303\241tica/primitivas_cola_est\303\241tica.c" new file mode 100644 index 0000000..f4d8c05 --- /dev/null +++ "b/repaso cola est\303\241tica/primitivas_cola_est\303\241tica.c" @@ -0,0 +1,63 @@ +#include "primitivas_cola_estática.h" + +void crear_cola(t_cola *c) +{ + c->pri=0; + c->ult=-1; +} + +int cola_vacia(const t_cola *c) +{ + return c->ult==-1; +} + +int cola_llena(const t_cola *c) +{ + return (c->ult+1)%TAM==c->pri&&c->ult!=-1; +} + +int acolar(t_cola *c,const t_dato *d) +{ + if((c->ult+1)%TAM==c->pri&&c->ult!=-1) + return COLA_LLENA; + c->ult=(c->ult+1)%TAM; + c->cola[c->ult]=*d; + return OK; +} + +int desacolar(t_cola *c,t_dato *d) +{ + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + if(c->pri==c->ult) + { + c->pri=0; + c->ult=-1; + } + else + c->pri=(c->pri+1)%TAM; + return OK; +} + +int ver_primero(const t_cola *c,t_dato *d) +{ + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->pri]; + return OK; +} + +int ver_ultimo(const t_cola *c,t_dato *d) +{ + if(c->ult==-1) + return COLA_VACIA; + *d=c->cola[c->ult]; + return OK; +} + +void vaciar_cola(t_cola *c) +{ + c->pri=0; + c->ult=1; +} diff --git "a/repaso cola est\303\241tica/primitivas_cola_est\303\241tica.h" "b/repaso cola est\303\241tica/primitivas_cola_est\303\241tica.h" new file mode 100644 index 0000000..39e79e1 --- /dev/null +++ "b/repaso cola est\303\241tica/primitivas_cola_est\303\241tica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define COLA_VACIA 0 +#define COLA_LLENA 0 +#define OK 1 + +typedef struct +{ + t_dato cola[TAM]; + int pri; + int ult; +}t_cola; + +void crear_cola(t_cola*); +int cola_vacia(const t_cola*); +int cola_llena(const t_cola*); +int acolar(t_cola*,const t_dato*); +int desacolar(t_cola*,t_dato*); +int ver_primero(const t_cola*,t_dato*); +int ver_ultimo(const t_cola*,t_dato*); +void vaciar_cola(t_cola*); diff --git "a/repaso cola est\303\241tica/repaso cola est\303\241tica.cbp" "b/repaso cola est\303\241tica/repaso cola est\303\241tica.cbp" new file mode 100644 index 0000000..56559a0 --- /dev/null +++ "b/repaso cola est\303\241tica/repaso cola est\303\241tica.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/repaso cola est\303\241tica/repaso cola est\303\241tica.depend" "b/repaso cola est\303\241tica/repaso cola est\303\241tica.depend" new file mode 100644 index 0000000..0fa6ea7 --- /dev/null +++ "b/repaso cola est\303\241tica/repaso cola est\303\241tica.depend" @@ -0,0 +1,19 @@ +# depslib dependency file v1.0 +1476994414 source:d:\unlam\programaciÓn\fabian\repaso cola estática\functions.c + "header.h" + +1476994475 d:\unlam\programaciÓn\fabian\repaso cola estática\header.h + + + + + "primitivas_cola_estática.h" + +1476995405 d:\unlam\programaciÓn\fabian\repaso cola estática\primitivas_cola_estática.h + "dato.h" + +1476994405 d:\unlam\programaciÓn\fabian\repaso cola estática\dato.h + +1476997201 source:d:\unlam\programaciÓn\fabian\repaso cola estática\main.c + "header.h" + diff --git "a/repaso cola est\303\241tica/repaso cola est\303\241tica.layout" "b/repaso cola est\303\241tica/repaso cola est\303\241tica.layout" new file mode 100644 index 0000000..006c41c --- /dev/null +++ "b/repaso cola est\303\241tica/repaso cola est\303\241tica.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/repaso lista circular/bin/Debug/repaso lista circular.exe b/repaso lista circular/bin/Debug/repaso lista circular.exe new file mode 100644 index 0000000..6d9b08d Binary files /dev/null and b/repaso lista circular/bin/Debug/repaso lista circular.exe differ diff --git a/repaso lista circular/dato.h b/repaso lista circular/dato.h new file mode 100644 index 0000000..1334a6b --- /dev/null +++ b/repaso lista circular/dato.h @@ -0,0 +1,4 @@ +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso lista circular/funciones.c b/repaso lista circular/funciones.c new file mode 100644 index 0000000..4a94ab1 --- /dev/null +++ b/repaso lista circular/funciones.c @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: %d \t",d->numero); +} diff --git a/repaso lista circular/header.h b/repaso lista circular/header.h new file mode 100644 index 0000000..c618507 --- /dev/null +++ b/repaso lista circular/header.h @@ -0,0 +1,9 @@ +#include "primitivas_lista_circular.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); diff --git a/repaso lista circular/main.c b/repaso lista circular/main.c new file mode 100644 index 0000000..bb0b287 --- /dev/null +++ b/repaso lista circular/main.c @@ -0,0 +1,47 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA CIRCULAR \n\a\a"); + + t_lista lista; + t_dato dato; + + crear_lista(&lista); + printf("\n Se ha creado una lista \n"); + + printf("\n Carga de 5 datos \n"); + int i; + for(i=0;i<5;i++) + { + cargar_dato(&dato); + poner_en_lista(&lista,&dato); + } + printf("\n\n Se han cargado 5 números en la lista \n"); + + if(!lista_llena(&lista)) + printf("\n\n La lista no está llena \n\n"); + + ver_primero_de_lista(&lista,&dato); + printf("\n\n El primero de la lista es: %d \n",dato.numero); + + printf("\n\n Sacar todo de la lista \n"); + while(!lista_vacia(&lista)) + { + sacar_de_lista(&lista,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desalistado todo \n"); + + printf("\n Carga de un dato \n"); + cargar_dato(&dato); + poner_en_lista(&lista,&dato); + + vaciar_lista(&lista); + printf("\n La lista fue vaciada \n"); + + printf("\n\n\t\t\t\t\t Fin del programa.. \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso lista circular/obj/Debug/funciones.o b/repaso lista circular/obj/Debug/funciones.o new file mode 100644 index 0000000..d0cb572 Binary files /dev/null and b/repaso lista circular/obj/Debug/funciones.o differ diff --git a/repaso lista circular/obj/Debug/main.o b/repaso lista circular/obj/Debug/main.o new file mode 100644 index 0000000..fab3f2d Binary files /dev/null and b/repaso lista circular/obj/Debug/main.o differ diff --git a/repaso lista circular/obj/Debug/primitivas_lista_circular.o b/repaso lista circular/obj/Debug/primitivas_lista_circular.o new file mode 100644 index 0000000..5debd16 Binary files /dev/null and b/repaso lista circular/obj/Debug/primitivas_lista_circular.o differ diff --git a/repaso lista circular/primitivas_lista_circular.c b/repaso lista circular/primitivas_lista_circular.c new file mode 100644 index 0000000..57bcd5b --- /dev/null +++ b/repaso lista circular/primitivas_lista_circular.c @@ -0,0 +1,74 @@ +#include "primitivas_lista_circular.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int poner_en_lista(t_lista *l,const t_dato *d) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + + nue->dato=*d; + if(*l) + { + nue->sig=(*l)->sig; + (*l)->sig=nue; + } + else + { + *l=nue; + nue->sig=nue; + } + return OK; +} + +int sacar_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + aux=(*l)->sig; + *d=aux->dato; + if(*l==aux) + *l=NULL; + else + (*l)->sig=aux->sig; + free(aux); + return OK; +} + +int ver_primero_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + *d=(*l)->dato; + return OK; +} + +void vaciar_lista(t_lista *l) +{ + t_nodo *aux,*pri=*l; + while(*l&&*l!=pri) + { + aux=*l; + l=&(*l)->sig; + free(aux); + } + free(*l); + *l=NULL; +} diff --git a/repaso lista circular/primitivas_lista_circular.h b/repaso lista circular/primitivas_lista_circular.h new file mode 100644 index 0000000..99d0745 --- /dev/null +++ b/repaso lista circular/primitivas_lista_circular.h @@ -0,0 +1,26 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int poner_en_lista(t_lista*,const t_dato*); +int sacar_de_lista(t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +void vaciar_lista(t_lista*); diff --git a/repaso lista circular/repaso lista circular.cbp b/repaso lista circular/repaso lista circular.cbp new file mode 100644 index 0000000..38f6f4b --- /dev/null +++ b/repaso lista circular/repaso lista circular.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso lista circular/repaso lista circular.depend b/repaso lista circular/repaso lista circular.depend new file mode 100644 index 0000000..8771947 --- /dev/null +++ b/repaso lista circular/repaso lista circular.depend @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1478981630 source:d:\unlam\programaciÓn\fabian\repaso lista circular\funciones.c + "header.h" + +1478981554 d:\unlam\programaciÓn\fabian\repaso lista circular\header.h + "primitivas_lista_circular.h" + + + + + +1478982388 d:\unlam\programaciÓn\fabian\repaso lista circular\primitivas_lista_circular.h + "dato.h" + + + + + +1478981308 d:\unlam\programaciÓn\fabian\repaso lista circular\dato.h + +1478984229 source:d:\unlam\programaciÓn\fabian\repaso lista circular\main.c + "header.h" + +1478984235 source:d:\unlam\programaciÓn\fabian\repaso lista circular\primitivas_lista_circular.c + "primitivas_lista_circular.h" + diff --git a/repaso lista circular/repaso lista circular.layout b/repaso lista circular/repaso lista circular.layout new file mode 100644 index 0000000..c9b4b98 --- /dev/null +++ b/repaso lista circular/repaso lista circular.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso lista doblemente enlazada/bin/Debug/repaso lista doblemente enlazada.exe b/repaso lista doblemente enlazada/bin/Debug/repaso lista doblemente enlazada.exe new file mode 100644 index 0000000..3268907 Binary files /dev/null and b/repaso lista doblemente enlazada/bin/Debug/repaso lista doblemente enlazada.exe differ diff --git a/repaso lista doblemente enlazada/dato.h b/repaso lista doblemente enlazada/dato.h new file mode 100644 index 0000000..1334a6b --- /dev/null +++ b/repaso lista doblemente enlazada/dato.h @@ -0,0 +1,4 @@ +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso lista doblemente enlazada/funciones.c b/repaso lista doblemente enlazada/funciones.c new file mode 100644 index 0000000..7b8c093 --- /dev/null +++ b/repaso lista doblemente enlazada/funciones.c @@ -0,0 +1,31 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n DATO: \t %d \n",d->numero); +} + +int comparar_dato(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} + +int comparar_clave(const void *v,const void *c) +{ + t_dato *e=(t_dato*)v; + int *clave=(int*)c; + return e->numero-*clave; +} + +void mostrar_nodo(const void *v) +{ + t_dato *e=(t_dato*)v; + printf("\n NODO: %d \n",e->numero); +} diff --git a/repaso lista doblemente enlazada/header.h b/repaso lista doblemente enlazada/header.h new file mode 100644 index 0000000..eaeb715 --- /dev/null +++ b/repaso lista doblemente enlazada/header.h @@ -0,0 +1,12 @@ +#include "lista_doblemente_enlazada.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); +int comparar_dato(const void*,const void*); +int comparar_clave(const void*,const void*); +void mostrar_nodo(const void*); diff --git a/repaso lista doblemente enlazada/lista_doblemente_enlazada.c b/repaso lista doblemente enlazada/lista_doblemente_enlazada.c new file mode 100644 index 0000000..88cf49b --- /dev/null +++ b/repaso lista doblemente enlazada/lista_doblemente_enlazada.c @@ -0,0 +1,236 @@ +#include "lista_doblemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int insertar_en_lista_ordenada_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(!(cmp=comparar((void*)&act->dato,(void*)d))) + return DUPLICADO; + if(cmp>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + act->dato=*d; + act->ant=ant; + act->sig=sig; + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + *l=act; + return OK; +} + +int insertar_en_lista_ordenada_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + if(comparar((void*)&act->dato,(void*)d)>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + act->dato=*d; + act->ant=ant; + act->sig=sig; + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + *l=act; + return OK; +} + +int eliminar_de_lista_ordenada_por_clave(t_lista *l,t_dato *d,void *clave,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant; + t_nodo *sig; + if(!act) + return LISTA_VACIA; + while(comparar((void*)&act->dato,clave)<0) + act=act->sig; + while(comparar((void*)&act->dato,clave)>0) + act=act->ant; + if(comparar((void*)&act->dato,clave)) + return NO_ENCONTRADO; + *d=act->dato; + ant=act->ant; + sig=act->sig; + if(ant) + { + ant->sig=act->sig; + *l=ant; + } + if(sig) + { + sig->ant=act->ant; + *l=sig; + } + if(!ant&&!sig) + *l=NULL; + free(act); + return OK; +} + +int eliminar_primero_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + while((*l)->ant) + l=&(*l)->ant; + aux=*l; + l=&(*l)->sig; + (*l)->ant=NULL; + *d=aux->dato; + free(aux); + return OK; +} + +int eliminar_ultimo_de_lista(t_lista *l,t_dato *d) +{ + t_nodo *aux; + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + aux=*l; + l=&(*l)->ant; + (*l)->sig=NULL; + *d=aux->dato; + free(aux); + return OK; +} + +int ver_nodo_actual_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + *d=(*l)->dato; + return OK; +} + +int ver_primero_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->ant) + l=&(*l)->ant; + *d=(*l)->dato; + return OK; +} + +int ver_ultimo_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + *d=(*l)->dato; + return OK; +} + +void mostrar_lista_orden_ascendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->ant) + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + while((*l)->sig) + { + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + } +} + +void mostrar_lista_orden_descendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->sig) + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + while((*l)->ant) + { + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + } +} + +int contar_nodos_de_lista(const t_lista *l) +{ + int cont=0; + while((*l)->ant) + l=&(*l)->ant; + if(*l) + cont++; + while((*l)->sig) + { + l=&(*l)->sig; + cont++; + } + return cont; +} + +void vaciar_lista(t_lista *l) +{ + t_nodo *aux; + while((*l)->ant) + l=&(*l)->ant; + while((*l)->sig) + { + aux=*l; + l=&(*l)->sig; + free(aux); + } + *l=NULL; +} diff --git a/repaso lista doblemente enlazada/lista_doblemente_enlazada.h b/repaso lista doblemente enlazada/lista_doblemente_enlazada.h new file mode 100644 index 0000000..b1b87c4 --- /dev/null +++ b/repaso lista doblemente enlazada/lista_doblemente_enlazada.h @@ -0,0 +1,40 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *ant; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int insertar_en_lista_ordenada_sin_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenada_con_duplicado(t_lista*,const t_dato*,t_cmp); +int eliminar_de_lista_ordenada_por_clave(t_lista*,t_dato*,void*,t_cmp); +int eliminar_primero_de_lista(t_lista*,t_dato*); +int eliminar_ultimo_de_lista(t_lista*,t_dato*); +int ver_nodo_actual_de_lista(const t_lista*,t_dato*); +int ver_primero_de_lista(const t_lista*,t_dato*); +int ver_ultimo_de_lista(const t_lista*,t_dato*); +void mostrar_lista_orden_ascendente(const t_lista*,t_mst); +void mostrar_lista_orden_descendente(const t_lista*,t_mst); +int contar_nodos_de_lista(const t_lista*); +void vaciar_lista(t_lista*); diff --git a/repaso lista doblemente enlazada/main.c b/repaso lista doblemente enlazada/main.c new file mode 100644 index 0000000..503bb80 --- /dev/null +++ b/repaso lista doblemente enlazada/main.c @@ -0,0 +1,83 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA DOBLEMENTE ENLAZADA \n\a\a"); + + t_lista lista; + t_dato dato; + + crear_lista(&lista); + printf("\n Se ha creado una lista \n"); + + if(lista_vacia(&lista)) + printf("\n La lista está vacía \n"); + + printf("\n\n Cargue algunos elementos a la lista \n"); + int i; + for(i=0;i<7;i++) + { + cargar_dato(&dato); + if(!insertar_en_lista_ordenada_sin_duplicado(&lista,&dato,comparar_dato)) + printf("\n Duplicado \n"); + } + printf("\n La lista ya tiene elementos \n\n"); + + if(!lista_llena(&lista)) + printf("\n La lista no está llena \n"); + + printf("\n Lista en orden ascendente \n"); + mostrar_lista_orden_ascendente(&lista,mostrar_nodo); + + printf("\n Eliminar el primero de la lista \n"); + if(eliminar_primero_de_lista(&lista,&dato)) + { + printf("\n Nodo eliminado: \n"); + mostrar_dato(&dato); + } + + printf("\n Eliminar el último de la lista \n"); + if(eliminar_ultimo_de_lista(&lista,&dato)) + { + printf("\n Nodo eliminado: \n"); + mostrar_dato(&dato); + } + + printf("\n\n Lista en orden descendente \n"); + mostrar_lista_orden_descendente(&lista,mostrar_nodo); + + printf("\n Eliminar un nodo \n"); + printf("\n Cargue una clave a eliminar: \n"); + int clave; + printf("\n Ingrese clave (número): \t"); + scanf("%d",&clave); + if(eliminar_de_lista_ordenada_por_clave(&lista,&dato,(void*)&clave,comparar_clave)) + { + printf("\n Nodo eliminado: \n"); + mostrar_dato(&dato); + } + else + printf("\n El nodo no fue encontrado \n"); + + printf("\n Ver nodo actual de la lista \n"); + ver_nodo_actual_de_lista(&lista,&dato); + mostrar_dato(&dato); + + printf("\n Ver primero de la lista \n"); + ver_primero_de_lista(&lista,&dato); + mostrar_dato(&dato); + + printf("\n Ver último de la lista \n"); + ver_ultimo_de_lista(&lista,&dato); + mostrar_dato(&dato); + + printf("\n Cantidad de nodos: \t %d \n",contar_nodos_de_lista(&lista)); + + vaciar_lista(&lista); + printf("\n La lista fue vaciada \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso lista doblemente enlazada/obj/Debug/funciones.o b/repaso lista doblemente enlazada/obj/Debug/funciones.o new file mode 100644 index 0000000..7b3889d Binary files /dev/null and b/repaso lista doblemente enlazada/obj/Debug/funciones.o differ diff --git a/repaso lista doblemente enlazada/obj/Debug/lista_doblemente_enlazada.o b/repaso lista doblemente enlazada/obj/Debug/lista_doblemente_enlazada.o new file mode 100644 index 0000000..7122993 Binary files /dev/null and b/repaso lista doblemente enlazada/obj/Debug/lista_doblemente_enlazada.o differ diff --git a/repaso lista doblemente enlazada/obj/Debug/main.o b/repaso lista doblemente enlazada/obj/Debug/main.o new file mode 100644 index 0000000..8cb4f48 Binary files /dev/null and b/repaso lista doblemente enlazada/obj/Debug/main.o differ diff --git a/repaso lista doblemente enlazada/repaso lista doblemente enlazada.cbp b/repaso lista doblemente enlazada/repaso lista doblemente enlazada.cbp new file mode 100644 index 0000000..e62f192 --- /dev/null +++ b/repaso lista doblemente enlazada/repaso lista doblemente enlazada.cbp @@ -0,0 +1,53 @@ + + + + + + diff --git a/repaso lista doblemente enlazada/repaso lista doblemente enlazada.depend b/repaso lista doblemente enlazada/repaso lista doblemente enlazada.depend new file mode 100644 index 0000000..01bbc14 --- /dev/null +++ b/repaso lista doblemente enlazada/repaso lista doblemente enlazada.depend @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1479057385 source:d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada\funciones.c + "header.h" + +1479050427 d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada\header.h + "lista_doblemente_enlazada.h" + + + + + +1479054562 d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada\lista_doblemente_enlazada.h + "dato.h" + + + + + +1479049989 d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada\dato.h + +1479057457 source:d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada\lista_doblemente_enlazada.c + "lista_doblemente_enlazada.h" + +1479057495 source:d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada\main.c + "header.h" + diff --git a/repaso lista doblemente enlazada/repaso lista doblemente enlazada.layout b/repaso lista doblemente enlazada/repaso lista doblemente enlazada.layout new file mode 100644 index 0000000..ad0ac2a --- /dev/null +++ b/repaso lista doblemente enlazada/repaso lista doblemente enlazada.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso lista doblemente enlazada_nuevo/bin/Debug/repaso lista doblemente enlazada_nuevo.exe b/repaso lista doblemente enlazada_nuevo/bin/Debug/repaso lista doblemente enlazada_nuevo.exe new file mode 100644 index 0000000..4e04574 Binary files /dev/null and b/repaso lista doblemente enlazada_nuevo/bin/Debug/repaso lista doblemente enlazada_nuevo.exe differ diff --git a/repaso lista doblemente enlazada_nuevo/dato.h b/repaso lista doblemente enlazada_nuevo/dato.h new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/dato.h @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso lista doblemente enlazada_nuevo/funciones.c b/repaso lista doblemente enlazada_nuevo/funciones.c new file mode 100644 index 0000000..a628595 --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/funciones.c @@ -0,0 +1,25 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1; + int *e2=(int*)v2; + return *e1-*e2; +} + +void mostrar_nodo(const void *v) +{ + int *e=(int *)v; + printf("\t %d",*e); +} diff --git a/repaso lista doblemente enlazada_nuevo/header.h b/repaso lista doblemente enlazada_nuevo/header.h new file mode 100644 index 0000000..ccfe5e5 --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/header.h @@ -0,0 +1,12 @@ +#include "lista_doblemente_enlazada.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); + +int comparar_enteros(const void*,const void*); +void mostrar_nodo(const void*); diff --git a/repaso lista doblemente enlazada_nuevo/lista_doblemente_enlazada.c b/repaso lista doblemente enlazada_nuevo/lista_doblemente_enlazada.c new file mode 100644 index 0000000..499c25e --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/lista_doblemente_enlazada.c @@ -0,0 +1,213 @@ +#include "lista_doblemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int insertar_en_lista_ordenada_sin_duplicados(t_lista *l,const t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + + if(!(cmp=comparar((void*)&act->dato,(void*)d))) + return DUPLICADO; + + if(cmp>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + + act->dato=*d; + act->ant=ant; + act->sig=sig; + + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + + *l=act; + return OK; +} + +int insertar_en_lista_ordenada_con_duplicados(t_lista *l,const t_dato *d,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant=NULL; + t_nodo *sig=NULL; + + if(act) + { + while(act->sig&&comparar((void*)&act->dato,(void*)d)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)d)>0) + act=act->ant; + + if(comparar((void*)&act->dato,(void*)d)>0) + { + sig=act; + ant=act->ant; + } + else + { + ant=act; + sig=act->sig; + } + } + + act=(t_nodo*)malloc(sizeof(t_nodo)); + if(!act) + return MEMORIA_LLENA; + + act->dato=*d; + act->ant=ant; + act->sig=sig; + + if(ant) + ant->sig=act; + if(sig) + sig->ant=act; + + *l=act; + return OK; +} + +int eliminar_de_lista_ordenada_con_clave(t_lista *l,t_dato *d,void *clave,t_cmp comparar) +{ + t_nodo *act=*l; + t_nodo *ant; + t_nodo *sig; + + if(!act) + return LISTA_VACIA; + + while(act->sig&&comparar((void*)&act->dato,(void*)clave)<0) + act=act->sig; + while(act->ant&&comparar((void*)&act->dato,(void*)clave)>0) + act=act->ant; + + if(comparar((void*)&act->dato,(void*)clave)) + return NO_ENCONTRADO; + + *d=act->dato; + ant=act->ant; + sig=act->sig; + + if(ant) + { + ant->sig=sig; + *l=ant; + } + + if(sig) + { + sig->ant=ant; + *l=sig; + } + + if(!ant&&!sig) + *l=NULL; + + free(act); + return OK; +} + +int ver_primero_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + + while((*l)->ant) + l=&(*l)->ant; + + *d=(*l)->dato; + return OK; +} + +int ver_ultimo_de_lista(const t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + + while((*l)->sig) + l=&(*l)->sig; + + *d=(*l)->dato; + return OK; +} + +void mostrar_lista_orden_ascendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->ant) + l=&(*l)->ant; + + mostrar((void*)&(*l)->dato); + while((*l)->sig) + { + l=&(*l)->sig; + mostrar((void*)&(*l)->dato); + } +} + +void mostrar_lista_orden_descendente(const t_lista *l,t_mst mostrar) +{ + while((*l)->sig) + l=&(*l)->sig; + + mostrar((void*)&(*l)->dato); + while((*l)->ant) + { + l=&(*l)->ant; + mostrar((void*)&(*l)->dato); + } +} + +void vaciar_lista(t_lista *l) +{ + t_nodo *aux; + + while((*l)->sig) + l=&(*l)->sig; + + while((*l)->sig) + { + aux=*l; + l=&(*l)->sig; + free(aux); + } + + *l=NULL; +} diff --git a/repaso lista doblemente enlazada_nuevo/lista_doblemente_enlazada.h b/repaso lista doblemente enlazada_nuevo/lista_doblemente_enlazada.h new file mode 100644 index 0000000..18308b2 --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/lista_doblemente_enlazada.h @@ -0,0 +1,36 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define NO_ENCONTRADO 0 +#define DUPLICADO 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *ant; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_lista(t_lista*); +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); +int insertar_en_lista_ordenada_sin_duplicados(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenada_con_duplicados(t_lista*,const t_dato*,t_cmp); +int eliminar_de_lista_ordenada_con_clave(t_lista*,t_dato*,void*,t_cmp); +int ver_primero_de_lista(const t_lista*,t_dato*); +int ver_ultimo_de_lista(const t_lista*,t_dato*); +void mostrar_lista_orden_ascendente(const t_lista*,t_mst); +void mostrar_lista_orden_descendente(const t_lista*,t_mst); +void vaciar_lista(t_lista*); diff --git a/repaso lista doblemente enlazada_nuevo/main.c b/repaso lista doblemente enlazada_nuevo/main.c new file mode 100644 index 0000000..1eb3fda --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/main.c @@ -0,0 +1,64 @@ +#include "header.h" + +int main() +{ + t_lista lista; + t_dato dato; + + int i; + int clave; + + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + printf("\n\n \t\t LISTA DOBLEMENTE ENLAZADA \n\a\a"); + + crear_lista(&lista); + printf("\n\n Se ha creado una lista \n"); + + if(lista_vacia(&lista)) + printf("\n\n La lista está vacía \n"); + + printf("\n\n Carga de algunos elementos \n"); + for(i=0;i<7;i++) + { + cargar_dato(&dato); + insertar_en_lista_ordenada_sin_duplicados(&lista,&dato,comparar_enteros); + } + printf("\n\n Se han cargado algunos elementos \n"); + + if(!lista_llena(&lista)) + printf("\n\n La lista no está llena \n"); + + printf("\n\n Primero de la lista \n"); + ver_primero_de_lista(&lista,&dato); + mostrar_dato(&dato); + + printf("\n\n Último de la lista \n"); + ver_ultimo_de_lista(&lista,&dato); + mostrar_dato(&dato); + + printf("\n\n Eliminar por clave (tres eliminaciones) \n"); + for(i=0;i<3;i++) + { + printf("\n\n Ingrese clave a eliminar: \t"); + scanf("%d",&clave); + if(eliminar_de_lista_ordenada_con_clave(&lista,&dato,(void*)&clave,comparar_enteros)) + printf("\n\n Se ha eliminado el nodo exitosamente \n"); + else + printf("\n\n No se ha encontrado un dato con esa clave \n"); + } + + printf("\n\n Lista en orden ascendente \n\n"); + mostrar_lista_orden_ascendente(&lista,mostrar_nodo); + + printf("\n\n Lista en orden descendente \n\n"); + mostrar_lista_orden_descendente(&lista,mostrar_nodo); + + vaciar_lista(&lista); + printf("\n\n La lista se ha vaciado \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n \a\a"); + getch(); + return 0; +} diff --git a/repaso lista doblemente enlazada_nuevo/obj/Debug/funciones.o b/repaso lista doblemente enlazada_nuevo/obj/Debug/funciones.o new file mode 100644 index 0000000..932d5a2 Binary files /dev/null and b/repaso lista doblemente enlazada_nuevo/obj/Debug/funciones.o differ diff --git a/repaso lista doblemente enlazada_nuevo/obj/Debug/lista_doblemente_enlazada.o b/repaso lista doblemente enlazada_nuevo/obj/Debug/lista_doblemente_enlazada.o new file mode 100644 index 0000000..a274ecc Binary files /dev/null and b/repaso lista doblemente enlazada_nuevo/obj/Debug/lista_doblemente_enlazada.o differ diff --git a/repaso lista doblemente enlazada_nuevo/obj/Debug/main.o b/repaso lista doblemente enlazada_nuevo/obj/Debug/main.o new file mode 100644 index 0000000..4f97ac8 Binary files /dev/null and b/repaso lista doblemente enlazada_nuevo/obj/Debug/main.o differ diff --git a/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.cbp b/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.cbp new file mode 100644 index 0000000..92c7b36 --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.depend b/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.depend new file mode 100644 index 0000000..0044e2c --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.depend @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1480041342 source:d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada_nuevo\funciones.c + "header.h" + +1480035820 d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada_nuevo\header.h + "lista_doblemente_enlazada.h" + + + + + +1480041300 d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada_nuevo\lista_doblemente_enlazada.h + "dato.h" + + + + + +1480033719 d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada_nuevo\dato.h + +1480041615 source:d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada_nuevo\lista_doblemente_enlazada.c + "lista_doblemente_enlazada.h" + +1480041703 source:d:\unlam\programaciÓn\fabian\repaso lista doblemente enlazada_nuevo\main.c + "header.h" + diff --git a/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.layout b/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.layout new file mode 100644 index 0000000..eb3030e --- /dev/null +++ b/repaso lista doblemente enlazada_nuevo/repaso lista doblemente enlazada_nuevo.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso lista simplemente enlazada/bin/Debug/repaso lista simplemente enlazada.exe b/repaso lista simplemente enlazada/bin/Debug/repaso lista simplemente enlazada.exe new file mode 100644 index 0000000..d2f6bf4 Binary files /dev/null and b/repaso lista simplemente enlazada/bin/Debug/repaso lista simplemente enlazada.exe differ diff --git a/repaso lista simplemente enlazada/dato.h b/repaso lista simplemente enlazada/dato.h new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ b/repaso lista simplemente enlazada/dato.h @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso lista simplemente enlazada/functions.c b/repaso lista simplemente enlazada/functions.c new file mode 100644 index 0000000..e8699aa --- /dev/null +++ b/repaso lista simplemente enlazada/functions.c @@ -0,0 +1,18 @@ +#include "header.h" + +void cargar_dato(t_dato *dato) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&dato->numero); +} + +void mostrar_dato(t_dato *dato) +{ + printf("\n DATO: \t %d",dato->numero); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} diff --git a/repaso lista simplemente enlazada/header.h b/repaso lista simplemente enlazada/header.h new file mode 100644 index 0000000..155e5d5 --- /dev/null +++ b/repaso lista simplemente enlazada/header.h @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +#include "lista_simplemente_enlazada.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); + +int comparar_enteros(const void*,const void*); diff --git a/repaso lista simplemente enlazada/lista_simplemente_enlazada.c b/repaso lista simplemente enlazada/lista_simplemente_enlazada.c new file mode 100644 index 0000000..37ba78f --- /dev/null +++ b/repaso lista simplemente enlazada/lista_simplemente_enlazada.c @@ -0,0 +1,232 @@ +#include "lista_simplemente_enlazada.h" + +void crear_lista(t_lista *l) +{ + *l=NULL; +} + +void vaciar_lista(t_lista *l) +{ + t_nodo *aux; + while(*l) + { + aux=*l; + (*l)=aux->sig; + free(aux); + } +} + +int lista_vacia(const t_lista *l) +{ + return *l==NULL; +} + +int lista_llena(const t_lista *l) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int poner_en_lista_primero(t_lista *l,const t_dato *d) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; +} + +int poner_en_lista_ultimo(t_lista *l,const t_dato *d) +{ + while(*l) + l=&(*l)->sig; + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato=*d; + (*l)->sig=NULL; + return OK; +} + +int sacar_de_lista_primero(t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + t_nodo *aux=*l; + *d=aux->dato; + *l=aux->sig; + free(aux); + return OK; +} + +int sacar_de_lista_ultimo(t_lista *l,t_dato *d) +{ + if(!*l) + return LISTA_VACIA; + while((*l)->sig) + l=&(*l)->sig; + t_nodo *aux=*l; + *d=aux->dato; + *l=NULL; + free(aux); + return OK; +} + +int insertar_en_lista_por_posicion(t_lista *l,const t_dato *d,unsigned *pos) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + while(*l&&*pos-->1) + l=&(*l)->sig; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; +} + +int insertar_en_lista_ordenada_con_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + while(*l&&comparar((void*)&(*l)->dato,(void*)d)<=0) + l=&(*l)->sig; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; +} +/* +int insertar_en_lista_ordenada_sin_duplicado(t_lista l*,const t_dato *d,t_cmp comparar) +{ + int cmp; + while(*l&&(cmp=comparar((void*)&(*l)->sig,(void*)d))<0) + { + if(!cmp) + return DUPLICADO; + l=&(*l)->sig; + } + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; +} + + ESTA FUNCIÓN ANDA PERO LA PODEMOS RETOCAR PARA QUE SEA UN POCO MÁS EFICIENTE--> QUEDA ASÍ +*/ + +int insertar_en_lista_ordenada_sin_duplicado(t_lista *l,const t_dato *d,t_cmp comparar) +{ + while(*l&&comparar((void*)&(*l)->sig,(void*)d)<0) + l=&(*l)->sig; + if(*l&&!comparar((void*)&(*l)->sig,(void*)d)) + return DUPLICADO; + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*l; + *l=nue; + return OK; +} + +/* + esta función solo tiene sentido si se implementa un tipo de dato que contenga un campo clave y un campo contador de la cantidad de repeticiones + +int insertar_en_lista_si_no_existe_clave(t_lista *l,const t_dato *d,int clave) +{ + while(*l&&(*l)->dato.clave!=clave) + l=&(*l)->sig; + if(*l) + { + (*l)->dato.cant_rep++; + return CLAVE_DUPLICADA;//return 1, ya que la inserción no se hizo pero se aumentó el contador de la cantidad de repeticiones + } + *l=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*l) + return MEMORIA_LLENA; + (*l)->dato.clave=clave; + (*l)->dato.cant_rep=0; + (*l)->sig=NULL; + return OK; +} +*/ + +int buscar_en_lista_ordenada(t_lista *l,const t_dato *d,t_cmp comparar) +{ + while(*l&&comparar((void*)&(*l)->sig,(void*)d)<0) + l=&(*l)->sig; + if(*l&&!comparar((void*)&(*l)->sig,(void*)d)) + return NO_ENCONTRADO; + return ENCONTRADO; +} + +int buscar_en_lista_desordenada(t_lista *l,const t_dato *d,t_cmp comparar) +{ + while(*l&&comparar((void*)&(*l)->sig,(void*)d)) + l=&(*l)->sig; + if(*l) + return NO_ENCONTRADO; + return ENCONTRADO; +} + +int eliminar_por_clave_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) +{ + while(*l&&comparar((void*)&(*l)->dato,(void*)clave)<0) + l=&(*l)->sig; + if(*l&&comparar((void*)&(*l)->dato,(void*)clave)) + return NO_ENCONTRADO; + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; +} + +int eliminar_por_clave_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) +{ + while(*l&&comparar((void*)&(*l)->dato,(void*)clave)!=0) + l=&(*l)->sig; + if(!*l) + return NO_ENCONTRADO; + t_nodo *aux=*l; + *l=aux->sig; + free(aux); + return OK; +} + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista *l,void *clave,t_cmp comparar) +{ + t_nodo *aux; + while(*l&&comparar((void*)&(*l)->dato,(void*)clave)<0) + { + if(!comparar((void*)&(*l)->dato,(void*)clave)) + { + aux=*l; + *l=aux->sig; + free(aux); + } + l=&(*l)->sig; + } +} + +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista *l,void *clave,t_cmp comparar) +{ + t_nodo *aux; + while(*l) + { + if(!comparar((void*)&(*l)->dato,(void*)clave)) + { + aux=*l; + *l=aux->sig; + free(aux); + } + l=&(*l)->sig; + } +} diff --git a/repaso lista simplemente enlazada/lista_simplemente_enlazada.h b/repaso lista simplemente enlazada/lista_simplemente_enlazada.h new file mode 100644 index 0000000..0074387 --- /dev/null +++ b/repaso lista simplemente enlazada/lista_simplemente_enlazada.h @@ -0,0 +1,49 @@ +#include "dato.h" + +#include +#include + +#define LISTA_VACIA 0 +#define MEMORIA_LLENA 0 +#define ENCONTRADO 0 +#define NO_ENCONTRADO 0 +#define DUPLICADO 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +typedef int(*t_cmp)(const void*,const void*); + +void crear_lista(t_lista*); +void vaciar_lista(t_lista*); + +int lista_vacia(const t_lista*); +int lista_llena(const t_lista*); + +int poner_en_lista_primero(t_lista*,const t_dato*); +int poner_en_lista_ultimo(t_lista*,const t_dato*); + +int sacar_de_lista_primero(t_lista*,t_dato*); +int sacar_de_lista_ultimo(t_lista*,t_dato*); + +int insertar_en_lista_por_posicion(t_lista*,const t_dato*,unsigned*); + +int insertar_en_lista_ordenada_con_duplicado(t_lista*,const t_dato*,t_cmp); +int insertar_en_lista_ordenada_sin_duplicado(t_lista*,const t_dato*,t_cmp); + +//int insertar_en_lista_si_no_existe_clave(t_lista*,const t_dato*,int); + +int buscar_en_lista_ordenada(t_lista*,const t_dato*,t_cmp); +int buscar_en_lista_desordenada(t_lista*,const t_dato*,t_cmp); + +int eliminar_por_clave_en_lista_ordenada(t_lista*,void*,t_cmp); +int eliminar_por_clave_en_lista_desordenada(t_lista*,void*,t_cmp); + +void eliminar_todas_ocurrencias_en_lista_ordenada(t_lista*,void*,t_cmp); +void eliminar_todas_ocurrencias_en_lista_desordenada(t_lista*,void*,t_cmp); diff --git a/repaso lista simplemente enlazada/main.c b/repaso lista simplemente enlazada/main.c new file mode 100644 index 0000000..29e8aab --- /dev/null +++ b/repaso lista simplemente enlazada/main.c @@ -0,0 +1,14 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n LISTA SIMPLEMENTE ENLAZADA \n\a\a"); + + ///acá habría que probarlas + ///lo que yo quería era repasar las primitivas + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/repaso lista simplemente enlazada/obj/Debug/functions.o b/repaso lista simplemente enlazada/obj/Debug/functions.o new file mode 100644 index 0000000..90d068d Binary files /dev/null and b/repaso lista simplemente enlazada/obj/Debug/functions.o differ diff --git a/repaso lista simplemente enlazada/obj/Debug/lista_simplemente_enlazada.o b/repaso lista simplemente enlazada/obj/Debug/lista_simplemente_enlazada.o new file mode 100644 index 0000000..3141ec1 Binary files /dev/null and b/repaso lista simplemente enlazada/obj/Debug/lista_simplemente_enlazada.o differ diff --git a/repaso lista simplemente enlazada/obj/Debug/main.o b/repaso lista simplemente enlazada/obj/Debug/main.o new file mode 100644 index 0000000..c2d71bd Binary files /dev/null and b/repaso lista simplemente enlazada/obj/Debug/main.o differ diff --git a/repaso lista simplemente enlazada/repaso lista simplemente enlazada.cbp b/repaso lista simplemente enlazada/repaso lista simplemente enlazada.cbp new file mode 100644 index 0000000..690cd3e --- /dev/null +++ b/repaso lista simplemente enlazada/repaso lista simplemente enlazada.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso lista simplemente enlazada/repaso lista simplemente enlazada.depend b/repaso lista simplemente enlazada/repaso lista simplemente enlazada.depend new file mode 100644 index 0000000..a56d3a6 --- /dev/null +++ b/repaso lista simplemente enlazada/repaso lista simplemente enlazada.depend @@ -0,0 +1,24 @@ +# depslib dependency file v1.0 +1477003961 source:d:\unlam\programaciÓn\fabian\repaso lista simplemente enlazada\functions.c + "header.h" + +1477003704 d:\unlam\programaciÓn\fabian\repaso lista simplemente enlazada\header.h + + + + + "lista_simplemente_enlazada.h" + +1477013335 d:\unlam\programaciÓn\fabian\repaso lista simplemente enlazada\lista_simplemente_enlazada.h + "dato.h" + + + +1477002959 d:\unlam\programaciÓn\fabian\repaso lista simplemente enlazada\dato.h + +1477009083 source:d:\unlam\programaciÓn\fabian\repaso lista simplemente enlazada\main.c + "header.h" + +1477013481 source:d:\unlam\programaciÓn\fabian\repaso lista simplemente enlazada\lista_simplemente_enlazada.c + "lista_simplemente_enlazada.h" + diff --git a/repaso lista simplemente enlazada/repaso lista simplemente enlazada.layout b/repaso lista simplemente enlazada/repaso lista simplemente enlazada.layout new file mode 100644 index 0000000..0d20e99 --- /dev/null +++ b/repaso lista simplemente enlazada/repaso lista simplemente enlazada.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso matrices/bin/Debug/repaso matrices.exe b/repaso matrices/bin/Debug/repaso matrices.exe new file mode 100644 index 0000000..369b471 Binary files /dev/null and b/repaso matrices/bin/Debug/repaso matrices.exe differ diff --git a/repaso matrices/funciones.c b/repaso matrices/funciones.c new file mode 100644 index 0000000..9559033 --- /dev/null +++ b/repaso matrices/funciones.c @@ -0,0 +1,311 @@ +#include "header.h" + +void cargar_matriz(int m[][COL],int f,int c) +{ + int i,j; + for(i=0;i=0&&i=0&&j",m[x+i][y+j]); +} +*/ diff --git a/repaso matrices/header.h b/repaso matrices/header.h new file mode 100644 index 0000000..79e76fb --- /dev/null +++ b/repaso matrices/header.h @@ -0,0 +1,51 @@ +#include +#include +#include +#include + +#define FIL 4 +#define COL 4 + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_matriz(int[][COL],int,int); +void mostrar_matriz(int[][COL],int,int); + +void elementos_diagonal_principal(int[][COL],int,int); +void elementos_diagonal_secundaria(int[][COL],int,int); + +void triangulo_superior_diag_pral_sin_diag(int[][COL],int,int); +void triangulo_superior_diag_pral_con_diag(int[][COL],int,int); + +void triangulo_inferior_diag_pral_sin_diag(int[][COL],int,int); +void triangulo_inferior_diag_pral_con_diag(int[][COL],int,int); + +void triangulo_superior_diag_secund_sin_diag(int[][COL],int,int); +void triangulo_superior_diag_secund_con_diag(int[][COL],int,int); + +void triangulo_inferior_diag_secund_sin_diag(int[][COL],int,int); +void triangulo_inferior_diag_secund_con_diag(int[][COL],int,int); + +void triangulito_arriba_sin_diagonal(int[][COL],int,int); +void triangulito_arriba_con_diagonal(int[][COL],int,int); +void triangulito_abajo_sin_diagonal(int[][COL],int,int); +void triangulito_abajo_con_diagonal(int[][COL],int,int); + +void transpuesta_mostrar(int[][COL],int,int); +void transpuesta_in_situ(int[][COL],int,int); + +void opuesta_mostrar(int[][COL],int,int); + +int es_matriz_nula(int[][COL],int,int); +int es_matriz_diagonal(int[][COL],int,int); +int es_matriz_identidad(int[][COL],int,int); +int es_matriz_escalar(int[][COL],int,int); +int es_matriz_antisimetrica(int[][COL],int,int); + +int es_matriz_simetrica_respecto_diag_pral(int[][COL],int,int); +int es_matriz_simetrica_respecto_diag_secund(int[][COL],int,int); +int es_matriz_simetrica_horizontalmente(int[][COL],int,int); +int es_matriz_simetrica_verticalmente(int[][COL],int,int); + +void producto_matricial_cuadradas(int[][COL],int[][COL],int[][COL],int,int,int,int); +void vecinos(int[][COL],int,int,int,int); diff --git a/repaso matrices/main.c b/repaso matrices/main.c new file mode 100644 index 0000000..7e2db26 --- /dev/null +++ b/repaso matrices/main.c @@ -0,0 +1,174 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n \t\t MATRICES \n \a\a"); + + int mat[FIL][COL]; + + printf("\n\n Cargar matriz: \n"); + cargar_matriz(mat,FIL,COL); + + printf("\n\n Mostrar matriz: \n"); + mostrar_matriz(mat,FIL,COL); + + + + printf("\n\n\n Elementos de la diagonal principal \n\n"); + elementos_diagonal_principal(mat,FIL,COL); + + printf("\n\n Elementos de la diagonal secundaria \n\n"); + elementos_diagonal_secundaria(mat,FIL,COL); + + + + printf("\n\n Elementos triángulo superior a diagonal principal sin diag \n\n"); + triangulo_superior_diag_pral_sin_diag(mat,FIL,COL); + + printf("\n\n Elementos triángulo superior a diagonal principal con diag \n\n"); + triangulo_superior_diag_pral_con_diag(mat,FIL,COL); + + + + printf("\n\n Elementos triángulo superior a diagonal secundaria sin diag \n\n"); + triangulo_superior_diag_secund_sin_diag(mat,FIL,COL); + + printf("\n\n Elementos triángulo superior a diagonal secundaria con diag \n\n"); + triangulo_superior_diag_secund_con_diag(mat,FIL,COL); + + + + printf("\n\n Elementos triángulo inferior a diagonal principal sin diag \n\n"); + triangulo_inferior_diag_pral_sin_diag(mat,FIL,COL); + + printf("\n\n Elementos triángulo inferior a diagonal principal con diag \n\n"); + triangulo_inferior_diag_pral_con_diag(mat,FIL,COL); + + + + printf("\n\n Elementos triángulo inferior a diagonal secundaria sin diag \n\n"); + triangulo_inferior_diag_secund_sin_diag(mat,FIL,COL); + + printf("\n\n Elementos triángulo inferior a diagonal secundaria con diag \n\n"); + triangulo_inferior_diag_secund_con_diag(mat,FIL,COL); + + + + printf("\n\n Triangulito arriba sin diagonal \n\n"); + triangulito_arriba_sin_diagonal(mat,FIL,COL); + + printf("\n\n Triangulito arriba con diagonal \n\n"); + triangulito_arriba_con_diagonal(mat,FIL,COL); + + + + printf("\n\n Triangulito abajo sin diagonal \n\n"); + triangulito_abajo_sin_diagonal(mat,FIL,COL); + + printf("\n\n Triangulito abajo con diagonal \n\n"); + triangulito_abajo_con_diagonal(mat,FIL,COL); + + + + printf("\n\n\n Matriz original \n\n"); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n\n Mostrar transpuesta \n\n"); + transpuesta_mostrar(mat,FIL,COL); + + printf("\n\n\n Transpuesta in situ \n\n"); + transpuesta_in_situ(mat,FIL,COL); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n\n Transpuesta in situ \n\n "); + transpuesta_in_situ(mat,FIL,COL); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n\n Mostrar opuesta \n\n"); + opuesta_mostrar(mat,FIL,COL); + + + + printf("\n\n\n La matriz %s nula \n",es_matriz_nula(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s diagonal \n",es_matriz_diagonal(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s identidad \n",es_matriz_identidad(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s escalar \n",es_matriz_escalar(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s antisimétrica \n",es_matriz_antisimetrica(mat,FIL,COL)?"es":"no es"); + + + + printf("\n\n La matriz %s simétrica respecto diagonal principal \n",es_matriz_simetrica_respecto_diag_pral(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s simétrica respecto diagonal secundaria \n",es_matriz_simetrica_respecto_diag_secund(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s simétrica horizontalmente \n",es_matriz_simetrica_horizontalmente(mat,FIL,COL)?"es":"no es"); + + printf("\n\n La matriz %s simétrica verticalmente \n",es_matriz_simetrica_verticalmente(mat,FIL,COL)?"es":"no es"); + + + + printf("\n\n PRODUCTO MATRICIAL \n"); + int mat2[FIL][COL]; + int mat3[FIL][COL]; + + printf("\n\n Cargar una matriz con que multiplicar a la otra: \n"); + cargar_matriz(mat2,FIL,COL); + + printf("\n\n MATRIZ 1 \n"); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n MATRIZ 2: \n"); + mostrar_matriz(mat2,FIL,COL); + + printf("\n\n PRODUCTO \n"); + producto_matricial_cuadradas(mat,mat2,mat3,FIL,COL,FIL,COL); + mostrar_matriz(mat3,FIL,COL); + + int i,j,op,band; + do + { + printf("\a\a\a"); + printf("\n\n\n\t\t * VECINOS DE UN ELEMENTO DE LA MATRIZ *"); + printf("\n\n VECINDARIO \n"); + mostrar_matriz(mat,FIL,COL); + + printf("\n\n %c Descubra cuáles son los vecinos de alguien \n a partir de sus coordenadas en el vecindario: \n",16); + band=0; + do + { + if(band==1) + printf("\n\n Esa fila no está en el vecindario.\n\a\a"); + printf("\n Ingrese la fila (1 a %d): \t",FIL); + scanf("%d",&i); + band=1; + } + while(!DATO_VALIDO(i,1,FIL)); + band=0; + do + { + if(band==1) + printf("\n\n Esa columna no está en el vecindario.\n\a\a"); + printf("\n Ingrese la columna (1 a %d): \t",COL); + scanf("%d",&j); + band=1; + } + while(!DATO_VALIDO(j,1,COL)); + + printf("\n VECINOS: \n\n\a\a"); + vecinos(mat,FIL,COL,i-1,j-1); + + printf("\n\n ----------------------------------------------------------------------------- \n"); + printf("\n Para realizar una nueva búsqueda de vecinos, presione 1. \n\t Caso contrario, presione cualquier tecla:\t"); + scanf("%d",&op); + } + while(op==1); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n"); + getch(); + return 0; +} diff --git a/repaso matrices/obj/Debug/funciones.o b/repaso matrices/obj/Debug/funciones.o new file mode 100644 index 0000000..e0b6048 Binary files /dev/null and b/repaso matrices/obj/Debug/funciones.o differ diff --git a/repaso matrices/obj/Debug/main.o b/repaso matrices/obj/Debug/main.o new file mode 100644 index 0000000..61bc2e4 Binary files /dev/null and b/repaso matrices/obj/Debug/main.o differ diff --git a/repaso matrices/repaso matrices.cbp b/repaso matrices/repaso matrices.cbp new file mode 100644 index 0000000..a17b133 --- /dev/null +++ b/repaso matrices/repaso matrices.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/repaso matrices/repaso matrices.depend b/repaso matrices/repaso matrices.depend new file mode 100644 index 0000000..c23e888 --- /dev/null +++ b/repaso matrices/repaso matrices.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1476839820 source:d:\unlam\programaciÓn\fabian\repaso matrices\funciones.c + "header.h" + +1476837716 d:\unlam\programaciÓn\fabian\repaso matrices\header.h + + + + + +1476839571 source:d:\unlam\programaciÓn\fabian\repaso matrices\main.c + "header.h" + diff --git a/repaso matrices/repaso matrices.layout b/repaso matrices/repaso matrices.layout new file mode 100644 index 0000000..2bca7a4 --- /dev/null +++ b/repaso matrices/repaso matrices.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/repaso ordenamiento por seleccion simulacro qsort/bin/Debug/repaso ordenamiento por seleccion simulacro qsort.exe b/repaso ordenamiento por seleccion simulacro qsort/bin/Debug/repaso ordenamiento por seleccion simulacro qsort.exe new file mode 100644 index 0000000..2a52ae8 Binary files /dev/null and b/repaso ordenamiento por seleccion simulacro qsort/bin/Debug/repaso ordenamiento por seleccion simulacro qsort.exe differ diff --git a/repaso ordenamiento por seleccion simulacro qsort/functions.c b/repaso ordenamiento por seleccion simulacro qsort/functions.c new file mode 100644 index 0000000..a125f8f --- /dev/null +++ b/repaso ordenamiento por seleccion simulacro qsort/functions.c @@ -0,0 +1,56 @@ +#include "header.h" + +void *mem_cpy(void *destino,const void *origen,size_t tam_memb) +{ + void *inicio=destino; + while(tam_memb--) + { + *(char*)destino=*(char*)origen; + destino++; + origen++; + } + return inicio; +} + +void intercambio(void *v1,void *v2,size_t tam_memb) +{ + void *aux=malloc(tam_memb); + if(!aux) + exit(EXIT_FAILURE); + mem_cpy(aux,v1,tam_memb); + mem_cpy(v1,v2,tam_memb); + mem_cpy(v2,aux,tam_memb); + free(aux); +} + +void ordenamiento_por_seleccion(void *v,size_t n_memb,size_t tam_memb,t_cmp comparar) +{ + void *lector,*menor,*ult=v+(n_memb-1)*tam_memb; + while(v +#include +#include +#include + +#define TAM 10 + +void *mem_cpy(void*,const void*,size_t); + +typedef int(*t_cmp)(const void*,const void*); + +void intercambio(void*,void*,size_t); + +void ordenamiento_por_seleccion(void*,size_t,size_t,t_cmp); + +void mostrar_vector_enteros(int[],int); + +int comparar_enteros(const void*,const void*); diff --git a/repaso ordenamiento por seleccion simulacro qsort/main.c b/repaso ordenamiento por seleccion simulacro qsort/main.c new file mode 100644 index 0000000..eda6de0 --- /dev/null +++ b/repaso ordenamiento por seleccion simulacro qsort/main.c @@ -0,0 +1,20 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n ORDENAMIENTO POR SELECCIÓN \n\a\a"); + + int vec1[TAM]={4,8,9,6,5,7,3,1,0,2}; + + printf("\n\n Ordenando vector de enteros \n"); + printf("\n\n Antes \n\n"); + mostrar_vector_enteros(vec1,TAM); + printf("\n\n Después \n\n"); + ordenamiento_por_seleccion(vec1,TAM,sizeof(int),comparar_enteros); + mostrar_vector_enteros(vec1,TAM); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso ordenamiento por seleccion simulacro qsort/obj/Debug/functions.o b/repaso ordenamiento por seleccion simulacro qsort/obj/Debug/functions.o new file mode 100644 index 0000000..d9ec672 Binary files /dev/null and b/repaso ordenamiento por seleccion simulacro qsort/obj/Debug/functions.o differ diff --git a/repaso ordenamiento por seleccion simulacro qsort/obj/Debug/main.o b/repaso ordenamiento por seleccion simulacro qsort/obj/Debug/main.o new file mode 100644 index 0000000..d5dffa3 Binary files /dev/null and b/repaso ordenamiento por seleccion simulacro qsort/obj/Debug/main.o differ diff --git a/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.cbp b/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.cbp new file mode 100644 index 0000000..12714b6 --- /dev/null +++ b/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.depend b/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.depend new file mode 100644 index 0000000..c744cba --- /dev/null +++ b/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.depend @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1477016797 source:d:\unlam\programaciÓn\fabian\repaso ordenamiento por seleccion simulacro qsort\functions.c + "header.h" + +1477016302 d:\unlam\programaciÓn\fabian\repaso ordenamiento por seleccion simulacro qsort\header.h + + + + + +1477015685 source:d:\unlam\programaciÓn\fabian\repaso ordenamiento por seleccion simulacro qsort\main.c + "header.h" + diff --git a/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.layout b/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.layout new file mode 100644 index 0000000..19a6713 --- /dev/null +++ b/repaso ordenamiento por seleccion simulacro qsort/repaso ordenamiento por seleccion simulacro qsort.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/repaso pila circular/bin/Debug/repaso pila circular.exe b/repaso pila circular/bin/Debug/repaso pila circular.exe new file mode 100644 index 0000000..b6a936c Binary files /dev/null and b/repaso pila circular/bin/Debug/repaso pila circular.exe differ diff --git a/repaso pila circular/dato.h b/repaso pila circular/dato.h new file mode 100644 index 0000000..1334a6b --- /dev/null +++ b/repaso pila circular/dato.h @@ -0,0 +1,4 @@ +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso pila circular/funciones.c b/repaso pila circular/funciones.c new file mode 100644 index 0000000..6383757 --- /dev/null +++ b/repaso pila circular/funciones.c @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} diff --git a/repaso pila circular/header.h b/repaso pila circular/header.h new file mode 100644 index 0000000..745c30a --- /dev/null +++ b/repaso pila circular/header.h @@ -0,0 +1,9 @@ +#include "primitivas_pila_circular.h" + +#include +#include +#include +#include + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); diff --git a/repaso pila circular/main.c b/repaso pila circular/main.c new file mode 100644 index 0000000..b0cc2bd --- /dev/null +++ b/repaso pila circular/main.c @@ -0,0 +1,47 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PILA CIRCULAR \n"); + + t_lista pila; + t_dato dato; + + crear_pila(&pila); + printf("\n\n Se ha creado una pila \n"); + + printf("\n Carga de 5 elementos \n"); + int i; + for(i=0;i<5;i++) + { + cargar_dato(&dato); + apilar(&pila,&dato); + } + printf("\n La pila fue cargada \n"); + + if(!pila_llena(&pila)) + printf("\n La pila no está llena \n"); + + ver_tope(&pila,&dato); + printf("\n El tope de la pila es: \t %d \n",dato.numero); + + printf("\n Desapilar todo \n"); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + } + printf("\n Se desapiló todo \n"); + + printf("\n Apila algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + + vaciar_pila(&pila); + printf("\n La pila fue vaciada \n"); + + printf("\n\n\t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso pila circular/obj/Debug/funciones.o b/repaso pila circular/obj/Debug/funciones.o new file mode 100644 index 0000000..3dbb559 Binary files /dev/null and b/repaso pila circular/obj/Debug/funciones.o differ diff --git a/repaso pila circular/obj/Debug/main.o b/repaso pila circular/obj/Debug/main.o new file mode 100644 index 0000000..6e4fa22 Binary files /dev/null and b/repaso pila circular/obj/Debug/main.o differ diff --git a/repaso pila circular/obj/Debug/primitivas_pila_circular.o b/repaso pila circular/obj/Debug/primitivas_pila_circular.o new file mode 100644 index 0000000..c96864c Binary files /dev/null and b/repaso pila circular/obj/Debug/primitivas_pila_circular.o differ diff --git a/repaso pila circular/primitivas_pila_circular.c b/repaso pila circular/primitivas_pila_circular.c new file mode 100644 index 0000000..dc7c667 --- /dev/null +++ b/repaso pila circular/primitivas_pila_circular.c @@ -0,0 +1,69 @@ +#include "primitivas_pila_circular.h" + +void crear_pila(t_lista *p) +{ + *p=NULL; +} + +int pila_vacia(const t_lista *p) +{ + return *p==NULL; +} + +int pila_llena(const t_lista *p) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int apilar(t_lista *p,const t_dato *d) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + if(!*p) + *p=nue; + else + nue->sig=(*p)->sig; + (*p)->sig=nue; + return OK; +} + +int desapilar(t_lista *p,t_dato *d) +{ + t_nodo *aux; + if(!*p) + return PILA_VACIA; + aux=(*p)->sig; + *d=aux->dato; + if(*p==aux) + *p=NULL; + else + (*p)->sig=aux->sig; + free(aux); + return OK; +} + +int ver_tope(const t_lista *p,t_dato *d) +{ + if(!*p) + return PILA_VACIA; + *d=(*p)->sig->dato; + return OK; +} + +void vaciar_pila(t_lista *p) +{ + t_nodo *aux,*pri=*p; + *p=(*p)->sig; + while(*p&&*p!=pri) + { + aux=*p; + *p=aux->sig; + free(aux); + } + free(*p); + *p=NULL; +} diff --git a/repaso pila circular/primitivas_pila_circular.h b/repaso pila circular/primitivas_pila_circular.h new file mode 100644 index 0000000..28a7acb --- /dev/null +++ b/repaso pila circular/primitivas_pila_circular.h @@ -0,0 +1,26 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +void crear_pila(t_lista*); +int pila_vacia(const t_lista*); +int pila_llena(const t_lista*); +int apilar(t_lista*,const t_dato*); +int desapilar(t_lista*,t_dato*); +int ver_tope(const t_lista*,t_dato*); +void vaciar_pila(t_lista*); diff --git a/repaso pila circular/repaso pila circular.cbp b/repaso pila circular/repaso pila circular.cbp new file mode 100644 index 0000000..1e12c57 --- /dev/null +++ b/repaso pila circular/repaso pila circular.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/repaso pila circular/repaso pila circular.depend b/repaso pila circular/repaso pila circular.depend new file mode 100644 index 0000000..89daac4 --- /dev/null +++ b/repaso pila circular/repaso pila circular.depend @@ -0,0 +1,23 @@ +# depslib dependency file v1.0 +1478986542 source:d:\unlam\programaciÓn\fabian\repaso pila circular\funciones.c + "header.h" + +1478986454 d:\unlam\programaciÓn\fabian\repaso pila circular\header.h + "primitivas_pila_circular.h" + + + + + +1478990078 d:\unlam\programaciÓn\fabian\repaso pila circular\primitivas_pila_circular.h + "dato.h" + + + + + +1478986187 d:\unlam\programaciÓn\fabian\repaso pila circular\dato.h + +1478990050 source:d:\unlam\programaciÓn\fabian\repaso pila circular\main.c + "header.h" + diff --git a/repaso pila circular/repaso pila circular.layout b/repaso pila circular/repaso pila circular.layout new file mode 100644 index 0000000..a5e9365 --- /dev/null +++ b/repaso pila circular/repaso pila circular.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/repaso pila circular_nuevo/bin/Debug/repaso pila circular_nuevo.exe b/repaso pila circular_nuevo/bin/Debug/repaso pila circular_nuevo.exe new file mode 100644 index 0000000..63c627f Binary files /dev/null and b/repaso pila circular_nuevo/bin/Debug/repaso pila circular_nuevo.exe differ diff --git a/repaso pila circular_nuevo/dato.h b/repaso pila circular_nuevo/dato.h new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ b/repaso pila circular_nuevo/dato.h @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git a/repaso pila circular_nuevo/funciones.c b/repaso pila circular_nuevo/funciones.c new file mode 100644 index 0000000..6383757 --- /dev/null +++ b/repaso pila circular_nuevo/funciones.c @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} diff --git a/repaso pila circular_nuevo/header.h b/repaso pila circular_nuevo/header.h new file mode 100644 index 0000000..edc075b --- /dev/null +++ b/repaso pila circular_nuevo/header.h @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "pila circular.h" + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); diff --git a/repaso pila circular_nuevo/main.c b/repaso pila circular_nuevo/main.c new file mode 100644 index 0000000..56941fb --- /dev/null +++ b/repaso pila circular_nuevo/main.c @@ -0,0 +1,55 @@ +#include "header.h" + +int main() +{ + t_lista pila; + t_dato dato; + + int i; + + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + printf("\n\n \t\t PILA CIRCULAR \n\a\a"); + + crear_pila(&pila); + printf("\n\n Se ha creado una pila \n"); + + if(pila_vacia(&pila)) + printf("\n\n La pila está vacía \n"); + + printf("\n\n Carga de 5 datos \n"); + for(i=0;i<5;i++) + { + cargar_dato(&dato); + apilar(&pila,&dato); + } + printf("\n\n Se han cargado 5 datos \n"); + + if(!pila_llena(&pila)) + printf("\n\n La pila no está llena \n"); + + printf("\n\n Tope de la pila \n"); + ver_tope_de_pila(&pila,&dato); + mostrar_dato(&dato); + + printf("\n\n Desapilamos todo \n"); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desapilado todo \n"); + + printf("\n\n Apilo algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + printf("\n\n Se apiló algo"); + + vaciar_pila(&pila); + printf("\n\n Se ha desapilado todo \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git a/repaso pila circular_nuevo/obj/Debug/funciones.o b/repaso pila circular_nuevo/obj/Debug/funciones.o new file mode 100644 index 0000000..db5bb3c Binary files /dev/null and b/repaso pila circular_nuevo/obj/Debug/funciones.o differ diff --git a/repaso pila circular_nuevo/obj/Debug/main.o b/repaso pila circular_nuevo/obj/Debug/main.o new file mode 100644 index 0000000..8c97097 Binary files /dev/null and b/repaso pila circular_nuevo/obj/Debug/main.o differ diff --git a/repaso pila circular_nuevo/obj/Debug/pila circular.o b/repaso pila circular_nuevo/obj/Debug/pila circular.o new file mode 100644 index 0000000..db84da2 Binary files /dev/null and b/repaso pila circular_nuevo/obj/Debug/pila circular.o differ diff --git a/repaso pila circular_nuevo/pila circular.c b/repaso pila circular_nuevo/pila circular.c new file mode 100644 index 0000000..c60d61f --- /dev/null +++ b/repaso pila circular_nuevo/pila circular.c @@ -0,0 +1,69 @@ +#include "pila circular.h" + +void crear_pila(t_lista *p) +{ + *p=NULL; +} + +int pila_vacia(const t_lista *p) +{ + return *p==NULL; +} + +int pila_llena(const t_lista *p) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int apilar(t_lista *p,const t_dato *d) +{ + t_nodo *nuevo=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + if(!*p) + *p=nuevo; + else + nuevo->sig=(*p)->sig; + (*p)->sig=nuevo; + return OK; +} + +int desapilar(t_lista *p,t_dato *d) +{ + t_nodo *aux; + if(!*p) + return PILA_VACIA; + aux=(*p)->sig; + *d=aux->dato; + if(aux==*p) + *p=NULL; + else + (*p)->sig=aux->sig; + free(aux); + return OK; +} + +int ver_tope_de_pila(const t_lista *p,t_dato *d) +{ + if(!*p) + return PILA_VACIA; + *d=(*p)->sig->dato; + return OK; +} + +void vaciar_pila(t_lista *p) +{ + t_nodo *aux,*pri=*p; + *p=(*p)->sig; + while(*p&&*p!=pri) + { + aux=*p; + *p=(*p)->sig; + free(aux); + } + free(*p); + *p=NULL; +} diff --git a/repaso pila circular_nuevo/pila circular.h b/repaso pila circular_nuevo/pila circular.h new file mode 100644 index 0000000..10959db --- /dev/null +++ b/repaso pila circular_nuevo/pila circular.h @@ -0,0 +1,26 @@ +#include "dato.h" + +#include +#include +#include +#include + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_lista; + +void crear_pila(t_lista*); +int pila_vacia(const t_lista*); +int pila_llena(const t_lista*); +int apilar(t_lista*,const t_dato*); +int desapilar(t_lista*,t_dato*); +int ver_tope_de_pila(const t_lista*,t_dato*); +void vaciar_pila(t_lista*); diff --git a/repaso pila circular_nuevo/repaso pila circular_nuevo.cbp b/repaso pila circular_nuevo/repaso pila circular_nuevo.cbp new file mode 100644 index 0000000..8529d7a --- /dev/null +++ b/repaso pila circular_nuevo/repaso pila circular_nuevo.cbp @@ -0,0 +1,53 @@ + + + + + + diff --git a/repaso pila circular_nuevo/repaso pila circular_nuevo.depend b/repaso pila circular_nuevo/repaso pila circular_nuevo.depend new file mode 100644 index 0000000..f1511ed --- /dev/null +++ b/repaso pila circular_nuevo/repaso pila circular_nuevo.depend @@ -0,0 +1,26 @@ +# depslib dependency file v1.0 +1480027401 source:d:\unlam\programaciÓn\fabian\repaso pila circular_nuevo\funciones.c + "header.h" + +1480027225 d:\unlam\programaciÓn\fabian\repaso pila circular_nuevo\header.h + + + + + "pila circular.h" + +1480029976 d:\unlam\programaciÓn\fabian\repaso pila circular_nuevo\pila circular.h + "dato.h" + + + + + +1480026648 d:\unlam\programaciÓn\fabian\repaso pila circular_nuevo\dato.h + +1480030106 source:d:\unlam\programaciÓn\fabian\repaso pila circular_nuevo\main.c + "header.h" + +1480030080 source:d:\unlam\programaciÓn\fabian\repaso pila circular_nuevo\pila circular.c + "pila circular.h" + diff --git a/repaso pila circular_nuevo/repaso pila circular_nuevo.layout b/repaso pila circular_nuevo/repaso pila circular_nuevo.layout new file mode 100644 index 0000000..b6d4bd6 --- /dev/null +++ b/repaso pila circular_nuevo/repaso pila circular_nuevo.layout @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/repaso pila din\303\241mica/bin/Debug/repaso pila din\303\241mica.exe" "b/repaso pila din\303\241mica/bin/Debug/repaso pila din\303\241mica.exe" new file mode 100644 index 0000000..2385b68 Binary files /dev/null and "b/repaso pila din\303\241mica/bin/Debug/repaso pila din\303\241mica.exe" differ diff --git "a/repaso pila din\303\241mica/dato.h" "b/repaso pila din\303\241mica/dato.h" new file mode 100644 index 0000000..ce4f252 --- /dev/null +++ "b/repaso pila din\303\241mica/dato.h" @@ -0,0 +1,6 @@ + +typedef struct +{ + int numero; +}t_dato; + diff --git "a/repaso pila din\303\241mica/functions.c" "b/repaso pila din\303\241mica/functions.c" new file mode 100644 index 0000000..8eee6f6 --- /dev/null +++ "b/repaso pila din\303\241mica/functions.c" @@ -0,0 +1,13 @@ +#include "header.h" + +void cargar_dato(t_dato *dato) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&dato->numero); +} + +void mostrar_dato(t_dato *dato) +{ + printf("\n DATO: \t %d",dato->numero); +} + diff --git "a/repaso pila din\303\241mica/header.h" "b/repaso pila din\303\241mica/header.h" new file mode 100644 index 0000000..01832b9 --- /dev/null +++ "b/repaso pila din\303\241mica/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#include + +#include "primitivas_pila_dinámica.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); + diff --git "a/repaso pila din\303\241mica/main.c" "b/repaso pila din\303\241mica/main.c" new file mode 100644 index 0000000..8b4ad9b --- /dev/null +++ "b/repaso pila din\303\241mica/main.c" @@ -0,0 +1,50 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PILA DINÁMICA \n\a\a"); + + t_pila pila; + t_dato dato; + + crear_pila(&pila); + printf("\n\n Se ha creado una pila \n"); + + if(pila_vacia(&pila)) + printf("\n\n La pila está vacía \n\n"); + + printf("\n\n Apilar \n"); + int i; + for(i=0;i<5;i++) + { + cargar_dato(&dato); + apilar(&pila,&dato); + } + printf("\n\n Se ha cargado la pila \n"); + + printf("\n\n Ver tope \n"); + ver_tope(&pila,&dato); + mostrar_dato(&dato); + + printf("\n\n Desapilar \n"); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desapilado todo \n"); + + printf("\n\n Ingresar algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + printf("\n\n Se ha cargado algo \n"); + + vaciar_pila(&pila); + printf("\n\n Se ha vaciado la pila \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} + diff --git "a/repaso pila din\303\241mica/obj/Debug/functions.o" "b/repaso pila din\303\241mica/obj/Debug/functions.o" new file mode 100644 index 0000000..984c287 Binary files /dev/null and "b/repaso pila din\303\241mica/obj/Debug/functions.o" differ diff --git "a/repaso pila din\303\241mica/obj/Debug/main.o" "b/repaso pila din\303\241mica/obj/Debug/main.o" new file mode 100644 index 0000000..b61e78d Binary files /dev/null and "b/repaso pila din\303\241mica/obj/Debug/main.o" differ diff --git "a/repaso pila din\303\241mica/obj/Debug/primitivas_pila_din\303\241mica.o" "b/repaso pila din\303\241mica/obj/Debug/primitivas_pila_din\303\241mica.o" new file mode 100644 index 0000000..1500289 Binary files /dev/null and "b/repaso pila din\303\241mica/obj/Debug/primitivas_pila_din\303\241mica.o" differ diff --git "a/repaso pila din\303\241mica/primitivas_pila_din\303\241mica.c" "b/repaso pila din\303\241mica/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..b1b92af --- /dev/null +++ "b/repaso pila din\303\241mica/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,60 @@ +#include "primitivas_pila_dinámica.h" + +void crear_pila(t_pila *p) +{ + *p=NULL; +} + +int pila_vacia(const t_pila *p) +{ + return *p==NULL; +} + +int pila_llena(const t_pila *p) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +int apilar(t_pila *p,const t_dato *d) +{ + t_nodo *nue=(t_nodo*)malloc(sizeof(t_nodo)); + if(!nue) + return MEMORIA_LLENA; + nue->dato=*d; + nue->sig=*p; + *p=nue; + return OK; +} + +int desapilar(t_pila *p,t_dato *d) +{ + t_nodo *aux; + if(!*p) + return PILA_VACIA; + aux=*p; + *d=aux->dato; + *p=aux->sig; + free(aux); + return OK; +} + +int ver_tope(const t_pila *p,t_dato *d) +{ + if(!*p) + return PILA_VACIA; + *d=(*p)->dato; + return OK; +} + +void vaciar_pila(t_pila *p) +{ + t_nodo *aux; + while(*p) + { + aux=*p; + (*p)=aux->sig; + free(aux); + } +} diff --git "a/repaso pila din\303\241mica/primitivas_pila_din\303\241mica.h" "b/repaso pila din\303\241mica/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..6f102a5 --- /dev/null +++ "b/repaso pila din\303\241mica/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,24 @@ +#include "dato.h" +#include +#include + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *sig; +}t_nodo; + +typedef t_nodo* t_pila; + +void crear_pila(t_pila*); +int pila_vacia(const t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); + diff --git "a/repaso pila din\303\241mica/repaso pila din\303\241mica.cbp" "b/repaso pila din\303\241mica/repaso pila din\303\241mica.cbp" new file mode 100644 index 0000000..a4e6884 --- /dev/null +++ "b/repaso pila din\303\241mica/repaso pila din\303\241mica.cbp" @@ -0,0 +1,53 @@ + + + + + + diff --git "a/repaso pila din\303\241mica/repaso pila din\303\241mica.depend" "b/repaso pila din\303\241mica/repaso pila din\303\241mica.depend" new file mode 100644 index 0000000..c0002f1 --- /dev/null +++ "b/repaso pila din\303\241mica/repaso pila din\303\241mica.depend" @@ -0,0 +1,24 @@ +# depslib dependency file v1.0 +1476991788 source:d:\unlam\programaciÓn\fabian\repaso pila dinámica\functions.c + "header.h" + +1476991907 d:\unlam\programaciÓn\fabian\repaso pila dinámica\header.h + + + + + "primitivas_pila_dinámica.h" + +1476994086 d:\unlam\programaciÓn\fabian\repaso pila dinámica\primitivas_pila_dinámica.h + "dato.h" + + + +1476991855 d:\unlam\programaciÓn\fabian\repaso pila dinámica\dato.h + +1476994265 source:d:\unlam\programaciÓn\fabian\repaso pila dinámica\main.c + "header.h" + +1476994065 source:d:\unlam\programaciÓn\fabian\repaso pila dinámica\primitivas_pila_dinámica.c + "primitivas_pila_dinámica.h" + diff --git "a/repaso pila din\303\241mica/repaso pila din\303\241mica.layout" "b/repaso pila din\303\241mica/repaso pila din\303\241mica.layout" new file mode 100644 index 0000000..2241e31 --- /dev/null +++ "b/repaso pila din\303\241mica/repaso pila din\303\241mica.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/repaso pila est\303\241tica/bin/Debug/repaso pila est\303\241tica.exe" "b/repaso pila est\303\241tica/bin/Debug/repaso pila est\303\241tica.exe" new file mode 100644 index 0000000..a566b7b Binary files /dev/null and "b/repaso pila est\303\241tica/bin/Debug/repaso pila est\303\241tica.exe" differ diff --git "a/repaso pila est\303\241tica/dato.h" "b/repaso pila est\303\241tica/dato.h" new file mode 100644 index 0000000..7848e3b --- /dev/null +++ "b/repaso pila est\303\241tica/dato.h" @@ -0,0 +1,6 @@ +#define TAM 10 + +typedef struct +{ + int numero; +}t_dato; diff --git "a/repaso pila est\303\241tica/functions.c" "b/repaso pila est\303\241tica/functions.c" new file mode 100644 index 0000000..34c126b --- /dev/null +++ "b/repaso pila est\303\241tica/functions.c" @@ -0,0 +1,12 @@ +#include "header.h" + +void cargar_dato(t_dato *dato) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&dato->numero); +} + +void mostrar_dato(t_dato *dato) +{ + printf("\n DATO: \t %d",dato->numero); +} diff --git "a/repaso pila est\303\241tica/header.h" "b/repaso pila est\303\241tica/header.h" new file mode 100644 index 0000000..bd63fca --- /dev/null +++ "b/repaso pila est\303\241tica/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "primitivas_pila_estática.h" + +void cargar_dato(t_dato*); +void mostrar_dato(t_dato*); diff --git "a/repaso pila est\303\241tica/main.c" "b/repaso pila est\303\241tica/main.c" new file mode 100644 index 0000000..1d79c7d --- /dev/null +++ "b/repaso pila est\303\241tica/main.c" @@ -0,0 +1,48 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n PILA ESTÁTICA \n\a\a"); + + t_pila pila; + t_dato dato; + + crear_pila(&pila); + printf("\n\n Se ha creado una pila \n"); + + if(pila_vacia(&pila)) + printf("\n\n La pila está vacía \n\n"); + + printf("\n\n Apilar \n"); + while(!pila_llena(&pila)) + { + cargar_dato(&dato); + apilar(&pila,&dato); + } + printf("\n\n Se ha cargado la pila \n"); + + printf("\n\n Ver tope \n"); + ver_tope(&pila,&dato); + mostrar_dato(&dato); + + printf("\n\n Desapilar \n"); + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + mostrar_dato(&dato); + } + printf("\n\n Se ha desapilado todo \n"); + + printf("\n\n Ingresar algo \n"); + cargar_dato(&dato); + apilar(&pila,&dato); + printf("\n\n Se ha cargado algo \n"); + + vaciar_pila(&pila); + printf("\n\n Se ha vaciado la pila \n"); + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git "a/repaso pila est\303\241tica/obj/Debug/functions.o" "b/repaso pila est\303\241tica/obj/Debug/functions.o" new file mode 100644 index 0000000..b6d8f60 Binary files /dev/null and "b/repaso pila est\303\241tica/obj/Debug/functions.o" differ diff --git "a/repaso pila est\303\241tica/obj/Debug/main.o" "b/repaso pila est\303\241tica/obj/Debug/main.o" new file mode 100644 index 0000000..d37678b Binary files /dev/null and "b/repaso pila est\303\241tica/obj/Debug/main.o" differ diff --git "a/repaso pila est\303\241tica/obj/Debug/primitivas_pila_est\303\241tica.o" "b/repaso pila est\303\241tica/obj/Debug/primitivas_pila_est\303\241tica.o" new file mode 100644 index 0000000..697f8ea Binary files /dev/null and "b/repaso pila est\303\241tica/obj/Debug/primitivas_pila_est\303\241tica.o" differ diff --git "a/repaso pila est\303\241tica/primitivas_pila_est\303\241tica.c" "b/repaso pila est\303\241tica/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..b525a3c --- /dev/null +++ "b/repaso pila est\303\241tica/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,47 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) +{ + p->tope=0; +} + +int pila_vacia(const t_pila *p) +{ + return p->tope==0; +} + +int pila_llena(const t_pila *p) +{ + return p->tope==TAM; +} + +int apilar(t_pila *p,const t_dato *d) +{ + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; +} + +int desapilar(t_pila *p,t_dato *d) +{ + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; +} + +int ver_tope(const t_pila *p,t_dato *d) +{ + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; +} + +void vaciar_pila(t_pila *p) +{ + p->tope=0; +} diff --git "a/repaso pila est\303\241tica/primitivas_pila_est\303\241tica.h" "b/repaso pila est\303\241tica/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..d8d4756 --- /dev/null +++ "b/repaso pila est\303\241tica/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 0 +#define OK 1 + +typedef struct +{ + t_dato pila[TAM]; + int tope; +}t_pila; + +void crear_pila(t_pila*); +int pila_vacia(const t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/repaso pila est\303\241tica/repaso pila est\303\241tica.cbp" "b/repaso pila est\303\241tica/repaso pila est\303\241tica.cbp" new file mode 100644 index 0000000..96a8847 --- /dev/null +++ "b/repaso pila est\303\241tica/repaso pila est\303\241tica.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/repaso pila est\303\241tica/repaso pila est\303\241tica.depend" "b/repaso pila est\303\241tica/repaso pila est\303\241tica.depend" new file mode 100644 index 0000000..a350e33 --- /dev/null +++ "b/repaso pila est\303\241tica/repaso pila est\303\241tica.depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1476991460 source:d:\unlam\programaciÓn\fabian\repaso pila estática\functions.c + "header.h" + +1476989392 d:\unlam\programaciÓn\fabian\repaso pila estática\header.h + + + + + "primitivas_pila_estática.h" + +1476994111 d:\unlam\programaciÓn\fabian\repaso pila estática\primitivas_pila_estática.h + "dato.h" + +1476988594 d:\unlam\programaciÓn\fabian\repaso pila estática\dato.h + +1476991186 source:d:\unlam\programaciÓn\fabian\repaso pila estática\main.c + "header.h" + +1476990262 source:d:\unlam\programaciÓn\fabian\repaso pila estática\primitivas_pila_estática.c + "primitivas_pila_estática.h" + diff --git "a/repaso pila est\303\241tica/repaso pila est\303\241tica.layout" "b/repaso pila est\303\241tica/repaso pila est\303\241tica.layout" new file mode 100644 index 0000000..b710f57 --- /dev/null +++ "b/repaso pila est\303\241tica/repaso pila est\303\241tica.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/repaso validar fecha/bin/Debug/repaso validar fecha.exe b/repaso validar fecha/bin/Debug/repaso validar fecha.exe new file mode 100644 index 0000000..0ffcb75 Binary files /dev/null and b/repaso validar fecha/bin/Debug/repaso validar fecha.exe differ diff --git a/repaso validar fecha/funciones.c b/repaso validar fecha/funciones.c new file mode 100644 index 0000000..51df130 --- /dev/null +++ b/repaso validar fecha/funciones.c @@ -0,0 +1,17 @@ +#include "header.h" + +int fecha_valida(tFecha f) +{ + return (f.anio>=1600&&f.mes>=1&&f.mes<=12&&f.dia>=1&&f.dia<=cant_dias_mes(f.mes,f.anio)); +} + +int cant_dias_mes(int m,int a) +{ + int dias[12]={31,28,31,30,31,30,31,31,30,31,30,31}; + return (m==2)?28+bisiesto(a):dias[m-1]; +} + +int bisiesto(int a) +{ + return (a%4==0&&a%100!=0)||a%400==0; +} diff --git a/repaso validar fecha/header.h b/repaso validar fecha/header.h new file mode 100644 index 0000000..192be75 --- /dev/null +++ b/repaso validar fecha/header.h @@ -0,0 +1,12 @@ +#include +#include +#include +typedef struct + { + int dia, + mes, + anio; + }tFecha; +int fecha_valida(tFecha); +int cant_dias_mes(int,int); +int bisiesto(int); diff --git a/repaso validar fecha/main.c b/repaso validar fecha/main.c new file mode 100644 index 0000000..3a9e153 --- /dev/null +++ b/repaso validar fecha/main.c @@ -0,0 +1,12 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + tFecha f; + printf("\n ***** VALIDACIÓN DE FECHAS ***** \n"); + printf("\n Ingrese una fecha en formato dd/mm/aaaa: \n\t"); + scanf("%d/%d/%d",&f.dia,&f.mes,&f.anio); + printf("\n La fecha %s válida \n",fecha_valida(f)?"es":"no es"); + getch(); + return 0; + } diff --git a/repaso validar fecha/obj/Debug/funciones.o b/repaso validar fecha/obj/Debug/funciones.o new file mode 100644 index 0000000..649a6d3 Binary files /dev/null and b/repaso validar fecha/obj/Debug/funciones.o differ diff --git a/repaso validar fecha/obj/Debug/main.o b/repaso validar fecha/obj/Debug/main.o new file mode 100644 index 0000000..f9f82aa Binary files /dev/null and b/repaso validar fecha/obj/Debug/main.o differ diff --git a/repaso validar fecha/repaso validar fecha.cbp b/repaso validar fecha/repaso validar fecha.cbp new file mode 100644 index 0000000..213098f --- /dev/null +++ b/repaso validar fecha/repaso validar fecha.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/repaso validar fecha/repaso validar fecha.depend b/repaso validar fecha/repaso validar fecha.depend new file mode 100644 index 0000000..28f7a8b --- /dev/null +++ b/repaso validar fecha/repaso validar fecha.depend @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1477017625 source:d:\unlam\programaciÓn\fabian\repaso validar fecha\funciones.c + "header.h" + +1471741006 d:\unlam\programaciÓn\fabian\repaso validar fecha\header.h + + + + diff --git a/repaso validar fecha/repaso validar fecha.layout b/repaso validar fecha/repaso validar fecha.layout new file mode 100644 index 0000000..0df8ddb --- /dev/null +++ b/repaso validar fecha/repaso validar fecha.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/bin/Debug/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.exe" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/bin/Debug/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.exe" new file mode 100644 index 0000000..86f5cbf Binary files /dev/null and "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/bin/Debug/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.exe" differ diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/encabezados.h" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/encabezados.h" new file mode 100644 index 0000000..869cb3e --- /dev/null +++ "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/encabezados.h" @@ -0,0 +1,6 @@ +#include +#include +#include +#include +#define ORO 1.618034 +float enesimo_termino_aprox_serie_fibonacci(int); diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/funciones.c" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/funciones.c" new file mode 100644 index 0000000..ceeb2f9 --- /dev/null +++ "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/funciones.c" @@ -0,0 +1,5 @@ +#include "encabezados.h" +float enesimo_termino_aprox_serie_fibonacci(int x) + { + return (float)(pow(ORO,x)-pow(1-ORO,x))/sqrt(5);//por propiedad del enésimo término de la serie de fibonacci + } diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/main.c" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/main.c" new file mode 100644 index 0000000..1727dd0 --- /dev/null +++ "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/main.c" @@ -0,0 +1,19 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n; + float fn; + printf("\n ENÉSIMO TÉRMINO APROXIMADO DE LA SERIE DE FIBONACCI \n"); + do + { + printf("\n Ingrese el número del término de la serie de Fibonacci que desea aproximar: \n\n\t\t"); + scanf("%d",&n); + } + while(n<1); + fn=enesimo_termino_aprox_serie_fibonacci(n); + printf("\n El término %d de la serie de Fibonacci es aproximadamente %f \n\n",n,fn); + getch(); + return 0; + } + diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/obj/Debug/funciones.o" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/obj/Debug/funciones.o" new file mode 100644 index 0000000..6674dd4 Binary files /dev/null and "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/obj/Debug/funciones.o" differ diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/obj/Debug/main.o" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/obj/Debug/main.o" new file mode 100644 index 0000000..7b333af Binary files /dev/null and "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/obj/Debug/main.o" differ diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.cbp" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.cbp" new file mode 100644 index 0000000..ee1d5e0 --- /dev/null +++ "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.depend" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.depend" new file mode 100644 index 0000000..53f4173 --- /dev/null +++ "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.depend" @@ -0,0 +1,13 @@ +# depslib dependency file v1.0 +1472316418 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_enésimo término aproximado con número áurico\funciones.c + "encabezados.h" + +1471568691 d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_enésimo término aproximado con número áurico\encabezados.h + + + + + +1471568678 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_enésimo término aproximado con número áurico\main.c + "encabezados.h" + diff --git "a/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.layout" "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.layout" new file mode 100644 index 0000000..e4a274f --- /dev/null +++ "b/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico/serie de fibonacci_en\303\251simo t\303\251rmino aproximado con n\303\272mero \303\241urico.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/serie de fibonacci_generada con bucle/bin/Debug/serie de fibonacci_generada con bucle.exe b/serie de fibonacci_generada con bucle/bin/Debug/serie de fibonacci_generada con bucle.exe new file mode 100644 index 0000000..3ebd1a7 Binary files /dev/null and b/serie de fibonacci_generada con bucle/bin/Debug/serie de fibonacci_generada con bucle.exe differ diff --git a/serie de fibonacci_generada con bucle/main.c b/serie de fibonacci_generada con bucle/main.c new file mode 100644 index 0000000..cae0e14 --- /dev/null +++ b/serie de fibonacci_generada con bucle/main.c @@ -0,0 +1,30 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int x,y,z,tope,i; + x=1;//primer término + y=1;//segundo término + printf("\n\t\t SERIE DE FIBONACCI \n\n"); + do + { + printf("\n Ingrese la cantidad de términos que desea calcular \n de la serie de Fibonacci (mínimo 2): \n\n\t\t"); + scanf("%d",&tope); + } + while(tope<2); + printf("\n Los primeros %d términos de la serie de Fibonacci son: \n",tope); + printf("\n\t 1 \n\t 1"); + tope-=2;//para comenzar el for desde cero + for(i=0;i + + + + + diff --git a/serie de fibonacci_generada con bucle/serie de fibonacci_generada con bucle.depend b/serie de fibonacci_generada con bucle/serie de fibonacci_generada con bucle.depend new file mode 100644 index 0000000..6b085a1 --- /dev/null +++ b/serie de fibonacci_generada con bucle/serie de fibonacci_generada con bucle.depend @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1471563373 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con bucle\main.c + + + + diff --git a/serie de fibonacci_generada con bucle/serie de fibonacci_generada con bucle.layout b/serie de fibonacci_generada con bucle/serie de fibonacci_generada con bucle.layout new file mode 100644 index 0000000..54a4f85 --- /dev/null +++ b/serie de fibonacci_generada con bucle/serie de fibonacci_generada con bucle.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/serie de fibonacci_generada con recursividad y consultas/bin/Debug/serie de fibonacci_generada con recursividad y consultas.exe b/serie de fibonacci_generada con recursividad y consultas/bin/Debug/serie de fibonacci_generada con recursividad y consultas.exe new file mode 100644 index 0000000..13b4964 Binary files /dev/null and b/serie de fibonacci_generada con recursividad y consultas/bin/Debug/serie de fibonacci_generada con recursividad y consultas.exe differ diff --git a/serie de fibonacci_generada con recursividad y consultas/encabezados.h b/serie de fibonacci_generada con recursividad y consultas/encabezados.h new file mode 100644 index 0000000..ba2ef55 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y consultas/encabezados.h @@ -0,0 +1,4 @@ +#include +#include +#include +int fibonacci(int); diff --git a/serie de fibonacci_generada con recursividad y consultas/funciones.c b/serie de fibonacci_generada con recursividad y consultas/funciones.c new file mode 100644 index 0000000..deb6608 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y consultas/funciones.c @@ -0,0 +1,15 @@ +#include "encabezados.h" +int fibonacci(int n)//recibe el número de término + { + if(n>2) + return fibonacci(n-1)+fibonacci(n-2);//genero un término cualquiera + else + if(n==2) + return 1;//segundo término + else + if(n==1) + return 1;//primer término + else + if(n==0) + return 0; + } diff --git a/serie de fibonacci_generada con recursividad y consultas/main.c b/serie de fibonacci_generada con recursividad y consultas/main.c new file mode 100644 index 0000000..ae63742 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y consultas/main.c @@ -0,0 +1,26 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int i,tope; + printf("\n SERIE DE FIBONACCI \n\n"); + do + { + printf("\n Ingrese la cantidad de términos que desea calcular \n de la serie de Fibonacci: \n\n\t\t"); + scanf("%d",&tope); + } + while(tope<0); + if(tope==0)//evacúo + { + printf("\n No desea calcular ningún término de la serie \n\n \t\t\t Fin del programa.. \a\a"); + exit(0); + } + printf("\n Los primeros %d términos de la serie de Fibonacci son: \n",tope); + for(i=1;i<=tope;i++) + { + printf("\n\t %d",fibonacci(i)); + } + printf("\n\n"); + getch(); + return 0; + } diff --git a/serie de fibonacci_generada con recursividad y consultas/obj/Debug/funciones.o b/serie de fibonacci_generada con recursividad y consultas/obj/Debug/funciones.o new file mode 100644 index 0000000..8808f89 Binary files /dev/null and b/serie de fibonacci_generada con recursividad y consultas/obj/Debug/funciones.o differ diff --git a/serie de fibonacci_generada con recursividad y consultas/obj/Debug/main.o b/serie de fibonacci_generada con recursividad y consultas/obj/Debug/main.o new file mode 100644 index 0000000..d7a3700 Binary files /dev/null and b/serie de fibonacci_generada con recursividad y consultas/obj/Debug/main.o differ diff --git a/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.cbp b/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.cbp new file mode 100644 index 0000000..2c6fd9e --- /dev/null +++ b/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.depend b/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.depend new file mode 100644 index 0000000..68e4e0d --- /dev/null +++ b/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471564239 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con recursividad y consultas\funciones.c + "encabezados.h" + +1471564015 d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con recursividad y consultas\encabezados.h + + + + +1471564554 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con recursividad y consultas\main.c + "encabezados.h" + diff --git a/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.layout b/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.layout new file mode 100644 index 0000000..ece99b0 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y consultas/serie de fibonacci_generada con recursividad y consultas.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/serie de fibonacci_generada con recursividad y switch/bin/Debug/serie de fibonacci_generada con recursividad y switch.exe b/serie de fibonacci_generada con recursividad y switch/bin/Debug/serie de fibonacci_generada con recursividad y switch.exe new file mode 100644 index 0000000..e321357 Binary files /dev/null and b/serie de fibonacci_generada con recursividad y switch/bin/Debug/serie de fibonacci_generada con recursividad y switch.exe differ diff --git a/serie de fibonacci_generada con recursividad y switch/encabezados.h b/serie de fibonacci_generada con recursividad y switch/encabezados.h new file mode 100644 index 0000000..f6bbf9c --- /dev/null +++ b/serie de fibonacci_generada con recursividad y switch/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +int fibonacci(int); + diff --git a/serie de fibonacci_generada con recursividad y switch/funciones.c b/serie de fibonacci_generada con recursividad y switch/funciones.c new file mode 100644 index 0000000..e3172b0 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y switch/funciones.c @@ -0,0 +1,12 @@ +#include "encabezados.h" +int fibonacci(int n)//recibe el número de término + { + switch(n) + { + case 2: + case 1: return 1; //primeros dos términos + break; + case 0: return 0; + default:return fibonacci(n-1)+fibonacci(n-2);//genero un término cualquiera + } + } diff --git a/serie de fibonacci_generada con recursividad y switch/main.c b/serie de fibonacci_generada con recursividad y switch/main.c new file mode 100644 index 0000000..adf923a --- /dev/null +++ b/serie de fibonacci_generada con recursividad y switch/main.c @@ -0,0 +1,26 @@ +#include "encabezados.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int i,tope; + printf("\n SERIE DE FIBONACCI \n\n"); + do + { + printf("\n Ingrese la cantidad de términos que desea calcular \n de la serie de Fibonacci: \n\n\t\t"); + scanf("%d",&tope); + } + while(tope<0); + if(tope==0)//por si acaso + { + printf("\n\n Udted no desea generar ningún término de la serie \n\n\t\t\t Fin del programa.. \n\n\a\a"); + exit(0); + } + printf("\n Los primeros %d términos de la serie de Fibonacci son: \n",tope); + for(i=1;i<=tope;i++) + { + printf("\n\t %d",fibonacci(i)); + } + printf("\n\n"); + getch(); + return 0; + } diff --git a/serie de fibonacci_generada con recursividad y switch/obj/Debug/funciones.o b/serie de fibonacci_generada con recursividad y switch/obj/Debug/funciones.o new file mode 100644 index 0000000..cd9da64 Binary files /dev/null and b/serie de fibonacci_generada con recursividad y switch/obj/Debug/funciones.o differ diff --git a/serie de fibonacci_generada con recursividad y switch/obj/Debug/main.o b/serie de fibonacci_generada con recursividad y switch/obj/Debug/main.o new file mode 100644 index 0000000..81d7415 Binary files /dev/null and b/serie de fibonacci_generada con recursividad y switch/obj/Debug/main.o differ diff --git a/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.cbp b/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.cbp new file mode 100644 index 0000000..815e3d3 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.depend b/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.depend new file mode 100644 index 0000000..658dd07 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1471565768 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con recursividad y switch\funciones.c + "encabezados.h" + +1471565451 d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con recursividad y switch\encabezados.h + + + + +1471565707 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_generada con recursividad y switch\main.c + "encabezados.h" + diff --git a/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.layout b/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.layout new file mode 100644 index 0000000..aa5c344 --- /dev/null +++ b/serie de fibonacci_generada con recursividad y switch/serie de fibonacci_generada con recursividad y switch.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/serie de fibonacci_n pertenece/bin/Debug/serie de fibonacci_n pertenece.exe b/serie de fibonacci_n pertenece/bin/Debug/serie de fibonacci_n pertenece.exe new file mode 100644 index 0000000..1563768 Binary files /dev/null and b/serie de fibonacci_n pertenece/bin/Debug/serie de fibonacci_n pertenece.exe differ diff --git a/serie de fibonacci_n pertenece/encabezados.h b/serie de fibonacci_n pertenece/encabezados.h new file mode 100644 index 0000000..90c9cfd --- /dev/null +++ b/serie de fibonacci_n pertenece/encabezados.h @@ -0,0 +1,5 @@ +#include +#include +#include +int es_de_fibonacci(int); + diff --git a/serie de fibonacci_n pertenece/funciones.c b/serie de fibonacci_n pertenece/funciones.c new file mode 100644 index 0000000..bfed6fd --- /dev/null +++ b/serie de fibonacci_n pertenece/funciones.c @@ -0,0 +1,16 @@ +#include "encabezados.h" +int es_de_fibonacci(int n) + { + if(n==1) + return 1; + int x,y,z; + x=y=1;//primeros dos términos + do + { + z=x+y;//genero un nuevo término y luego actualizo los últimos dos términos + x=y; + y=z; + } + while(z + + + + + diff --git a/serie de fibonacci_n pertenece/serie de fibonacci_n pertenece.depend b/serie de fibonacci_n pertenece/serie de fibonacci_n pertenece.depend new file mode 100644 index 0000000..a945639 --- /dev/null +++ b/serie de fibonacci_n pertenece/serie de fibonacci_n pertenece.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472316331 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_n pertenece\funciones.c + "encabezados.h" + +1471739790 d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_n pertenece\encabezados.h + + + + +1471739797 source:d:\unlam\programaciÓn\fabian 2da\serie de fibonacci_n pertenece\main.c + "encabezados.h" + diff --git a/serie de fibonacci_n pertenece/serie de fibonacci_n pertenece.layout b/serie de fibonacci_n pertenece/serie de fibonacci_n pertenece.layout new file mode 100644 index 0000000..a208ba6 --- /dev/null +++ b/serie de fibonacci_n pertenece/serie de fibonacci_n pertenece.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/sscanf y sprintf/bin/Debug/sscanf y sprintf.exe b/sscanf y sprintf/bin/Debug/sscanf y sprintf.exe new file mode 100644 index 0000000..639febb Binary files /dev/null and b/sscanf y sprintf/bin/Debug/sscanf y sprintf.exe differ diff --git a/sscanf y sprintf/header.h b/sscanf y sprintf/header.h new file mode 100644 index 0000000..3adb32a --- /dev/null +++ b/sscanf y sprintf/header.h @@ -0,0 +1,3 @@ +#include +#include +#include diff --git a/sscanf y sprintf/main.c b/sscanf y sprintf/main.c new file mode 100644 index 0000000..af5ebba --- /dev/null +++ b/sscanf y sprintf/main.c @@ -0,0 +1,32 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char nombre[20]="",entrada[81]="",salida[81]=""; + unsigned int edad=0; + + printf("\n\n SSCANF \n"); + printf("\n Esta función toma valores desde un string, que están separados por \n una variable reservada para funcionar como separador, como un espacio \n y los graba en diferentes variables y cadenas \n"); + printf("\n Veamos un ejemplo: \n\n"); + printf("\n Escriba su nombre y edad, en una misma línea, separados por un espacio: \n\n\t"); + fflush(stdin); + gets(entrada); + sscanf(entrada,"%s %u",nombre,&edad); + printf("\n\n Has escrito: \t %s",entrada); + printf("\n\n Nombre: \t %s \t Edad: \t %d \n",nombre,edad); + + printf("\n\n SPRINTF \n"); + printf("\n Esta función toma valores desde diferentes variables y cadenas, \n y los graba en otra cadena con un formato especificado \n"); + printf("\n Veamos un ejemplo: \n\n"); + printf("\n Escriba su nombre: \t"); + scanf("%s",nombre); + printf("\n Escribe su edad: \t"); + scanf("%u",&edad); + sprintf(salida,"\n Hola %s. Tienes %d años. \n",nombre,edad); + puts(salida); + + printf("\n\n \t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } + diff --git a/sscanf y sprintf/obj/Debug/main.o b/sscanf y sprintf/obj/Debug/main.o new file mode 100644 index 0000000..c39ac37 Binary files /dev/null and b/sscanf y sprintf/obj/Debug/main.o differ diff --git a/sscanf y sprintf/sscanf y sprintf.cbp b/sscanf y sprintf/sscanf y sprintf.cbp new file mode 100644 index 0000000..5c84c3b --- /dev/null +++ b/sscanf y sprintf/sscanf y sprintf.cbp @@ -0,0 +1,45 @@ + + + + + + diff --git a/sscanf y sprintf/sscanf y sprintf.depend b/sscanf y sprintf/sscanf y sprintf.depend new file mode 100644 index 0000000..6fa9466 --- /dev/null +++ b/sscanf y sprintf/sscanf y sprintf.depend @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1473698993 source:d:\unlam\programaciÓn\fabian 2\sscanf y sprintf\main.c + "header.h" + +1473696391 d:\unlam\programaciÓn\fabian 2\sscanf y sprintf\header.h + + + + diff --git a/sscanf y sprintf/sscanf y sprintf.layout b/sscanf y sprintf/sscanf y sprintf.layout new file mode 100644 index 0000000..6eebda9 --- /dev/null +++ b/sscanf y sprintf/sscanf y sprintf.layout @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git "a/suma de los n primeros n\303\272meros naturales/bin/Debug/suma de los n primeros n\303\272meros naturales.exe" "b/suma de los n primeros n\303\272meros naturales/bin/Debug/suma de los n primeros n\303\272meros naturales.exe" new file mode 100644 index 0000000..bd22dde Binary files /dev/null and "b/suma de los n primeros n\303\272meros naturales/bin/Debug/suma de los n primeros n\303\272meros naturales.exe" differ diff --git "a/suma de los n primeros n\303\272meros naturales/main.c" "b/suma de los n primeros n\303\272meros naturales/main.c" new file mode 100644 index 0000000..4f29667 --- /dev/null +++ "b/suma de los n primeros n\303\272meros naturales/main.c" @@ -0,0 +1,21 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n,suma,i; + printf("\n SUMA DE LOS N PRIMEROS NÚMEROS NATURALES \n"); + do + { + printf("\n Ingrese un número entero positivo:\t"); + scanf("%d",&n); + } + while(n<1); + suma=0; + for(i=0;i<=n;i++)//genero los naturales + suma+=i;//acumulo + printf("\n\n La suma de los primeros %d números naturales es %d \n\n",n,suma); + getch(); + return 0; + } diff --git "a/suma de los n primeros n\303\272meros naturales/obj/Debug/main.o" "b/suma de los n primeros n\303\272meros naturales/obj/Debug/main.o" new file mode 100644 index 0000000..5caa625 Binary files /dev/null and "b/suma de los n primeros n\303\272meros naturales/obj/Debug/main.o" differ diff --git "a/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.cbp" "b/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.cbp" new file mode 100644 index 0000000..c6fe59a --- /dev/null +++ "b/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.depend" "b/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.depend" new file mode 100644 index 0000000..f7ce23f --- /dev/null +++ "b/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1471483532 source:d:\unlam\programaciÓn\fabian 2da\suma de los n primeros números naturales\main.c + + + + diff --git "a/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.layout" "b/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.layout" new file mode 100644 index 0000000..550b321 --- /dev/null +++ "b/suma de los n primeros n\303\272meros naturales/suma de los n primeros n\303\272meros naturales.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/suma de los n primeros n\303\272meros pares/bin/Debug/suma de los n primeros n\303\272meros pares.exe" "b/suma de los n primeros n\303\272meros pares/bin/Debug/suma de los n primeros n\303\272meros pares.exe" new file mode 100644 index 0000000..88f4ed0 Binary files /dev/null and "b/suma de los n primeros n\303\272meros pares/bin/Debug/suma de los n primeros n\303\272meros pares.exe" differ diff --git "a/suma de los n primeros n\303\272meros pares/main.c" "b/suma de los n primeros n\303\272meros pares/main.c" new file mode 100644 index 0000000..f3fa889 --- /dev/null +++ "b/suma de los n primeros n\303\272meros pares/main.c" @@ -0,0 +1,21 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n,suma,i; + suma=0; + printf("\n SUMA DE N PRIMEROS NÚMEROS PARES \n"); + do + { + printf("\n Ingrese un número mayor o igual a cero:\t"); + scanf("%d",&n); + } + while(n<0); + for(i=1;i<=n;i++)//el contador genera la cantidad de números pares + suma+=2*i;//sumo esa cantidad de pares + printf("\n La suma de los %d primeros números pares es %d \n\n",n,suma); + getch(); + return 0; + } diff --git "a/suma de los n primeros n\303\272meros pares/obj/Debug/main.o" "b/suma de los n primeros n\303\272meros pares/obj/Debug/main.o" new file mode 100644 index 0000000..cbeeb1e Binary files /dev/null and "b/suma de los n primeros n\303\272meros pares/obj/Debug/main.o" differ diff --git "a/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.cbp" "b/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.cbp" new file mode 100644 index 0000000..73b5a83 --- /dev/null +++ "b/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.depend" "b/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.depend" new file mode 100644 index 0000000..67b7d32 --- /dev/null +++ "b/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.depend" @@ -0,0 +1,6 @@ +# depslib dependency file v1.0 +1471484926 source:d:\unlam\programaciÓn\fabian 2da\suma de los n primeros números pares\main.c + + + + diff --git "a/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.layout" "b/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.layout" new file mode 100644 index 0000000..2c211a4 --- /dev/null +++ "b/suma de los n primeros n\303\272meros pares/suma de los n primeros n\303\272meros pares.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/suma de los n\303\272meros pares menores a n/bin/Debug/suma de los n\303\272meros pares menores a n.exe" "b/suma de los n\303\272meros pares menores a n/bin/Debug/suma de los n\303\272meros pares menores a n.exe" new file mode 100644 index 0000000..ceecf65 Binary files /dev/null and "b/suma de los n\303\272meros pares menores a n/bin/Debug/suma de los n\303\272meros pares menores a n.exe" differ diff --git "a/suma de los n\303\272meros pares menores a n/main.c" "b/suma de los n\303\272meros pares menores a n/main.c" new file mode 100644 index 0000000..bae613a --- /dev/null +++ "b/suma de los n\303\272meros pares menores a n/main.c" @@ -0,0 +1,25 @@ +#include +#include +#include +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int n,suma,par; + suma=0; + par=2;//primer número par + printf("\n SUMA DE NÚMEROS PARES MENORES A N \n"); + do + { + printf("\n Ingrese un número mayor o igual a cero: \t"); + scanf("%d",&n); + } + while(n<0); + while(par + + + + + diff --git "a/suma de los n\303\272meros pares menores a n/suma de los n\303\272meros pares menores a n.layout" "b/suma de los n\303\272meros pares menores a n/suma de los n\303\272meros pares menores a n.layout" new file mode 100644 index 0000000..bdda73f --- /dev/null +++ "b/suma de los n\303\272meros pares menores a n/suma de los n\303\272meros pares menores a n.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/suma y promedio de un array/LEER AHORA.txt b/suma y promedio de un array/LEER AHORA.txt new file mode 100644 index 0000000..11d0bde --- /dev/null +++ b/suma y promedio de un array/LEER AHORA.txt @@ -0,0 +1 @@ +comentar el main que no quiera ejecutar \ No newline at end of file diff --git a/suma y promedio de un array/bin/Debug/suma y promedio de un array.exe b/suma y promedio de un array/bin/Debug/suma y promedio de un array.exe new file mode 100644 index 0000000..f0860c5 Binary files /dev/null and b/suma y promedio de un array/bin/Debug/suma y promedio de un array.exe differ diff --git a/suma y promedio de un array/functions.c b/suma y promedio de un array/functions.c new file mode 100644 index 0000000..0882982 --- /dev/null +++ b/suma y promedio de un array/functions.c @@ -0,0 +1,45 @@ +#include "header.h" +void cargar_array(int *v,int ce) + { + int i; + for(i=1;i<=ce;i++) + { + printf("\n Ingrese el número %d :\t",i); + scanf("%d",v); + v++; + } + printf("\n\n La carga del array ha finalizado \n"); + } +void mostrar_array(int *v,int ce) + { + int i; + for(i=1;i<=ce;i++) + { + printf("\n Elemento número %d: \t %d",i,*v); + v++; + } + } +float suma_y_promedio_main1(int *v,int ce,long int*suma) + { + int i; + *suma=0; + for(i=0;i +#include +#include +#include + +typedef struct + { + long int suma; + float promedio; + }t_calculos; + +void cargar_array(int*,int); +void mostrar_array(int*,int); +float suma_y_promedio_main1(int*,int,long int*); +t_calculos suma_y_promedio_main2(int*,int); diff --git a/suma y promedio de un array/main1.c b/suma y promedio de un array/main1.c new file mode 100644 index 0000000..c2f13ad --- /dev/null +++ b/suma y promedio de un array/main1.c @@ -0,0 +1,40 @@ +#include "header.h" +/* +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n MAIN 1 \n"); + int band,ce; + long int suma; + float promedio; + printf("\n\n ARRAY DE FLOAT \n"); + printf("\n\n Usted debe cargar un array de números enteros \n"); + printf("\n Para ello, se le solicita que ingrese la cantidad de elementos a ingresar en el array: \t"); + band=0; + do + { + if(band==1) + printf("\n\n El número ingresado no es lógico. Ingrese un nuevo número: \t\a\a"); + scanf("%d",&ce); + band=1; + } + while(ce<=0); + int v[ce]; + cargar_array(v,ce); + if(ce==0) + { + printf("\n\n El array está vacío \n No tiene sentido continuar con la ejecución del programa \n\n\a\a"); + printf("\n\n Programa evacuado \n\n"); + exit(1); + } + printf("\n El vector ingresado tiene %d posiciones ocupadas \n",ce); + printf("\n Sus elementos son: \n\n"); + mostrar_array(v,ce); + promedio=suma_y_promedio_main1(v,ce,&suma); + printf("\n\n Características del array \n"); + printf("\n\n SUMA: \t %li \t PROMEDIO: \t %.2f \n\n",suma,promedio); + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } +*/ diff --git a/suma y promedio de un array/main2.c b/suma y promedio de un array/main2.c new file mode 100644 index 0000000..6bb5bc6 --- /dev/null +++ b/suma y promedio de un array/main2.c @@ -0,0 +1,37 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + printf("\n\n MAIN 2 \n"); + int band,ce; + t_calculos resultados; + printf("\n\n ARRAY DE FLOAT \n"); + printf("\n\n Usted debe cargar un array de números enteros \n"); + printf("\n Para ello, se le solicita que ingrese la cantidad de elementos a ingresar en el array: \t"); + band=0; + do + { + if(band==1) + printf("\n\n El número ingresado no es lógico. Ingrese un nuevo número: \t\a\a"); + scanf("%d",&ce); + band=1; + } + while(ce<=0); + int v[ce]; + cargar_array(v,ce); + if(ce==0) + { + printf("\n\n El array está vacío \n No tiene sentido continuar con la ejecución del programa \n\n\a\a"); + printf("\n\n Programa evacuado \n\n"); + exit(1); + } + printf("\n El vector ingresado tiene %d posiciones ocupadas \n",ce); + printf("\n Sus elementos son: \n\n"); + mostrar_array(v,ce); + resultados=suma_y_promedio_main2(v,ce); + printf("\n\n Características del array \n"); + printf("\n\n SUMA: \t %li \t PROMEDIO: \t %.2f \n\n",resultados.suma,resultados.promedio); + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/suma y promedio de un array/obj/Debug/functions.o b/suma y promedio de un array/obj/Debug/functions.o new file mode 100644 index 0000000..7e4bfdc Binary files /dev/null and b/suma y promedio de un array/obj/Debug/functions.o differ diff --git a/suma y promedio de un array/obj/Debug/main1.o b/suma y promedio de un array/obj/Debug/main1.o new file mode 100644 index 0000000..7baa761 Binary files /dev/null and b/suma y promedio de un array/obj/Debug/main1.o differ diff --git a/suma y promedio de un array/obj/Debug/main2.o b/suma y promedio de un array/obj/Debug/main2.o new file mode 100644 index 0000000..99ce87b Binary files /dev/null and b/suma y promedio de un array/obj/Debug/main2.o differ diff --git a/suma y promedio de un array/suma y promedio de un array.cbp b/suma y promedio de un array/suma y promedio de un array.cbp new file mode 100644 index 0000000..9ef0510 --- /dev/null +++ b/suma y promedio de un array/suma y promedio de un array.cbp @@ -0,0 +1,51 @@ + + + + + + diff --git a/suma y promedio de un array/suma y promedio de un array.depend b/suma y promedio de un array/suma y promedio de un array.depend new file mode 100644 index 0000000..2ee68ac --- /dev/null +++ b/suma y promedio de un array/suma y promedio de un array.depend @@ -0,0 +1,16 @@ +# depslib dependency file v1.0 +1473625938 source:d:\unlam\programaciÓn\fabian 2\suma y promedio de un array\functions.c + "header.h" + +1473626281 d:\unlam\programaciÓn\fabian 2\suma y promedio de un array\header.h + + + + + +1473626131 source:d:\unlam\programaciÓn\fabian 2\suma y promedio de un array\main1.c + "header.h" + +1473626411 source:d:\unlam\programaciÓn\fabian 2\suma y promedio de un array\main2.c + "header.h" + diff --git a/suma y promedio de un array/suma y promedio de un array.layout b/suma y promedio de un array/suma y promedio de un array.layout new file mode 100644 index 0000000..1db4276 --- /dev/null +++ b/suma y promedio de un array/suma y promedio de un array.layout @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/bin/Debug/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.exe" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/bin/Debug/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.exe" new file mode 100644 index 0000000..3255c96 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/bin/Debug/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.exe" differ diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/dato.h" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/dato.h" new file mode 100644 index 0000000..a668696 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/dato.h" @@ -0,0 +1,6 @@ +#define TAM 30 + +typedef struct + { + int numero; + }t_dato; diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/functions.c" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/functions.c" new file mode 100644 index 0000000..0b50f01 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/functions.c" @@ -0,0 +1,59 @@ +#include "header.h" + +void sumar_pilas(t_pila *pila1,t_pila *pila2,t_pila *pila3) + { + t_dato digito1,digito2,suma,carry; + carry.numero=0; + + while(!pila_vacia(pila1)&&!pila_vacia(pila2)) + { + desapilar(pila1,&digito1); + desapilar(pila2,&digito2); + + suma.numero=digito1.numero+digito2.numero+carry.numero; + if(suma.numero>9) + { + suma.numero-=10; + carry.numero=1; + } + else + carry.numero=0; + + apilar(pila3,&suma); + } + + while(!pila_vacia(pila1)) + { + desapilar(pila1,&digito1); + suma.numero=digito1.numero+carry.numero; + + if(suma.numero>9) + { + suma.numero-=10; + carry.numero=1; + } + else + carry.numero=0; + + apilar(pila3,&suma); + } + + while(!pila_vacia(pila2)) + { + desapilar(pila2,&digito2); + suma.numero=digito2.numero+carry.numero; + + if(suma.numero>9) + { + suma.numero-=10; + carry.numero=1; + } + else + carry.numero=0; + + apilar(pila3,&suma); + } + + if(carry.numero==1) + apilar(pila3,&carry); + } diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/header.h" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/header.h" new file mode 100644 index 0000000..33b1674 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/header.h" @@ -0,0 +1,8 @@ +#include +#include +#include +#include + +#include "primitivas_pila_estática.h" + +void sumar_pilas(t_pila*,t_pila*,t_pila*); diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/main.c" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/main.c" new file mode 100644 index 0000000..1eeb8bf --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/main.c" @@ -0,0 +1,50 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 7C"); + + printf("\n\n SUMAR NÚMEROS CARGADOS EN PILAS \n"); + + t_pila pila1,pila2,pila3; + t_dato aux; + + crear_pila(&pila1); + crear_pila(&pila2); + crear_pila(&pila3); + + printf("\n Números que sumo \n"); + //cargados de forma casera + int numero1[8]={7,5,1,4,9,8,6,3}; + int numero2[8]={6,3,5,4,7,9,0,5}; + printf("\n Número 1: \t 75149863"); + printf("\n Número 2: \t 63547905"); + + //los cargo en las pilas + int i; + for(i=0;i<8;i++) + { + aux.numero=numero1[i]; + apilar(&pila1,&aux); + } + for(i=0;i<8;i++) + { + aux.numero=numero2[i]; + apilar(&pila2,&aux); + } + + sumar_pilas(&pila1,&pila2,&pila3); + + //muestro el resultado desapilando + printf("\n Suma: \t\t"); + while(!pila_vacia(&pila3)) + { + desapilar(&pila3,&aux); + printf("%d",aux.numero); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/functions.o" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/functions.o" new file mode 100644 index 0000000..7051458 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/functions.o" differ diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/main.o" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/main.o" new file mode 100644 index 0000000..6736fd7 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/main.o" differ diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/primitivas_pila_est\303\241tica.o" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/primitivas_pila_est\303\241tica.o" new file mode 100644 index 0000000..d5d4e43 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/obj/Debug/primitivas_pila_est\303\241tica.o" differ diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/primitivas_pila_est\303\241tica.c" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..c1da8f4 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,48 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) + { + p->tope=0; + } + +int pila_llena(const t_pila *p) + { + return p->tope==TAM; + } + +int apilar(t_pila *p,const t_dato *d) + { + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return p->tope==0; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; + } + +void vaciar_pila(t_pila *p) + { + p->tope=0; + } + diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/primitivas_pila_est\303\241tica.h" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..b227de3 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 1 +#define OK 1 + +typedef struct + { + t_dato pila[TAM]; + int tope;//primera libre + }t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.cbp" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.cbp" new file mode 100644 index 0000000..dcfb8ba --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.cbp" @@ -0,0 +1,52 @@ + + + + + + diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.depend" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.depend" new file mode 100644 index 0000000..950bb09 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1474754039 source:d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_ versión 1\primitivas_pila_estática.c + "primitivas_pila_estática.h" + +1474755851 d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_ versión 1\primitivas_pila_estática.h + "dato.h" + +1474760274 d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_ versión 1\dato.h + +1474760299 source:d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_ versión 1\functions.c + "header.h" + +1474758737 d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_ versión 1\header.h + + + + + "primitivas_pila_estática.h" + +1474760720 source:d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_ versión 1\main.c + "header.h" + diff --git "a/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.layout" "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.layout" new file mode 100644 index 0000000..02aafae --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_ versi\303\263n 1/sumar n\303\272meros cargados en pilas_ versi\303\263n 1.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/bin/Debug/sumar n\303\272meros cargados en pilas_versi\303\263n 2.exe" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/bin/Debug/sumar n\303\272meros cargados en pilas_versi\303\263n 2.exe" new file mode 100644 index 0000000..420baf9 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/bin/Debug/sumar n\303\272meros cargados en pilas_versi\303\263n 2.exe" differ diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/dato.h" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/dato.h" new file mode 100644 index 0000000..a164df1 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/dato.h" @@ -0,0 +1,7 @@ +#define TAM 30 + +typedef struct + { + int numero; + }t_dato; + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/functions.c" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/functions.c" new file mode 100644 index 0000000..1fd5d4e --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/functions.c" @@ -0,0 +1,22 @@ +#include "header.h" + +void sumar_pilas(t_pila *pila1,t_pila *pila2,t_pila *pila3) + { + t_dato digito1,digito2,suma,carry; + carry.numero=0; + + while(!pila_vacia(pila1)||!pila_vacia(pila2)) + { + if(!desapilar(pila1,&digito1)) + digito1.numero=0; + if(!desapilar(pila2,&digito2)) + digito2.numero=0; + + suma.numero=(digito1.numero+digito2.numero+carry.numero)%10; + carry.numero=(digito1.numero+digito2.numero+carry.numero)/10; + apilar(pila3,&suma); + } + if(carry.numero==1) + apilar(pila3,&carry); + } + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/header.h" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/header.h" new file mode 100644 index 0000000..906b1d4 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/header.h" @@ -0,0 +1,9 @@ +#include +#include +#include +#include + +#include "primitivas_pila_estática.h" + +void sumar_pilas(t_pila*,t_pila*,t_pila*); + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/main.c" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/main.c" new file mode 100644 index 0000000..e143b05 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/main.c" @@ -0,0 +1,51 @@ +#include "header.h" + +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 7C"); + + printf("\n\n SUMAR NÚMEROS CARGADOS EN PILAS \n"); + + t_pila pila1,pila2,pila3; + t_dato aux; + + crear_pila(&pila1); + crear_pila(&pila2); + crear_pila(&pila3); + + printf("\n Números que sumo \n"); + //cargados de forma casera + int numero1[8]={7,5,1,4,9,8,6,3}; + int numero2[8]={6,3,5,4,7,9,0,5}; + printf("\n Número 1: \t 75149863"); + printf("\n Número 2: \t 63547905"); + + //los cargo en las pilas + int i; + for(i=0;i<8;i++) + { + aux.numero=numero1[i]; + apilar(&pila1,&aux); + } + for(i=0;i<8;i++) + { + aux.numero=numero2[i]; + apilar(&pila2,&aux); + } + + sumar_pilas(&pila1,&pila2,&pila3); + + //muestro el resultado desapilando + printf("\n Suma: \t\t"); + while(!pila_vacia(&pila3)) + { + desapilar(&pila3,&aux); + printf("%d",aux.numero); + } + + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; + } + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/functions.o" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/functions.o" new file mode 100644 index 0000000..e5d9132 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/functions.o" differ diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/main.o" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/main.o" new file mode 100644 index 0000000..a7024a6 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/main.o" differ diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/primitivas_pila_est\303\241tica.o" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/primitivas_pila_est\303\241tica.o" new file mode 100644 index 0000000..b14bec7 Binary files /dev/null and "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/obj/Debug/primitivas_pila_est\303\241tica.o" differ diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/primitivas_pila_est\303\241tica.c" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/primitivas_pila_est\303\241tica.c" new file mode 100644 index 0000000..c1da8f4 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/primitivas_pila_est\303\241tica.c" @@ -0,0 +1,48 @@ +#include "primitivas_pila_estática.h" + +void crear_pila(t_pila *p) + { + p->tope=0; + } + +int pila_llena(const t_pila *p) + { + return p->tope==TAM; + } + +int apilar(t_pila *p,const t_dato *d) + { + if(p->tope==TAM) + return PILA_LLENA; + p->pila[p->tope]=*d; + p->tope++; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return p->tope==0; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + p->tope--; + *d=p->pila[p->tope]; + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(p->tope==0) + return PILA_VACIA; + *d=p->pila[p->tope-1]; + return OK; + } + +void vaciar_pila(t_pila *p) + { + p->tope=0; + } + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/primitivas_pila_est\303\241tica.h" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/primitivas_pila_est\303\241tica.h" new file mode 100644 index 0000000..b227de3 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/primitivas_pila_est\303\241tica.h" @@ -0,0 +1,19 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define PILA_LLENA 1 +#define OK 1 + +typedef struct + { + t_dato pila[TAM]; + int tope;//primera libre + }t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.cbp" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.cbp" new file mode 100644 index 0000000..dec23f3 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.cbp" @@ -0,0 +1,53 @@ + + + + + + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.depend" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.depend" new file mode 100644 index 0000000..86a93e5 --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.depend" @@ -0,0 +1,22 @@ +# depslib dependency file v1.0 +1474764501 source:d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_versión 2\functions.c + "header.h" + +1474761244 d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_versión 2\header.h + + + + + "primitivas_pila_estática.h" + +1474755851 d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_versión 2\primitivas_pila_estática.h + "dato.h" + +1474761251 d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_versión 2\dato.h + +1474761228 source:d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_versión 2\main.c + "header.h" + +1474754039 source:d:\unlam\programaciÓn\fabian 2\sumar números cargados en pilas_versión 2\primitivas_pila_estática.c + "primitivas_pila_estática.h" + diff --git "a/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.layout" "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.layout" new file mode 100644 index 0000000..08c962d --- /dev/null +++ "b/sumar n\303\272meros cargados en pilas_versi\303\263n 2/sumar n\303\272meros cargados en pilas_versi\303\263n 2.layout" @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/torneo de f\303\272tbol/bin/Debug/torneo de f\303\272tbol.exe" "b/torneo de f\303\272tbol/bin/Debug/torneo de f\303\272tbol.exe" new file mode 100644 index 0000000..b1ab6a9 Binary files /dev/null and "b/torneo de f\303\272tbol/bin/Debug/torneo de f\303\272tbol.exe" differ diff --git "a/torneo de f\303\272tbol/functions.c" "b/torneo de f\303\272tbol/functions.c" new file mode 100644 index 0000000..d8fe34e --- /dev/null +++ "b/torneo de f\303\272tbol/functions.c" @@ -0,0 +1,79 @@ +#include "header.h" +void inicializar_vector(int v[],int ce) + { + int k; + for(k=0;kpuntos_del_campeon) + puntos_del_campeon=v[k]; + for(k=0;k +#include +#include + +#define EQUIPOS 6 +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void inicializar_vector(int[],int); +void cargar_tabla(int[][EQUIPOS],int); +void puntos_por_equipo(int[][EQUIPOS],int[],int); +void mostrar_puntos(int[],int); +void campeon_del_torneo(int[],int); diff --git "a/torneo de f\303\272tbol/main.c" "b/torneo de f\303\272tbol/main.c" new file mode 100644 index 0000000..bbbb2fc --- /dev/null +++ "b/torneo de f\303\272tbol/main.c" @@ -0,0 +1,23 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int tabla[EQUIPOS][EQUIPOS],puntos[EQUIPOS]; + inicializar_vector(puntos,EQUIPOS); + printf("\n TORNEO DE FÚTBOL \a\a"); + printf("\n ----------------"); + printf("\n Cantidad de equipos participantes: \t %d \n",EQUIPOS); + printf("\n Cargue los puntos que obtuvieron los equipos locales en cada partido \n"); + printf("\n\t Victoria: 3 \n"); + printf("\n\t Empate: 1 \n"); + printf("\n\t Derrota: 0 \n\n"); + cargar_tabla(tabla,EQUIPOS); + puntos_por_equipo(tabla,puntos,EQUIPOS); + printf("\n PUNTOS DE CADA EQUIPO \n\n"); + printf("\n EQUIPO \t PUNTOS"); + mostrar_puntos(puntos,EQUIPOS); + campeon_del_torneo(puntos,EQUIPOS); + printf("\n\n Fin del programa...... \a\a \n\n"); + getch(); + return 0; + } diff --git "a/torneo de f\303\272tbol/obj/Debug/functions.o" "b/torneo de f\303\272tbol/obj/Debug/functions.o" new file mode 100644 index 0000000..2fbca4f Binary files /dev/null and "b/torneo de f\303\272tbol/obj/Debug/functions.o" differ diff --git "a/torneo de f\303\272tbol/obj/Debug/main.o" "b/torneo de f\303\272tbol/obj/Debug/main.o" new file mode 100644 index 0000000..1bf7902 Binary files /dev/null and "b/torneo de f\303\272tbol/obj/Debug/main.o" differ diff --git "a/torneo de f\303\272tbol/torneo de f\303\272tbol.cbp" "b/torneo de f\303\272tbol/torneo de f\303\272tbol.cbp" new file mode 100644 index 0000000..96f6ae0 --- /dev/null +++ "b/torneo de f\303\272tbol/torneo de f\303\272tbol.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/torneo de f\303\272tbol/torneo de f\303\272tbol.depend" "b/torneo de f\303\272tbol/torneo de f\303\272tbol.depend" new file mode 100644 index 0000000..5911d0b --- /dev/null +++ "b/torneo de f\303\272tbol/torneo de f\303\272tbol.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473037950 source:d:\unlam\programaciÓn\fabian 2\torneo de fútbol\main.c + "header.h" + +1473038562 d:\unlam\programaciÓn\fabian 2\torneo de fútbol\header.h + + + + +1473038544 source:d:\unlam\programaciÓn\fabian 2\torneo de fútbol\functions.c + "header.h" + diff --git "a/torneo de f\303\272tbol/torneo de f\303\272tbol.layout" "b/torneo de f\303\272tbol/torneo de f\303\272tbol.layout" new file mode 100644 index 0000000..7e3f041 --- /dev/null +++ "b/torneo de f\303\272tbol/torneo de f\303\272tbol.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/uso de argumentos de la l\303\255nea de comandos/bin/Debug/uso de argumentos de la l\303\255nea de comandos.exe" "b/uso de argumentos de la l\303\255nea de comandos/bin/Debug/uso de argumentos de la l\303\255nea de comandos.exe" new file mode 100644 index 0000000..604bf8c Binary files /dev/null and "b/uso de argumentos de la l\303\255nea de comandos/bin/Debug/uso de argumentos de la l\303\255nea de comandos.exe" differ diff --git "a/uso de argumentos de la l\303\255nea de comandos/main.c" "b/uso de argumentos de la l\303\255nea de comandos/main.c" new file mode 100644 index 0000000..0650224 --- /dev/null +++ "b/uso de argumentos de la l\303\255nea de comandos/main.c" @@ -0,0 +1,42 @@ +/* Uso de argumentos en la línea de comandos */ +#include + +int main( int argc, char *argv[] ) +{ + FILE *ptrEntArchivo; /* apuntador de archivo de entrada */ + FILE *ptrSalArchivo; /* apuntador de archivo de salida */ + + int c; /* define c para almacenar los caracteres introducidos por el usuario */ + /* verifica el número de argumentos de la línea de comandos */ + + if ( argc != 3 ) + { + printf( "Uso: copia archivoEnt archivoSal\n" ); + } /* fin de if */ + else + { + /* si el archivo de entrada se puede abrir */ + if ( ( ptrEntArchivo = fopen( argv[ 1 ], "r" ) ) != NULL ) + { + /* si el archivo de salida se puede abrir */ + if ( ( ptrSalArchivo = fopen( argv[ 2 ], "w" ) ) != NULL ) + { + /* lee los caracteres y los arroja */ + while ( ( c = fgetc( ptrEntArchivo ) ) != EOF ) + { + fputc( c, ptrSalArchivo ); + } /* fin de while */ + } /* fin de if */ + else /* no se puede abrir el archivo de salida */ + { + printf( "El archivo \"%s\" no se pudo abrir\n", argv[ 2 ] ); + } /* fin de else */ + } /* fin de if */ + else /* no se puede abrir el archivo de entrada */ + { + printf( "El archivo \"%s\" no se pudo abrir\n", argv[ 1 ] ); + } /* fin de else */ + } /* fin de else */ + + return 0; /* indica terminación exitosa */ +} /* fin de main */ diff --git "a/uso de argumentos de la l\303\255nea de comandos/obj/Debug/main.o" "b/uso de argumentos de la l\303\255nea de comandos/obj/Debug/main.o" new file mode 100644 index 0000000..8c02282 Binary files /dev/null and "b/uso de argumentos de la l\303\255nea de comandos/obj/Debug/main.o" differ diff --git "a/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.cbp" "b/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.cbp" new file mode 100644 index 0000000..beefa05 --- /dev/null +++ "b/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.cbp" @@ -0,0 +1,43 @@ + + + + + + diff --git "a/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.depend" "b/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.depend" new file mode 100644 index 0000000..cced576 --- /dev/null +++ "b/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.depend" @@ -0,0 +1,4 @@ +# depslib dependency file v1.0 +1482880529 source:d:\unlam\programaciÓn\fabian\uso de argumentos de la línea de comandos\main.c + + diff --git "a/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.layout" "b/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.layout" new file mode 100644 index 0000000..d19a234 --- /dev/null +++ "b/uso de argumentos de la l\303\255nea de comandos/uso de argumentos de la l\303\255nea de comandos.layout" @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/uso de operadores binarios/bin/Debug/uso de operadores binarios.exe b/uso de operadores binarios/bin/Debug/uso de operadores binarios.exe new file mode 100644 index 0000000..4a236b6 Binary files /dev/null and b/uso de operadores binarios/bin/Debug/uso de operadores binarios.exe differ diff --git a/uso de operadores binarios/main.c b/uso de operadores binarios/main.c new file mode 100644 index 0000000..11bc14f --- /dev/null +++ b/uso de operadores binarios/main.c @@ -0,0 +1,75 @@ +/* Uso de los operadores de bits AND, OR incluyente, OR excluyente a nivel de bits y complemento */ +#include + +void despliegaBits( unsigned valor ); /* prototipo */ + +int main() +{ + unsigned numero1; /* define numero1 */ + unsigned numero2; /* define numero2 */ + unsigned mascara; /* define mascara */ + unsigned estableceBits; /* define estableceBits */ + + printf("\n\n USO DE OPERADORES BINARIOS \n\n"); + + /* demuestra el operador de bits AND (&) */ + numero1 = 65535; + mascara = 1; + printf( "El resultado de combinar los siguientes valores\n" ); + despliegaBits( numero1 ); + despliegaBits( mascara ); + printf( "con el uso del operador de bits AND (&) es\n" ); + despliegaBits( numero1 & mascara ); + + /* demuestra el operador de bits OR incluyente (|) */ + numero1 = 15; + estableceBits = 241; + printf( "\nEl resultado de combinar los siguientes valores\n" ); + despliegaBits( numero1 ); + despliegaBits( estableceBits ); + printf( "con el uso del operador de bits OR incluyente (|) es\n" ); + despliegaBits( numero1 | estableceBits ); + + /* demuestra el operador de bits OR excluyente (^) */ + numero1 = 139; + numero2 = 199; + printf( "\nEl resultado de combinar los siguientes valores\n" ); + despliegaBits( numero1 ); + despliegaBits( numero2 ); + printf( "con el uso del operador de bits OR excluyente (^) es\n" ); + despliegaBits( numero1 ^ numero2 ); + + /* demuestra el operador de bits complemento (~) */ + numero1 = 21845; + printf( "\nEl complemento a uno de\n" ); + despliegaBits( numero1 ); + printf( "es\n" ); + despliegaBits( ~numero1 ); + + return 0; /* indica terminación exitosa */ +} /* fin de main */ + +/* despliega los bits de un valor entero sin signo */ +void despliegaBits( unsigned valor ) +{ + unsigned c; /* contador */ + /* declara despliegaMarcara y desplaza 31 bits a la izquierda */ + unsigned despliegaMascara = 1 << 31; + + printf( "%10u = ", valor ); + + /* ciclo a través de los bits */ + for ( c = 1; c <= 32; c++ ) + { + putchar( valor & despliegaMascara ? '1' : '0' ); + valor <<= 1; /* desplaza el valor 1 bit a la izquierda */ + + if ( c % 8 == 0 ) /* muestra un espacio después de 8 bits */ + { + putchar( ' '); + } /* fin de if */ + + } /* fin de for */ + + putchar( '\n' ); +} /* fin de la función despliegaBits */ diff --git a/uso de operadores binarios/obj/Debug/main.o b/uso de operadores binarios/obj/Debug/main.o new file mode 100644 index 0000000..973441f Binary files /dev/null and b/uso de operadores binarios/obj/Debug/main.o differ diff --git a/uso de operadores binarios/uso de operadores binarios.cbp b/uso de operadores binarios/uso de operadores binarios.cbp new file mode 100644 index 0000000..192bad3 --- /dev/null +++ b/uso de operadores binarios/uso de operadores binarios.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/uso de operadores binarios/uso de operadores binarios.layout b/uso de operadores binarios/uso de operadores binarios.layout new file mode 100644 index 0000000..33c62c0 --- /dev/null +++ b/uso de operadores binarios/uso de operadores binarios.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git "a/valor num\303\251rico de una cadena de caracteres/bin/Debug/valor num\303\251rico de una cadena de caracteres.exe" "b/valor num\303\251rico de una cadena de caracteres/bin/Debug/valor num\303\251rico de una cadena de caracteres.exe" new file mode 100644 index 0000000..5c7ff85 Binary files /dev/null and "b/valor num\303\251rico de una cadena de caracteres/bin/Debug/valor num\303\251rico de una cadena de caracteres.exe" differ diff --git "a/valor num\303\251rico de una cadena de caracteres/functions.c" "b/valor num\303\251rico de una cadena de caracteres/functions.c" new file mode 100644 index 0000000..b16b4dc --- /dev/null +++ "b/valor num\303\251rico de una cadena de caracteres/functions.c" @@ -0,0 +1,21 @@ +#include "header.h" +size_t str_len(const char *s) + { + size_t cont=0; + while(*s) + { + cont++; + s++; + } + return cont; + } +size_t valor_numerico_cadena(char *c) + { + size_t acum=0; + char *cadena=c; + int longitud=str_len(cadena); + while(longitud--) + acum+=*cadena++; + return acum; + } + diff --git "a/valor num\303\251rico de una cadena de caracteres/header.h" "b/valor num\303\251rico de una cadena de caracteres/header.h" new file mode 100644 index 0000000..efcea22 --- /dev/null +++ "b/valor num\303\251rico de una cadena de caracteres/header.h" @@ -0,0 +1,6 @@ +#include +#include +#include +#define TOPE 50 +size_t str_len(const char*); +size_t valor_numerico_cadena(char*); diff --git "a/valor num\303\251rico de una cadena de caracteres/main.c" "b/valor num\303\251rico de una cadena de caracteres/main.c" new file mode 100644 index 0000000..51ff8ac --- /dev/null +++ "b/valor num\303\251rico de una cadena de caracteres/main.c" @@ -0,0 +1,14 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + char cadena[TOPE]; + printf("\n\n VALOR NUMÉRICO DE UNA CADENA DE CARACTERES \n"); + printf("\n Cada caracter de una cadena representa un número en código Ascii.\n"); + printf("\n El valor numérico de una cadena es la suma de los ascii de todos los caracteres\n\n"); + printf("\n Ingrese una cadena de caracteres: \n\n\t"); + gets(cadena); + printf("\n El valor numérico de \"%s\" es %d \n\n",cadena,valor_numerico_cadena(cadena)); + getch(); + return 0; + } diff --git "a/valor num\303\251rico de una cadena de caracteres/obj/Debug/functions.o" "b/valor num\303\251rico de una cadena de caracteres/obj/Debug/functions.o" new file mode 100644 index 0000000..042434a Binary files /dev/null and "b/valor num\303\251rico de una cadena de caracteres/obj/Debug/functions.o" differ diff --git "a/valor num\303\251rico de una cadena de caracteres/obj/Debug/main.o" "b/valor num\303\251rico de una cadena de caracteres/obj/Debug/main.o" new file mode 100644 index 0000000..f0c3205 Binary files /dev/null and "b/valor num\303\251rico de una cadena de caracteres/obj/Debug/main.o" differ diff --git "a/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.cbp" "b/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.cbp" new file mode 100644 index 0000000..0bae958 --- /dev/null +++ "b/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.depend" "b/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.depend" new file mode 100644 index 0000000..66c2cc3 --- /dev/null +++ "b/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1473363093 source:d:\unlam\programaciÓn\fabian 2\valor numérico de una cadena de caracteres\main.c + "header.h" + +1473363168 d:\unlam\programaciÓn\fabian 2\valor numérico de una cadena de caracteres\header.h + + + + +1473363845 source:d:\unlam\programaciÓn\fabian 2\valor numérico de una cadena de caracteres\functions.c + "header.h" + diff --git "a/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.layout" "b/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.layout" new file mode 100644 index 0000000..7856020 --- /dev/null +++ "b/valor num\303\251rico de una cadena de caracteres/valor num\303\251rico de una cadena de caracteres.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/variables globales y externas/bin/Debug/variables globales y externas.exe b/variables globales y externas/bin/Debug/variables globales y externas.exe new file mode 100644 index 0000000..d2d82a4 Binary files /dev/null and b/variables globales y externas/bin/Debug/variables globales y externas.exe differ diff --git a/variables globales y externas/funciones.c b/variables globales y externas/funciones.c new file mode 100644 index 0000000..cfb14eb --- /dev/null +++ b/variables globales y externas/funciones.c @@ -0,0 +1,15 @@ +#include "header.h" + +void primero() + { + extern unsigned x; + x=0; + printf("\n %u",x); + } + +void siguiente() + { + extern unsigned x; + x++; + printf("\n %u",x); + } diff --git a/variables globales y externas/header.h b/variables globales y externas/header.h new file mode 100644 index 0000000..14104b3 --- /dev/null +++ b/variables globales y externas/header.h @@ -0,0 +1,8 @@ +#include +#include +#include + +unsigned x; + +void primero(); +void siguiente(); diff --git a/variables globales y externas/main.c b/variables globales y externas/main.c new file mode 100644 index 0000000..08740b3 --- /dev/null +++ b/variables globales y externas/main.c @@ -0,0 +1,19 @@ +#include "header.h" + +int main() + { + printf("\n\n VARIABLES GLOBALES Y EXTERNAS \n\n"); + + primero(); + siguiente(); + siguiente(); + siguiente(); + primero(); + siguiente(); + siguiente(); + siguiente(); + + printf("\n\n \t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } diff --git a/variables globales y externas/obj/Debug/funciones.o b/variables globales y externas/obj/Debug/funciones.o new file mode 100644 index 0000000..ff92867 Binary files /dev/null and b/variables globales y externas/obj/Debug/funciones.o differ diff --git a/variables globales y externas/obj/Debug/main.o b/variables globales y externas/obj/Debug/main.o new file mode 100644 index 0000000..a78d18e Binary files /dev/null and b/variables globales y externas/obj/Debug/main.o differ diff --git a/variables globales y externas/variables globales y externas.cbp b/variables globales y externas/variables globales y externas.cbp new file mode 100644 index 0000000..26adbd8 --- /dev/null +++ b/variables globales y externas/variables globales y externas.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/variables globales y externas/variables globales y externas.depend b/variables globales y externas/variables globales y externas.depend new file mode 100644 index 0000000..3b4bfe4 --- /dev/null +++ b/variables globales y externas/variables globales y externas.depend @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1476137601 source:d:\unlam\programaciÓn\fabian\variables globales y externas\main.c + "header.h" + +1476137547 d:\unlam\programaciÓn\fabian\variables globales y externas\header.h + + + + +1476137547 source:d:\unlam\programaciÓn\fabian\variables globales y externas\funciones.c + "header.h" + diff --git a/variables globales y externas/variables globales y externas.layout b/variables globales y externas/variables globales y externas.layout new file mode 100644 index 0000000..1394356 --- /dev/null +++ b/variables globales y externas/variables globales y externas.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/bin/Debug/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.exe" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/bin/Debug/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.exe" new file mode 100644 index 0000000..7c9da20 Binary files /dev/null and "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/bin/Debug/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.exe" differ diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/functions.c" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/functions.c" new file mode 100644 index 0000000..ae9d10d --- /dev/null +++ "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/functions.c" @@ -0,0 +1,139 @@ +#include "header.h" +int validadato(int x,int li,int ls) + { + if(x>=li&&x<=ls) + return 1; + else + return 0; + } +int menu() + { + int op,band; + band=0; + printf("\n\n\t <<>> \n"); + printf("\n\t 1-Llenar vector"); + printf("\n\t 2-Mostrar vector"); + printf("\n\t 3-Eliminar elemento de una posición del vector"); + printf("\n\t 4-Salir"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,4)); + return op; + } +void llenar_vector(int *v,int *prim_lib) + { + int i,op,band=0; + if(*prim_lib!=0) + { + printf("\n El vector ya ha sido llenado. Si continúa se borrarán \n los datos del vector. ¿Desea continuar? \n\a\a"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==2) + return; + *prim_lib=0; + printf("\n Se han borrado todos los datos del vector \n\n\a\a"); + } + printf("\n Proceda a la carga del vector \n (cuenta con %d posiciones para almacenar números enteros)\n",TAM); + for(i=0;i*prim_lib); + for(i=pos-1;i<*prim_lib;i++) + *(v+i)=*(v+i+1); + *prim_lib-=1; + printf("\n El elemento ha sido eliminado exitosamente \n\n"); + } + } + diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/header.h" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/header.h" new file mode 100644 index 0000000..c3de460 --- /dev/null +++ "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/header.h" @@ -0,0 +1,10 @@ +#include +#include +#include +#define TAM 20 +int validadato(int,int,int); +int menu(); +void llenar_vector(int*,int*); +void mostrar_vector(int*,int); +void borrar_elemento_por_posicion(int*,int*); + diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/main.c" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/main.c" new file mode 100644 index 0000000..0cc8164 --- /dev/null +++ "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/main.c" @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int op,vec[TAM],prim_lib=0; + printf("\n\t\t\a\a ***VECTORES***"); + op=menu(); + while(op!=4) + { + switch(op) + { + case 1: llenar_vector(vec,&prim_lib); + break; + case 2: mostrar_vector(vec,prim_lib); + break; + case 3: borrar_elemento_por_posicion(vec,&prim_lib); + break; + } + op=menu(); + } + printf("\n\t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return; + } diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/obj/Debug/functions.o" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/obj/Debug/functions.o" new file mode 100644 index 0000000..9d98852 Binary files /dev/null and "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/obj/Debug/functions.o" differ diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/obj/Debug/main.o" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/obj/Debug/main.o" new file mode 100644 index 0000000..6ebe5d5 Binary files /dev/null and "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/obj/Debug/main.o" differ diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.cbp" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.cbp" new file mode 100644 index 0000000..b5f8fd7 --- /dev/null +++ "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.layout" "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.layout" new file mode 100644 index 0000000..94219c4 --- /dev/null +++ "b/vectores_eliminar elemento dada una posici\303\263n_con indirecciones/vectores_eliminar elemento dada una posici\303\263n_con indirecciones.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/bin/Debug/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.exe" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/bin/Debug/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.exe" new file mode 100644 index 0000000..3752956 Binary files /dev/null and "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/bin/Debug/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.exe" differ diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/functions.c" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/functions.c" new file mode 100644 index 0000000..7059e99 --- /dev/null +++ "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/functions.c" @@ -0,0 +1,125 @@ +#include "header.h" +int validadato(int x,int li,int ls) + { + if(x>=li&&x<=ls) + return 1; + else + return 0; + } +int menu() + { + int op,band; + band=0; + printf("\n\n\t <<>> \n"); + printf("\n\t 1-Llenar vector"); + printf("\n\t 2-Mostrar vector"); + printf("\n\t 3-Eliminar la primera aparición de un elemento del vector"); + printf("\n\t 4-Salir"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,4)); + return op; + } +void llenar_vector(int *v,int *prim_lib) + { + int i,op,band=0; + if(*prim_lib!=0) + { + printf("\n El vector ya ha sido llenado. Si continúa se borrarán \n los datos del vector. ¿Desea continuar? \n\a\a"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==2) + return; + *prim_lib=0; + printf("\n Se han borrado todos los datos del vector \n\n\a\a"); + } + printf("\n Proceda a la carga del vector \n (cuenta con %d posiciones para almacenar números enteros)\n",TAM); + for(i=0;i +#include +#include +#define TAM 20 +int validadato(int,int,int); +int menu(); +void llenar_vector(int*,int*); +void mostrar_vector(int*,int); +void borrar_primera_aparicion_de_elemento(int*,int*); +int busqueda_secuencial(int*,int,int); + diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/main.c" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/main.c" new file mode 100644 index 0000000..3c3f4cd --- /dev/null +++ "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/main.c" @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int op,vec[TAM],prim_lib=0; + printf("\n\t\t\a\a ***VECTORES***"); + op=menu(); + while(op!=4) + { + switch(op) + { + case 1: llenar_vector(vec,&prim_lib); + break; + case 2: mostrar_vector(vec,prim_lib); + break; + case 3: borrar_primera_aparicion_de_elemento(vec,&prim_lib); + break; + } + op=menu(); + } + printf("\n\t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return; + } diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/obj/Debug/functions.o" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/obj/Debug/functions.o" new file mode 100644 index 0000000..07d9332 Binary files /dev/null and "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/obj/Debug/functions.o" differ diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/obj/Debug/main.o" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/obj/Debug/main.o" new file mode 100644 index 0000000..5d974e7 Binary files /dev/null and "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/obj/Debug/main.o" differ diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.cbp" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.cbp" new file mode 100644 index 0000000..7910822 --- /dev/null +++ "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.depend" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.depend" new file mode 100644 index 0000000..8a56d7e --- /dev/null +++ "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.depend" @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1472183695 source:d:\unlam\programaciÓn\fabian 2da\vectores_eliminar la primera aparición de un elemento_con indirecciones\functions.c + "header.h" + +1472183590 d:\unlam\programaciÓn\fabian 2da\vectores_eliminar la primera aparición de un elemento_con indirecciones\header.h + + + + diff --git "a/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.layout" "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.layout" new file mode 100644 index 0000000..fe6c81d --- /dev/null +++ "b/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones/vectores_eliminar la primera aparici\303\263n de un elemento_con indirecciones.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/bin/Debug/vectores_eliminar todas las apariciones de un elemento_con indirecciones.exe b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/bin/Debug/vectores_eliminar todas las apariciones de un elemento_con indirecciones.exe new file mode 100644 index 0000000..9ae1a69 Binary files /dev/null and b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/bin/Debug/vectores_eliminar todas las apariciones de un elemento_con indirecciones.exe differ diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/functions.c b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/functions.c new file mode 100644 index 0000000..a9507c2 --- /dev/null +++ b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/functions.c @@ -0,0 +1,129 @@ +#include "header.h" +int validadato(int x,int li,int ls) + { + if(x>=li&&x<=ls) + return 1; + else + return 0; + } +int menu() + { + int op,band; + band=0; + printf("\n\n\t <<>> \n"); + printf("\n\t 1-Llenar vector"); + printf("\n\t 2-Mostrar vector"); + printf("\n\t 3-Eliminar todas las apariciones de un elemento del vector"); + printf("\n\t 4-Salir"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,4)); + return op; + } +void llenar_vector(int *v,int *prim_lib) + { + int i,op,band=0; + if(*prim_lib!=0) + { + printf("\n El vector ya ha sido llenado. Si continúa se borrarán \n los datos del vector. ¿Desea continuar? \n\a\a"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==2) + return; + *prim_lib=0; + printf("\n Se han borrado todos los datos del vector \n\n\a\a"); + } + printf("\n Proceda a la carga del vector \n (cuenta con %d posiciones para almacenar números enteros)\n",TAM); + for(i=0;i +#include +#include +#define TAM 20 +int validadato(int,int,int); +int menu(); +void llenar_vector(int*,int*); +void mostrar_vector(int*,int); +void borrar_todas_las_apariciones_de_elemento(int*,int*); +int busqueda_secuencial(int*,int,int); + diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/main.c b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/main.c new file mode 100644 index 0000000..5f46c2d --- /dev/null +++ b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/main.c @@ -0,0 +1,24 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int op,vec[TAM],prim_lib=0; + printf("\n\t\t\a\a ***VECTORES***"); + op=menu(); + while(op!=4) + { + switch(op) + { + case 1: llenar_vector(vec,&prim_lib); + break; + case 2: mostrar_vector(vec,prim_lib); + break; + case 3: borrar_todas_las_apariciones_de_elemento(vec,&prim_lib); + break; + } + op=menu(); + } + printf("\n\t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return; + } diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/obj/Debug/functions.o b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/obj/Debug/functions.o new file mode 100644 index 0000000..97b8325 Binary files /dev/null and b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/obj/Debug/functions.o differ diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/obj/Debug/main.o b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/obj/Debug/main.o new file mode 100644 index 0000000..707fbef Binary files /dev/null and b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/obj/Debug/main.o differ diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/vectores_eliminar todas las apariciones de un elemento_con indirecciones.cbp b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/vectores_eliminar todas las apariciones de un elemento_con indirecciones.cbp new file mode 100644 index 0000000..557219e --- /dev/null +++ b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/vectores_eliminar todas las apariciones de un elemento_con indirecciones.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/vectores_eliminar todas las apariciones de un elemento_con indirecciones/vectores_eliminar todas las apariciones de un elemento_con indirecciones.layout b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/vectores_eliminar todas las apariciones de un elemento_con indirecciones.layout new file mode 100644 index 0000000..46658cf --- /dev/null +++ b/vectores_eliminar todas las apariciones de un elemento_con indirecciones/vectores_eliminar todas las apariciones de un elemento_con indirecciones.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/bin/Debug/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.exe" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/bin/Debug/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.exe" new file mode 100644 index 0000000..8616489 Binary files /dev/null and "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/bin/Debug/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.exe" differ diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/functions.c" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/functions.c" new file mode 100644 index 0000000..e5dee49 --- /dev/null +++ "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/functions.c" @@ -0,0 +1,241 @@ +#include "header.h" +int validadato(int x,int li,int ls) + { + if(x>=li&&x<=ls) + return 1; + else + return 0; + } +int menu() + { + int op,band; + band=0; + printf("\n\n\t <<>> \n"); + printf("\n\t 1-Llenar vector"); + printf("\n\t 2-Mostrar vector"); + printf("\n\t 3-Insertar un elemento en el vector dada la posición de inserción"); + printf("\n\t 4-Salir"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,4)); + return op; + } +void llenar_vector(int *v,int *prim_lib) + { + int i,op,band=0; + if(*prim_lib!=0) + { + printf("\n El vector ya ha sido llenado. Si continúa se borrarán \n los datos del vector. ¿Desea continuar? \n\a\a"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==2) + return; + *prim_lib=0; + printf("\n Se han borrado todos los datos del vector \n\n\a\a"); + } + printf("\n Proceda a la carga del vector \n (cuenta con %d posiciones para almacenar números enteros)\n",TAM); + for(i=0;iprim_lib); + printf("\n Ingrese el elemento a insertar en la posición %d: \n\n\t\t",pos); + scanf("%d",&nuevo); + aux=*(v+(pos-1)); + *(v+(pos-1))=nuevo; + for(i=pos-2;i>=0;i--) + { + aux2=*(v+i); + *(v+i)=aux; + aux=aux2; + } + printf("\n\n El elemento ha sido insertado exitosamente \n\n"); + } +void insertar_y_desplazar_a_derecha(int *v,int prim_lib) + { + int band,pos,nuevo,aux,aux2,i; + printf("\n Ingrese la posición de inserción \n (1 a %d)",TAM); + printf("\n (La posición de inserción debe ser menor o igual a %d): \n\n\t\t",prim_lib); + band=0; + do + { + if(band==1) + printf("\n La posición ingresada no es correcta. Reingrésela: \n\n\t\t\a\a"); + scanf("%d",&pos); + band=1; + } + while(!validadato(pos,1,TAM)||pos>prim_lib); + printf("\n Ingrese el elemento a insertar en la posición %d: \n\n\t\t",pos); + scanf("%d",&nuevo); + aux=*(v+(pos-1)); + *(v+(pos-1))=nuevo; + for(i=pos;i +#include +#include +#define TAM 20 +int validadato(int,int,int); +int menu(); +void llenar_vector(int*,int*); +void mostrar_vector(int*,int); +void insertar_elemento(int*,int*); +void insertar_y_desplazar_a_izquierda(int*,int); +void insertar_y_desplazar_a_derecha(int*,int); diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/main.c" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/main.c" new file mode 100644 index 0000000..3f337e0 --- /dev/null +++ "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/main.c" @@ -0,0 +1,25 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int op,vec[TAM],prim_lib=0; + printf("\n\t\t\a\a ***VECTORES***"); + op=menu(); + while(op!=4) + { + switch(op) + { + case 1: llenar_vector(vec,&prim_lib); + break; + case 2: mostrar_vector(vec,prim_lib); + break; + case 3: insertar_elemento(vec,&prim_lib); + break; + } + op=menu(); + } + printf("\n\t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } + diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/obj/Debug/functions.o" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/obj/Debug/functions.o" new file mode 100644 index 0000000..78183be Binary files /dev/null and "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/obj/Debug/functions.o" differ diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/obj/Debug/main.o" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/obj/Debug/main.o" new file mode 100644 index 0000000..b9c622d Binary files /dev/null and "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/obj/Debug/main.o" differ diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.cbp" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.cbp" new file mode 100644 index 0000000..acb9dde --- /dev/null +++ "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.depend" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.depend" new file mode 100644 index 0000000..a59bf6e --- /dev/null +++ "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.depend" @@ -0,0 +1,9 @@ +# depslib dependency file v1.0 +1472155523 source:d:\unlam\programaciÓn\fabian 2da\vectores_insertar elemento dada la posición de inserción_con indirecciones\main.c + "header.h" + +1472158231 d:\unlam\programaciÓn\fabian 2da\vectores_insertar elemento dada la posición de inserción_con indirecciones\header.h + + + + diff --git "a/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.layout" "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.layout" new file mode 100644 index 0000000..074b8f7 --- /dev/null +++ "b/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones/vectores_insertar elemento dada la posici\303\263n de inserci\303\263n_con indirecciones.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/bin/Debug/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.exe b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/bin/Debug/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.exe new file mode 100644 index 0000000..0c3233e Binary files /dev/null and b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/bin/Debug/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.exe differ diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/functions.c b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/functions.c new file mode 100644 index 0000000..0394536 --- /dev/null +++ b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/functions.c @@ -0,0 +1,347 @@ +#include "header.h" +int validadato(int x,int li,int ls) + { + if(x>=li&&x<=ls) + return 1; + else + return 0; + } +int menu() + { + int op,band; + band=0; + printf("\n\n\t <<>> \n"); + printf("\n\t 1-Llenar vector ordenado ascendentemente"); + printf("\n\t 2-Mostrar vector"); + printf("\n\t 3-Insertar un elemento en el vector sin alterar el orden"); + printf("\n\t 4-Salir"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,4)); + return op; + } +void llenar_vector_ordenado(int *v,int *prim_lib) + { + int i,op,band=0; + if(*prim_lib!=0) + { + printf("\n El vector ya ha sido llenado. Si continúa se borrarán \n los datos del vector. ¿Desea continuar? \n\a\a"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==2) + return; + *prim_lib=0; + printf("\n Se han borrado todos los datos del vector \n\n\a\a"); + } + printf("\n Proceda a la carga del vector \n (cuenta con %d posiciones para almacenar números enteros)\n",TAM); + printf("\n Seleccione una de las siguientes opciones: \n"); + printf("\n\t 1-Cargar los datos de manera ordenada ascendentemente"); + printf("\n\t 2-Cargar los datos desordenados y \n\t\t ordenarlos automáticamente en forma ascendente \n"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==1) + { + for(i=0;i*(v+1)) + { + op=*v; + *v=*(v+1); + *(v+1)=op; + } + *prim_lib+=1; + printf("\n\n El elemento ha sido insertado exitosamente de forma ordenada ascendentemente \n\n"); + return; + } + } + if(*prim_lib==TAM) + { + printf("\n El vector está lleno. Si continúa perderá algún dato."); + printf("\n ¿Desea continuar? \n"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==1) + { + printf("\n Al insertar, desplazar datos a la: \n"); + printf("\n\t 1-izquierda \n\t 2-derecha \n"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==1) + { + printf("\n Se perderá el primer elemento: \n"); + insertar_ordenado_y_desplazar_a_izquierda(v,*prim_lib); + } + else + { + printf("\n Se perderá el último elemento: \n"); + insertar_ordenado_y_desplazar_a_derecha(v,*prim_lib); + } + } + else + return; + } + else + { + printf("\n El vector no está lleno."); + if(*prim_lib==0) + { + printf("\n\t De hecho, el vector está vacío \n"); + printf("\n Usted puede cargar su primer elemento: \n"); + *prim_lib+=1; + insertar_ordenado_y_desplazar_a_derecha(v,*prim_lib); + return; + } + printf("\n Al insertar, desplazar datos a la: \n"); + printf("\n\t 1-izquierda \n\t 2-derecha \n"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + band=0; + if(op==1) + { + printf("\n Si continúa perderá el primer elemento. ¿Desea continuar? \n\a\a"); + printf("\n\t 1-SI \n\t 2-NO \n"); + do + { + if(band==1) + printf("\n La opción ingresada no existe. Preste atención a lo que hace. \n\a\a"); + printf("\n\t\t Opción: \t\t"); + scanf("%d",&op); + band=1; + } + while(!validadato(op,1,2)); + if(op==1) + { + printf("\n Se perderá el primer elemento: \n"); + insertar_ordenado_y_desplazar_a_izquierda(v,*prim_lib); + } + else + return; + } + else + { + *prim_lib+=1; + insertar_ordenado_y_desplazar_a_derecha(v,*prim_lib); + } + } + } +void insertar_ordenado_y_desplazar_a_izquierda(int *v,int prim_lib) + { + int band,pos,nuevo,aux,aux2,i; + printf("\n Ingrese el elemento a insertar: \n\n\t\t"); + scanf("%d",&nuevo); + band=0; + for(i=0;i=nuevo) + { + pos=i-1; + band=1; + } + if(band==1) + break; + } + aux=*(v+pos); + *(v+pos)=nuevo; + for(i=pos-1;i>=0;i--) + { + aux2=*(v+i); + *(v+i)=aux; + aux=aux2; + } + printf("\n\n El elemento ha sido insertado exitosamente de forma ordenada ascendentemente \n\n"); + } +void insertar_ordenado_y_desplazar_a_derecha(int *v,int prim_lib) + { + int band,pos,nuevo,aux,aux2,i; + printf("\n Ingrese el elemento a insertar: \n\n\t\t"); + scanf("%d",&nuevo); + band=0; + for(i=0;i=nuevo) + { + pos=i; + band=1; + } + if(band==1) + break; + } + aux=*(v+pos); + *(v+pos)=nuevo; + for(i=pos+1;i +#include +#include +#define TAM 20 +int validadato(int,int,int); +int menu(); +void llenar_vector_ordenado(int*,int*); +void ordenamiento_ascendente_por_seleccion(int*,int); +void mostrar_vector(int*,int); +void insertar_elemento_ordenado(int*,int*); +void insertar_ordenado_y_desplazar_a_izquierda(int*,int); +void insertar_ordenado_y_desplazar_a_derecha(int*,int); diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/main.c b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/main.c new file mode 100644 index 0000000..f50fa05 --- /dev/null +++ b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/main.c @@ -0,0 +1,25 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int op,vec[TAM],prim_lib=0; + printf("\n\t\t\a\a ***VECTORES***"); + op=menu(); + while(op!=4) + { + switch(op) + { + case 1: llenar_vector_ordenado(vec,&prim_lib); + break; + case 2: mostrar_vector(vec,prim_lib); + break; + case 3: insertar_elemento_ordenado(vec,&prim_lib); + break; + } + op=menu(); + } + printf("\n\t\t\t\t\t Fin del programa.. \n\n"); + getch(); + return 0; + } + diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/obj/Debug/functions.o b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/obj/Debug/functions.o new file mode 100644 index 0000000..a9ccaac Binary files /dev/null and b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/obj/Debug/functions.o differ diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/obj/Debug/main.o b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/obj/Debug/main.o new file mode 100644 index 0000000..83a8b21 Binary files /dev/null and b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/obj/Debug/main.o differ diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.cbp b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.cbp new file mode 100644 index 0000000..a6f431a --- /dev/null +++ b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.depend b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.depend new file mode 100644 index 0000000..8b8bce8 --- /dev/null +++ b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.depend @@ -0,0 +1,23 @@ +# depslib dependency file v1.0 +1472161947 source:d:\unlam\programaciÓn\fabian 2da\vectores_insertar elemento sin alterar el orden ascendente_con indirecciones\main.c + "header.h" + +1472163660 d:\unlam\programaciÓn\fabian 2da\vectores_insertar elemento sin alterar el orden ascendente_con indirecciones\header.h + + + + +1472172922 source:d:\unlam\programaciÓn\fabian 2da\vectores_insertar elemento sin alterar el orden ascendente_con indirecciones\functions.c + "header.h" + +1472172922 source:d:\unlam\programaciÓn\fabian 2\vectores_insertar elemento sin alterar el orden ascendente_con indirecciones\functions.c + "header.h" + +1472163660 d:\unlam\programaciÓn\fabian 2\vectores_insertar elemento sin alterar el orden ascendente_con indirecciones\header.h + + + + +1472161947 source:d:\unlam\programaciÓn\fabian 2\vectores_insertar elemento sin alterar el orden ascendente_con indirecciones\main.c + "header.h" + diff --git a/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.layout b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.layout new file mode 100644 index 0000000..7680ade --- /dev/null +++ b/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones/vectores_insertar elemento sin alterar el orden ascendente_con indirecciones.layout @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/bin/Debug/vectores_insertar y eliminar_con aritm\303\251tica de punteros.exe" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/bin/Debug/vectores_insertar y eliminar_con aritm\303\251tica de punteros.exe" new file mode 100644 index 0000000..3ec1aa7 Binary files /dev/null and "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/bin/Debug/vectores_insertar y eliminar_con aritm\303\251tica de punteros.exe" differ diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/functions.c" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/functions.c" new file mode 100644 index 0000000..8ea11a2 --- /dev/null +++ "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/functions.c" @@ -0,0 +1,155 @@ +#include "header.h" +int mostrar_vector(int *v,int prim_lib,int tam) + { + if(prim_lib==1) + return 0; + int *fin=v+prim_lib-1; + while(vtam||pos>*prim_lib) + return 0; + int aux; + int *fin=v+*prim_lib-1; + v+=pos-1; + do + { + aux=*v; + *v=nuevo; + nuevo=aux; + v++; + } + while(v<=fin); + *prim_lib+=1; + return 1; + } +int insertar_en_posicion_hacia_izquierda(int *v,int *prim_lib,int tam,int nuevo,int pos) + { + if(*prim_lib>tam||pos>=*prim_lib) + return 0; + if(pos==1) + { + *v=nuevo; + return 1; + } + int *fin=v+pos-1; + int *sig=v+1; + do + { + *v=*sig; + v++; + sig++; + } + while(sig<=fin); + *v=nuevo; + return 1; + } +int insertar_en_orden(int *v,int *prim_lib,int tam,int nuevo) + { + if(*prim_lib>tam) + return 0; + int aux; + int *fin=v+*prim_lib-1; + while(*vtam) + return 0; + int *inicio=v; + v+=*prim_lib-2; + while(*v>nuevo&&v>inicio) + v--; + if(v==inicio&&*v>=nuevo) + return 0; + int aux; + do + { + aux=*v; + *v=nuevo; + nuevo=aux; + v--; + } + while(v>=inicio); + return 1; + } +int eliminar_de_posicion(int *v,int *prim_lib,int tam,int pos) + { + if(*prim_lib==1||*prim_lib==pos) + return 0; + int *fin=v+*prim_lib-1; + v+=pos-1; + int *sig=v+1; + do + { + *v=*sig; + v++; + sig++; + } + while(sig +#include +#include +#define TAM 10 +int mostrar_vector(int*,int,int); +int insertar_en_posicion(int*,int*,int,int,int); +int insertar_en_posicion_hacia_izquierda(int*,int*,int,int,int); +int insertar_en_orden(int*,int*,int,int); +int insertar_en_orden_hacia_izquierda(int*,int*,int,int); +int eliminar_de_posicion(int*,int*,int,int); +int eliminar_primera_aparicion(int*,int*,int,int); +int eliminar_todas_las_apariciones(int*,int*,int,int); diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/main.c" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/main.c" new file mode 100644 index 0000000..692ed2f --- /dev/null +++ "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/main.c" @@ -0,0 +1,61 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int v[TAM]={2,4,6,8}; + int prim_lib=5; + mostrar_vector(v,prim_lib,TAM); + +// if(insertar_en_posicion(v,&prim_lib,TAM,3,5)) +// printf("\n Se insertó un nuevo elemento \n"); +// else +// printf("\n No se puede insertar \n"); +// if(!mostrar_vector(v,prim_lib,TAM)) +// printf("\n El vector está vacío \n"); + +// if(insertar_en_posicion_hacia_izquierda(v,&prim_lib,TAM,7,4)) +// printf("\n Se insertó un nuevo elemento \n"); +// else +// printf("\n No se puede insertar \n"); +// if(!mostrar_vector(v,prim_lib,TAM)) +// printf("\n El vector está vacío \n"); + +// if(insertar_en_orden(v,&prim_lib,TAM,9)) +// printf("\n Se insertó un nuevo elemento \n"); +// else +// printf("\n No se puede insertar \n"); +// if(!mostrar_vector(v,prim_lib,TAM)) +// printf("\n El vector está vacío \n"); + + if(insertar_en_orden_hacia_izquierda(v,&prim_lib,TAM,2)) + printf("\n Se insertó un nuevo elemento \n"); + else + printf("\n No se puede insertar \n"); + if(!mostrar_vector(v,prim_lib,TAM)) + printf("\n El vector está vacío \n"); + +// if(eliminar_de_posicion(v,&prim_lib,TAM,1)) +// printf("\n Se eliminó un elemento \n"); +// else +// printf("\n No se puede eliminar \n"); +// if(!mostrar_vector(v,prim_lib,TAM)) +// printf("\n El vector está vacío \n"); + +// if(eliminar_primera_aparicion(v,&prim_lib,TAM,2)) +// printf("\n Se eliminó un elemento \n"); +// else +// printf("\n No se puede eliminar \n"); +// if(!mostrar_vector(v,prim_lib,TAM)) +// printf("\n El vector está vacío \n"); + +// if(eliminar_todas_las_apariciones(v,&prim_lib,TAM,4)) +// printf("\n Se eliminaron todas las apariciones del elemento \n"); +// else +// printf("\n No se puede eliminar \n"); +// if(!mostrar_vector(v,prim_lib,TAM)) +// printf("\n El vector está vacío \n"); + + printf("\n %d",prim_lib); + getch(); + return 0 ; + } diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/obj/Debug/functions.o" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/obj/Debug/functions.o" new file mode 100644 index 0000000..0f4461d Binary files /dev/null and "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/obj/Debug/functions.o" differ diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/obj/Debug/main.o" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/obj/Debug/main.o" new file mode 100644 index 0000000..17d57f4 Binary files /dev/null and "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/obj/Debug/main.o" differ diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.cbp" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.cbp" new file mode 100644 index 0000000..fc7b420 --- /dev/null +++ "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.cbp" @@ -0,0 +1,48 @@ + + + + + + diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.depend" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.depend" new file mode 100644 index 0000000..cac35ca --- /dev/null +++ "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.depend" @@ -0,0 +1,12 @@ +# depslib dependency file v1.0 +1472442684 source:d:\unlam\programaciÓn\fabian 2\vectores_insertar y eliminar_con aritmética de punteros\main.c + "header.h" + +1472442158 d:\unlam\programaciÓn\fabian 2\vectores_insertar y eliminar_con aritmética de punteros\header.h + + + + +1472442707 source:d:\unlam\programaciÓn\fabian 2\vectores_insertar y eliminar_con aritmética de punteros\functions.c + "header.h" + diff --git "a/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.layout" "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.layout" new file mode 100644 index 0000000..ca84bf0 --- /dev/null +++ "b/vectores_insertar y eliminar_con aritm\303\251tica de punteros/vectores_insertar y eliminar_con aritm\303\251tica de punteros.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/vectores_menu completo/bin/Debug/vectores_menu completo.exe b/vectores_menu completo/bin/Debug/vectores_menu completo.exe new file mode 100644 index 0000000..999ddb2 Binary files /dev/null and b/vectores_menu completo/bin/Debug/vectores_menu completo.exe differ diff --git a/vectores_menu completo/functions.c b/vectores_menu completo/functions.c new file mode 100644 index 0000000..3084955 --- /dev/null +++ b/vectores_menu completo/functions.c @@ -0,0 +1,297 @@ +#include "header.h" +int cargar_vector(int *v,int tam,int *prim_libre) + { + int band,cant,*ult; + printf("\n Ingrese la cantidad de elementos que desea cargar (máximo %d): \t",tam-(*prim_libre-1)); + band=0; + do + { + if(band==1) + printf("\n La cantidad ingresada no es correcta. Reingrésela: \t"); + scanf("%d",&cant); + band=1; + } + while(!DATO_VALIDO(cant,0,tam-(*prim_libre-1))); + if(cant==0) + return 0; + ult=v+*prim_libre-1+cant; + for(v=v+*prim_libre-1;v*sig) + { + aux=*v; + *v=*sig; + *sig=aux; + hubo_cambio=1; + } + v++; + sig++; + } + v=inicio; + sig=v+1; + fin--; + } + while(hubo_cambio==1&&sig*comp) + { + menor=comp; + band=1; + } + comp++; + } + if(band==1) + { + aux=*v; + *v=*menor; + *menor=aux; + } + v++; + } + } +void seleccion_orden_descendente(int *v,int ce) + { + if(ce==1||ce==0) + return; + int aux,band=0,*fin=v+ce,*mayor,*comp=v; + while(vtam||pos>*prim_lib) + return 0; + int aux; + int *fin=v+*prim_lib-1; + v+=pos-1; + do + { + aux=*v; + *v=nuevo; + nuevo=aux; + v++; + } + while(v<=fin); + *prim_lib+=1; + return 1; + } +int insertar_en_posicion_hacia_izquierda(int *v,int *prim_lib,int tam,int nuevo,int pos) + { + if(*prim_lib>tam||pos>=*prim_lib) + return 0; + if(pos==1) + { + *v=nuevo; + return 1; + } + int *fin=v+pos-1; + int *sig=v+1; + do + { + *v=*sig; + v++; + sig++; + } + while(sig<=fin); + *v=nuevo; + return 1; + } +int insertar_en_orden(int *v,int *prim_lib,int tam,int nuevo) + { + if(*prim_lib>tam) + return 0; + int aux; + int *fin=v+*prim_lib-1; + while(*vtam) + return 0; + int *inicio=v; + v+=*prim_lib-2; + while(*v>nuevo&&v>inicio) + v--; + if(v==inicio&&*v>=nuevo) + return 0; + int aux; + do + { + aux=*v; + *v=nuevo; + nuevo=aux; + v--; + } + while(v>=inicio); + return 1; + } +int eliminar_de_posicion(int *v,int *prim_lib,int tam,int pos) + { + if(*prim_lib==1||*prim_lib==pos) + return 0; + int *fin=v+*prim_lib-1; + v+=pos-1; + int *sig=v+1; + do + { + *v=*sig; + v++; + sig++; + } + while(sig +#include +#include +#include +#define TAM 10 +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls))?1:0 +void menu(int*,int,int*); +int cargar_vector(int*,int,int*); +void vaciar_vector(int*,int,int*); +int mostrar_vector(int*,int,int); +void mostrar_informe_del_vector(int*,int,int); +void burbujeo_orden_ascendente(int*,int); +void burbujeo_orden_descendente(int*,int); +void seleccion_orden_ascendente(int*,int); +void seleccion_orden_descendente(int*,int); +int insertar_en_posicion(int*,int*,int,int,int); +int insertar_en_posicion_hacia_izquierda(int*,int*,int,int,int); +int insertar_en_orden(int*,int*,int,int); +int insertar_en_orden_hacia_izquierda(int*,int*,int,int); +int eliminar_de_posicion(int*,int*,int,int); +int eliminar_primera_aparicion(int*,int*,int,int); +int eliminar_todas_las_apariciones(int*,int*,int,int); diff --git a/vectores_menu completo/main.c b/vectores_menu completo/main.c new file mode 100644 index 0000000..e8344c6 --- /dev/null +++ b/vectores_menu completo/main.c @@ -0,0 +1,12 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 0E"); + int v[TAM]; + int prim_libre=1; + menu(v,TAM,&prim_libre); + printf("\n\n\a\a Fin del programa... \n\n\a\a"); + getch(); + return 0; + } diff --git a/vectores_menu completo/menu.c b/vectores_menu completo/menu.c new file mode 100644 index 0000000..f8feb6c --- /dev/null +++ b/vectores_menu completo/menu.c @@ -0,0 +1,362 @@ +#include "header.h" +void menu(int *v,int tam,int *prim_libre) + { + int op,op2,band; + do + { + system("cls"); + printf("\n\t\t\t ************"); + printf("\n\t\t\t * VECTORES *"); + printf("\n\t\t\t ************\n\a\a"); + printf("\n\t 1- Cargar vector"); + printf("\n\t 2- Vaciar vector"); + printf("\n\t 3- Mostrar vector"); + printf("\n\t 4- Ordenar el vector"); + printf("\n\t 5- Mostrar informe del vector"); + printf("\n\t 6- Insertar elementos en el vector"); + printf("\n\t 7- Eliminar elementos del vector"); + printf("\n\t 8- Salir"); + printf("\n\t\t\t\t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada es incorrecta. Ingrese una opción: \t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,8)); + system("cls"); + switch(op) + { + case 1: + if(*prim_libre!=1) + { + printf("\n El vector ya ha sido cargado. Usted puede elegir entre las siguientes opciones: \n\a\a"); + printf("\n\t 1- Cargar el vector desde cero \n\t 2- Seguir cargando elementos \n"); + printf("\n\t\t Opción: \t"); + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + printf("\n Se borrarán todos los elementos del vector \n ¿Desea continuar? \a\a"); + printf("\n\t 1- SI \t 2- NO \t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + vaciar_vector(v,tam,prim_libre); + printf("\n El vector fue vaciado correctamente \n\a\a"); + } + else + break; + } + } + if(cargar_vector(v,tam,prim_libre)) + printf("\n Se han cargado elementos en el vector \n\a\a"); + else + printf("\n No se han cargado elementos en el vector \n\a\a"); + break; + case 2: + if(*prim_libre==1) + printf("\n No se puede vaciar el vector ya que está vacío \n\a\a"); + else + { + vaciar_vector(v,tam,prim_libre); + printf("\n El vector fue vaciado correctamente \n\a\a"); + } + break; + case 3: + if(!mostrar_vector(v,tam,*prim_libre)) + printf("\n El vector que desea mostrar está vacío \n\a\a"); + break; + case 4: + if(*prim_libre==1) + { + printf("\n No se puede ordenar el vector ya que está vacío \n\a\a"); + break; + } + printf("\n Seleccione una de éstas técnicas de ordenamiento: \n\a\a"); + printf("\n\t 1- Burbujeo \t 2- Selección \t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + printf("\n ¿De qué forma desea ordenarlo? \n\a\a"); + printf("\n\t 1- Orden Ascendente \t 2- Orden Descendente \t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + burbujeo_orden_ascendente(v,*prim_libre-1); + printf("\n El vector fue ordenado ascendentemente mediante la técnica de burbujeo \n\n\a\a"); + } + else + { + burbujeo_orden_descendente(v,*prim_libre-1); + printf("\n El vector fue ordenado descendentemente mediante la técnica de burbujeo \n\n\a\a"); + } + } + else + { + printf("\n ¿De qué forma desea ordenarlo? \n\a\a"); + printf("\n\t 1- Orden Ascendente \t 2- Orden Descendente \t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + seleccion_orden_ascendente(v,*prim_libre-1); + printf("\n El vector fue ordenado ascendentemente mediante la técnica de selección \n\n\a\a"); + } + else + { + seleccion_orden_descendente(v,*prim_libre-1); + printf("\n El vector fue ordenado descendentemente mediante la técnica de selección \n\n\a\a"); + } + } + break; + case 5: + printf("\n Informe del vector \n\a\a"); + mostrar_informe_del_vector(v,tam,*prim_libre); + break; + case 6: + printf("\n Elija una de las siguientes opciones:\n\a\a"); + printf("\n\t 1- Insertar elemento en posición con desplazamiento a la derecha"); + printf("\n\t 2- Insertar elemento en posición con desplazamiento a la izquierda"); + printf("\n\t 3- Insertar elemento sin alterar el orden ascendente \n\t\t\t con desplazamiento a la derecha"); + printf("\n\t 4- Insertar elemento sin alterar el orden ascendente \n\t\t\t con desplazamiento a la izquierda"); + printf("\n\n\t\t\t\t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,3)); + system("cls"); + switch(op) + { + case 1: + printf("\n Ingrese la posición en la que desea insertar un elemento: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,*prim_libre)); + system("cls"); + printf("\n Ingrese el número que desea insertar en esa posición: \t"); + scanf("%d",&op2); + system("cls"); + if(insertar_en_posicion(v,prim_libre,tam,op2,op)) + printf("\n Se insertó el elemento exitosamente \n\a\a"); + else + printf("\n No se insertó el elemento ya que la posición es inválida \n\a\a"); + break; + case 2: + printf("\n Ingrese la posición en la que desea insertar un elemento: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,*prim_libre)); + system("cls"); + printf("\n Ingrese el número que desea insertar en esa posición: \t"); + scanf("%d",&op2); + system("cls"); + if(insertar_en_posicion_hacia_izquierda(v,prim_libre,tam,op2,op)) + printf("\n Se insertó el elemento exitosamente \n\a\a"); + else + printf("\n No se insertó el elemento ya que la posición es inválida \n\a\a"); + break; + case 3: + printf("\n El vector debe estar ordenado ascendentemente\a\a"); + if(*prim_libre==1) + { + printf("\n No se puede ordenar el vector ya que está vacío \n\a\a"); + break; + } + printf("\n Si no lo está será ordenado. ¿Desea continuar? \n\a\a"); + printf("\n\t 1- SI \t 2- NO \t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + burbujeo_orden_ascendente(v,*prim_libre-1); + printf("\n El vector fue ordenado exitosamente \n\a\a"); + getch(); + } + else + break; + system("cls"); + printf("\n Ingrese el número que desea insertar en orden: \t"); + scanf("%d",&op); + system("cls"); + if(insertar_en_orden(v,prim_libre,tam,op)) + printf("\n Se insertó el elemento exitosamente \n\a\a"); + else + printf("\n No se insertó el elemento \n\a\a"); + break; + case 4: + if(*prim_libre==1) + { + printf("\n No se puede ordenar el vector ya que está vacío \n\a\a"); + break; + } + printf("\n El vector debe estar ordenado ascendentemente\a\a"); + printf("\n Si no lo está será ordenado. ¿Desea continuar? \n\a\a"); + printf("\n\t 1- SI \t 2- NO \t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + system("cls"); + if(op==1) + { + burbujeo_orden_ascendente(v,*prim_libre-1); + printf("\n El vector fue ordenado exitosamente \n\a\a"); + getch(); + } + else + break; + system("cls"); + printf("\n Ingrese el número que desea insertar en orden: \t"); + scanf("%d",&op); + system("cls"); + if(insertar_en_orden_hacia_izquierda(v,prim_libre,tam,op)) + printf("\n Se insertó el elemento exitosamente \n\a\a"); + else + printf("\n No se insertó el elemento \n\a\a"); + break; + } + break; + case 7: + if(*prim_libre==1) + { + printf("\n No se pueden eliminar elementos del vector ya que está vacío \n\a\a"); + break; + } + printf("\n Elija una de las siguientes opciones:\n\a\a"); + printf("\n\t 1- Eliminar elemento de una posición del vector"); + printf("\n\t 2- Eliminar primera aparición de un elemento del vector"); + printf("\n\t 3- Eliminar todas las apariciones de un elemento del vector"); + printf("\n\n\t\t\t\t\t Opción: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,3)); + system("cls"); + switch(op) + { + case 1: + printf("\n Ingrese la posición de la que desea eliminar un elemento: \t"); + band=0; + do + { + if(band==1) + printf("\n La opción ingresada no es correcta. Ingrese opción:\t\a\a"); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,*prim_libre)); + system("cls"); + if(eliminar_de_posicion(v,prim_libre,tam,op)) + printf("\n Se eliminó el elemento de esa posición exitosamente \n\a\a"); + else + printf("\n No se eliminó el elemento ya que la posición es inválida \n\a\a"); + break; + case 2: + printf("\n Ingrese el número del que desea eliminar su primera aparición: \t"); + scanf("%d",&op); + system("cls"); + if(eliminar_primera_aparicion(v,prim_libre,tam,op)) + printf("\n Se eliminó la primera aparición del elemento exitosamente \n\a\a"); + else + printf("\n No se eliminó el elemento ya que no se encuentra en el vector \n\a\a"); + break; + case 3: + printf("\n Ingrese el número del que desea eliminar todas sus apariciones: \t"); + scanf("%d",&op); + system("cls"); + if(eliminar_todas_las_apariciones(v,prim_libre,tam,op)) + printf("\n Se eliminaron todas las apariciones del elemento exitosamente \n\a\a"); + else + printf("\n No se eliminó el elemento ya que no se encuentra en el vector \n\a\a"); + break; + } + break; + } + if(op!=8) + { + printf("\n\n Presione cualquier tecla para retornar al menú principal \n\n"); + getch(); + } + } + while(op!=8); + } diff --git a/vectores_menu completo/obj/Debug/functions.o b/vectores_menu completo/obj/Debug/functions.o new file mode 100644 index 0000000..b29d287 Binary files /dev/null and b/vectores_menu completo/obj/Debug/functions.o differ diff --git a/vectores_menu completo/obj/Debug/main.o b/vectores_menu completo/obj/Debug/main.o new file mode 100644 index 0000000..eed71d9 Binary files /dev/null and b/vectores_menu completo/obj/Debug/main.o differ diff --git a/vectores_menu completo/obj/Debug/menu.o b/vectores_menu completo/obj/Debug/menu.o new file mode 100644 index 0000000..99fb933 Binary files /dev/null and b/vectores_menu completo/obj/Debug/menu.o differ diff --git a/vectores_menu completo/vectores_menu completo.cbp b/vectores_menu completo/vectores_menu completo.cbp new file mode 100644 index 0000000..cb0d6a4 --- /dev/null +++ b/vectores_menu completo/vectores_menu completo.cbp @@ -0,0 +1,51 @@ + + + + + + diff --git a/vectores_menu completo/vectores_menu completo.depend b/vectores_menu completo/vectores_menu completo.depend new file mode 100644 index 0000000..de3219d --- /dev/null +++ b/vectores_menu completo/vectores_menu completo.depend @@ -0,0 +1,16 @@ +# depslib dependency file v1.0 +1472675876 source:d:\unlam\programaciÓn\fabian 2\vectores_menu completo\functions.c + "header.h" + +1472614394 d:\unlam\programaciÓn\fabian 2\vectores_menu completo\header.h + + + + + +1472677377 source:d:\unlam\programaciÓn\fabian 2\vectores_menu completo\main.c + "header.h" + +1472676053 source:d:\unlam\programaciÓn\fabian 2\vectores_menu completo\menu.c + "header.h" + diff --git a/vectores_menu completo/vectores_menu completo.layout b/vectores_menu completo/vectores_menu completo.layout new file mode 100644 index 0000000..6dfef9e --- /dev/null +++ b/vectores_menu completo/vectores_menu completo.layout @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/bin/Debug/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.exe" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/bin/Debug/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.exe" new file mode 100644 index 0000000..2b09b6d Binary files /dev/null and "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/bin/Debug/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.exe" differ diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/funciones.c" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/funciones.c" new file mode 100644 index 0000000..12a856f --- /dev/null +++ "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/funciones.c" @@ -0,0 +1,25 @@ +#include "header.h" +int validadato(int x,int li,int ls) + { + if(x>=li&&x<=ls) + return 1; + else + return 0; + } +float angulo_entre_manecillas(int h,int m) + { + int beta,theta; + float alfa,phi; + beta=m*6; + theta=h*30; + alfa=m*0.5; + phi=(theta+alfa)-beta; + return fabs(phi); + } +float sexagesimales_a_radianes(float sex) + { + float rad; + rad=sex*0.017453; + return fabs(rad); + } + diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/header.h" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/header.h" new file mode 100644 index 0000000..48e8518 --- /dev/null +++ "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/header.h" @@ -0,0 +1,7 @@ +#include +#include +#include +int validadato(int,int,int); +float angulo_entre_manecillas(int,int); +float sexagesimales_a_radianes(float); + diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/main.c" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/main.c" new file mode 100644 index 0000000..b577d91 --- /dev/null +++ "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/main.c" @@ -0,0 +1,31 @@ +#include "header.h" +int main() + { + setlocale(LC_CTYPE,"Spanish"); + int hs,min,band; + printf("\n ÁNGULO ENTRE MANECILLAS DEL RELOJ ANALÓGICO \n"); + printf("\n Ingrese un horario (hora y minutos) en formato de 12hs \n"); + band=0; + do + { + if(band==1) + printf("\n La hora ingresada no existe. Reingrésela: \n"); + printf("\n Hora (0 a 11): \n\n\t\t"); + scanf("%d",&hs); + } + while(!validadato(hs,0,11)); + band=0; + do + { + if(band==1) + printf("\n Los minutos ingresados no existen. Reingréselos: \n"); + printf("\n Minutos (0 a 59): \n\n\t\t"); + scanf("%d",&min); + } + while(!validadato(min,0,59)); + printf("\n Ángulo entre manecillas: \n"); + printf("\n\t en grados sexagesimales: %.2f \n",angulo_entre_manecillas(hs,min)); + printf("\n\t en radianes: %.2f \n\n\n",sexagesimales_a_radianes(angulo_entre_manecillas(hs,min))); + getch(); + return 0; + } diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/obj/Debug/funciones.o" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/obj/Debug/funciones.o" new file mode 100644 index 0000000..6adc059 Binary files /dev/null and "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/obj/Debug/funciones.o" differ diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/obj/Debug/main.o" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/obj/Debug/main.o" new file mode 100644 index 0000000..689f5c0 Binary files /dev/null and "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/obj/Debug/main.o" differ diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.cbp" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.cbp" new file mode 100644 index 0000000..eb1cdd7 --- /dev/null +++ "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.cbp" @@ -0,0 +1,47 @@ + + + + + + diff --git "a/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.layout" "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.layout" new file mode 100644 index 0000000..4222504 --- /dev/null +++ "b/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica/\303\241ngulo entre las manecillas de un reloj_movimiento circular uniforme_f\303\255sica.layout" @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git "a/\303\241rbol_men\303\272/arbol en inorden.bin" "b/\303\241rbol_men\303\272/arbol en inorden.bin" new file mode 100644 index 0000000..cdaad98 Binary files /dev/null and "b/\303\241rbol_men\303\272/arbol en inorden.bin" differ diff --git "a/\303\241rbol_men\303\272/arbol en inorden.txt" "b/\303\241rbol_men\303\272/arbol en inorden.txt" new file mode 100644 index 0000000..3b34ad1 --- /dev/null +++ "b/\303\241rbol_men\303\272/arbol en inorden.txt" @@ -0,0 +1 @@ +12|18|20|25|30|40|50|60|70|75|90|100| \ No newline at end of file diff --git "a/\303\241rbol_men\303\272/arbol en posorden.bin" "b/\303\241rbol_men\303\272/arbol en posorden.bin" new file mode 100644 index 0000000..f7198ed Binary files /dev/null and "b/\303\241rbol_men\303\272/arbol en posorden.bin" differ diff --git "a/\303\241rbol_men\303\272/arbol en posorden.txt" "b/\303\241rbol_men\303\272/arbol en posorden.txt" new file mode 100644 index 0000000..8af3594 --- /dev/null +++ "b/\303\241rbol_men\303\272/arbol en posorden.txt" @@ -0,0 +1 @@ +18|20|12|30|40|25|70|60|100|90|75|50| \ No newline at end of file diff --git "a/\303\241rbol_men\303\272/arbol en preorden.bin" "b/\303\241rbol_men\303\272/arbol en preorden.bin" new file mode 100644 index 0000000..5681fb7 Binary files /dev/null and "b/\303\241rbol_men\303\272/arbol en preorden.bin" differ diff --git "a/\303\241rbol_men\303\272/arbol en preorden.txt" "b/\303\241rbol_men\303\272/arbol en preorden.txt" new file mode 100644 index 0000000..2cb3982 --- /dev/null +++ "b/\303\241rbol_men\303\272/arbol en preorden.txt" @@ -0,0 +1 @@ +50|25|12|20|18|40|30|75|60|70|90|100| \ No newline at end of file diff --git "a/\303\241rbol_men\303\272/bin/Debug/\303\241rbol_men\303\272.exe" "b/\303\241rbol_men\303\272/bin/Debug/\303\241rbol_men\303\272.exe" new file mode 100644 index 0000000..972c894 Binary files /dev/null and "b/\303\241rbol_men\303\272/bin/Debug/\303\241rbol_men\303\272.exe" differ diff --git "a/\303\241rbol_men\303\272/dato.h" "b/\303\241rbol_men\303\272/dato.h" new file mode 100644 index 0000000..d4efa23 --- /dev/null +++ "b/\303\241rbol_men\303\272/dato.h" @@ -0,0 +1,5 @@ + +typedef struct +{ + int numero; +}t_dato; diff --git "a/\303\241rbol_men\303\272/funciones.c" "b/\303\241rbol_men\303\272/funciones.c" new file mode 100644 index 0000000..86a232c --- /dev/null +++ "b/\303\241rbol_men\303\272/funciones.c" @@ -0,0 +1,58 @@ +#include "header.h" + +void cargar_dato(t_dato *d) +{ + printf("\n\n Ingrese dato (número): \t"); + scanf("%d",&d->numero); +} + +void mostrar_dato(const t_dato *d) +{ + printf("\n\n DATO: \t %d \n",d->numero); +} + +void mostrar_nodo(const void *v) +{ + t_dato *d=(t_dato*)v; + printf("\t %d",d->numero); +} + +int comparar_enteros(const void *v1,const void *v2) +{ + int *e1=(int*)v1,*e2=(int*)v2; + return *e1-*e2; +} + +int ingresa_nivel(void) +{ + int nivel,band=0; + printf("\n\n Ingrese nivel (mayor o igual a -1): \n\n\t\a\a"); + do + { + if(band==1) + printf("\n\n El nivel ingresado no es válido. Ingrese el nivel: \n\n\t"); + fflush(stdin); + scanf("%d",&nivel); + band=1; + } + while(nivel<-1); + system("cls"); + return nivel; +} + +int ingresa_altura(void) +{ + int altura,band=0; + printf("\n\n Ingrese altura (mayor o igual a 0): \n\n\t\a\a"); + do + { + if(band==1) + printf("\n\n La altura ingresada no es válida. Ingrese la altura: \n\n\t"); + fflush(stdin); + scanf("%d",&altura); + band=1; + } + while(altura<0); + system("cls"); + return altura; +} diff --git "a/\303\241rbol_men\303\272/header.h" "b/\303\241rbol_men\303\272/header.h" new file mode 100644 index 0000000..29e54af --- /dev/null +++ "b/\303\241rbol_men\303\272/header.h" @@ -0,0 +1,29 @@ +#include +#include +#include +#include + +#include "primitivas_árbol.h" + +#define DATO_VALIDO(x,li,ls) ((x)>=(li)&&(x)<=(ls)) + +void cargar_dato(t_dato*); +void mostrar_dato(const t_dato*); +void mostrar_nodo(const void*); +int comparar_enteros(const void*,const void*); + +int menu(void); + +int recursiva_o_iterativa(void); +int submenu_recorrer(void); + +int binario_o_texto(void); +int submenu_exportar(void); + +int submenu_contar(void); +int submenu_mostrar(void); +int submenu_mostrar_y_contar(void); +int submenu_podar(void); + +int ingresa_nivel(void); +int ingresa_altura(void); diff --git "a/\303\241rbol_men\303\272/main.c" "b/\303\241rbol_men\303\272/main.c" new file mode 100644 index 0000000..c94905d --- /dev/null +++ "b/\303\241rbol_men\303\272/main.c" @@ -0,0 +1,1298 @@ +#include "header.h" + +int main() +{ + setlocale(LC_CTYPE,"Spanish"); + system("COLOR 5F"); + + int op,band,hay_arbol=0,nivel,altura; + + t_arbol arbol; + t_nodo **padre; + t_dato dato; + t_arbol *nodo; + + FILE *pf; + char path[20]; + + op=menu(); + while(op) + { + switch(op) + { + case 1: + if(hay_arbol) + { + printf("\n\n Ya se ha creado un árbol. Si continúa, lo perderá.\a\a"); + printf("\n\n ¿Desea continuar? \n\n\t 1- Si \t 2-No \t Opción: \t"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==2) + { + printf("\n\n Creación de árbol abortada \n\a\a"); + getch(); + break; + } + + vaciar_arbol(&arbol); + hay_arbol=0; + printf("\n\n El árbol ha sido descartado \n\a\a"); + getch(); + system("cls"); + } + + crear_arbol(&arbol); + hay_arbol=1; + printf("\n\n Se ha creado un nuevo árbol exitosamente \n\n\a\a"); + getch(); + break; + + case 2: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede talarlo. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n Si tala el árbol, éste dejará de existir"); + printf("\n\n Además, no se liberará la memoria de los nodos"); + printf("\n\n Se cortará el árbol directamente desde la ráiz"); + printf("\n\n ¿Desea continuar? \n\n\t 1- Si \t 2-No \t Opción: \t\a\a"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==2) + { + printf("\n\n Tala de árbol abortada \n\a\a"); + getch(); + break; + } + + talar_arbol(&arbol); + hay_arbol=0; + printf("\n\n Se ha talado el árbol exitosamente \n\n\a\a"); + getch(); + break; + + case 3: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede vaciarlo. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido vaciarlo. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n Si vacía el árbol, perderá todos sus datos, \a\a"); + printf("\n pero el árbol seguirá existiendo"); + printf("\n\n ¿Desea continuar? \n\n\t 1- Si \t 2-No \t Opción: \t"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==2) + { + printf("\n\n Vaciamiento de árbol abortado \n\a\a"); + getch(); + break; + } + + vaciar_arbol(&arbol); + printf("\n\n Se ha vaciado el árbol exitosamente \n\n\a\a"); + getch(); + break; + + case 4: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede preguntar si está vacío. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n El árbol %s vacío \n\n\a\a",arbol_vacio(&arbol)?"está":"no está"); + getch(); + break; + + case 5: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede preguntar si está lleno. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n El árbol %s lleno \n\n\a\a",arbol_lleno(&arbol)?"está":"no está"); + getch(); + break; + + break; + + case 6: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede recorrerlo. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido recorrerlo. \n\n\a\a"); + getch(); + break; + } + + op=submenu_recorrer(); + while(op) + { + switch(op) + { + case 1: + if(recursiva_o_iterativa()==1) + { + printf("\n\n Notación Infija Usual \n\n\a\a"); + recorrer_arbol_inorden_recursiva(&arbol,mostrar_nodo); + } + else + { + printf("\n\n Notación Infija Usual \n\n\a\a"); + recorrer_arbol_inorden_iterativa(&arbol,mostrar_nodo); + } + getch(); + break; + + case 2: + if(recursiva_o_iterativa()==1) + { + printf("\n\n Notación Polaca \n\n\a\a"); + recorrer_arbol_preorden_recursiva(&arbol,mostrar_nodo); + } + else + { + printf("\n\n Notación Polaca \n\n\a\a"); + recorrer_arbol_preorden_iterativa(&arbol,mostrar_nodo); + } + getch(); + break; + + case 3: + if(recursiva_o_iterativa()==1) + { + printf("\n\n Notación Polaca Inversa \n\n\a\a"); + recorrer_arbol_posorden_recursiva(&arbol,mostrar_nodo); + } + else + { + printf("\n\n Notación Polaca Inversa \n\n\a\a"); + recorrer_arbol_posorden_iterativa(&arbol,mostrar_nodo); + } + getch(); + break; + } + + op=submenu_recorrer(); + } + + printf("\n\n \t\t SUBMENU ABORTADO \n\a\a"); + getch(); + break; + + case 7: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede insertar un dato. \n\n\a\a"); + getch(); + break; + } + + band=0; + do + { + system("cls"); + printf("\n\n Carga de dato a insertar \n\a\a"); + fflush(stdin); + cargar_dato(&dato); + system("cls"); + + if(recursiva_o_iterativa()==1) + { + if(insertar_en_arbol_recursiva(&arbol,&dato,comparar_enteros)) + printf("\n\n Se ha insertado el dato exitosamente \n\n\a\a"); + else + printf("\n\n No se ha logrado concretar la inserción \n\n\a\a"); + } + else + { + if(insertar_en_arbol_iterativa(&arbol,&dato,comparar_enteros)) + printf("\n\n Se ha insertado el dato exitosamente \n\n\a\a"); + else + printf("\n\n No se ha logrado concretar la inserción \n\n\a\a"); + } + + getch(); + system("cls"); + printf("\n\n ¿Desea insertar otro dato? \n\n\t 1- Si \t 2-No \t Opción: \t\a\a"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + } + while(op==1); + + system("cls"); + printf("\n\n Inserción finalizada \n\n\a\a"); + getch(); + break; + + case 8: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede buscar un dato. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido buscar algo. \n\n\a\a"); + getch(); + break; + } + + band=0; + do + { + system("cls"); + printf("\n\n Carga de dato a buscar \n\a\a"); + fflush(stdin); + cargar_dato(&dato); + system("cls"); + + printf("\n\n Elija el resultado que espera de la búsqueda:\a\a"); + printf("\n 1- Dato encontrado \t 2- Padre del dato buscado \n\n\t\t Opción: \t"); + fflush(stdin); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==1) + { + if(recursiva_o_iterativa()==1) + { + if(buscar_en_arbol_recursiva(&arbol,&dato,comparar_enteros)) + { + printf("\n\n El dato ha sido encontrado \a\a"); + mostrar_dato(&dato); + } + else + printf("\n\n No se ha encontrado el dato \n\n\a\a"); + } + else + { + if(buscar_en_arbol_iterativa(&arbol,&dato,comparar_enteros)) + { + printf("\n\n El dato ha sido encontrado \a\a"); + mostrar_dato(&dato); + } + else + printf("\n\n No se ha encontrado el dato \n\n\a\a"); + } + } + else + { + if(recursiva_o_iterativa()==1) + { + if((padre=buscar_en_arbol_y_retornar_direccion_padre_recursiva(&arbol,&dato,comparar_enteros))) + { + printf("\n\n El dato ha sido encontrado \a\a"); + printf("\n\n Padre el dato: \n"); + mostrar_dato(&(*padre)->dato); + } + else + printf("\n\n No se ha encontrado al padre del dato buscado \n\n\a\a"); + } + else + { + if((padre=buscar_en_arbol_y_retornar_direccion_padre_iterativa(&arbol,&dato,comparar_enteros))) + { + printf("\n\n El dato ha sido encontrado \a\a"); + printf("\n\n Padre del dato: \n"); + mostrar_dato(&(*padre)->dato); + } + else + printf("\n\n No se ha encontrado al padre del dato buscado \n\n\a\a"); + } + } + + getch(); + system("cls"); + printf("\n\n ¿Desea buscar otro dato? \n\n\t 1- Si \t 2-No \t Opción: \t\a\a"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + } + while(op==1); + + system("cls"); + printf("\n\n Búsqueda finalizada \n\n\a\a"); + getch(); + break; + + case 9: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede grabarlo en un archivo. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido grabarlo en un archivo. \n\n\a\a"); + getch(); + break; + } + + op=submenu_exportar(); + while(op) + { + switch(op) + { + case 1: + if(binario_o_texto()==1) + { + printf("\n\n Ingrese el path del archivo binario a grabar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"wb"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo \"%s\" \a\a",path); + printf("\n\n No se puede exportar el árbol \n\n"); + getch(); + break; + } + + grabar_arbol_en_inorden_en_archivo_binario(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue exportado exitosamente en inorden a binario \n\n\a\a"); + } + else + { + printf("\n\n Ingrese el path del archivo de texto a grabar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"wt"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo \"%s\" \a\a",path); + printf("\n\n No se puede exportar el árbol \n\n"); + getch(); + break; + } + + grabar_arbol_en_inorden_en_archivo_de_texto(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue exportado exitosamente en inorden a texto \n\n\a\a"); + } + getch(); + break; + + case 2: + if(binario_o_texto()==1) + { + printf("\n\n Ingrese el path del archivo binario a grabar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"wb"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo \"%s\" \a\a",path); + printf("\n\n No se puede exportar el árbol \n\n"); + getch(); + break; + } + + grabar_arbol_en_preorden_en_archivo_binario(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue exportado exitosamente en preorden a binario \n\n\a\a"); + } + else + { + printf("\n\n Ingrese el path del archivo de texto a grabar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"wt"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo \"%s\" \a\a",path); + printf("\n\n No se puede exportar el árbol \n\n"); + getch(); + break; + } + + grabar_arbol_en_preorden_en_archivo_de_texto(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue exportado exitosamente en preorden a texto \n\n\a\a"); + } + getch(); + break; + + case 3: + if(binario_o_texto()==1) + { + printf("\n\n Ingrese el path del archivo binario a grabar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"wb"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo \"%s\" \a\a",path); + printf("\n\n No se puede exportar el árbol \n\n"); + getch(); + break; + } + + grabar_arbol_en_posorden_en_archivo_binario(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue exportado exitosamente en posorden a binario \n\n\a\a"); + } + else + { + printf("\n\n Ingrese el path del archivo de texto a grabar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"wt"); + if(!pf) + { + printf("\n\n No se ha podido crear el archivo \"%s\" \a\a",path); + printf("\n\n No se puede exportar el árbol \n\n"); + getch(); + break; + } + + grabar_arbol_en_posorden_en_archivo_de_texto(&arbol,pf); + fclose(pf); + printf("\n\n El árbol fue exportado exitosamente en posorden a texto \n\n\a\a"); + } + getch(); + break; + } + + op=submenu_exportar(); + } + + printf("\n\n \t\t SUBMENU ABORTADO \n\a\a"); + getch(); + break; + + case 10: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede cargarlo. \n\n\a\a"); + getch(); + break; + } + + if(!arbol_vacio(&arbol)) + { + printf("\n\n Ya se ha cargado un árbol. Si continúa, lo perderá.\a\a"); + printf("\n\n ¿Desea continuar? \n\n\t 1- Si \t 2-No \t Opción: \t"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==2) + { + printf("\n\n Carga de árbol abortada \n\a\a"); + getch(); + break; + } + + vaciar_arbol(&arbol); + hay_arbol=0; + printf("\n\n El árbol ha sido descartado \n\a\a"); + getch(); + system("cls"); + } + + printf("\n\n Ingrese el recorrido en el que fue grabado el árbol a levantar:\a\a"); + printf("\n 1- Preorden \t 2- Posorden \n\n\t\t Opción: \t"); + fflush(stdin); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==1) + { + if(binario_o_texto()==1) + { + printf("\n\n Ingrese el path del archivo binario a levantar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"rb"); + if(!pf) + { + printf("\n\n No se ha podido leer el archivo \"%s\" \a\a",path); + printf("\n\n No se puede cargar el árbol \n\n"); + getch(); + break; + } + + if(cargar_arbol_en_preorden_desde_archivo_binario(&arbol,pf,comparar_enteros)) + printf("\n\n El árbol fue cargado exitosamente en preorden desde binario \n\n\a\a"); + else + { + printf("\n\n No se pudo cargar el árbol \n\n\a\a"); + break; + } + fclose(pf); + } + else + { + printf("\n\n Ingrese el path del archivo de texto a levantar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"rt"); + if(!pf) + { + printf("\n\n No se ha podido leer el archivo \"%s\" \a\a",path); + printf("\n\n No se puede cargar el árbol \n\n"); + getch(); + break; + } + + if(cargar_arbol_en_preorden_desde_archivo_de_texto(&arbol,pf,comparar_enteros)) + printf("\n\n El árbol fue cargado exitosamente en preorden desde texto \n\n\a\a"); + else + { + printf("\n\n No se pudo cargar el árbol \n\n\a\a"); + break; + } + fclose(pf); + } + } + else + { + if(binario_o_texto()==1) + { + printf("\n\n Ingrese el path del archivo binario a levantar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"rb"); + if(!pf) + { + printf("\n\n No se ha podido leer el archivo \"%s\" \a\a",path); + printf("\n\n No se puede cargar el árbol \n\n"); + getch(); + break; + } + + if(cargar_arbol_en_posorden_desde_archivo_binario(&arbol,pf,comparar_enteros)) + printf("\n\n El árbol fue cargado exitosamente en posorden desde binario \n\n\a\a"); + else + { + printf("\n\n No se pudo cargar el árbol \n\n\a\a"); + break; + } + fclose(pf); + } + else + { + printf("\n\n Ingrese el path del archivo de texto a levantar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"rt"); + if(!pf) + { + printf("\n\n No se ha podido leer el archivo \"%s\" \a\a",path); + printf("\n\n No se puede cargar el árbol \n\n"); + getch(); + break; + } + + if(cargar_arbol_en_posorden_desde_archivo_de_texto(&arbol,pf,comparar_enteros)) + printf("\n\n El árbol fue cargado exitosamente en posorden desde texto \n\n\a\a"); + else + { + printf("\n\n No se pudo cargar el árbol \n\n\a\a"); + break; + } + fclose(pf); + } + } + + hay_arbol=1; + getch(); + break; + + case 11: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede contar. \n\n\a\a"); + getch(); + break; + } + + op=submenu_contar(); + while(op) + { + switch(op) + { + case 1: + printf("\n\n Cantidad de nodos: \t %d \n\n\a\a",contar_nodos(&arbol)); + break; + + case 2: + printf("\n\n Cantidad de hojas: \t %d \n\n\a\a",contar_hojas(&arbol)); + break; + + case 3: + printf("\n\n Cantidad de no hojas: \t %d \n\n\a\a",contar_no_hojas(&arbol)); + break; + + case 4: + printf("\n\n Cantidad de nodos con hijos solo por izquierda: \t %d \n\n\a\a",contar_nodos_con_hijos_solo_por_izquierda(&arbol)); + break; + + case 5: + printf("\n\n Cantidad de nodos con hijos solo por derecha: \t %d \n\n\a\a",contar_nodos_con_hijos_solo_por_derecha(&arbol)); + break; + + case 6: + printf("\n\n Cantidad de nodos con hijos por izquierda o por derecha: \t %d \n\n\a\a",contar_nodos_con_hijos_por_izquierda_o_por_derecha(&arbol)); + break; + + case 7: + printf("\n\n Cantidad de nodos con hijos por izquierda o por derecha, exclusiva: \t %d \n\n\a\a",contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&arbol)); + break; + + case 8: + printf("\n\n Cantidad de nodos con hijos por izquierda y por derecha: \t %d \n\n\a\a",contar_nodos_con_hijos_por_izquierda_y_por_derecha(&arbol)); + break; + + case 9: + nivel=ingresa_nivel(); + printf("\n\n Cantidad de nodos del nivel %d: \t %d \n\n\a\a",nivel,contar_nodos_de_un_nivel(&arbol,nivel)); + break; + + case 10: + nivel=ingresa_nivel(); + printf("\n\n Cantidad de nodos hasta el nivel %d: \t %d \n\n\a\a",nivel,contar_nodos_hasta_un_nivel(&arbol,nivel)); + break; + + case 11: + nivel=ingresa_nivel(); + printf("\n\n Cantidad de nodos hasta el nivel %d inclusive: \t %d \n\n\a\a",nivel,contar_nodos_hasta_un_nivel_inclusive(&arbol,nivel)); + break; + + case 12: + nivel=ingresa_nivel(); + printf("\n\n Cantidad de nodos desde el nivel %d: \t %d \n\n\a\a",nivel,contar_nodos_desde_un_nivel_inclusive(&arbol,nivel)); + break; + + case 13: + nivel=ingresa_nivel(); + printf("\n\n Cantidad de nodos desde el nivel %d inclusive: \t %d \n\n\a\a",nivel,contar_nodos_desde_un_nivel_inclusive(&arbol,nivel)); + break; + } + + getch(); + op=submenu_contar(); + } + + printf("\n\n \t\t SUBMENU ABORTADO \n\a\a"); + getch(); + break; + + case 12: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede mostrar. \n\n\a\a"); + getch(); + break; + } + + op=submenu_mostrar(); + while(op) + { + switch(op) + { + case 1: + printf("\n\n Nodos \n\n\a\a"); + mostrar_nodos(&arbol,mostrar_nodo); + break; + + case 2: + printf("\n\n Hojas \n\n\a\a"); + mostrar_hojas(&arbol,mostrar_nodo); + break; + + case 3: + printf("\n\n No hojas \n\n\a\a"); + mostrar_no_hojas(&arbol,mostrar_nodo); + break; + + case 4: + printf("\n\n Nodos con hijos solo por izquierda \n\n\a\a"); + mostrar_nodos_con_hijos_solo_por_izquierda(&arbol,mostrar_nodo); + break; + + case 5: + printf("\n\n Nodos con hijos solo por derecha \n\n\a\a"); + mostrar_nodos_con_hijos_solo_por_derecha(&arbol,mostrar_nodo); + break; + + case 6: + printf("\n\n Nodos con hijos por izquierda o por derecha \n\n\a\a"); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&arbol,mostrar_nodo); + break; + + case 7: + printf("\n\n Nodos con hijos por izquierda o por derecha, exclusiva \n\n\a\a"); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&arbol,mostrar_nodo); + break; + + case 8: + printf("\n\n Nodos con hijos por izquierda y por derecha \n\n\a\a"); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&arbol,mostrar_nodo); + break; + + case 9: + nivel=ingresa_nivel(); + printf("\n\n Nodos del nivel %d \n\n\a\a",nivel); + mostrar_nodos_de_un_nivel(&arbol,nivel,mostrar_nodo); + break; + + case 10: + nivel=ingresa_nivel(); + printf("\n\n Nodos hasta el nivel %d \n\n\a\a",nivel); + mostrar_nodos_hasta_un_nivel(&arbol,nivel,mostrar_nodo); + break; + + case 11: + nivel=ingresa_nivel(); + printf("\n\n Nodos hasta el nivel %d inclusive \n\n\a\a",nivel); + mostrar_nodos_hasta_un_nivel_inclusive(&arbol,nivel,mostrar_nodo); + break; + + case 12: + nivel=ingresa_nivel(); + printf("\n\n Nodos desde el nivel %d \n\n\a\a",nivel); + mostrar_nodos_desde_un_nivel(&arbol,nivel,mostrar_nodo); + break; + + case 13: + nivel=ingresa_nivel(); + printf("\n\n Nodos desde el nivel %d inclusive \n\n\a\a",nivel); + mostrar_nodos_desde_un_nivel_inclusive(&arbol,nivel,mostrar_nodo); + break; + } + + getch(); + op=submenu_mostrar(); + } + + printf("\n\n \t\t SUBMENU ABORTADO \n\a\a"); + getch(); + break; + + case 13: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede mostrar y contar. \n\n\a\a"); + getch(); + break; + } + + op=submenu_mostrar_y_contar(); + while(op) + { + switch(op) + { + case 1: + printf("\n\n Nodos \n\n\a\a"); + printf("\n\n Cantidad de nodos: \t %d \n\n",mostrar_y_contar_nodos(&arbol,mostrar_nodo)); + break; + + case 2: + printf("\n\n Hojas \n\n\a\a"); + printf("\n\n Cantidad de hojas: \t %d \n\n",mostrar_y_contar_hojas(&arbol,mostrar_nodo)); + break; + + case 3: + printf("\n\n No hojas \n\n\a\a"); + printf("\n\n Cantidad de no hojas: \t %d \n\n",mostrar_y_contar_no_hojas(&arbol,mostrar_nodo)); + break; + + case 4: + printf("\n\n Nodos con hijos solo por izquierda \n\n\a\a"); + printf("\n\n Cantidad de nodos con hijos solo por izquierda: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&arbol,mostrar_nodo)); + break; + + case 5: + printf("\n\n Nodos con hijos solo por derecha \n\n\a\a"); + printf("\n\n Cantidad de nodos con hijos solo por derecha: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&arbol,mostrar_nodo)); + break; + + case 6: + printf("\n\n Nodos con hijos por izquierda o por derecha \n\n\a\a"); + printf("\n\n Cantidad de nodos con hijos por izquierda o por derecha: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&arbol,mostrar_nodo)); + break; + + case 7: + printf("\n\n Nodos con hijos por izquierda o por derecha, exclusiva \n\n\a\a"); + printf("\n\n Cantidad de nodos con hijos por izquierda o por derecha, exclusiva: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&arbol,mostrar_nodo)); + break; + + case 8: + printf("\n\n Nodos con hijos por izquierda y por derecha \n\n\a\a"); + printf("\n\n Cantidad de nodos con hijos por izquierda y por derecha: \t %d \n\n",mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&arbol,mostrar_nodo)); + break; + + case 9: + nivel=ingresa_nivel(); + printf("\n\n Nodos del nivel %d \n\n\a\a",nivel); + printf("\n\n Cantidad de nodos del nivel %d: \t %d \n\n",nivel,mostrar_y_contar_nodos_de_un_nivel(&arbol,nivel,mostrar_nodo)); + break; + + case 10: + nivel=ingresa_nivel(); + printf("\n\n Nodos hasta el nivel %d \n\n\a\a",nivel); + printf("\n\n Cantidad de nodos hasta el nivel %d: \t %d \n\n",nivel,mostrar_y_contar_nodos_hasta_un_nivel(&arbol,nivel,mostrar_nodo)); + break; + + case 11: + nivel=ingresa_nivel(); + printf("\n\n Nodos hasta el nivel %d inclusive \n\n\a\a",nivel); + printf("\n\n Cantidad de nodos hasta el nivel %d inclusive: \t %d \n\n",nivel,mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&arbol,nivel,mostrar_nodo)); + break; + + case 12: + nivel=ingresa_nivel(); + printf("\n\n Nodos desde el nivel %d \n\n\a\a",nivel); + printf("\n\n Cantidad de nodos desde el nivel %d: \t %d \n\n",nivel,mostrar_y_contar_nodos_desde_un_nivel_inclusive(&arbol,nivel,mostrar_nodo)); + break; + + case 13: + nivel=ingresa_nivel(); + printf("\n\n Nodos desde el nivel %d inclusive \n\n\a\a",nivel); + printf("\n\n Cantidad de nodos desde el nivel %d inclusive: \t %d \n\n",nivel,mostrar_y_contar_nodos_desde_un_nivel_inclusive(&arbol,nivel,mostrar_nodo)); + break; + } + + getch(); + op=submenu_mostrar_y_contar(); + } + + printf("\n\n \t\t SUBMENU ABORTADO \n\a\a"); + getch(); + break; + + case 14: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede podar. \n\n\a\a"); + getch(); + break; + } + + op=submenu_podar(); + while(op) + { + switch(op) + { + case 1: + podar_hojas(&arbol); + printf("\n\n Se han podado las hojas exitosamente \n\a\a"); + break; + + case 2: + nivel=ingresa_nivel(); + podar_hasta_nivel(&arbol,nivel); + printf("\n\n Se ha podado el árbol hasta el nivel %d \n\a\a",nivel); + break; + + case 3: + nivel=ingresa_nivel(); + podar_hasta_nivel_inclusive(&arbol,nivel); + printf("\n\n Se ha podado el árbol hasta el nivel %d inclusive \n\a\a",nivel); + break; + + case 4: + altura=ingresa_altura(); + podar_hasta_altura(&arbol,altura); + printf("\n\n Se ha podado el árbol hasta la altura %d \n\a\a",altura); + break; + + case 5: + altura=ingresa_altura(); + podar_hasta_altura_inclusive(&arbol,altura); + printf("\n\n Se ha podado el árbol hasta la altura %d inclusive \n\a\a",altura); + break; + } + + getch(); + op=submenu_podar(); + } + + printf("\n\n \t\t SUBMENU ABORTADO \n\a\a"); + getch(); + break; + + case 15: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se puede calcular el nivel. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n Nivel del árbol: \t %d \n\n\a\a",calcular_nivel(&arbol)); + getch(); + break; + + case 16: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se puede calcular el altura. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n Altura del árbol: \t %d \n\n\a\a",calcular_altura(&arbol)); + getch(); + break; + + case 17: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede preguntar si es semibalanceado. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n El árbol %s semibalanceado \n\n\a\a",arbol_semibalanceado(&arbol)?"es":"no es"); + getch(); + break; + + case 18: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede preguntar si es balanceado. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n El árbol %s balanceado \n\n\a\a",arbol_balanceado(&arbol)?"es":"no es"); + getch(); + break; + + case 19: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede preguntar si es completo. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n El árbol %s completo \n\n\a\a",arbol_completo(&arbol)?"es":"no es"); + getch(); + break; + + case 20: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No puede cargarlo. \n\n\a\a"); + getch(); + break; + } + + if(!arbol_vacio(&arbol)) + { + printf("\n\n Ya se ha cargado un árbol. Si continúa, lo perderá.\a\a"); + printf("\n\n ¿Desea continuar? \n\n\t 1- Si \t 2-No \t Opción: \t"); + + band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada no existe. Ingrese una opción válida: \t\a\a"); + } + scanf("%d",&op); + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + if(op==2) + { + printf("\n\n Carga de árbol abortada \n\a\a"); + getch(); + break; + } + + vaciar_arbol(&arbol); + hay_arbol=0; + printf("\n\n El árbol ha sido descartado \n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n Ingrese el path del archivo binario en inorden a levantar \n\n\a\a"); + fflush(stdin); + gets(path); + system("cls"); + + pf=fopen(path,"rb"); + if(!pf) + { + printf("\n\n No se ha podido leer el archivo \"%s\" \a\a",path); + printf("\n\n No se puede cargar el árbol \n\n"); + getch(); + break; + } + + if(cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(&arbol,pf,comparar_enteros)) + printf("\n\n El árbol fue cargado desde inorden lo más balanceado posible \n\n\a\a"); + else + { + printf("\n\n No se pudo cargar el árbol \n\n\a\a"); + break; + } + fclose(pf); + hay_arbol=1; + getch(); + break; + + case 21: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se tiene sentido ver si es hoja. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido ver si es hoja. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n El árbol %s una hoja \n\n\a\a",hoja(&arbol)?"es":"no es"); + getch(); + break; + + case 22: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se puede buscar el nodo menor. \n\n\a\a"); + getch(); + break; + } + + if((nodo=buscar_nodo_menor(&arbol))) + { + printf("\n\n El nodo menor es: \a\a"); + mostrar_dato(&(*nodo)->dato); + } + else + printf("\n\n El árbol está vacío. No hay nodo menor \n\n\a\a"); + getch(); + break; + + case 23: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se puede buscar el nodo mayor. \n\n\a\a"); + getch(); + break; + } + + if((nodo=buscar_nodo_mayor(&arbol))) + { + printf("\n\n El nodo mayor es: \a\a"); + mostrar_dato(&(*nodo)->dato); + } + else + printf("\n\n El árbol está vacío. No hay nodo mayor \n\n\a\a"); + getch(); + break; + + case 24: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se puede eliminar un nodo. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido eliminar un nodo. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n Carga de dato a eliminar \n\a\a"); + fflush(stdin); + cargar_dato(&dato); + system("cls"); + + if(recursiva_o_iterativa()==1) + { + if(eliminar_nodo_y_acomodar_ramas_recursiva(&arbol,&dato,comparar_enteros)) + printf("\n\n El nodo fue eliminado y sus ramas fueron acomodadas \n\n\a\a"); + else + printf("\n\n No se ha encontrado el dato a eliminar \n\n\a\a"); + } + else + { + if(eliminar_nodo_y_acomodar_ramas_iterativa(&arbol,&dato,comparar_enteros)) + printf("\n\n El nodo fue eliminado y sus ramas fueron acomodadas \n\n\a\a"); + else + printf("\n\n No se ha encontrado el dato a eliminar \n\n\a\a"); + } + getch(); + break; + + case 25: + if(hay_arbol==0) + { + printf("\n\n No se ha creado un árbol. No se puede graficar el árbol. \n\n\a\a"); + getch(); + break; + } + + if(arbol_vacio(&arbol)) + { + printf("\n\n El árbol está vacío. No tiene sentido graficar el árbol. \n\n\a\a"); + getch(); + break; + } + + printf("\n\n Árbol gráfico \n\n\a\a"); + arbol_grafico(&arbol,mostrar_nodo); + + getch(); + break; + } + + op=menu(); + } + printf("\n\n \t\t MENU ABORTADO \n\a\a"); + getch(); + printf("\n\n \t\t\t\t\t Fin del programa... \n\n\a\a"); + getch(); + return 0; +} diff --git "a/\303\241rbol_men\303\272/menu.c" "b/\303\241rbol_men\303\272/menu.c" new file mode 100644 index 0000000..c679cac --- /dev/null +++ "b/\303\241rbol_men\303\272/menu.c" @@ -0,0 +1,345 @@ +#include "header.h" + +int menu(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida. \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n \t\t ****************"); + printf("\n \t\t * MENU - ÁRBOL * \a\a"); + printf("\n \t\t **************** \n\n"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Crear árbol"); + printf("\n 2- Talar árbol"); + printf("\n 3- Vaciar árbol"); + printf("\n 4- ¿Está vacío el árbol?"); + printf("\n 5- ¿Está lleno el árbol?"); + printf("\n 6- Recorrer árbol"); + printf("\n 7- Insertar en árbol"); + printf("\n 8- Buscar en árbol"); + printf("\n 9- Exportar árbol a archivo"); + printf("\n 10- Cargar árbol desde archivo"); + printf("\n 11- Contar..."); + printf("\n 12- Mostrar..."); + printf("\n 13- Mostrar y contar..."); + printf("\n 14- Podar..."); + printf("\n 15- Calcular nivel"); + printf("\n 16- Calcular altura"); + printf("\n 17- ¿Es semibalanceado el árbol?"); + printf("\n 18- ¿Es balanceado el árbol?"); + printf("\n 19- ¿Es completo el árbol?"); + printf("\n 20- Cargar árbol desde archivo en inorden lo más balanceado posible"); + printf("\n 21- ¿Es hoja?"); + printf("\n 22- Buscar nodo menor"); + printf("\n 23- Buscar nodo mayor"); + printf("\n 24- Eliminar nodo y acomodar ramas"); + printf("\n 25- Árbol gráfico"); + + printf("\n\n 0- SALIR"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,25)); + + system("cls"); + return op; +} + +int recursiva_o_iterativa(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida. \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n Elija el tipo de función que desea implementar: \n\a\a"); + printf("\n 1- Recursiva \t 2- Iterativa \t Opción: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + return op; +} + +int submenu_recorrer(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida. \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n \t\t SUBMENU - RECORRER ÁRBOL \n\a\a"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Recorrer el árbol en INORDEN"); + printf("\n 2- Recorrer el árbol en PREORDEN"); + printf("\n 3- Recorrer el árbol en POSORDEN"); + + printf("\n\n 0- RETORNAR AL MENU PRINCIPAL"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,3)); + + system("cls"); + return op; +} + +int binario_o_texto(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida. \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n Elija el tipo de archivo que desea implementar: \n\a\a"); + printf("\n 1- Binario \t 2- De Texto \t Opción: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,1,2)); + + system("cls"); + return op; +} + +int submenu_exportar(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida. \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n \t\t SUBMENU - EXPORTAR ÁRBOL \n\a\a"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Exportar el árbol en INORDEN"); + printf("\n 2- Exportar el árbol en PREORDEN"); + printf("\n 3- Exportar el árbol en POSORDEN"); + + printf("\n\n 0- RETORNAR AL MENU PRINCIPAL"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,3)); + + system("cls"); + return op; +} + +int submenu_contar(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n \t\t SUBMENÚ - CONTAR \n\a\a"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Contar nodos"); + printf("\n 2- Contar hojas"); + printf("\n 3- Contar no hojas"); + printf("\n 4- Contar nodos con hijos solo por izquierda"); + printf("\n 5- Contar nodos con hijos solo por derecha"); + printf("\n 6- Contar nodos con hijos por izquierda o derecha"); + printf("\n 7- Contar nodos con hijos por izquierda o derecha, excluciva"); + printf("\n 8- Contar nodos con hijos por izquierda y por derecha"); + printf("\n 9- Contar nodos de un nivel"); + printf("\n 10- Contar nodos hasta un nivel"); + printf("\n 11- Contar nodos hasta un nivel inclusive"); + printf("\n 12- Contar nodos desde un nivel"); + printf("\n 13- Contar nodos desde un nivel inclusive"); + + printf("\n\n 0- RETORNAR AL MENÚ PRINCIPAL"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,13)); + + system("cls"); + return op; +} + +int submenu_mostrar(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n \t\t SUBMENÚ - MOSTRAR \n\a\a"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Mostrar nodos"); + printf("\n 2- Mostrar hojas"); + printf("\n 3- Mostrar no hojas"); + printf("\n 4- Mostrar nodos con hijos solo por izquierda"); + printf("\n 5- Mostrar nodos con hijos solo por derecha"); + printf("\n 6- Mostrar nodos con hijos por izquierda o derecha"); + printf("\n 7- Mostrar nodos con hijos por izquierda o derecha, excluciva"); + printf("\n 8- Mostrar nodos con hijos por izquierda y por derecha"); + printf("\n 9- Mostrar nodos de un nivel"); + printf("\n 10- Mostrar nodos hasta un nivel"); + printf("\n 11- Mostrar nodos hasta un nivel inclusive"); + printf("\n 12- Mostrar nodos desde un nivel"); + printf("\n 13- Mostrar nodos desde un nivel inclusive"); + + printf("\n\n 0- RETORNAR AL MENÚ PRINCIPAL"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,13)); + + system("cls"); + return op; +} + +int submenu_mostrar_y_contar(void) +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n \t\t SUBMENÚ - MOSTRAR Y CONTAR \n\a\a"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Mostrar y contar nodos"); + printf("\n 2- Mostrar y contar hojas"); + printf("\n 3- Mostrar y contar no hojas"); + printf("\n 4- Mostrar y contar nodos con hijos solo por izquierda"); + printf("\n 5- Mostrar y contar nodos con hijos solo por derecha"); + printf("\n 6- Mostrar y contar nodos con hijos por izquierda o derecha"); + printf("\n 7- Mostrar y contar nodos con hijos por izquierda o derecha, excluciva"); + printf("\n 8- Mostrar y contar nodos con hijos por izquierda y por derecha"); + printf("\n 9- Mostrar y contar nodos de un nivel"); + printf("\n 10- Mostrar y contar nodos hasta un nivel"); + printf("\n 11- Mostrar y contar nodos hasta un nivel inclusive"); + printf("\n 12- Mostrar y contar nodos desde un nivel"); + printf("\n 13- Mostrar y contar nodos desde un nivel inclusive"); + + printf("\n\n 0- RETORNAR AL MENÚ PRINCIPAL"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,13)); + + system("cls"); + return op; +} + +int submenu_podar() +{ + int op,band=0; + do + { + if(band==1) + { + system("cls"); + printf("\n\n La opción ingresada es inválida. Elija una opción válida \n\n\a\a"); + getch(); + } + + system("cls"); + printf("\n\n \t\t SUBMENÚ - PODAR \n\a\a"); + + printf("\n Seleccione una de las siguientes opciones: \n"); + + printf("\n 1- Podar hojas"); + printf("\n 2- Podar hasta nivel"); + printf("\n 3- Podar hasta nivel inclusive"); + printf("\n 4- Podar hasta altura"); + printf("\n 5- Podar hasta altura inclusive"); + + printf("\n\n 0- RETORNAR AL MENÚ PRINCIPAL"); + + printf("\n\n\t\t OPCIÓN: \t"); + fflush(stdin); + scanf("%d",&op); + band=1; + } + while(!DATO_VALIDO(op,0,5)); + + system("cls"); + return op; +} diff --git "a/\303\241rbol_men\303\272/obj/Debug/funciones.o" "b/\303\241rbol_men\303\272/obj/Debug/funciones.o" new file mode 100644 index 0000000..630e81e Binary files /dev/null and "b/\303\241rbol_men\303\272/obj/Debug/funciones.o" differ diff --git "a/\303\241rbol_men\303\272/obj/Debug/main.o" "b/\303\241rbol_men\303\272/obj/Debug/main.o" new file mode 100644 index 0000000..d1631d5 Binary files /dev/null and "b/\303\241rbol_men\303\272/obj/Debug/main.o" differ diff --git "a/\303\241rbol_men\303\272/obj/Debug/menu.o" "b/\303\241rbol_men\303\272/obj/Debug/menu.o" new file mode 100644 index 0000000..6a315bc Binary files /dev/null and "b/\303\241rbol_men\303\272/obj/Debug/menu.o" differ diff --git "a/\303\241rbol_men\303\272/obj/Debug/primitivas_pila_din\303\241mica.o" "b/\303\241rbol_men\303\272/obj/Debug/primitivas_pila_din\303\241mica.o" new file mode 100644 index 0000000..e0c6ef0 Binary files /dev/null and "b/\303\241rbol_men\303\272/obj/Debug/primitivas_pila_din\303\241mica.o" differ diff --git "a/\303\241rbol_men\303\272/obj/Debug/primitivas_\303\241rbol.o" "b/\303\241rbol_men\303\272/obj/Debug/primitivas_\303\241rbol.o" new file mode 100644 index 0000000..807754f Binary files /dev/null and "b/\303\241rbol_men\303\272/obj/Debug/primitivas_\303\241rbol.o" differ diff --git "a/\303\241rbol_men\303\272/primitivas_pila_din\303\241mica.c" "b/\303\241rbol_men\303\272/primitivas_pila_din\303\241mica.c" new file mode 100644 index 0000000..b2dede4 --- /dev/null +++ "b/\303\241rbol_men\303\272/primitivas_pila_din\303\241mica.c" @@ -0,0 +1,63 @@ +#include "primitivas_pila_dinámica.h" + +//no sé por qué si no pongo las bibliotecas acá me tira error +#include +#include + +void crear_pila(t_pila *p) + { + *p=NULL; + } + +int pila_llena(const t_pila *p) + { + void *aux=malloc(sizeof(t_nodo_pila)); + free(aux); + return aux==NULL; + } + +int apilar(t_pila *p,const t_dato *d) + { + t_nodo_pila *nuevo=(t_nodo_pila*)malloc(sizeof(t_nodo_pila)); + if(!nuevo) + return MEMORIA_LLENA; + nuevo->dato=*d; + nuevo->sig=*p; + *p=nuevo; + return OK; + } + +int pila_vacia(const t_pila *p) + { + return *p==NULL; + } + +int desapilar(t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + t_nodo_pila *aux=*p; + *d=(*p)->dato;//*d=aux->dato; + *p=aux->sig;//*p=(*p)->sig; + free(aux); + return OK; + } + +int ver_tope(const t_pila *p,t_dato *d) + { + if(*p==NULL) + return PILA_VACIA; + *d=(*p)->dato; + return OK; + } + +void vaciar_pila(t_pila *p) + { + t_nodo_pila *aux; + while(*p) + { + aux=*p; + *p=aux->sig; + free(aux); + } + } diff --git "a/\303\241rbol_men\303\272/primitivas_pila_din\303\241mica.h" "b/\303\241rbol_men\303\272/primitivas_pila_din\303\241mica.h" new file mode 100644 index 0000000..de93910 --- /dev/null +++ "b/\303\241rbol_men\303\272/primitivas_pila_din\303\241mica.h" @@ -0,0 +1,21 @@ +#include "dato.h" + +#define PILA_VACIA 0 +#define MEMORIA_LLENA 0 +#define OK 1 + +typedef struct s_nodo_pila + { + t_dato dato; + struct s_nodo_pila *sig; + }t_nodo_pila; + +typedef t_nodo_pila* t_pila; + +void crear_pila(t_pila*); +int pila_llena(const t_pila*); +int apilar(t_pila*,const t_dato*); +int pila_vacia(const t_pila*); +int desapilar(t_pila*,t_dato*); +int ver_tope(const t_pila*,t_dato*); +void vaciar_pila(t_pila*); diff --git "a/\303\241rbol_men\303\272/primitivas_\303\241rbol.c" "b/\303\241rbol_men\303\272/primitivas_\303\241rbol.c" new file mode 100644 index 0000000..f737049 --- /dev/null +++ "b/\303\241rbol_men\303\272/primitivas_\303\241rbol.c" @@ -0,0 +1,1037 @@ +#include "primitivas_árbol.h" + +void crear_arbol(t_arbol *a) +{ + *a=NULL; +} + +void vaciar_arbol(t_arbol *a) +{ + if(*a) + { + vaciar_arbol(&(*a)->izq); + vaciar_arbol(&(*a)->der); + free(*a); + *a=NULL; + } +} + +int arbol_vacio(const t_arbol *a) +{ + return *a==NULL; +} + +int arbol_lleno(const t_arbol *a) +{ + void *aux=malloc(sizeof(t_nodo)); + free(aux); + return aux==NULL; +} + +void recorrer_arbol_inorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_inorden_recursiva(&(*a)->izq,mostrar); + mostrar(&(*a)->dato); + recorrer_arbol_inorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_preorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + recorrer_arbol_preorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_preorden_recursiva(&(*a)->der,mostrar); + } +} + +void recorrer_arbol_posorden_recursiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + recorrer_arbol_posorden_recursiva(&(*a)->izq,mostrar); + recorrer_arbol_posorden_recursiva(&(*a)->der,mostrar); + mostrar(&(*a)->dato); + } +} + +void recorrer_arbol_inorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_preorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +void recorrer_arbol_posorden_iterativa(const t_arbol *a,t_mst mostrar) +{ + +} + +int insertar_en_arbol_recursiva(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + if(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + return insertar_en_arbol_recursiva(&(*a)->izq,d,comparar); + if(comparar((void*)&(*a)->dato,(void*)d)<0) + return insertar_en_arbol_recursiva(&(*a)->der,d,comparar); + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int insertar_en_arbol_iterativa(t_arbol *a,const t_dato *d,t_cmp comparar) +{ + while(*a) + { + if(comparar((void*)&(*a)->dato,(void*)d)>0) + a=&(*a)->izq; + else + if(comparar((void*)&(*a)->dato,(void*)d)<0) + a=&(*a)->der; + else + return DUPLICADO; + } + *a=(t_nodo*)malloc(sizeof(t_nodo)); + if(!*a) + return MEMORIA_LLENA; + (*a)->dato=*d; + (*a)->izq=NULL; + (*a)->der=NULL; + return OK; +} + +int buscar_en_arbol_recursiva(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + return buscar_en_arbol_recursiva(&(*a)->izq,d,comparar); + else + return buscar_en_arbol_recursiva(&(*a)->der,d,comparar); + } + return NO_ENCONTRADO; +} + +int buscar_en_arbol_iterativa(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + { + *d=(*a)->dato; + return OK; + } + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NO_ENCONTRADO; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo **padre=a; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return NULL; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(t_arbol *a,t_dato *d,t_cmp comparar,t_nodo **padre) +{ + int cmp; + if(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return padre; + *padre=*a; + if(cmp>0) + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->izq,d,comparar,padre); + else + return buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(&(*a)->der,d,comparar,padre); + } + return NULL; +} + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_iterativa(t_arbol *a,t_dato *d,t_cmp comparar) +{ + int cmp; + t_nodo **padre=a; + while(*a) + { + if(!(cmp=comparar((void*)&(*a)->dato,(void*)d))) + return (padre!=a)?padre:NULL; + padre=a; + if(cmp>0) + a=&(*a)->izq; + else + a=&(*a)->der; + } + return NULL; +} + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->izq,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_inorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_binario(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_binario(&(*a)->der,pf); + fwrite(&(*a)->dato,sizeof(t_dato),1,pf); + } +} + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->izq,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_inorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + fprintf(pf,"%d|",(*a)->dato.numero); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_preorden_en_archivo_de_texto(&(*a)->der,pf); + } +} + +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol *a,FILE *pf) +{ + if(*a) + { + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->izq,pf); + grabar_arbol_en_posorden_en_archivo_de_texto(&(*a)->der,pf); + fprintf(pf,"%d|",(*a)->dato.numero); + } +} + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + fread(&dato,sizeof(t_dato),1,pf); + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_pila pila; + crear_pila(&pila); + fread(&dato,sizeof(t_dato),1,pf); + while(!feof(pf)) + { + if(!apilar(&pila,&dato)) + return 0; + fread(&dato,sizeof(t_dato),1,pf); + } + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + } + return OK; +} + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + return OK; +} + +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol *a,FILE *pf,t_cmp comparar) +{ + t_dato dato; + t_pila pila; + crear_pila(&pila); + while(fscanf(pf,"%d|",&dato.numero)!=EOF) + if(!apilar(&pila,&dato)) + return 0; + while(!pila_vacia(&pila)) + { + desapilar(&pila,&dato); + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + } + return OK; +} + +int contar_nodos(const t_arbol *a) +{ + if(*a) + return contar_nodos(&(*a)->izq)+contar_nodos(&(*a)->der)+1; + return 0; +} + +int contar_hojas(const t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + return 1; + return contar_hojas(&(*a)->izq)+contar_hojas(&(*a)->der); + } + return 0; +} + +int contar_no_hojas(const t_arbol *a) +{ + if(*a) + if((*a)->izq||(*a)->der) + return contar_no_hojas(&(*a)->izq)+contar_no_hojas(&(*a)->der)+1; + return 0; +} + +int contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + return contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq)+1; + return contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq)+contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + return contar_nodos_con_hijos_solo_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_solo_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + return contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + return contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der); + } + return 0; +} + +int contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + return contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der)+1; + return contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq)+contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der); + } + return 0; +} + +int contar_nodos_de_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel) + return contar_nodos_de_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_de_un_nivel(&(*a)->der,nivel-1); + return 1; + } + return 0; +} + +int contar_nodos_hasta_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + if(nivel) + return contar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_hasta_un_nivel(&(*a)->der,nivel-1)+1; + return 0; +} + +int contar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel) + return contar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1)+1; + return 1; + } + return 0; +} + +int contar_nodos_desde_un_nivel(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel>=0) + return contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel(&(*a)->der,nivel-1); + return contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel(&(*a)->der,nivel-1)+1; + } + return 0; +} + +int contar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel) +{ + if(*a) + { + if(nivel>=1) + return contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1); + return contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1)+contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1)+1; + } + return 0; +} + +void mostrar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + mostrar_nodos(&(*a)->izq,mostrar); + mostrar_nodos(&(*a)->der,mostrar); + } +} + +void mostrar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + mostrar(&(*a)->dato); + mostrar_hojas(&(*a)->izq,mostrar); + mostrar_hojas(&(*a)->der,mostrar); + } +} + +void mostrar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + mostrar(&(*a)->dato); + mostrar_no_hojas(&(*a)->izq,mostrar); + mostrar_no_hojas(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + mostrar(&(*a)->dato); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar); + mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } +} + +void mostrar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + { + mostrar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + } + else + mostrar(&(*a)->dato); + } +} + +void mostrar_nodos_hasta_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + { + mostrar(&(*a)->dato); + mostrar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_hasta_un_nivel(&(*a)->der,nivel-1,mostrar); + } + } +} + +void mostrar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + if(nivel) + { + mostrar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + } + } +} + +void mostrar_nodos_desde_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel<0) + mostrar(&(*a)->dato); + mostrar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar); + } +} + +void mostrar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel<=0) + mostrar(&(*a)->dato); + mostrar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar); + mostrar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + } +} + +int mostrar_y_contar_nodos(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos(&(*a)->izq,mostrar)+mostrar_y_contar_nodos(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + { + mostrar(&(*a)->dato); + return 1; + } + return mostrar_y_contar_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_hojas(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_no_hojas(const t_arbol *a,t_mst mostrar) +{ + if(*a) + if((*a)->izq||(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_no_hojas(&(*a)->izq,mostrar)+mostrar_y_contar_no_hojas(&(*a)->der,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&!(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(!(*a)->izq&&(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_solo_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq||(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if(((*a)->izq||(*a)->der)&&(!((*a)->izq&&(*a)->der))) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(&(*a)->der,mostrar); + } + return 0; +} + + +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol *a,t_mst mostrar) +{ + if(*a) + { + if((*a)->izq&&(*a)->der) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar)+1; + } + return mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->izq,mostrar)+mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(&(*a)->der,mostrar); + } + return 0; +} + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel) + return mostrar_y_contar_nodos_de_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_de_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return 1; + } + return 0; +} + +int mostrar_y_contar_nodos_hasta_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + if(nivel) + { + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_hasta_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_hasta_un_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_hasta_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + mostrar(&(*a)->dato); + if(nivel) + return mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_hasta_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + return 1; + } + return 0; +} + +int mostrar_y_contar_nodos_desde_un_nivel(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=0) + return mostrar_y_contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_desde_un_nivel(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +int mostrar_y_contar_nodos_desde_un_nivel_inclusive(const t_arbol *a,int nivel,t_mst mostrar) +{ + if(*a) + { + if(nivel>=1) + return mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar); + mostrar(&(*a)->dato); + return mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->izq,nivel-1,mostrar)+mostrar_y_contar_nodos_desde_un_nivel_inclusive(&(*a)->der,nivel-1,mostrar)+1; + } + return 0; +} + +void talar_arbol(t_arbol *a) +{ + *a=NULL; +} + +void podar_hojas(t_arbol *a) +{ + if(*a) + { + if(!(*a)->izq&&!(*a)->der) + { + free(*a); + *a=NULL; + } + else + { + podar_hojas(&(*a)->izq); + podar_hojas(&(*a)->der); + } + } +} + +void podar_hasta_nivel(t_arbol *a,int nivel) +{ + if(*a) + { + podar_hasta_nivel(&(*a)->izq,nivel-1); + podar_hasta_nivel(&(*a)->der,nivel-1); + if(nivel<0) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_nivel_inclusive(t_arbol *a,int nivel) +{ + if(*a) + { + podar_hasta_nivel_inclusive(&(*a)->izq,nivel-1); + podar_hasta_nivel_inclusive(&(*a)->der,nivel-1); + if(!nivel) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_altura(t_arbol *a,int altura) +{ + if(*a) + { + podar_hasta_altura(&(*a)->izq,altura-1); + podar_hasta_altura(&(*a)->der,altura-1); + if(!altura) + { + free(*a); + *a=NULL; + } + } +} + +void podar_hasta_altura_inclusive(t_arbol *a,int altura) +{ + if(*a) + { + podar_hasta_altura_inclusive(&(*a)->izq,altura-1); + podar_hasta_altura_inclusive(&(*a)->der,altura-1); + if(altura<=1) + { + free(*a); + *a=NULL; + } + } +} + +int calcular_nivel(const t_arbol *a) +{ + if(*a) + { + int niv_izq=calcular_nivel(&(*a)->izq); + int niv_der=calcular_nivel(&(*a)->der); + return (niv_izq>=niv_der)?niv_izq+1:niv_der+1; + } + return -1; +} + +int calcular_altura(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (alt_izq>=alt_der)?alt_izq+1:alt_der+1; + } + return 0; +} + +int arbol_semibalanceado(const t_arbol *a) +{ + if(*a) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + return (ABS(alt_izq-alt_der)>1)?0:arbol_semibalanceado(&(*a)->izq)&&arbol_semibalanceado(&(*a)->der); + } + return 1; +} + +int arbol_balanceado(const t_arbol *a) +{ + int h=calcular_altura(a); + return arbol_balanceado_interna(a,h); +} + +int arbol_balanceado_interna(const t_arbol *a,int altura) +{ + if(*a) + return arbol_balanceado_interna(&(*a)->izq,altura-1)&&arbol_balanceado_interna(&(*a)->der,altura-1); + return altura<=1; +} + +int arbol_completo(const t_arbol *a) +{ + int h=calcular_altura(a); + return arbol_completo_interno(a,h); +} + +int arbol_completo_interno(const t_arbol *a,int altura) +{ + if(*a) + return arbol_completo_interno(&(*a)->izq,altura-1)&&arbol_completo_interno(&(*a)->der,altura-1); + return altura==0; +} + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(t_arbol *a,FILE *pf,t_cmp comparar) +{ + fseek(pf,0L,SEEK_END); + return cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,1,ftell(pf)/sizeof(t_dato),comparar); +} + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(t_arbol *a,FILE *pf,int pri,int ult,t_cmp comparar) +{ + t_dato dato; + if(pri<=ult) + { + int medio=(pri+ult)/2; + fseek(pf,(medio-1)*sizeof(t_dato),SEEK_SET); + fread(&dato,sizeof(t_dato),1,pf); + if(!feof(pf)) + { + if(!insertar_en_arbol_iterativa(a,&dato,comparar)) + { + vaciar_arbol(a); + return 0; + } + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,pri,medio-1,comparar); + cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(a,pf,medio+1,ult,comparar); + } + } + return OK; +} + +int hoja(const t_arbol *a) +{ + return *a&&!(*a)->izq&&!(*a)->der; +} + +t_nodo **buscar_nodo_menor(t_arbol *a) +{ + if(!*a) + return NULL; + while((*a)->izq) + a=&(*a)->izq; + return a; +} + +t_nodo **buscar_nodo_mayor(t_arbol *a) +{ + if(!*a) + return NULL; + while((*a)->der) + a=&(*a)->der; + return a; +} + +int eliminar_nodo_y_acomodar_ramas_iterativa(t_arbol *a,t_dato *d,t_cmp comparar) +{ + t_arbol *sub_arbol; + a=buscar_en_arbol_y_retornar_direccion_padre_iterativa(a,d,comparar); + if(!a) + return NO_ENCONTRADO; + while((*a)->izq||(*a)->der) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + sub_arbol=(alt_izq<=alt_der)?buscar_nodo_menor(&(*a)->izq):buscar_nodo_mayor(&(*a)->der); + (*a)->dato=(*sub_arbol)->dato; + a=sub_arbol; + } + free(*a); + *a=NULL; + return OK; +} + +int eliminar_nodo_y_acomodar_ramas_recursiva(t_arbol *a,t_dato *d,t_cmp comparar) +{ + a=buscar_en_arbol_y_retornar_direccion_padre_iterativa(a,d,comparar); + if(!a) + return NO_ENCONTRADO; + return eliminar_nodo_y_acomodar_ramas_recursiva_interna(a,d); +} + +int eliminar_nodo_y_acomodar_ramas_recursiva_interna(t_arbol *a,t_dato *d) +{ + if((*a)->izq||(*a)->der) + { + int alt_izq=calcular_altura(&(*a)->izq); + int alt_der=calcular_altura(&(*a)->der); + t_arbol *sub_arbol=(alt_izq<=alt_der)?buscar_nodo_menor(&(*a)->izq):buscar_nodo_mayor(&(*a)->der); + (*a)->dato=(*sub_arbol)->dato; + a=sub_arbol; + return eliminar_nodo_y_acomodar_ramas_recursiva_interna(a,d); + } + free(*a); + *a=NULL; + return OK; +} + +void arbol_grafico(const t_arbol *a,t_mst mostrar) +{ + arbol_grafico_interna(a,mostrar,0); +} + +void arbol_grafico_interna(const t_arbol *a,t_mst mostrar,int nivel) +{ + if(*a) + { + if((*a)->der) + arbol_grafico_interna(&(*a)->der,mostrar,nivel+1); + + tab(nivel); + mostrar((void*)&(*a)->dato); + printf("\n\n"); + + if((*a)->izq) + arbol_grafico_interna(&(*a)->izq,mostrar,nivel+1); + } +} + +void tab(int x) +{ + int i; + for(i=0;i +#include + +#define ARBOL_VACIO 0 +#define MEMORIA_LLENA 0 +#define DUPLICADO 0 +#define NO_ENCONTRADO 0 +#define OK 1 + +#define ABS(x) ((x)>0)?(x):(-(x)) + +typedef struct s_nodo +{ + t_dato dato; + struct s_nodo *izq; + struct s_nodo *der; +}t_nodo; + +typedef t_nodo* t_arbol; + +typedef int(*t_cmp)(const void*,const void*); +typedef void(*t_mst)(const void*); + +void crear_arbol(t_arbol*); +void vaciar_arbol(t_arbol*); + +int arbol_vacio(const t_arbol*); +int arbol_lleno(const t_arbol*); + +void recorrer_arbol_inorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_preorden_recursiva(const t_arbol*,t_mst); +void recorrer_arbol_posorden_recursiva(const t_arbol*,t_mst); + +void recorrer_arbol_inorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_preorden_iterativa(const t_arbol*,t_mst); +void recorrer_arbol_posorden_iterativa(const t_arbol*,t_mst); + +int insertar_en_arbol_recursiva(t_arbol*,const t_dato*,t_cmp); +int insertar_en_arbol_iterativa(t_arbol*,const t_dato*,t_cmp); + +int buscar_en_arbol_recursiva(t_arbol*,t_dato*,t_cmp); +int buscar_en_arbol_iterativa(t_arbol*,t_dato*,t_cmp); + +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva(t_arbol*,t_dato*,t_cmp); +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_recursiva_interna(t_arbol*,t_dato*,t_cmp,t_nodo**); +t_nodo **buscar_en_arbol_y_retornar_direccion_padre_iterativa(t_arbol*,t_dato*,t_cmp); + +void grabar_arbol_en_inorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_binario(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_binario(const t_arbol*,FILE*); + +void grabar_arbol_en_inorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_preorden_en_archivo_de_texto(const t_arbol*,FILE*); +void grabar_arbol_en_posorden_en_archivo_de_texto(const t_arbol*,FILE*); + +int cargar_arbol_en_preorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_binario(t_arbol*,FILE*,t_cmp); + +int cargar_arbol_en_preorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_posorden_desde_archivo_de_texto(t_arbol*,FILE*,t_cmp); + +int contar_nodos(const t_arbol*); +int contar_hojas(const t_arbol*); +int contar_no_hojas(const t_arbol*); + +int contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*); +int contar_nodos_con_hijos_solo_por_derecha(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*); +int contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*); + +int contar_nodos_de_un_nivel(const t_arbol*,int); +int contar_nodos_hasta_un_nivel(const t_arbol*,int); +int contar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int); +int contar_nodos_desde_un_nivel(const t_arbol*,int); +int contar_nodos_desde_un_nivel_inclusive(const t_arbol*,int); + +void mostrar_nodos(const t_arbol*,t_mst); +void mostrar_hojas(const t_arbol*,t_mst); +void mostrar_no_hojas(const t_arbol*,t_mst); + +void mostrar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +void mostrar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +void mostrar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_hasta_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int,t_mst); +void mostrar_nodos_desde_un_nivel(const t_arbol*,int,t_mst); +void mostrar_nodos_desde_un_nivel_inclusive(const t_arbol*,int,t_mst); + +int mostrar_y_contar_nodos(const t_arbol*,t_mst); +int mostrar_y_contar_hojas(const t_arbol*,t_mst); +int mostrar_y_contar_no_hojas(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_con_hijos_solo_por_izquierda(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_solo_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_o_por_derecha_exclusiva(const t_arbol*,t_mst); +int mostrar_y_contar_nodos_con_hijos_por_izquierda_y_por_derecha(const t_arbol*,t_mst); + +int mostrar_y_contar_nodos_de_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_hasta_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_hasta_un_nivel_inclusive(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_desde_un_nivel(const t_arbol*,int,t_mst); +int mostrar_y_contar_nodos_desde_un_nivel_inclusive(const t_arbol*,int,t_mst); + +void talar_arbol(t_arbol*); + +void podar_hojas(t_arbol*); +void podar_hasta_nivel(t_arbol*,int); +void podar_hasta_nivel_inclusive(t_arbol*,int); +void podar_hasta_altura(t_arbol*,int); +void podar_hasta_altura_inclusive(t_arbol*,int); + +int calcular_nivel(const t_arbol*); +int calcular_altura(const t_arbol*); + +int arbol_semibalanceado(const t_arbol*); + +int arbol_balanceado(const t_arbol*); +int arbol_balanceado_interna(const t_arbol*,int); + +int arbol_completo(const t_arbol*); +int arbol_completo_interno(const t_arbol*,int); + +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible(t_arbol*,FILE*,t_cmp); +int cargar_arbol_en_inorden_desde_archivo_binario_lo_mas_balanceado_posible_interna(t_arbol*,FILE*,int,int,t_cmp); + +int hoja(const t_arbol*); + +t_nodo **buscar_nodo_menor(t_arbol*); +t_nodo **buscar_nodo_mayor(t_arbol*); + +int eliminar_nodo_y_acomodar_ramas_iterativa(t_arbol*,t_dato*,t_cmp); +int eliminar_nodo_y_acomodar_ramas_recursiva(t_arbol*,t_dato*,t_cmp); +int eliminar_nodo_y_acomodar_ramas_recursiva_interna(t_arbol*,t_dato*); + +void arbol_grafico(const t_arbol*,t_mst); +void arbol_grafico_interna(const t_arbol*,t_mst,int); +void tab(int); diff --git "a/\303\241rbol_men\303\272/primitivas_\303\241rbol.o" "b/\303\241rbol_men\303\272/primitivas_\303\241rbol.o" new file mode 100644 index 0000000..dac7d82 Binary files /dev/null and "b/\303\241rbol_men\303\272/primitivas_\303\241rbol.o" differ diff --git "a/\303\241rbol_men\303\272/\303\241rbol de prueba.png" "b/\303\241rbol_men\303\272/\303\241rbol de prueba.png" new file mode 100644 index 0000000..4c7bcb4 Binary files /dev/null and "b/\303\241rbol_men\303\272/\303\241rbol de prueba.png" differ diff --git "a/\303\241rbol_men\303\272/\303\241rbol_men\303\272.cbp" "b/\303\241rbol_men\303\272/\303\241rbol_men\303\272.cbp" new file mode 100644 index 0000000..e403fdb --- /dev/null +++ "b/\303\241rbol_men\303\272/\303\241rbol_men\303\272.cbp" @@ -0,0 +1,59 @@ + + + + + + diff --git "a/\303\241rbol_men\303\272/\303\241rbol_men\303\272.depend" "b/\303\241rbol_men\303\272/\303\241rbol_men\303\272.depend" new file mode 100644 index 0000000..2061ab9 --- /dev/null +++ "b/\303\241rbol_men\303\272/\303\241rbol_men\303\272.depend" @@ -0,0 +1,35 @@ +# depslib dependency file v1.0 +1478551603 source:d:\unlam\programaciÓn\fabian\árbol_menú\funciones.c + "header.h" + +1478548675 d:\unlam\programaciÓn\fabian\árbol_menú\header.h + + + + + "primitivas_árbol.h" + +1480953444 d:\unlam\programaciÓn\fabian\árbol_menú\primitivas_árbol.h + "primitivas_pila_dinámica.h" + + + +1477843548 d:\unlam\programaciÓn\fabian\árbol_menú\primitivas_pila_dinámica.h + "dato.h" + +1477952674 d:\unlam\programaciÓn\fabian\árbol_menú\dato.h + +1480209699 source:d:\unlam\programaciÓn\fabian\árbol_menú\menu.c + "header.h" + +1477843602 source:d:\unlam\programaciÓn\fabian\árbol_menú\primitivas_pila_dinámica.c + "primitivas_pila_dinámica.h" + + + +1479091829 source:d:\unlam\programaciÓn\fabian\árbol_menú\primitivas_árbol.c + "primitivas_árbol.h" + +1480210454 source:d:\unlam\programaciÓn\fabian\árbol_menú\main.c + "header.h" + diff --git "a/\303\241rbol_men\303\272/\303\241rbol_men\303\272.layout" "b/\303\241rbol_men\303\272/\303\241rbol_men\303\272.layout" new file mode 100644 index 0000000..109367d --- /dev/null +++ "b/\303\241rbol_men\303\272/\303\241rbol_men\303\272.layout" @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +