int main(int argc, char** argv) {
char cad[80]="hola pepe";
int l;
char *paux;
l=longitud(cad);
fflush(stdin);
leerPalabra(cad);
fflush(stdin);
leerCadena(cad);
strcpy(cad,"hola pepe");
paux=hallarSubcadena("hola pepe","epe");
paux=hallarSubcadena("hola pepe","epo");
paux=hallarSubcadena("hola pepe","pep");
paux=hallarSubcadena("hola pepe","");
paux=suprimirSubcadena(cad,"pep");
paux=suprimirSubcadena(cad,"ola");
paux=suprimirSubcadena(cad,"epe");
paux=insertarCadena(cad,", ¿cómo estás?",strlen(cad));
paux=suprimirSubcadena(cad,", ¿cómo estás?");
paux=insertarCadena(cad," vecino",4);
paux=suprimirSubcadena(cad," vecino");
paux=suprimirSubcadena(cad,"hola");
paux=insertarCadena(cad,"hello ",0);
paux=concatenar(cad,", ¿Cómo estás?");
paux=buscaChar(cad,'C');
paux=concatenar(cad,", ¿Cómo estás?");
paux=concatenar(cad,". Espero que bien.");
paux=concatenar(cad,", ¿Cómo estás?");
paux=sustituir(cad,", ¿Cómo estás?","");
paux=sustituirChar(cad,'e','U');
}
Net* Net::load(const char *path, const char *id){
Net* net;
int i,j,nlinks,ids,idr;
char *s;
FILE *f;
Neuron **N;
Link *l;
bool *links;
net = new Net();
net->id = strdup(id);
f = fopen(s = concatenar(path,id,"NET.txt"),"r");
free(s);
fscanf(f,"D:%d m:%d\n",&(net->D),&(net->m));
fclose(f);
net->N = new LinkedList<Neuron *>();
N = new Neuron*[net->m];
f = fopen(s = concatenar(path,id,"W.txt"),"r");
free(s);
for(i = 0; i < net->m; i++){
N[i] = new Neuron(i,net->D);
for(j = 0; j < net->D-1; j++)
fscanf(f,"%lf ",N[i]->w+j);
fscanf(f,"%lf\n",N[i]->w+j);
net->N->add(N[i]);
}
fclose(f);
f = fopen(s = concatenar(path,id,"NEURONS.txt"),"r");
free(s);
links = new bool[net->m*(net->m+1)/2];
for(i = 0; i < net->m*(net->m+1)/2; i++)
links[i] = false;
for(i = 0; i < net->m; i++){
fscanf(f,"id:%d nlinks:%d ",&j,&nlinks);
for(j = 0; j < nlinks; j++){
fscanf(f,"e1:%d e2:%d ",&ids,&idr);
if(ids < idr){
int aux = ids;
ids = idr;
idr = aux;
}
if(!links[ids*(ids+1)/2+idr]){
l = new Link(N[ids],N[idr],0);
N[ids]->L->add(l);
N[idr]->L->add(l);
links[ids*(ids+1)/2+idr] = true;
}
}
}
fclose(f);
delete N;
return net;
}
void main()
{
struct nodo *cabeza,*cabeza1;
struct nodo *insertar1 (struct nodo *p, int n);
void insertar2 (struct nodo **p, int n);
void escribir_lista (struct nodo *p);
void concatenar (struct nodo **p,struct nodo *q);
int numero;
printf ("utilizando la funcion insertar2 ()\n");
cabeza = NULL;
printf ("de numero a insertar en la lista\n");
scanf ("%d",&numero);
while (numero != 9999) {
insertar2 (&cabeza,numero);
printf ("de numero a insertar en la lista\n");
scanf ("%d",&numero);
}
printf ("\n utilizando la funcion insertar1 ()\n");
cabeza1 = NULL;
printf ("de numero a insertar en la lista\n");
scanf ("%d",&numero);
while (numero != 9999) {
cabeza1 = insertar1 (cabeza1,numero);
printf ("de numero a insertar en la lista\n");
scanf ("%d",&numero);
}
concatenar (&cabeza,cabeza1);
escribir_lista (cabeza);
}
int main()
{
struct node * head =list (7);
struct node * head2 =list (4);
print(head);
printf("\n");
head=insertb(0,head);
print(head);
printf("\n");
head=eliminar(0,head);
print(head);
printf("\n");
head=inserto(head,8);
print(head);
printf("\n");
head=insertm(15,head);
print(head);
printf("\n");
concatenar(head,head2);
print(head);
return 0;
}
void Net::save(const char *path, const char *id){
int i;
char *s;
FILE *f;
Neuron *n;
Link *l;
this->N->sort(cmpNeuron);
f = fopen(s = concatenar(path,id,"NET.txt"),"w");
free(s);
fprintf(f,"D:%d m:%d\n",this->D,this->m);
fclose(f);
f = fopen(s = concatenar(path,id,"NEURONS.txt"),"w");
free(s);
this->N->reset();
while(this->N->hasNext()){
n = this->N->next();
if(n->L->isEmpty())
fprintf(f,"id:%d nlinks:%d\n",n->id,0);
else{
fprintf(f,"id:%d nlinks:%d",n->id,n->L->size());
n->L->reset();
while(n->L->isBeforeLast()){
l = n->L->next();
fprintf(f," e1:%d e2:%d",l->r->id,l->s->id);
}
l = n->L->next();
fprintf(f," e1:%d e2:%d\n",l->r->id,l->s->id);
}
}
fclose(f);
f = fopen(s = concatenar(path,id,"W.txt"),"w");
free(s);
this->N->reset();
while(this->N->hasNext()){
n = this->N->next();
for(i = 0; i < this->D-1; i++)
fprintf(f,"%f ",n->w[i]);
fprintf(f,"%f\n",n->w[i]);
}
fclose(f);
}
void compresor(char *archivo) {
unsigned char c;
unsigned char caracter[1];
int bits = 9;
unsigned char *cadena = malloc(sizeof(unsigned char)*32);
unsigned char *cadena_original = malloc(sizeof(unsigned char)*32);
FILE *archivo_binario = fopen("Archivo_comprimido","wb");
FILE *archivo_fuente = fopen(archivo,"r");
cadena[0] = '\0';
int i;
for(i = 0; i < 32; i++) {
cadena[i] = '\0';
cadena_original[i] = '\0';
}
char hola[11] = "hola";
char chau[4] = "chau";
printf("%s \n",strcat(hola,chau));
inicializar_diccionario();
while(((c = getc(archivo_fuente)) != EOF)) {
//printf("Caracter c = %d \n",c);
caracter[0] = c;
//printf("caracter[0] = (%c) \t",caracter[0]);
//printf("cadena_original = (%s) \t",cadena);
//printf("cadena = (%s) \t",cadena);
cadena_original = (unsigned char *)strcpy(cadena_original,cadena);
//printf("Ncadena_original = (%s) \n",cadena);
concatenar(cadena,c);
//printf("cadena++caracter = (%s) \n",cadena);
if(arbol.nelem >= pow(2, bits)) {
bits++;
}
if(c == 255) {
agregar_binario(cadena_original, bits,archivo_binario);
break;
}
if(esta_en_diccionario(cadena) == -1) {
//printf("Dentro del if \n");
agregar_binario(cadena_original, arbol.nelem, archivo_binario);
// putc('\n',archivo_binario);
agregar_al_diccionario(cadena);
cadena[0] = c;
cadena[1] = '\0';
//printf("En el if : cadena = (%s) \n",cadena);
}
}
return;
}
char* obtener_ruta_comando(char** rutas, char** argumentos){
char** rut = rutas;
char** args = argumentos;
char* semiruta=concatenar("/",*args);
char* copia=malloc(sizeof(char)*1024);
copia="NADA";
copia=concatenar(getcwd(NULL,0),semiruta);
FILE* archivo=fopen(copia,"r");
if(archivo){
return copia;
}
while(*rut!=NULL){
copia=concatenar(*rut,semiruta);
rut++;
archivo=fopen(copia,"r");
if(archivo)
return copia;
else copia="NADA";
}
return copia;
}
FILE *comprimir(char *nombre) {
int bits = 8;
int i,x, pos;
unsigned int c = 3;
int *bin;
char cadena[1000];
char cadena_temp[1000];
char *primer_elem;
FILE *salida = fopen("archbin.lzw", "wb");
FILE *fuente = fopen(nombre, "rb");
inicializar_diccionario();
cadena[0] = '\0';
for(i = 0; (c = fgetc(fuente)) != EOF; i++) {
strcpy(cadena_temp,cadena);
concatenar(cadena, c);
//printf("Cadena (%s) antes del if \n",cadena);
if (arbol.nelem > pow(2,bits))
bits++;
/*if (c == '/') {
agregar_binario(cadena, bits,salida);
}*/
printf("bits %d - nelems %d \n",bits, arbol.nelem);
if(-1 == (pos = esta_en_diccionario(cadena))) {
//printf("Agregar cadena %s al diccionario\n",cadena);
agregar_al_diccionario(cadena);
//printf("Esta %s pos dic %d \n",cadena,esta_en_diccionario(cadena));
ultimo_elemento(cadena);
//printf("Agregar cadena (%s) al binario \n",cadena);
agregar_binario(pos, arbol.nelem, salida);
//putc('\n',salida);
primer_elemento(cadena, c);
}
}
printf("Agregar cadena (%s) al binario \n",cadena);
printf("afuera del for \n");
if (c == EOF)
agregar_binario(cadena, bits,salida);
if(cant != 0) {
while(cant++ != 8){
byte[0] = byte[0] << 1;
}
fwrite(byte, sizeof(unsigned char), 1, salida);
}
return salida;
}
/* Funcion que genera la cadena de bytes para almacenar la Formacion. Debe recibir por
* referencia un int que pueda almacenar el tamaño de la cadena, para su guardado
* posterior en el archivo.
*/
Byte * CampoCadena::obtenerRegistro(int *tam){
//Obtengo el tamaño de la cadena y lo serializo
int tamDescripcion = this->descripcion.size()+1; //agrego 1 para incluir el caracter nulo
Byte *sizeString = intToBytes(tamDescripcion);
// Serializo la descripcion
Byte *string = convertirAByte(this->descripcion);
// Defino el tamaño de 'sizeString'+'string' y lo serializo
int tamRegistro = (int)sizeof(int) + tamDescripcion;
Byte *sizeRegistro = intToBytes(tamRegistro);
// Defino el tamaño total que va a tener la serializacion
*tam = sizeof(int)*2 + tamDescripcion;
// concateno los integer
Byte *tmp;
concatenar(&tmp, sizeRegistro, 4, sizeString, 4);
// concateno el tmp con la descripcion
Byte *registro;
concatenar(®istro, tmp, 8, string, tamDescripcion);
// elimino los punteros internos
delete sizeString;
delete string;
delete tmp;
//retorno
return registro;
}
int main()
{
// Aquí estamos creando un array de caracteres (string). No le estamos
// agregando el '\0' necesario para que todas las funciones que operen
// con strings sepan cuando el string finaliza.
char strSinBarraCero[] = { 'u', 'n', 't', 'r', 'e', 'f' };
// Por lo que comentamos anteriormente creamos un string utilizando como
// último caracter el '\0'
char strConCodigosDecimales[] = { 'H', 'o', 'l', 'a', 32, 'U', '\0' };
// Las formas anteriores son muy incómodas, C nos provee el siguiente
// atajo. Este SÍ incluye el '\0' al final del string
char strConBarraCero[] = "HOLA UNTREF";
assert(sizeof(strSinBarraCero), 6); // NO Incluye el '\0' POR QUE NO LO AGREGAMOS
assert(sizeof(strConCodigosDecimales), 7); // SI Incluye el '\0' POR QUE LO AGREGAMOS
assert(sizeof(strConBarraCero), 12); // Incluye el '\0'
// Imprimamos para ver que tienen los strings
// printf("strSinBarraCero: %s\n", strSinBarraCero);
// printf("strConCodigosDecimales: %s\n", strConCodigosDecimales);
// printf("strConBarraCero: %s\n", strConBarraCero );
// En lugar de imprimir el contenido del str para comprobar que es lo
// que tiene, podemos hacer unos tests
denyStr(strConBarraCero, "untref");
assertStr(strConCodigosDecimales, "Hola U");
assertStr(strConBarraCero, "HOLA UNTREF");
// Ahora quiero agregarle al string strConBarraCero el str 2015. NO HAY LUGAR LUEGO DE LA 'F'
// porque solo alocamos espacio para 'HOLA UNTREF'.
// Necesitamos creear un buffer en el cual entre 'HOLA UNTREF 2015'
char buffer[BUFFER_SIZE];
// Copiamos el contenido de strConBarraCero al buffer
copiar(buffer, strConBarraCero);
concatenar(buffer, " 2015");
assertStr(buffer, "HOLA UNTREF 2015");
#if 0
char* str3 = davidCopy(strConBarraCero);
printf("%s\n", str3);
#endif
return 0;
}
int main() {
lista lst = crear_lista();
nat cont_comandos = 0;
bool salir = false;
while (!salir) {
mostrar_prompt(cont_comandos);
enum_cmd_t enum_com = identificador_comando();
// procesar el comando
switch (enum_com) {
case cmd_fin:
salir = true;
imprimir_con_nl(msg_fin);
break;
case cmd_comentario:
escribir_nueva_linea();
break;
case cmd_ins_lista: {
info_t info = leer_info(MAX_LARGO_PALABRA);
while (es_valida_info(info)) {
insertar_despues(info, final_lista(lst), lst);
info = leer_info(MAX_LARGO_PALABRA);
}
liberar_info(info);
texto_t txt = cadena_a_texto("primero");
info = crear_info(0, txt);
insertar_antes(info, inicio_lista(lst), lst);
imprimir_lista(lst);
break;
}
case cmd_recorrido_lista: {
if (!es_vacia_lista(lst)) {
localizador loc = inicio_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = siguiente(loc, lst);
}
loc = final_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = anterior(loc, lst);
}
escribir_nueva_linea();
}
break;
}
case cmd_segmentos_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador desde = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador hasta = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(desde) && es_localizador_lista(hasta) &&
precede_en_lista(desde, hasta, lst)) {
lista sgm = separar_segmento(desde, hasta, lst);
lista copia = segmento_lista(inicio_lista(sgm), final_lista(sgm), sgm);
imprimir_lista(sgm);
liberar_lista(sgm);
insertar_segmento_despues(copia, final_lista(lst), lst);
liberar_lista(copia);
imprimir_lista(lst);
}
break;
}
case cmd_modificar_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador loc1 = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador loc2 = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(loc1) && es_localizador_lista(loc2)) {
intercambiar(loc1, loc2, lst);
imprimir_lista(lst);
retroceder(loc2, lst);
imprimir_lista(lst);
}
break;
}
case cmd_ordenar_lista: {
nat len_lst = longitud(lst);
imprimir_int(len_lst);
localizador loc = inicio_lista(lst);
for (nat i = 0; i < len_lst / 2 - 1; i++)
loc = siguiente(loc, lst);
lista primera = segmento_lista(inicio_lista(lst), loc, lst);
lista segunda =
segmento_lista(siguiente(loc, lst), final_lista(lst), lst);
lista concat = concatenar(primera, segunda);
imprimir_lista(concat);
liberar_lista(concat);
if (son_numeros_iguales(primera, segunda)) {
imprimir_lista(primera);
}
if (!esta_ordenada(primera))
ordenar(primera);
if (!esta_ordenada(segunda))
ordenar(segunda);
lista mzc = mezcla(primera, segunda);
imprimir_lista(mzc);
unificar(mzc);
imprimir_lista(mzc);
liberar_lista(mzc);
liberar_lista(primera);
liberar_lista(segunda);
break;
}
case cmd_filtrado_lista: {
int clave = leer_int();
texto_t palabra = leer_palabra(MAX_LARGO_PALABRA);
comp_t criterio = texto_a_comp(palabra);
liberar_texto(palabra);
if (pertenece(clave, lst)) {
imprimir_int(cantidad(clave, lst));
}
lista flt = filtrado(clave, criterio, lst);
imprimir_lista(flt);
liberar_lista(flt);
break;
}
case cmd_reversa_lista: {
int dato1 = leer_int();
int dato2 = leer_int();
if (esta_ordenada(lst) && pertenece(dato1, lst) &&
pertenece(dato2, lst) && dato1 < dato2) {
lista sub = sublista(dato1, dato2, lst);
imprimir_lista(sub);
lista rev = reversa(sub);
imprimir_lista(rev);
cambiar_todos(dato1, dato2, rev);
imprimir_lista(rev);
liberar_lista(sub);
liberar_lista(rev);
}
break;
}
case cmd_liberar_lista: {
liberar_lista(lst);
lst = crear_lista();
break;
}
default:
imprimir_con_nl(msg_cmd_no_reconocido);
break;
} // switch
texto_t resto_linea = leer_resto_linea(MAX_RESTO_LINEA);
liberar_texto(resto_linea);
} // while
liberar_lista(lst);
return 0;
}