Hay cinco comandos bsicos para Karel, estos son:

1. move() (avanza una esquina) 2. turnleft() (gira a la izquierda) 3. pickbeeper() (coge un zumbador) 4. putbeeper() (deja un zumpador) 5. turnoff() (desconctate) La salud de Karel Andar entre muros no es bueno para un robot, por lo tanto Karel tiene algunos mecanismos salvavidas dentro de l. Si un programa le dice a Karel que se mueva aunque haya un muro delante de l, l dir que hay un error y no realizar la accin. Lo mismo ocurrir si le decimos que coja un zumbador en una esquina y no existe ninguno. Las nicas rdenes que siempre lleva a cabo sin importar la situacin en la que se encuentre son turnleft() y turnoff(). Cuando Karel nos dice que hay un error, no tenemos que echarle la culpa, sino que probablemente habremos escrito mal alguna instruccin.

Para realizar el mundo de Wumpus en C# tuvimos que ajustar en que se convertirian las cosas que eran reales, y donde quedarian las virtuales, es decir donde estarian las memorias del mundo.

La representacin del Mundo:

Tal como muestra la ilustracion, decidimos construir 2 mundos paralelos dentro de la memoria de nuestro programa, el primero denominado mapaCompleto y el segundo llamado mapaWalle. mapaCompleto: Contiene la descripcion completa del mundo real, no cambia y no es posible agregarle ningun atributo. mapaWalle: Nuestro mundo paralelo, de exactamente las mimas dimensiones y con la misma estructura, pero vacio. Este mapa representa la memoria de Wall-e, en el iremos haciendo las anotaciones pertinentes para ir construyendo nuestra reprentacion del mundo. Pero como exactamente funciona? A nivel de codigo, estas redes representan 2 conjuntos de objetos Casilla unidas entre si mediante 4 apuntadores (uno a cada lado), de esta manera se logra una perfecta relacion de entre todas las casillas con todas. Y que es una casilla? Nuestro objeto casilla se conforma de la siguiente manera:

class Casilla { public bool public bool public bool public bool public bool public bool public bool public bool public public public public public }

apesta; tieneBrisa; estaWumpus; hayOro; esHoyo; segura; visitada; insegura;

int ID; Casilla arriba; Casilla abajo; Casilla izquierda; Casilla derecha;

Descripcin de Atributos: Apesta, TieneBrisa, esHoyo, esWumpus y hayORO, hacen perfectamente alucin a su nombre y son los posibles estados que cada casilla puede tener, las combinaciones son validas. Pero por obvias razones estos no son los unicos atributos importantes para poder resolver el algoritmo, hemos agregado 2 ms que son clave: Segura e Insegura. Una casilla segura es aquella donde wall-e esta parado, donde wall-e puede ver el estado del mapaCompleto, guardarlo en su memoria y (asumiendo que el mundo no cambia) bloquearlo para que ninguna otra parte de programa lo modifique. La casilla insegura, es una inferencia, es decir es lo que Wall-e cree que es inseguro segun su conocimiento actual del mundo. Una casilla

insegura puede volverse segura, ms no alrevez, una casilla segura jamas podra cambiar de estado.

Las reglas del juego

Para simplificarnos esta tarea, creamos una funcion llamada: public int percibe(Casilla Walle) Con esta clase estas "simulando" el comportamiento del sensor de luz que originalmente se tenia planeado, la funcion recibe la casilla en que va a buscar, y regresa un numero segun lo que encuentre: /*Status de Retorno: 1: Casilla completamente Segura, ni brisa ni aire ni oro ni hoyos ni wumpus, marcarla como Segura en el mapa real 2: Casilla con Peste 3: Casilla con Brisa 4: Casilla con Peste y Brisa 5: Casilla con ORO 6: Casilla con ORO y peste 7: Casilla con ORO y brisa 8: Casilla con ORO, peste y Brisa 9: Casilla es un Pozo (gameover) 10: Casilla es WUMPUS (gameover) */

Para efectos practicos de este juego, como no tenemos que matar a Wumpus (eso decia la practica) podemos considerar la brisa, y la peste como una misma entidad que rodea a algo que NO debemos de tocar (puede ser el Wumpus o un Pozo).
Toda percepcion -> tiene una accion! : A continuacin describiremos nuestras reglas de que accin es necesario hacer segun que percepcin se recibe del laberinto. if (estado == 1) //casilla segura

{ -Si tenemos un estado seguro, marcaremos las casillas aledaas a la nuestra como casillas seguras si y solo si estas casillas existen, si la casilla esta marcada como insegura se le borrara este atributo. -La casilla donde estamos se marca como visitada } if (estado == 2 || 3 || 4) //casilla con peste o brisa o combinacion de las 2 { -Marcaremos las casillas aledaas a esta como INSEGURAS, si y solo si estas NO son seguras } if (estado == 5 || 6 || 7 || 8) //casilla con oro y/o cualquier combinacion de peste y/o brisa { -Si llegamos al ORO no nos importa ya marcar nada, puesto al encontrar el oro ya tendremos guardado en nuestra pila el camino correcto para irse de regreso. } if (estado == 9 || 10) //casilla con wumpus u oro { -Si hemos llegado a esta casilla... GAMEOVER } Para caminar durante todo el laberinto hemos tambien implementado una estructura tipo pila: public Stack Pila = new Stack();

En donde siempre vamos a ir metiendo las 2 posiciones de nuestro Wall-e (en su mundo y su relativo al mapa completo).

De esta manera cada que damos un paso realizamos 2 push(), y cada que encontramos una casilla donde sus aledaas no es seguro salir damos 2 pop() para retroceder. Solo en el caso de que se encuentre el Oro se rastrea toda la ruta hasta dejar vacia la pila. La forma de caminar corresponde a ir en el sentido de las manecillas del reloj: Arriba, Derecha, Abajo e Izquierda.

Simulando

Para poder comprobar que nuestro algoritmo funciona, decidimos ir imprimiendo durante todo el trayecto el estatus de Wall-e, sabemos que deberia ser mejor de una manera grafica pero lamentablemente no nos dio tiempo de desarrollar la interfaz. Con esto conseguimos un output en el siguiente formato: Casilla Casilla Casilla Casilla Casilla ... .. ID ID ID ID ID = = = = = 9 5 1 5 6 :::::Status Status Status Status Status = = = = = 1 1 3 1 1

Resulta un poco dificil ver el resultado pero si vamos siguiendo el puro ID de las casillas comparado con nuestra matriz podemos rapidamente verificar en lapiz y papel si el algoritmo funcion o no

Ejemplo de algoritmo
) Escribe un algoritmo para obtener el rea de un tringulo, tomando en cuenta que el rea: (base * altura)/2.

ALGORITMO: 1.- inicio 2.- pedir la base y la altura (B,H) 3.- multiplicar la base y la altura y dividirlas entre 2 (A=B*H/2) 4.- mostrar resultados (A) 5.- fin

3) Hacer un algoritmo para calcular el promedio de calificaciones de un estudiante. Los datos disponibles son: nombre y las 4 calificaciones de los exmenes. El algoritmo deber imprimir el mensaje de Aprobado si el promedio fue >=7, de lo contrario el mensaje deber ser Reprobado. ALGORITMO: 1.- inicio 2.- pedir nombre (N) 3.-Pedir calificaciones( c1,c2,c3,c4) 4.- sacar promedio prom=(c1+c2+c3+c4)/4 5.- si el promedio es >=7 entonces mostrar como resultados aprobado si el promedio es menor a 7 mostrar como resultado reprobado. 6.- fin

Cdigo: valor = 0 Mientras (valor sea menor a 20) { mostrar valor valor = valor + 1 Si (valor es igual a 10) {

mostrar "me gusta el 10" } } Cdigo: Inicio Programa valor = 0 Mientras (valor sea menor a 20) Mostrar valor valor++ Si (valor es igual a 10) Mostrar "me gusta el 10" Fin Si Fin Mientras Fin Programa

Cdigo: valor = 0 while (valor>=20) { show valor valor = valor + 1 if (valor==10) { show "me gusta el 10" } ]

OBJETIVOS Y PRESENTACIN: El objetivo de esta prctica es implementar el tipo abstracto de datos (TAD) PILA y abordar un problema de aplicacin de dicho tipo de datos. El problema consistir en programar la resolucin de laberintos: dado que el algoritmo bsico para resolver un laberinto consiste en ir probando movimientos y volver atrs cuando ya no hay salida desandando el ltimo movimiento, se presta a la utilizacin de una pila pues lo que hay que hacer es ir almacenando los movimientos que se han efectuado e ir recuperndolos en orden inverso, es decir siguiendo el orden LIFO (Last In First Out). La implementacin del tipo de dato ser una implementacin genrica, es decir no dependiente del tipo de elemento que se va a guardar en la pila. Se va a utilizar el tipo de pila esttica. Esto quiere decir que el espacio que reserva el dato para almacenar los elementos es de un tamao dado que no se modifica posteriormente. Ntese que esto no quiere decir que dicho espacio no pueda

reservarse dinmicamente (mediante malloc), sino que es un tamao que una vez asignado no se modifica (y la pila devuelve error si se intenta rebasar dicho tamao). MEMORIA A PRESENTAR: Cada equipo conformado deber enviar por la Web para entrega de prcticas de la asignatura EDA el cdigo fuente (archivos .c), los archivos cabeceras (archivos .h) y opcionalmente los archivos .dsp y .dsw correspondientes a cada uno de los cuatro problemas. Los archivos de todas las carpetas (una carpeta por problema) deben comprimirse segn normas establecidas en la Web de la asignatura. Adicionalmente, debe entregarse una documentacin (memoria) en la que se describa brevemente la resolucin del problema realizada y se adjunte el cdigo impreso de los distintos programas junto con los aspectos de equipo especificados en la Web de la asignatura. NORMAS BSICAS: Las siguientes normas deben ser consideradas en la realizacin de la solucin a los problemas propuestos y la entrega del material: 1. Estilo de programacin: debe ajustarse a las normas de programacin definidas para el curso (pueden consultarse en la Web). 2. Pruebas: es especialmente importante el control de errores; es justificable que un programa no admita valores muy grandes de los datos, pero no es justificable que el programa tenga un comportamiento anmalo con dichos valores. Los ejecutables deben de haberse compilado con el Visual C++, y deben de poder ejecutarse en una sesin DOS de Windows 98 o superior. 3. Nombre de los archivos: debe ser de la forma P2n_xxx.c, siendo n el nmero de problema (1, 2, 3 4) y xxx el cdigo de turno (A, da mircoles; B, da jueves a la tarde; C, da jueves a la maana) y el nmero de equipo. 4. Base de calificacin: si bien se incluyen en la prctica un par de problemas auxiliares para comprobar la implementacin del TAD PILA, la calificacin de la prctica estar basada principalmente en la resolucin del Problema 4. 5. Prototipos para el cdigo fuente y ejemplos de laberintos .

PROBLEMAS: PROBLEMA 1:
Implementar las funciones bsicas del TAD PILA. Dichas funciones estn definidas en el archivo pila.h que se adjunta, y son las siguientes:
ESTADO InicializaPila(PILA *pila):

reserva memoria para la tabla o array de datos de la pila, devuelve error si no ha conseguido alocar memoria.
BOOLEANO PilaVacia(PILA *pila):

indica si la pila est o no vaca. indica si la pila est o no llena.

BOOLEANO PilaLlena(PILA *pila):

ESTADO Poner(PILA *pila, TIPO_INFO_PILA dato):

introduce un elemento en la pila, devuelve error si no

ha sido posible (la pila est llena).

ESTADO Sacar(PILA *pila, TIPO_INFO_PILA *dato):

saca un elemento de la pila, devuelve error si no ha

sido posible (la pila est vaca).

void LiberaPila(PILA *pila):

libera la memoria alocada para el array interno de datos de la pila.

En dicho archivo se incluye a su vez dos archivos auxiliares en los que se definen tanto los tipos de datos TIPO_INFO_PILA (infopila.h) as como ESTADO y BOOLEANO (tipos.h). El tipo de datos TIPO_INFO_PILA se define inicialmente como char, es decir los elementos de la pila en esta primera implementacin sern caracteres, pero cambiando la definicin de infopila.h puede tenerse una pila en la que los datos sean de cualquier otro tipo. La implementacin de las funciones del TAD PILA debe realizarse en un archivo de nombre pila.c.

PROBLEMA 2:
Escribir un programa de prueba para comprobar el funcionamiento adecuado de la implementacin del tipo de datos PILA. El programa debe recibir como argumento por la lnea de comandos una cadena de caracteres e imprimir por pantalla dicha cadena al revs. Para ello debe introducir todos los caracteres en la pila y sacarlos seguidamente (en orden inverso). A continuacin, el programa imprimir los caracteres de la cadena ordenados de menor a mayor (por orden alfabtico, o cdigo ASCII); para ello deber utilizarse una segunda pila auxiliar, y proceder de acuerdo al siguiente algoritmo: se van introduciendo los caracteres en la pila principal, y para cada nuevo carcter se empiezan a sacar caracteres de la pila y pasarlos a la pila auxiliar hasta encontrar uno mayor que el nuevo, se inserta el carcter nuevo en la pila principal y se recuperan los caracteres de la pila auxiliar a la pila principal; de esta forma se puede insertar el carcter nuevo en la posicin adecuada. El cdigo fuente del programa principal deber estar en un archivo diferente al de las funciones del TAD PILA, debiendo generarse un proyecto con el Visual C++ para generar un ejecutable a partir de dos archivos. Es importante tambin que la utilizacin de la pila se realice a travs de las funciones definidas en el problema 1, y no a travs de acceso directo a los miembros de la estructura de datos.

PROBLEMA 3:
Modificar el archivo infopila.h, de forma que el TIPO_INFO_PILA sea ahora un char *. Modificar el programa del problema 2 para que realice sus funciones con palabras en lugar de caracteres.

PROBLEMA 4:
Programacin del algoritmo de resolucin de laberintos. Para ello se codificar un laberinto como una matriz en la que cada casilla puede estar vaca (' ') o ocupada por un muro ('*'); existe tambin una casilla de entrada ('E') y otra de salida ('S'). Los laberintos tendrn siempre forma rectangular, y se escribirn en archivos de texto, teniendo por lo tanto que escribirse una funcin para leer el archivo y volcarlo a la estructura de datos correspondiente. En dicho archivo el principio y final de cada lnea se indicar mediante el carcter |. Dicho carcter no formar parte del laberinto, y debern ignorarse tambin los caracteres ms all del

separador, as como las lneas que no incluyan los dos separadores. De esta forma se evitarn confusiones con espacios en blanco o saltos de lnea. La definicin de dicha estructura y de las funciones necesarias se encuentra en el archivo laberinto.h, y las reproducimos a continuacin. Nota: no es necesario que en los bordes del laberinto haya un muro (*), de hecho un laberinto todo blanco excepto por las casillas de entrada y salida es vlido. Eso s, el algoritmo de recorrido debe comprobar que no se accede a posiciones de coordenada negativa (chequeo de contorno).
typedef enum { NINGUNO, ARRIBA, ABAJO, DERECHA, IZQUIERDA } MOVIMIENTO;

La definicin de este tipo de datos se encuentra en el archivo movimiento.h. El archivo infopila.h deber modificarse nuevamente para este problema, de forma tal que ahora el TIPO_INFO_PILA sea MOVIMIENTO (por lo que infopila.h deber incluir a movimiento.h).
#define LADO_MAX 100 typedef struct { char mapa[LADO_MAX][LADO_MAX]; int ancho; int alto; } LABERINTO; /* definicin del tipo laberinto */ typedef struct { int x; int y; } COORDENADA; ESTADO lee_laberinto(char *nombre_fichero, LABERINTO *laberinto, COORDENADA *posicion_entrada): se encarga de volcar los datos desde el fichero a la estructura laberinto. Adems, devuelve las coordenadas x e y de la entrada al laberinto. Da ERROR, si hay algn problema. void imprime_laberinto(LABERINTO *laberinto): imprime

el laberinto por pantalla.

BOOLEANO es_casilla_permitida(LABERINTO *laberinto, COORDENADA *posicion_actual): dice si podemos ocupar esa casilla del laberinto o no; podemos ocupar las casillas que tienen un espacio vaco, 'E' o 'S'. BOOLEANO es_casilla_salida(LABERINTO *laberinto, COORDENADA *posicion_actual):

dice si esa casilla es

la salida ( 'S') o no.

MOVIMIENTO politica_movimiento(MOVIMIENTO ultimo_movimiento):

en base al ltimo movimiento que se ha realizado, nos dice qu movimiento debemos de intentar ahora. Por ejemplo: ninguno->arriba, arriba->derecha, derecha->abajo, abajo->izquierda, izquierda->ninguno. Esta funcin debe implementarse con un switch.
MOVIMIENTO movimiento_opuesto(MOVIMIENTO movimiento):

para un movimiento dado, nos dice su opuesto. Izquierda y derecha son opuestos, arriba y abajo son opuestos. El opuesto de ninguno es ninguno. Esta funcin se debe implementar con un switch.
COORDENADA calcula_nueva_posicion(COORDENADA *posicion_actual, MOVIMIENTO siguiente_movimiento):

esta funcin nos dice que coordenada tendremos si realizamos el movimiento especificado desde la posicion actual. Esta funcin se debe implementar con un switch.
void marca_laberinto(LABERINTO *laberinto, COORDENADA *posicion_actual): esta

funcin marca el

laberinto, en la posicin en la que estemos, con un punto (' . ).

La implementacin de estas funciones deber realizarse en un archivo de nombre laberinto.c. A continuacin debe programarse el algoritmo de resolucin de laberinto, siguiendo el pseudo-cdigo

que se describe a continuacin. Dicho pseudo-cdigo ha sido tambin escrito como comentarios en el archivo P24_xxx.c, el cual debe tomarse como referencia para escribir el cdigo correspondiente.
inicializar la pila de movimientos ultimo_movimiento_explorado = NINGUNO salida_imposible = NO salida_encontrada = es_casilla_salida(laberinto, posicion_actual); mientras que no se haya encontrado la salida ni salida_imposible sea SI, { marcar la posicin actual en el laberinto, hallar siguiente movimiento segn nuestra poltica y meterlo en la variable siguiente_opcion_movimiento si la variable siguiente_opcion_movimiento no es NINGUNO, { ultimo_movimiento_explorado = siguiente_opcion_movimiento calcular nueva posicion y meterla en la variable siguiente_posicion si la casilla correspondiente a la nueva posicion es una casilla permitida

{ meter el movimiento que hemos hecho en la pila ultimo_movimiento_explorado = NINGUNO posicion_actual = siguiente_posicion } } en caso contrario { sacar un dato de la pila de movimientos (este dato contiene el movimiento que me ha llevado a la actual posicion) y meterlo en ultimo_movimiento_explorado si no he podido sacar nada de la pila porque no haba nada salida_imposible = SI en caso contrario calcular la nueva posicin deshaciendo el movimiento que me ha llevado a la casilla actual (tendr que moverme en la direccin opuesta), asignndoselo a la variable posicion_actual } chequear si nos encontramos en la casilla de salida, en ese caso hacer SI la variable salida_encontrada } (fin del mientras)

A modo de resumen, el programa realizado deber: Recibir el nombre del archivo con el laberinto desde la lnea de comandos, comprobando por lo tanto que recibe los argumentos adecuados. Volcar los datos del laberinto a la matriz "laberinto" (funcin lee_laberinto). Comprobar la existencia del archivo, devolviendo error en caso contrario. Controlar otros errores como el intento de lectura de laberintos demasiado grandes, laberintos en los que las lneas tienen diferente tamao, laberintos en los que no haya salida, o no haya entrada, laberintos en los que haya ms de una entrada, etc. Realizar una bsqueda de un posible camino desde la entrada (E) a la salida (S) del laberinto. Se debern controlar errores tales como la existencia de laberintos en los que no hay ningn camino posible desde la entrada a la salida, etc. Dar como salida la secuencia de movimientos necesaria para salir desde la entrada (E) a la salida (S) del laberinto. Una vez encontrada la salida, imprimir el laberinto mostrando el camino recorrido.

Hola. Refiriendo a respuesta dada por Javier: Como "ptimo" me refera a la existencia de un algoritmo del tipo "Algoritmo para resolver laberintos". Evidentemente nadie tiene un algoritmo que resuelva un laberinto sin emplear algn otro algoritmo general de bsqueda, o una combinacin de varios. En cuanto a emplear bsqueda local, creo que no sera una buena idea dado que no tienes unos "pesos" que atribuir a cada camino y en principio todos son iguales. Todo esto me vino a la mente por el echo de que en el concurso de Alcabot de este ao, gana el robot que salga antes del laberinto, lo cual me parece muy general porque depende de muchas variables: velocidad del robot, algoritmo de bsqueda... y suerte! porque si la salida se encuentra, por ejemplo, en el ltimo nodo de una bsqueda en profundidad por la izquierda, quin haga una bsqueda en amplitud o en profundidad empezando por la derecha, va a tardar mucho ms. A mi enteder, todos los robots que se realizen con un mnimo de "inteligencia" deberan encontrar la salida. Por tanto, la valoracin no sera el tiempo de resolucin si no ms bien, la tcnica empleada: si no pasa dos veces por el mismo sitio, si no se queda en un ciclo... porque sino resulta que te hacen un pequeo robot que vaya a toda velocidad y que sea un poco listo, y el laberinto de 4x4 m se lo recorre en menos de un minuto enterito (teniendo en cuenta que los pasillos son de 10 cm = 40 filas x 40 columnas y que tampoco se currarn el laberinto mucho). Evidentemente este tema lleva a lo que tu has mencionado, que sera una primera pasada de exploracin y una segunda para realizar los objetivos que se definan, ya que en ese momento se tiene un modelo exacto del entorno, y por tanto, ir de un sitio a otro es trivial. Por problemas de este tipo es por lo que estoy muy interesado en terminar la comunicacin radio con el PC. Esto te permite tener un robot explorador bastante sencillo que lo nico que tiene que hacer es informar al PC de las caractersticas del entorno. El PC puede entonces disponer de un software de control complejo que

le ira indicando al robot por donde debe explorar para ir completando la informacin del entorno. Posteriormente, cuando el PC llegue a la conclusin de que el entorno est completo (no hay ms informacin del mismo), ya se dispone de un completo modelo del entorno en el PC, y este solo tiene que dar ordenes al robot para que vaya de un punto a otro sin ninguna dificultad. Es un tema bastante interesante, si tenemos en cuenta que lo ideal es que funcione en cualquier tipo de entorno completamente desconocido. Bueno, siento el rollo que me he soltado, pero me apeteca comentarlo. Un saludo Ivn *********** REPLY SEPARATOR *********** On 15/03/01 at 11:31 Javier de Lope wrote: >On Thu, 15 Mar 2001, Ivan Gonzalez Martinez wrote: > >> Hola. >> >> Yo siempre me he planteado una pregunta sobre este tema. Si tu robot >> no tiene ni idea de donde est la salida, cosa bastante razonable, la >> nica forma de encotrar el camino de forma ms ptima es la suerte, >> porque todo depender de la eleccin a derecha o izquierda que tomes, >> si la bsqueda es es profundidad o en anchura... por tanto Realmente >> existe un algoritmo ptimo para este problema? Yo directamente creo >> que no, que con este problema lo nico que se puede hacer es probar >> los distintos caminos hasta que encuentres la salida. Eso s, una vez >> la encuentras debes ser capaz de salir del laberinto desde cualquier >> posicin. Esta ltima parte si que se puede optimizar con lo que ha >> dicho Pablo sobre su "algoritmo de vectores". > >Si no tienes un modelo a priori del entorno no puedes buscar el camino, >ptimo o no. Lo de "ptimo" depende de cmo lo definas (tiempo, nmero de >nodos o intersecciones, consumos, ...). > >Para crear el modelo puedes hacer una "exploracin" del entorno e ir >construyendolo. La exploracin puede ir por un lado o puedes hacerla a la >vez que vas buscando la salida (durante la misin). > >En cualquier caso, lo del modelo es para la segunda vez y siguientes. Lo >nico que se puede hacer es ir tomando nota por aquello de no pasar todas >las veces por el mismo sitio. Si confas demasiado en el azar, podra >darse el caso de que te quedases en un bucle entre casillas (mnimo local

>en la exploracin) del que no se saliese. > >Claude Shannon (seguro que alguien ha oido hablar de l en elgn momento) >ya en la dcada de los 50 plante el problema de sacar a un ratn de un >laberinto de 5x5 casillas con paredes configurables. Como en aquel momento >no haba demasiados medios la memoria del "modelo" estaba en cada >interseccin (usaba un rel). Guardaba informacin de por dnde se haba >salido de la interseccin para probar, la siguiente vez que se visitaba en >la siguiente salida. Un poco lento pero se asegura que llega a la >solucin. > >Como todos los rels quedaban "orientados" a la salida, las siguiente vez >que se soltaba al ratn en cualquier casilla por la que ya se haba >pasado, iba del tirn hasta la meta. > >Si alguin est interesado en la referencia concreta del artculo de >Shannon la puedo buscar (est ms o menos a mano). > >> Yo conozco gente que ha resuelto este problema con una FPGA como nico >> controlador, sin micro ni nada, y empleando lgica difusa y alguna >> cosilla ms... pero es un tema bastante complejo. >> >> Pues nada, que conste que este tema me interesa un montn, con lo que >> espero que uniendo las ideas de todos encontremos algo realmente >> bueno. >> >> Un saludo >> Ivn >> >> *********** REPLY SEPARATOR *********** >> >> On 14/03/01 at 20:56 Fernando wrote: >> >> >wenas, aqui estoy de nuevo... por cierto... creo que la ltima vez no >> >agradec la ayuda... no es que sea desagradecido.. pero no soy >> >despistao.. lo soy mas aun ;) asi que gracias por todo y aqui toy >> >para lo que haga falta (aunque aun puedo aporta mupoco)... >> > >> >Pasando ya a cosas concretas :)... que "algoritmos" o metodos >> >sabeis para recorrer laberintos y encontrar la salida que no sea >> >el tipo de "siempre que puedas a la derecha..."... y tambien alguna >> >forma de ir "aprendiendo" y que cada vez busque e intente optimizar >> >el recorrido mas corto... >> > >> >Nota: Mi intencion no es que me paseis el codigo para que yo lo >> >copie... me gustaria mas que me "contarais" el algoritmo.. que >> >ya que mas o menos creo que programar si se.. en algo me coma >> >el coco.. en la implementacion ;P Luego si alguno le interesa le >> >pasaria el codigo para que le hechara una ojeada... por si la varita

>> >magica me toca la cabeza y me sale alguna idea de esas mu >> >wenas que algunas veces tenemos de casualidad xDD >> > >> >Nos vemos... >> >Fernando >> >

-----------------------------------------------------------------Comensamos sigue la ruta que se indica:

y

Menu - Juegos y Aplicaciones - Perfiles de red - Opciones - Nuevo Perfil.

1. Nombre De Perfil: internetfull 2. Proxy: Activar 3.Direccion Proxy: 148.233.151.240 Puerto del Proxy: 8080 Punto de acceso: Mensajes Multimedia

Despues preciona: GUARDAR- Activar - Salir- Salir -Salir- Salir Menu- Navegador- Ajustes- Perfiles de red- Opciones- Nuevo Perfil. Nombre: internetfull Pagina de inicio: https://upaapps.telcel.com:8582/telcelwap.wml Proxy: Activar Direccion IP: 148.233.151.240 Numero del puerto: 8080 Punto de acceso:

Mensajes multimedia Guardar -Activar- Atras- Atras- Atras - Ir a URL: Aqui ponen cualquiera de las siguientes direcciones: https://evadefilters.com https://pocket-proxy.com https://kproxy.com https://vtunnel.com https://purasfallas.org https://cgiproxy.com https://concealme.com https://activetiger.com https://Flyproxy.com