|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Temas - Rombus
Páginas: [1]
1
« en: Domingo 14 de Marzo de 2010, 17:17 »
Hola gente, hace unos días necesité del GDB y probando con todos los IDE's que me crucé me di cuenta que hay un bug en Ubuntu relativo al GDB. Obtengo este error: > aviso: GDB: Failed to set controlling terminal: Operación no permitida
Buscando no encontré la solución a este problema y no importa que IDE use, el error está en otro lado. ¿Alguna idea?
2
« en: Lunes 29 de Diciembre de 2008, 19:32 »
Hola gente! estoy haciendo un programa con una sentencia switch muy extensa, y me encontre con un error bastante simple que no eh podido eliminar. el codigo reducido al problema es este (esta hecho para wingdows): #include <stdio.h> #include <stdlib.h> #include <windows.h> int main(void){ char caracter; printf("%dn",VK_NUMPAD0); printf("%dnn",VK_NUMPAD9); printf("%dn",'1'); printf("%dnn",'9'); printf("%dn",'A'); printf("%dnn",'Z'); for(caracter = 0; caracter < 256; caracter++){ switch(caracter){ case 'A'||'B'||'C'||'D'||'E'||'F'|| 'G'||'H'||'I'||'J'||'K'||'L'|| 'M'||'N'||'O'||'P'||'Q'||'R'|| 'S'||'T'||'U'||'V'||'W'||'X'|| 'Y'||'Z'|| '1'||'2'||'3'||'4'||'5'|| '6'||'7'||'8'||'9'||'0': printf("aguante...n"); break; case VK_NUMPAD0||VK_NUMPAD1||VK_NUMPAD2||VK_NUMPAD3||VK_NUMPAD4|| VK_NUMPAD5||VK_NUMPAD6||VK_NUMPAD7||VK_NUMPAD8||VK_NUMPAD9: printf("..el metal!!n"); break; } } return 0; }
el error q obtengo es el de que el valor case '1' ya ha sido utilizado. Lo extraño , o capaz mi mal interpretacion del error, es que ninguna constante usada en los cases es 1, imprimi sus valores al comienzo del programa y demuestra que no hay valores repetidos. sera que estoy utilizando mal la sentencia switch case? saludos!
3
« en: Viernes 24 de Octubre de 2008, 05:18 »
Hola gente! estoy realizando un arbol generico y me encuentro con el problema (despues de depurar bastante) que no estoy asignando bien los hijos de los nodos. mi codigo es el siguiente, como siempre, listo para compilar: #include <stdlib.h> #include <stdio.h> #include <assert.h> typedef int (*_funCmp_t)(void *a, void *b); typedef void (*_funPrint_t)(void *a); ///Arbol typedef struct _nodo{ void *valor; struct _nodo *iz; struct _nodo *der; }nodo_t; ///Estructura administrativa typedef struct { int sizeTipo; //Tamaño del dato a almacenar nodo_t *raiz; _funCmp_t funCmp; //Funcion de comparacion _funPrint_t funPrint; //Funcion de impresion }arbol_t; int comparaEnteros(void *a, void *b){ return *((int *)a) - *((int *)b); } void imprimeEnteros(void *a){ } arbol_t *arbolCreate(int sizeTipo, _funCmp_t funCmp, _funPrint_t funPrint){ arbol_t *arbol = (arbol_t *)malloc(sizeof(arbol_t )); arbol->sizeTipo = sizeTipo; arbol->funCmp = funCmp; arbol->funPrint = funPrint; arbol->raiz = NULL; return arbol; } nodo_t *creaNodo(arbol_t *arbol, void *valor, nodo_t *der, nodo_t *iz){ nodo_t *nodo = (nodo_t *)malloc(sizeof(nodo_t )); nodo->valor = valor; nodo->der = der; nodo->iz = iz; return nodo; } nodo_t *arbolInsert(arbol_t *arbol, nodo_t *nodo, void *aIngresar){ if(!nodo) return creaNodo(arbol, aIngresar, NULL, NULL); if(arbol->funCmp(nodo->valor, aIngresar) > 0) nodo->iz = arbolInsert(arbol, nodo->iz, aIngresar); else if(arbol->funCmp(nodo->valor, aIngresar) < 0) nodo->der = arbolInsert(arbol, nodo->der, aIngresar); return nodo; } void printArbol(arbol_t *arbol, nodo_t *nodo){ //Preorden if(nodo) arbol->funPrint(nodo->valor); if(nodo->iz) printArbol(arbol, nodo->iz); if(nodo->der) printArbol(arbol, nodo->der); } int main(void){ arbol_t *arbol = arbolCreate(sizeof(int),comparaEnteros, imprimeEnteros); int i = 5; arbol->raiz = arbolInsert(arbol, arbol->raiz, (void *)&i); i =4; arbol->raiz = arbolInsert(arbol, arbol->raiz, (void *)&i); i =3; arbol->raiz = arbolInsert(arbol, arbol->raiz, (void *)&i); i = 7; arbol->raiz = arbolInsert(arbol, arbol->raiz, (void *)&i); printArbol(arbol, arbol->raiz); return 0; }
el problema creo q esta en la funcion arbolInsert(); ya que nunca entra ni en el IF ni el ELSE IF de dicha funcion, siempre termina devolviendo el return creaNodo(); lo que genera que no se forme un arbol.. siempre se inserta en la cabeza y lo que habia antes se pierde. esto se debe a que la comparacion que contemplan los if's: arbol->funCmp(nodo->valor, aIngresar) , siempre da 0, y es porque tanto el valor que recibe como parametro nodo_t *nodo y void *aIngresar es el mismo :O!, imprimo las direcciones de memoria y los valores y siepmre compara (por ejemplo) A con A, B con B, y en la funcion de comparacion cuando las cadenas son iguales devuelve 0. entiendo que es lo que pasa... lo que no me sale es como arreglarlo :S alguien sabe como evitar esto? gracias de antemano!
4
« en: Sábado 18 de Octubre de 2008, 17:39 »
Hola gente! estoy realizando una estructura generica de lista (sigo con mis estructuras genercias XD) y estoy teniendo un problema a la hora de implementar una funcion insertaOrdenado(); que lo que debe hacer es , justamente, insertar nodos de manera ordenada segun el campo a comparar que se le sea especificado con un puntero a funcion. el codigo con el problema aislado es el siguiente, esta completo para poder probarlo directamente: #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h> #define FALSE 0 #define TRUE !FALSE typedef char boolean; typedef int (*list_funCmp_t)(void *a, void *b); typedef void (*list_funPrint_t)(void *a); #define INT 0 /* #define STRING 0 #define CHAR 0 */ typedef struct lPtr{ void *valor; struct lPtr *next; }list_t; typedef struct{ list_t *entrada; //Entrada a la lista; int sizeTipo; list_funCmp_t funCmp; list_funPrint_t funPrint; }listAdm_t; ///Funciones de COMPARACION---------------------------------------/// int comparaEnteros(void *a, void *b){ return *(int *)a - *(int *)b; } int comparaCadenas(void *a, void *b){ return ((int)strcpy((char *)a , (char*)b )); //0 si son iguales, > 1 si b < a; < 1 si a < b } ///Funciones de IMPRESION----------------------------------------/// void imprimeEnteros(void *a){ } void imprimeCadenas(void *a){ } ///Servicios de LISTA listAdm_t *lAdmCreate(int sizeTipo, list_funCmp_t funCmp, list_funPrint_t funPrint){ //Crea La estructura administrativa listAdm_t *listAdm = (listAdm_t *)malloc(sizeof(listAdm_t )); listAdm->funCmp = funCmp; listAdm->funPrint = funPrint; listAdm->sizeTipo = sizeTipo; listAdm->entrada = NULL; return listAdm; } list_t *creaNodo(listAdm_t *lista, list_t *pNext, void *elemento){ //necesito la estructura administrativa para el peso de dato list_t *nodo = (list_t *)malloc(sizeof(list_t )); nodo->next = pNext; memcpy((char *)nodo ->valor , (char *)elemento , lista ->sizeTipo ); return nodo; } list_t *lInsertOrdered(listAdm_t *listAdm, list_t *lista, void *elemento){ //Ordenado de menor a mayor if( !lista || (listAdm->funCmp(lista->valor,elemento)) >= 0 ){ return creaNodo(listAdm, listAdm->entrada, elemento); } lista->next = lInsertOrdered(listAdm, lista->next, elemento); return lista; } void printList(listAdm_t *listAdm, list_t *list){ if(list){ //Si existe la lista listAdm->funPrint(list->valor); printList(listAdm, list->next); } } int main(void){ #ifdef STRING char i[50] = "iber", b[50] = "jose"; listAdm_t *lista = lAdmCreate(sizeof(i), comparaCadenas,imprimeCadenas); #endif #ifdef CHAR char i = 'a', b = 'g'; listAdm_t *lista = lAdmCreate(sizeof(char), comparaCaracteres,imprimeCaracteres); #endif #ifdef INT int i= 6, b = 9; listAdm_t *lista = lAdmCreate(sizeof(int), comparaEnteros,imprimeEnteros); #endif lista->entrada = lInsertOrdered(lista, lista->entrada, (void *)&i); lista->entrada = lInsertOrdered(lista, lista->entrada, (void *)&b); printList(lista, lista->entrada); return 0; }
tiene un par de ifndefs para realizarle distintas pruebas con los diferentes tipos de datos y verificar que en verdad sea generica. ahora lo que pasa es q se queda iterando hasta un segmentation fault en el ciclo de impresion, antes habia logrado que funcione correctamente la inserta ordenado pero solo lo hacia con int's (poco generico q digamos XD). esca esta la funcion problematica (tambien esta en el codigo anterior pero para que se vea mas directo) list_t *lInsertOrdered(listAdm_t *listAdm, list_t *lista, void *elemento){ //Ordenado de menor a mayor if( !lista || (listAdm->funCmp(lista->valor,elemento)) >= 0 ){ return creaNodo(listAdm, listAdm->entrada, elemento); } lista->next = lInsertOrdered(listAdm, lista->next, elemento); return lista; }
la logica creo q esta bien. si no tengo lista, o si el valor es menor al que tengo en la lista inserto a la cabeza, sino llamo recursivamente a la funcion pasandole el siguiente elemento de la lista. estoy dandole vueltas al codigo pero no logro decifrar el error. espero sus comentarios! saludos!
5
« en: Domingo 12 de Octubre de 2008, 04:43 »
Hola gente! estube aberiguando sobre la funcion memcpy, ya que siempre tengo problemas de fallos de segmentacion y encontre un codigo de ejemplo en la pagina de c con clase. el codigo es el siguiente: #include <stdio.h> #include <string.h> #define LEN1 7 #define LEN2 5 int main(void){ char a[LEN1] = "abcdefg"; char *ptr; int i; for(i=0; i<LEN1; i++) printf( "a[%d]=%c ", i , a [i ] ); for(i=0; i<LEN2; i++) printf( "ptr[%d]=%c ", i , ptr [i ] ); return 0; }
deberia de andar, ya que parece bastante razonable y a parte esta en c con clase que es una pagina bastante confiable... el problema es que en mi gcc desde ubuntu me tira un segmentation fault en el memcpy alguien sabe a q se debe esto? gracias de antemano!
6
« en: Viernes 10 de Octubre de 2008, 16:49 »
Hola gente! estoy realizando la implementacion de estructuras de datos genericas, la de pila ya la tengo y no tube mayores problemas, pero cuando llegue a la de cola se me complico un poco. bien este es mi codigo, esta completo asi se puede pegar a un compilador o algun lugar donde se pueda leer mejor: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #define FALSE 0 #define TRUE !FALSE typedef char boolean; //Cola propiamente dicha typedef struct{ void *elementos; int size; int head, //Cantidad de puts(); tail; //Cantidad de Gets(); }cola_t; //Estructura Administrativa typedef struct{ cola_t *cola; int sizeTipo; }queue_t; queue_t *qCreate(int size, int sizeTipo){ queue_t *queue = (queue_t *)malloc(sizeof(queue_t )); queue ->cola = (cola_t *)malloc(sizeof(cola_t )); queue->sizeTipo = sizeTipo; queue ->cola ->elementos = (void *)malloc(sizeTipo * size ); assert(queue ->cola ->elementos ); queue->cola->size = size; queue->cola->head = queue->cola->tail = 0; return queue; } void qDestroy(queue_t *queue){ } int qFull(queue_t *queue){ if(queue && queue->cola) //Si tengo queue return ((queue->cola->tail - queue->cola->head) == queue->cola->size); return -1; //No hay cola, devuelvo -1 } int qEmpty(queue_t *queue){ if(queue && queue->cola) //si tengo queue return (queue->cola->tail == queue->cola->head); return -1; //No hay cola } boolean qPut(queue_t *queue, void *valor){ if(qFull(queue)) return FALSE; //Esta llena y no puedo ingresar nada memcpy( (char *)(queue ->cola ->elementos )+(queue ->cola ->tail % queue ->cola ->size ), valor , queue ->sizeTipo ); printf("Guardado: %dn",*(char *)((queue ->cola ->elementos )+(queue ->cola ->tail ))); //printf(" ingresado en: %dn",queue->cola->tail % queue->cola->size); queue->cola->tail++; return TRUE; } boolean qGet(queue_t *queue, void *valor){ if(qEmpty(queue)) return FALSE; //Esta vacia y no puedo ingresar nada /* * Resuelvo el problema de q los * indices crezcan hacia el infinito */ if(queue->cola->head > queue->cola->size){ queue->cola->head %= queue->cola->size; queue->cola->tail %= queue->cola->size; } memcpy(valor ,(void*)(queue ->cola ->elementos )+(queue ->cola ->head % queue ->cola ->size ), queue ->sizeTipo ); printf("Removido: %dn",*(int *)valor ); //printf(" removido de: %dn",queue->cola->head % queue->cola->size); queue->cola->head++; return TRUE; } int main(void){ queue_t *queue; int a = 3, b = 2, c,d; queue = qCreate(5,sizeof(int)); qPut (queue,(void *)&a); qPut (queue,(void *)&b); qGet(queue,(void *)&c); qGet(queue,(void *)&d); printf("Extraje en el main: %dn",(char)c ); printf("Extraje en el main: %dn",d ); qDestroy(queue); return 0; }
A simple vista no puedo encontrarle el error, pero de tantas pruebas que realice, me di cuenta que si casteo la variable donde guarde el valor removido de la cola a char, el resultado que obtengo es el esperado (linea 103). Pero sinceramente no entiendo porque pasa esto, ni como hacer para que no haga falta hacer ese casteo a char. ¿tendra algo que ver con el hecho de que en la funcion qPut donde esta el memcpy lo castie a (char *) ? (linea59), aunque probe en no castearlo y dejarlo void * pero me tira un error de compilacion, desreferenciando puntero void.
7
« en: Jueves 9 de Octubre de 2008, 20:40 »
Hola gente! estoy intentando hacer algo semejante a una libreria. y averiguando me entere que con esto: #ifndef _stdio_h #include <stdio.h> #endif #ifndef _stdlib_h #include <stdlib.h> #endif #ifndef _string_h #include <string.h> #endif #ifndef _assert_h #include <assert.h> #endif #ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE !FALSE #endif
evito problemas del tipo "redefinicion de tal cosa", tanto en inclusiones de librerias como de macros. Existe alguna forma de hacer lo mismo pero contemplando los typedefs?si el typedef de boolean no esta typedef char boolean; fin si
gracias por su tiempo!
8
« en: Jueves 9 de Octubre de 2008, 17:48 »
Hola! alguien sabe porque me esta dando un segmentation fault en la linea 16 del siguiente codigo? uso codeblocks con gcc en ubuntu 8.04 typedef struct pila_s{ void *elementos; int size; int head; }pila_t; typedef struct{ pila_t *pila; int sizeTipo; }pilaAdm_t; pilaAdm_t *stackCreate(int size, int sizeTipo){ pilaAdm_t *stack = (pilaAdm_t *) malloc (sizeof(pilaAdm_t )); void *elemens = (void *)malloc(size * sizeTipo ); stack->pila->elementos = elemens; stack->pila->size = size; stack->pila->head = 0; stack->sizeTipo = sizeTipo; return stack; }
cuando la llamo desde el main lo hago de la siguiente forma: int main(void){ pilaAdm_t *stack; int n = 1; stack = stackCreate(n,sizeof(int)); return 0; }
espero que alguien me pueda ayudar gracias!
9
« en: Martes 7 de Octubre de 2008, 17:52 »
Hola amigos! tengo un problema intentando implementar una funcion remover, para un arbol binario de busqueda. con un compañero planteamos este algoritmo: arbol_t *removerDesbalanceado(arbol_t *arbol, int valor){ arbol_t *aux; if(!arbol) return NULL; if(arbol->contenido > valor) arbol->iz = removerDesbalanceado(arbol->iz,valor); else if(arbol->contenido < valor) arbol->der = removerDesbalanceado(arbol->der,valor); else{ //Si es igual if(arbol->der == NULL){ if(arbol->iz == NULL) return NULL; //Si no tiene hijos retorna Null return arbol->iz; //sino retorna todo el subarbol izquierdo } else{ aux = menor(arbol->der); aux->iz = arbol->iz; aux = arbol->der; return aux; } } }
arbol_t es la estructura de un nodo con un campo contenido y dos campos punteros de hijos: typedef struct arbolStr{ int contenido; struct arbolStr *iz, *der; }arbol_t;
le pusimos removerDesbalanceado pq lo que hacemos es una vez q encontramos el nodo a remover ponemos en lugar de este, todo el arbol derecho, enlazando el nodo de mas abajo a la iz (el de menor valor) con el arbol izquierdo del nodo a remover. se lo mostramos a otro compañero y nos dijo, que el arbol se iba a desbalancear demaciado, y que lo mejor seria: agarrar el menor del hijo derecho del arbol a remover y poner el valor de ese nodo como el valor del nodo a remover y luego hacer que el que apuntaba al nodo del cual "robamos" el valor apunte a NULL. entonces el arbol quedaria mucho mas balanceado y la remocion seria mas efectiva. nuestro problema es el de hacer que el nodo que apuntaba al nodo del "robamos" el valor apunte a null. este es nuestro codigo, no terminado, en principio copiamos la funcion de removerDesbalanceado para modificarla, quiza hay cosas que son de la otra funcion y no estan modificadas: arbol_t *removerBalanceado(arbol_t *arbol, int valor){ arbol_t *a, *b; int cont; if(!arbol) return NULL; if(arbol->contenido > valor) arbol->iz = removerBalanceado(arbol->iz,valor); else if(arbol->contenido < valor) arbol->der->contenido = removerBalanceado(arbol->der,valor); else{ //Si es igual, osea, si encontre el nodo a remover if(arbol->der == NULL){ if(arbol->iz == NULL) return NULL; //Si no hay hijo iz ni der devuelvo null return arbol->iz; //si no hay hijo der pero si iz devuelvo subarbol iz } else{ a = menor(arbol->der); cont = a->contenido; b = rastreaAnterior(a); //busco el que apuntaba a aux para ponerlo en null b->iz = NULL; //se que es el izquierdo pq cuando busco el menor siempre va a estar a la iz free(a ); //Libero a, osea, remuevo el nodo a remover return b; //Devuelvo b que es el nodo que apuntaba } } arbol->contenido = cont; }
vamos por buen camino? como podriamos hacer la parte del else{} de la funcion anterior. ah!, me olvidaba, en el removerBlanaceado, llamo a una funcion auxiliar que me devuelve el que apunta a un nodo en particular, le paso el nodo minimo y cuando obtengo el nodo que lo apuntaba hago q apunte a NULL, parece razonable, el problema es que me parece medio enredado, y se que debe alguna otra forma para hacerlo mas eficiente. si alguien nos puede ayudar se lo agradecemos  saludos!
10
« en: Sábado 27 de Septiembre de 2008, 16:07 »
Hola gente! tengo un problema con el siguiente codigo: #include <stdio.h> #include <ctype.h> #include <string.h> #include <stdlib.h> #define PATH "/home/rombus/Escritorio/sample.c" #define FALSE 0 #define TRUE !FALSE #define escribeEnter(a) fputc('n',a) #define unoParaAtraz(a) fseek(a,(long)-1,SEEK_CUR) #define unoParaAdelante(a) fseek(a,(long)1,SEEK_CUR) typedef char boolean; boolean buscaLlave(FILE *a){ char c; do{ c = fgetc(a); }while(c != '{' && c != EOF); if(c == EOF) return FALSE; unoParaAtraz(a); return TRUE; } void limpiaString(char *a){ int i; for(i=0; a[i] != ' '; i++) a[i] = ' '; } char *getLine(FILE *a){ char *l = (char*)malloc(255*sizeof(char)); int i = 0; do{ l[i] = fgetc(a); }while((l[i] != 'n') && (l[i++] != EOF)); return l; } void escribeTab(FILE *a, int n){ int i; for(i=0; i<n; i++) fputc('t',a); } void indenta(char *path){ FILE *b = fopen(path,"r+b"); int cont = 0; char *aux = (char *)malloc(sizeof(char)*255); long lastLine; while(!feof(b)){ if(buscaLlave(b)){ cont++; limpiaString(aux); aux = getLine(b); if(strrchr(aux,'}')){ cont--; printf("chau...n"); } if(cont){ printf("entro en cont mayor a 1n"); do{ printf("entro en el don"); lastLine = ftell(b); limpiaString(aux); aux = getLine(b); if(strrchr(aux,'}')){ cont--; printf("cont --n"); } fseek(b,lastLine,SEEK_SET); escribeTab(b,cont); if(strrchr(aux,'{')) cont++; aux = getLine(b); if(strrchr(aux,'}')){ cont--; printf("cont --n"); } printf("cont: %dn",cont); }while(cont > 0 || !feof(b)); } } else break; } fclose(b); } int main(void){ indenta(PATH); printf("Finn"); return 0; }
el fichero que lee (el indicado en PATH) es el siguiente: void indenta(char *path){ FILE *b = fopen(path,"r+b"); int cont = 0; char *aux = (char *)malloc(sizeof(char)*255); long lastLine; while(!feof(b)){ if(buscaLlave(b)){ cont++; limpiaString(aux); aux = getLine(b); if(strrchr(aux,'}')){ cont--; printf("chau...n"); } if(cont){ printf("entro en cont mayor a 1n"); do{ printf("entro en el don"); lastLine = ftell(b); limpiaString(aux); aux = getLine(b); if(strrchr(aux,'}')){ cont--; printf("cont --n"); } fseek(b,lastLine,SEEK_SET); escribeTab(b,cont); if(strrchr(aux,'{')){ cont++; } aux = getLine(b); if(strrchr(aux,'}')){ cont--; printf("cont --n"); } printf("cont: %dn",cont); }while(cont > 0 || !feof(b)); } } } fclose(b); }
lo que quiero lograr es que agarre ese codigo sin indentacion y lo indente.. pero estoy perdiendo el primer caracter de cada linea cuando leo una linea y la indento, y no solo es el primero, como que se suman y a veces son dos o a veces no pierdo ningun caracter, pero la funcion de indentar no se efectua... no puedo descubrir donde esta el error, lo sigo en papel y no lo desifro... osea, el archivo modificado me queda: #include <stdio.h> int main(void){ nt a, b; rintf("ingrese a y b: "); canf("%d %d",&a,&b); if(a > b){ rintf("no solo a es mayor a b...n"); } else{ printf("a es mayor a b...n"); } for(b=0; b<a; b++){ if(b >1){ //linea; //linea; } } return 0; }
uno de mis problema era que no podia depurar en linux (a falta de un IDE completo), encontre el codeBlocks y lo depure... el error es en la linea 71 con la funcion strrchr(); esto es lo que me dice mi debug:   cuando la cadena AUX vale "tn" como que queda colgado en el strrchr()... alguien sabe a que se debe esto?, o como resolverlo? agradesco su ayuda
11
« en: Martes 23 de Septiembre de 2008, 00:16 »
Hola gente! estaba visitando el subforo de C y me hicieron recordar un codigo que hice el año pasado en pascal de pasar numeros de romano a decimal, me acuerdo que lo optimice bastante y quedo bastante corto. ya que lo encontre queria compartirlo con ustedes, capaz a alguno le venga bien este es el codigo: (*lunes, 12 de mayo de 2008, 10:55:23*) (* Rombus Evil Bones *) program rom; const B = 10; var num, cont, i : integer; (*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*) procedure numRomano (a, b, c: char; num: integer); begin case num of 9 : write(a,c); 5..8: begin write (b); for i:= 6 to num do write (a); end; 4 : write (a, b); 1..3: for i:= 1 to num do write (a); end; end; (*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*) procedure defragmenta(num : integer); begin if num < B then begin case cont of 1 : numRomano ('I','V','X',num); 2 : numRomano ('X','L','C',num); 3 : numRomano ('C','D','M',num); 4 : numRomano ('M',' ',' ',num); end; cont := cont - 1; end else begin cont := cont + 1; defragmenta(num div B); defragmenta(num MOD B); end; end; (*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*) begin cont := 1; write('Ingrese un num: '); readln(num); defragmenta(num); readln; end.
saludos!
12
« en: Martes 16 de Septiembre de 2008, 03:13 »
Hola gente! tengo un problema al intentar practicamente duplicar un archivo donde se cumpla una condicion, si la line del archivo es una directiva, y mas especificamente si es un include <...>. Intento hacer un programa que posea un preset para acomodar todos los codigos fuente que me pasen o que baje de internet a mi gusto, indentados, posicion de llaves, orden, etc... pero mi problema es que en la "duplicacion" cuando intento abrir el archivo duplicado me tira un error diciendome que en el archivo hay un byte NULL y que se abrio solo lectura. abro el archivo en un editor Hexadecimal y efectivamente hay un byte null. (totalmente involuntario) este es mi codigo: #include <stdio.h> #include <ctype.h> #include <stdlib.h> #define PATH "/home/rombus/Escritorio/sample.c" #define TERMINADO "/home/rombus/Escritorio/prueba.c" #define FALSE 0 #define TRUE !FALSE #define INCLUDE 1 #define DEFINE 2 #define UNKNOWN -1 #define STD 3 #define LOCAL 4 #define hastaEOL(a) while((fgetc(a)!= 'n') && (fgetc(a) != EOF)) #define unoParaAtraz(a) fseek(a,(long)-1,SEEK_CUR) #define dosParaAtraz(a) fseek(a,(long)-2,SEEK_CUR) #define unoParaAdelante(a) fseek(a,(long)1,SEEK_CUR) #define dosParaAdelnate(a) fseek(a,(long)2,SEEK_CUR) typedef char boolean; typedef char macroType; ///-Prototypes-/// char *getLine(FILE *a); macroType define_o_include(FILE *a); macroType std_o_local(FILE *a); boolean esMacro(FILE *a); void comeBlancos(FILE *a); boolean saltoMacros(FILE *a); void pasaIncludesStd(FILE *a, FILE *b, boolean *flagLocal){ long pos, inicio = ftell(a),len; char c; //Variable de control char *cadena = (char *)malloc(sizeof(char)*255); macroType control; while(esMacro(a)){ pos = (ftell(a)); control = define_o_include(a); if(control == INCLUDE){ c = std_o_local(a); if(c == STD){ hastaEOL(a); //Me paro al final de la linea len = ftell(a)-pos; //Me da la cantidad de bytes q se corrio del principio fseek(a,(long)pos,SEEK_SET); cadena = getLine(a); fwrite(cadena,sizeof(char),len,b); //Tener cuidado con esto, posible nido de bugs printf("escribio: %s - n",cadena); } else if(c == LOCAL) (*flagLocal) = TRUE; } else if(control == DEFINE) //Si es un define salto toda la linea hastaEOL(a); } fseek(a,inicio*-1,SEEK_CUR); //Voy a donde estaba cuando me lo pasaron } int main(void){ FILE *a = fopen(PATH,"rb"); FILE *b = fopen(TERMINADO,"wt"); boolean flagLocal = FALSE; pasaIncludesStd(a,b,&flagLocal); //pasar los includes <> fclose(a); fclose(b); return 0; } ///-FUNCIONES-/// char *getLine(FILE *a){ char *l = (char*)malloc(255*sizeof(char)); int i = 0; do{ l[i] = fgetc(a); }while((l[i] != 'n') && (l[i++] != EOF)); return l; } macroType define_o_include(FILE *a){ char c =fgetc(a); if(c == '#') //Por si cuando invocan la funcion no saben si es macro c = fgetc(a); if(c == 'i') return INCLUDE; if(c == 'd') return DEFINE; return UNKNOWN; } macroType std_o_local(FILE *a){ #define LEN_INCLUDE 8 //Largo de la palabra "#include " int i=0; char c = fgetc(a); if(c == '#') //Si llamo a la funcion sin antes haber leido el '#' unoParaAtraz(a); else //Si llamo a la funcion antes habiendo leido el '#' dosParaAtraz(a); while(i++<LEN_INCLUDE) //Salto el "#include " fgetc(a); c = fgetc(a); //Leo el "" o el <> printf("el caracter es: %cn",c); if(c == '"') return LOCAL; else if(c == '<') return STD; return UNKNOWN; } boolean esMacro(FILE *a){ char c; comeBlancos(a); c = fgetc(a); unoParaAtraz(a); if(c == '#') return TRUE; return FALSE; } void comeBlancos(FILE *a){ char b; while( (b = fgetc(a)) == ' ' || b == 'n' || b == 't'); printf("salio del comeBlancos con un %cn",b); unoParaAtraz(a); } boolean saltoMacros(FILE *a){ char c; boolean flag = FALSE; do{ if(flag) //Leo toda la linea una vez que leyo el primer caracter hastaEOL(a); else flag = TRUE; //Cuando es la primera vez habilito la bandera comeBlancos(a); c = fgetc(a); }while(c =='#'); unoParaAtraz(a); return FALSE; //Terminaron los macros }
si alguien me puede dar alguna pista, se lo agradesco. saludos! EI: Juntando mensajes.nadie sabe en que momento es que estoy escribiendo el byte NULL? me di cuenta que donde el archivo se corta a la mitad debido a este byte NULL es cuando en el archivo fuente, osea el archivo que estoy duplicando hay un "n", un enter.
13
« en: Domingo 14 de Septiembre de 2008, 20:23 »
Hola!
tengo una duda sobre la normalizacion de relaciones.
cuando como fruto de una normalizacion me quedan dos relaciones 1 a 1, es correcto?
o en esos casos es pq ya estaba normalizado y no hacia falta la normalizacion?
gracias!
14
« en: Domingo 24 de Agosto de 2008, 17:08 »
hola gente! estoy haciendo un programa que compare dos directorios y diga si son iguales o no, y si no lo son que muestre la ruta del/los archivo/s que difieren, para hacerlo pense en usar la funcion system que recibe una cadena como parametro y la ejecuta como si estubieras en la terminal, pero al hacerlo (trabajo bajo ubuntu 8.04) me tira errores, o simplemente me duestra el directorio raiz y no el directorio que le digo. Viendo esto, pense en emular simplemente una terminal (para eliminar cualquier problema ajeno a esa funcion) y sigo teniendo el mismo problema. #include <stdlib.h> int main (void){ system("cd /home"); system("dir > /home/rombus/Escritorio/aaa.txt"); return 0; }
En el codigo anterior lo que pretendo es hacer un cd al directorio /home y luego hacer un dir redireccionando la entrada/salida estandar a un fichero que esta en mi escritorio. Lo que obtengo es el fichero con los directorios del escritorio (donde esta el programa) no los directorios del /home. Alguien sabe a que se puede deber este problema? gracias!
Páginas: [1]
|
|
|
Mostrar Mensajes
