|
|
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.
Mensajes - Nagisa
76
« en: Jueves 24 de Febrero de 2005, 09:49 »
Hola MutenRo!! Lo he probado bajo Linux y si que funciona  , asi que supongo que sera algun tipo de problema con Windows  . Me falla a la hora de abrir el fichero de ordenes  De todos modos, la solucion al problema, a pesar de ser correcta, no es buena. Desperdicias demasiada memoria y pierdes demasiado tiempo. En concreto, en el ejemplo dado, tu reservas 25 x 25 = 625 posiciones de memoria, cuando se puede hacer con bastantes menos. En general lo hago con (2n + 1) + 1 puntero; con lo que son 21 + 1p para n = 10. En cuanto al tiempo... Se podria buscar una forma de saber mas rapido en que pila esta un bloque sin recorrerlas todas. En el peor de los casos, tu consultas n posiciones de memoria (es justo el ultimo de la ultima pila)... Mi solucion lo hace consultando solo una. Normalmente en los concursos de programacion te suelen limitar tanto el tiempo que permiten que ejecute tu programa como la memoria que le dejan usar. Si tienes tiempo y/o ganas intenta mejorarlo  . La solucion para una pequeña mejora: memoria dinamica y variables redundantes. La solucion para una mejor mejora: darle muchas vueltas a la solucion anterior  Salu2!!
77
« en: Lunes 21 de Febrero de 2005, 11:17 »
Hola MutenRo. siento contestar tan tarde. Los huecos si que se pueden rellenar. De hecho, cada vez que se dice que un bloque vuelve a su posicion inicial es a eso a lo que se refiere.
Sobre la posibilidad de volver a la posicion inicial... es imposible. Para devolver un bloque a su sitio, debes de apilar otro en la pila que lo contenia: asi que en el mejor de los casos tendras n-1 pilas de un bloque y una de dos.
Si bien como has podido observar, una vez llegues a una unica pila el resto de ordenes son ilicitas.
Deje bastante claro que la entrada era la entrada standrd (TECLADO!!!)
Ademas, aunque no lo he probado, creo que tu programa daria algun tipo de error al leer el comando quit, ya que no va seguido de nada mas(y tu lees dos cadenas y dos numeros).
Tampoco he dicho en ningun sitio que cada elemento sintactico este separado por un unico espacio; caso en el que tambien fallaria tu codigo.
De todos modos, a mi no me funciona en mi ordenador. Ya lo revisare.
Un saludo!!
78
« en: Viernes 18 de Febrero de 2005, 10:44 »
Uhm... lo que estas haciendo es meter el compilador tal cual, pero no lo has configurado para nada, y por eso no te encuentra las cosas. Te recomiendo que te instales directamente el paquete de GNAT que te incluye el gcc y demás amigos. Aqui tienes un link: ftp://lml.ls.fi.upm.es/pub/lenguajes/ada/gnat/3.13p/winnt(Para Windows) Lo bajas, lo instalas y creo que asi no te dara problemas. Una cosa: yo lo uso para Ada, pero por lo visto este compilador (gcc) compila casi todo (C seguro).
79
« en: Viernes 18 de Febrero de 2005, 10:35 »
Uhm.... Esto a nivel de programación no tendría ningún problema: como has visto, tu simplemente lees de la entrada/salida standard: sea esto teclado/pantalla o la salida/entrada de otro programa. Normalmente es la pantalla, aunque tu a la hora de ejecutar el programa le dices al Sistema Operativo que quieres que en lugar de eso, sea la salida del programa anterior al |. También tienes por ejemplo las redirecciones a fichero (> y <). Para redirigir entradas y salidas debes usar llamadas combinadas a Close y Dup (servicios del Sistema Operativo), aunque pertenecen al standard POSIX que creo que Windows no cumple del todo. Yo recuerdo que tuve que programar un Shell para una practica y hacíamos esto entre procesos (todo con unos forks y pipes muy bonitos )
80
« en: Viernes 18 de Febrero de 2005, 10:18 »
Por lo visto te pasa lo mismo.
Ahora el compilador no te encuentra donde están las librerías standard (en este caso stdio y stdlib) y te falla por que no encuentra las funciones scanf, printf y system...
La solución sería la misma: buscar donde están e incluirlo en el PATH; aunque eso normalmente ya esta configurado por defecto (yo tengo el gcc para Windows y Linux y no me ha dado ningún problema).
Espero que lo soluciones y puedas seguir aprendiendo C. Salu2!!
81
« en: Sábado 12 de Febrero de 2005, 12:44 »
Hola Cirrus!!  Acabo de echarle una ojeada a tu idea de las pilas y me parece que esta muy bien. La verdad que yo tambien estoy harto de usarlas en la Universidad, aunque quizas hay otras estructuras de datos que no sean tan usadas/conocidas y se podrian analizar en este topic. Pasando al planteamiento que haces de pilas, creo que sobran algunas operaciones y falta una. En principio, en un TAD unicamente debes incluir las operaciones que permitan el trabajo basico: si hay algo que se puede hacer con lo que das, que sea el usuario quien lo programe, no el diseñador.  Asi por ejemplo, veo redundante la que te invierte una pila (sacas los elementos en una auxiliar y devuelves la auxiliar) o la que te los ordena...  Aparte, si bien a nivel de funcionalidad estan bien, cualquier cosa que altere el orden de los elementos de la pila es algo "aberrante"  teniendo en cuenta la filosofia de esta ED (LIFO : Last In, First Out). Como dije, echo de menos una operacion que te diga si la pila esta vacia, ya que nunca podremos extraer cosas de esta pila (excepcion y todo eso). Por lo tanto, y desde mi punto de vista, las operaciones que deberian de haber son: - Crear_Vacia</li>
- Apilar</li>
- Desapilar</li>
- Primero (prescindible, dependiendo del diseño)</li>
- Es_Vacia</li>
- Destruir</li>
- Recorrido (opcional) : Aplica una operacion a todos los elementos de la pila (orden superior y todo eso...)</li>
Yo tengo una implementacion muy sencillita para enteros, aunque estamos con el problema de genericidad de tipos que comentabas antes... Con los punteros a void se soluciona en parte, aunque la idea es que todos los elementos de una pila sean del mismo tipo. Aqui te la dejo por si quieres echarla un vistazo, aunque es demasiado basica... Aunque como dije al principio, me parece muy guay lo que estas haciendo. Espero que desmenuzes otras estructuras algo mas interesantes (arboles-B o cosas asi) Saludos!!
82
« en: Sábado 12 de Febrero de 2005, 11:59 »
Como esto esta muy sosete voy a publicar un reto . Es muy sencillo, y corresponde al problema 101 del UVA (del que hablo Binary en algun post anterior). El enunciado, traducido casi literalmente del ingles, es el siguiente:
El Problema de los bloques.
TRASFONDO:
Muchas areas de la Informatica usan dominios simples y abstractos para estudios tanto analiticos como empiricos. Por ejemplo, un estudio prematuro de IA de planificacion y robotica (STRIP) usaba un mundo de bloques en el cual un brazo robotico llevaba a cabo tareas que implicaban la manipulacion de los bloques.
EL PROBLEMA:
El problema es procesar unas series de mandatos que instruyen a un brazo robotico sobre como manipular los bloques que estan en una mesa plana. Inicialmente hay n bloques en la mesa (enumerados desde 0 hasta n-1) con el bloque b(i) adyacente al bloque b(i+1) para todo 0 <= i < (n-1).
Los mandatos validos para el brazo robotico que manipula los bloques son:
move a onto b
donde a y b son numeros de bloque, pone el bloque a encima del bloque b despues de devolver cualquier bloque que estuviera apilado encima de los bloques a y b a sus posiciones iniciales.
move a over b
donde a y b son numeros de bloque, pone el bloque a encima de la pila que contiene el bloque b, despues de devolver cualquier bloque que estuviera encima del bloque a a su posicion inicial.
pile a onto b
donde a y b son numeros de bloque, mueve la pila de bloques consistente en el bloque a, y cualquier bloque apilado encima del bloque a, encima del bloque b. Todos los bloques encima del bloque b son movidos a sus posiciones iniciales antes del que el apilado tenga lugar. Los bloques apilados encima del bloque a mantienen el orden cuando son movidos.
pile a over b
donde a y b son numeros de bloque, mueve la pila de bloques consistente en el bloque a, y cualquier bloque apilado encima del bloque a, encima de la pila que contenga al bloque b. Los bloques apilados encima del bloque a mantienen el orden cuando son movidos.
quit
termina las manipulaciones en el mundo de bloques.
Cualquier mandato con a = b o en el que a y b esten en la misma pila es un mandato ilegal. Todos los mandatos ilegales deberan de ser ignorados y no deberan de afectar a la configuracion de los bloques.
LA ENTRADA:
La entrada empieza con un entero n en una linea por si misma y representa el numero de bloques en el mundo de bloques. Puedes asumir que 0 < n < 25.
El numero de bloques esta seguido por una secuencia de mandatos de bloques, uno por linea. Tu programa debera procesar todos los mandatos hasta que se encuentre al mandato quit.
Puedes asumir que todos los mandatos seran de la forma especificada arriba. No habra mandatos sintacticamente incorrectos.
LA SALIDA:
La salida debera de consistir en el estado final del mundo de bloques. Cada posicion inicial del bloque i ( 0 <= i < n, donde n es el numero de bloques) debera aparecer seguida inmediatmente por dos puntos (':'). Si hay al menos un bloque en ella, los dos puntos deberan de estar seguidos por un espacio, seguido de la lista de bloques que estan apilados en esa posicion con cada numero de bloque separado del resto por un espacio. No poner espacios sobrantes al final de la linea.
Debera haber una linea de salida por cada posicion de bloque (es decir, n lineas de salida donde n es el entero de la primera linea de la entrada).
ENTRADA DE EJEMPLO:
10 move 9 onto 1 move 8 over 1 move 7 over 1 move 6 over 1 pile 8 over 6 pile 8 over 5 move 2 over 1 move 4 over 9 quit
SALIDA DE EJEMPLO:
0: 0 1: 1 9 2 4 2: 3: 3 4: 5: 5 8 7 6 6: 7: 8: 9:
Como fecha final del reto daremos algo mas de 15 dias, aunque yo lo hice en una tarde...  Pongamos pues el dia 1 de Marzo como tope, dia en el cual publicare la solucion (me estoy currando un pdf que analiza el problema a fondo y lo desarrolla, aunque como ya dije no tiene mucha vuelta de hoja  ). Recordad que la entrada es la entrada estandard (teclado por defecto, salvo redirecciones). A ver si alguien se anima
83
« en: Sábado 12 de Febrero de 2005, 10:57 »
Si lo que quieres es la solucion simbolica, entonces te pasa lo que te ha dicho Amilius: es un problema de IA. Derivar se puede hacer automaticamente: definimos una ED recursiva que nos lleve a los casos basicos, y de ahi en adelante Regla de la Cadena para todos!! Integrar es mucho mas complicado. De entrada, nadie te asegura que cualquier funcion dada sea integrable. Y encima tienes el problema, en el caso de metodo de partes, de como escoger el u y el dv... Pero es que es complicado hasta hacer una integral inmediata, ya que en todo momento hay que identificar las partes en las cuales se puede descomponer... Si es complicado hacerlas a mano, imaginate buscar un algoritmo generico.
84
« en: Martes 8 de Febrero de 2005, 23:24 »
Hola!! Llevo algun tiempo fuera por los examenes y eso. Dos cosas:
Ya ha pasado casi un mes del final del reto, asi que supongo que lo has ampliado (o te has olvidado de el vilmente)
Y lo segundo: como nos dan la entrada?? Solo los coeficientes?? Las ecuaciones tal cual? Como sabemos cuantas y cuales son las incognitas (quizas lo primero sea lo mas dificil)??
De todos modos, quitando el tema de las fracciones, el reto parece algo simple... Creo que me podre con el en cuanto aclares este asunto.
Saludos!!
85
« en: Martes 8 de Febrero de 2005, 23:19 »
Yo la verdad es que solo conocia el de la universidad de Valladoliz (uva.es), y la verdad es que hay algunos que son muy muy dificiles... con decirte que me costo bastante el del 3n+1... Sera que estoy algo verde ( )en el tema. Pero seguire esforzandome
86
« en: Sábado 14 de Agosto de 2004, 11:50 »
hola!! Para ser de secundaria estas metiendo demasiada caña... Yo no voy a ponerme en ello por que como dije tengo las mañanas para estudiar, las tardes para trabajar y las noches para estudiar tb (dormir es un lujo que no puedo permitirme ). De todos modos este parece sencillo. Es contar los coches que empiezan detras de cada uno y con mayor velocidad. Para solucionar el problema de la complejidad cuadratica me imagino que habria que usar un coso tipo arbol o heap o algo asi. No obstante aun no lo he pensado... Es que has escogido una mala epoca para poner retos... Yo estoy preparandome uno de numeros primos. Cuando lo saque yo os lo posteare, pero ya digo que sera por Octubre...
87
« en: Lunes 9 de Agosto de 2004, 23:43 »
La verdad que mi primera (y lamento decir que unica) idea gue backtracking... Pero pronto descubri que era demasiado mala!! Asi que ahora mismo estoy asi: esperare a que postees la solucion para reirme de lo tonto que he sido , o no....
88
« en: Sábado 7 de Agosto de 2004, 14:37 »
Uhm... Por que no buscas en Google?? Yo lo he buscado tal cual ("pvm") y me han salido mas de 5.000 resultados en Español.
89
« en: Sábado 7 de Agosto de 2004, 13:20 »
De todos modos, ten cuidado por que la respuesta anterior es incorrecta (la mia no  ). La comparacion deberias hacerla convirtiendo numerador y denominador a Float antes de dividir, no despues. Te dejo un pequeño programita para que veas la diferencia: with Ada.Text_IO, Ada.Float_Text_IO; use Ada.Text_IO, Ada.Float_Text_IO; procedure Prueba is a, b : Integer := 0; begin a := 5; b := 6; Put ( float(a / b) ); New_Line; Put ( float(a) / float(b) ); end Prueba;
Eso te llevaria a hacer cuatro conversiones y dos divisiones entre Floats y luego una comparacion entre dos floats... Mientras que de mi forma solo haces dos multiplicaciones entre enteros y una comparacion entre enteros...
90
« en: Sábado 7 de Agosto de 2004, 13:03 »
hi!! Aunque la solucion que te han dado funciona, yo creo que lo que se espera que hagas es reducir ambas fracciones a comun denominador y comparar los numeradores. Parece complicado, pero so observas un poco es mas sencillo de lo que parece, por que podrias reducirlo a un simple producto en cruz:
Comparamos a/b y c/d:
a/b == (a*d)/(b*d)
c/d == (b*c)/(b*d)
Y ahora solo comparariamos los numeradores: a*d con b*c
Como digo, lo otro tambien vale.
91
« en: Sábado 7 de Agosto de 2004, 08:08 »
Hi!! Antes de nada decir que realmente yo no se como hacerlo , aunque lo de window supongo que estara en alguna libreria... De las soluciones, asi a simple vista me parece mejor la de window que la de reimprimir toda la pantalla, ya que si se actualiza con mucha frecuencia puede ser bastante molesto. La opcion de gotoxy tb me parece buena.... De todos modos con lo que tengas nos avisas a todos, por que a mi tb me gustaria saber como se hace Suerte con el juego
92
« en: Sábado 7 de Agosto de 2004, 07:49 »
Waaaaaaaaaaaaaa!! Es un reto bastante curioso cuando menos... Por lo menos se sale de la clasica vuelta del caballo (Knigth's Tour creo que se le llama en ingles).
Tengo una duda. El rey puede moverse tambien?? Digo solo y por si mismo con el movimiento clasico del rey (una casilla en cualquier direccion). Y otra mas... Si el rey se mueve con caballo, cuenta solo un movimiento, no??
Si puedo me pondre con el, aunque no creo por que tengo mucho que estudiar (9 para Septiembre y encima trabajo de 14:00 a 21:00) T__T Mi gcc me hecha de menos.... Aunque me vendria bien para el concurso de programacion de Octubre...
See ya!!
93
« en: Jueves 10 de Junio de 2004, 19:09 »
Gracias, gracias... realmente no era dificil
94
« en: Viernes 4 de Junio de 2004, 21:47 »
Si, realmente es muy facil. Yo ya lo tengo, lo que ocurre es que los datos que dan como prueba no producen la salida esperada. La cuestion es que el tamaño de un entero varia segun platraforma y compilador.
En mi ordenador con el gcc es de 32 bits, por lo que para producir un overflow necesitamos un numero del orden de 4.2E9 (algo mas).
Aqui posteo mi solucion, la cual considero bastante "elegante" (no habia hecho un codigo recursivo tan bonito desde mi primer factorial... snif)
(Adjunto como .txt por que como .c no me deja)
95
« en: Lunes 3 de Mayo de 2004, 22:02 »
Veamos... la respuesta depende de como soluciones el problema , y ambas serian aceptables!! Por eso se descartan esas entrada, por ser ambiguas. Bien... debido a los examenes no he podido optimizar en absoluto la solucion, la cual se puede mejorar por muchos sitios. Explicando a groso modo, el problema se reduce a uno de contar componentes conexas en un grafo, el cual viene dado por la entrada. Cuando hablo de mis posibles optimizaciones son a la hora de representar dicho grafo y el algoritmo de contado (cuando escribi el codigo todavia no sabia hacerlo). Aqui cada nodo del grafo es un registro con 4 punteros y un valor que lo identifica exclusivamente. El algoritmo de recorrido es destructivo (etiqueta los nodos visitados con un 0), y se aprovecha de que sabemos que ningun nodo tiene grado mayor que 2. Escojo un nodo valido (id != 0); una vez llego a un nodo, solo tengo un posible camino para seguir , por lo tanto lo marco (id = 0) y reitero por el siguiente ; si no, termino con esa componente conexa, la cuento y busco un nuevo nodo Tira con el gcc, asi que no creo que tengais problemas. Lo adjunto como .txt por que no me deja hacerlo como .c De todas formas, si hay cualquier duda, preguntadla 
96
« en: Lunes 26 de Abril de 2004, 23:19 »
Veamos... La primera entrada no seria posible, ya que el dibujo no esta cerrado.
Sobre el caso de que un '+' forme parte de varios lazos.... auqnue del enunciado no se deduce, la respuesta es que no. En tu segundo ejemplo... cual seria la solucion correcta?? 1 o 2?? Digamos que eso entraria en el caso de "lazo ambiguo".
97
« en: Martes 20 de Abril de 2004, 19:06 »
Hola!! Yo creia que el problema de la mochila era uno de los tipicos problemas que se resolvian por backtracking, no por divide y venceras.
Pones un objeto en la mochila, si el peso se pasa del maximo, devuelves la combinacion sin haber puesto ese objeto y continuas hasta obtener todas las combinaciones. Despues pasas un maximizador en funcion del valor y ya lo tienes. Tienes que tener cuidado de no repetir combinaciones.
Quizas sea algo mejor tener como variable global el maximo valor obtenido hasta el momento, para que una vez obtenga una combinacion y no pueda obtener mas a partir de ella, si no supera dicho valor no la devuelvo.
98
« en: Martes 20 de Abril de 2004, 18:49 »
Uhm... una forma en la que yo lo intentaria hacer es con un grafo. Las celdas son los vertices y cada arista se une a un nodo si las celdas son adyacentes.
Ponemos a cada arista un peso 1 y el problema se reduce a uno del tipo "el camino mas corto" (Dijkstra).
Para saber cuantos nodos poner, quizas deberiamos de calcular en que "corona" esta el mayor nodo, y completarla. Tenemos que la corona numero 'n' tiene forma de hexagono de lado n, por lo que el numero de celdas que contiene son 6*(n-2) (celdas de los lados quitando los extremos, para no contarlos dos veces) + 6 (los "vertices") = 6*(n-1).
Espero que te sea de alguna ayuda.
99
« en: Martes 20 de Abril de 2004, 00:35 »
Bien... no estoy seguro, y que me corrija alguien si me equivoco pero creo que el fallo es el siguiente: Tu le pides a scanf que te tome algo y lo trate como numero. Si le pasas una letra, scanf la coje y no la coje, es decir , acepta la entrada y la trata como numero, y vuelve a por un numero, pero la letra sigue alli (no ha avanzado en el buffer de entrada por que no tomo un numero), asi que la coje y vuelta a empezar. De ahi que te muestre infinitos mensajes. La naturaleza del mensaje quizas sea debida a que en cada vuelta redeclaras las variables, y recuerda que C no las inicializa por defecto, asi que valen cualquier cosa (y posiblemente en entero sea mayor que 100). Para comprobar lo que te digo, haz un printf("%d\n", a); despues de cada comprobacion, y asi ves lo que has metido al pulsar la letra (yo lo he hecho y 'w' -> 4008536). La solucion a este problema es algo complicada : leer los numeros como caracteres. No es complicada en si, aunque si que añade bastante codigo para algo que seria tan facil si el usuario no fuera tan torpe ^__^ Una cosa mas: donde pone printf("Volver a jugar(s/n):"); scanf("%d",B); supongo que es un : printf("Volver a jugar(s/n):"); scanf("%d",b ); y deberia ser un printf("Volver a jugar(s/n):"); scanf("%c",&b ); <------- b lo has declarado como char!! aunque de todos modos no entiendo por que lo haces, si en el switch haces un b = getchar() Espero haberte ayudado
100
« en: Lunes 19 de Abril de 2004, 23:50 »
Bien... Nada de Huskie... digo... Haskell. Ya tengo la primera parte del problema (la de los caballos). Solo hay una pega... Como ya te dije antes, eso se verifica siempre para un tablero de 8x8, asi que estaria bien saber para que dimension no se verifica (evidentemente mayor que 3), ya que por ahora he probado con tableros desde 4x4 hasta 15x15 y se cumple para todos (no prubo numeros mas altos por que para 15 ya piensa bastante...).
Lo posteare en cuanto haga una serie de optimizaciones de recursos, aunque si quieres puedo colgar lo que llevo.
Sobre lo de las 93 soluciones de las reinas... es muy probable. Tenia un codigo que te sacaba todas las soluciones y he contado 92, aunque puede que se me haya escapado alguna. Por si te interesa, te las mando adjuntas.
|
|
|
Mostrar Mensajes
