Mensajes

[Elige la de 96.8 MB]

Buenas.
............................................
¿Alguien puede ayudarme porfavor? Gracias.

Yo uso Code::Blocks

Elige la de 96.8 MB.

Felices Navidades y Próspero Año Nuevo.

Saluditos! ..... !!!!

[Code::Blocks]

con cual programa as compilado?Ya que se que no usas Dev XDD

Code::Blocks

Y una imagen de prueba de que furula bien:

Felices Navidades y Próspero Año Nuevo.

Saluditos! ..... !!!!

[eso seria una pasada]

ok! lo prometo que le echare un ojo. $_$  
.......................................................................
Otra cosa seria hacer que si reconoce el camino no vuelva a tomar el camino equivocado, eso seria una pasada. XDD
..................................................................

Pues es justamente lo que hace el programa. Ejecútalo y lo veras, pero no te olvides de activar las líneas de código que están  desactivadas para verlo. Las desactivo porque una vez comprobado que todo funciona, o al menos eso parece, vaya como un tiro. Recuerda el tiempo de ejecución en hallar el camino de salida y eso a pesar de que recula en un par de ocasiones:

Process returned 0 (0x0)   execution time : 0.586 s

No está nada mal para un aficionado.

  Felices Navidades y Próspero Año Nuevo.    
Saluditos! ..... !!!!

[Saluditos! ..... !!!!]

El primero va de estructuras y ahí ando flojo, pero el segundo puede ser algo tan simple como:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#define N 20

int  main(void){
   int i,aux;
   aux=0;
   for(i=0;i<=N;i++)
       if(i%2==0)
           aux=aux+i;
   printf ("La suma de los pares de 1 a %d es %d",N,aux);
   return 0;
}


Saluditos! ..... !!!!        

[rir3760]

¡Gracias por comentar, eres grande!

De eso nada, un aficionadillo simplemente. Estoy seguro que en conocimientos del lenguaje me ganas sobrado. En ese aspecto siento envidia sana de rir3760. ¡Que tío más grande!, ese si que domina el C/C++ hasta decir basta. Si no fuera porque ya soy mayor diría aquello que de mayor quiero ser como él.

Pero otra cosa es el ingenio para que afloren ideas simples a problemas aparentemente complicados, como el caso que nos ocupa. Lástima que no se anime mas gente y que aporten nuevas ideas o caminos.

..................................................................
Lo del aleatorio no abro mano XDD. Si no, no seria una búsqueda es mas como una trampa saber el camino ¿no?
Se supone que no sabes el camino, y si llegas a un punto con 3 o mas elecciones¿Que harás, vas hacia el final?  
...........................................

Ahí estás lo bueno de mi último código. No parto de un camino predeterminado,sino que voy eligiendo en cada posición la óptima, es más si te fijas en la solución que aporto veras que en uno de los caminos que sigue la X llega a un callejón donde delante arriba y abajo está bloqueada y ¡ voilâ ! se da la vuelta y retrocede sobre sus propios pasos buscando un nuevo camino:

0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 X 0 X X X X X X X X X X X X X 0 0 0   <===aki retrocede y luego sube
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0

 ¿Y como lo hago?. Con lo que ya te comenté de usar a la vez otra matriz con números que según vas pasando por las casillas se incrementan, de manera que en cada movimiento voy seleccionando la posición mas favorable   ¡¡¡ Como me quiero!!!  

Para ver mejor el cómo funciona, activa las líneas del código que te deje marcadas y veras la forma en  que actúa la matriz de números y como se seccionan las casillas. Lo dejé expresamente para ti, ya que supuse te interesaría el tema.

Un fuerte abrazo y Felices Navidades.

Saluditos! ..... !!!!        

[GeSHi]

Antes que nada cuando postees código elige las etiquetas GeSHi y toma la C++ y en medio de las etiquetas Code que aparecen "pegas" tu código. Al no hacerlo de esta manera parte del código no sale correcta, especialmente las matrices.

Igual te puede interesar este tema que trata de laberintos.


Saluditos! ..... !!!!        

[¡Pedazo de código!]

¡Pedazo de código!

UUUUFFFFFFFFFFFFF !!!!!!!!!!!!!.................... tanto trabajo merece la pena que se cite entero por largo que sea. Enhora buena por  tu paciencia para desarrollar semejante pedazo de código. ¿De dónde sacas tanto tiempo y ánimos?. Yo cuando voy por la línea 100 ya me parece que me paso  

Pero vamos por partes. Te cito

Eh mejorado un poco el código
Lo eh echo auto suficiente jaja
Este se busca la salida solo XD
Puedes cambiar el mapa a gusto.
Es algo ineficiente aun, lo estoy puliendo cosillas como cuando encuentra una calle sin salida, le tarda algo en volver al camino, pero lo encuentra.

Lo de mejorar supongo que no te referías al código que postee anteriormente. Estaba desarrollado para un laberinto concreto que puso el autor del tema y hacía lo que se le pedía: buscar la salida y la encontraba.  

Lo de ineficiente lo dices tú, yo soy demasiado pardillo aún en este mundillo para poner calificativos y mucho menos despectivos. Lo que no dejo de alabar es tu curro con el dichoso código.

Lo de que encuentra una salida no me parece. Lo tuve corriendo varios, pero varios, minutos y nada de nada. Fijándome un poco observe que el laberinto que propones en tu código no tiene solución: es un callejón sin salida, al menos yo la busque a simple vista y ningún camino conducía a la salida.

Tarda, pero tarda un *uevo no ya en salir, sino en moverse hacia alguna dirección concreta. Yo diría que más que buscar la salida, deambula sin tino concreto.

Esta echo en dev cpp orwell
Pronto subo la 2.0 o mejor lo mejoren vosotros si quieren  
Se debe de poner 0 en los bordes o puede ser bug

Dichosita manía con el DevC++, por muy Orwell que sea y no es por que no lo haya probado, que sí que lo he hecho, pero con lo chulo que es el Code::Blocks.


Espero que no cunda el desánimo, a mí me suele  ocurrir xD, y te animes a por una versión más depurada.

Y, en tu caso, lo del bug si no hay ceros en los bordes es porque los índices de la matriz que usas se sobrepasarían. Haz la prueba y veras que el mensaje que manda el programa es el de índices fuera de rango. Ello se debe a las condiciones que pones en los caminos lleva más allá del rango permitido, que ya de por sí es excesivo.

Conste que todo lo que te planteo amigo vangodp es con el mayor de los respetos y cariño hacía tí y hacía el curro que te has pegado.

Y ahora respecto al código un par de observaciones:

* Las dimensiones de la matriz no se corresponden con su tamaño. Una cosa es que pongas ceros, yo también lo hago, ya te comentaré, y otra es que trates de evitar un error lógico del código con esa artimaña.

* Creo sinceramente que consideras demasiadas opciones, o mejor dicho, las desmenuzas en demasía, lo que da origen a una cantidad interminable de "if". No paro de repetirlo, lo sé, pero te has pegado un curro de cuidado. Por un lado el obtener todas esas posibilidades y luego la paciencia de plasmarlo o escribirlo. Este es mi post más largo y ya estoy cansado, con lo que me imagino que tú no veas.

* Algo que no me termina de convencer es el uso de la aleatoriedad para elegir los movimientos, porque ello conduce a una secuencia casi interminable de pasos: tan  pronto da dos pasitos a la derecha como tres a la izquierda, sube tres y baja cuatro, etc. La consecuencia de esa aleatoriedad es que hace intervenir a la Estadística y ésta nos confirma que más bien irá rondando de forma continua cada nueva posición, lo que hace muy ineficiente el método.

Todo ello me ha animado a intentar, ya te comenté que soy muy nuevo en este mundillo, un método alternativo sin aleatorios y teniendo en cuenta que sólo hay cuatro posibles movimientos -ABAJO:DERECHA_ARRIBA_IZQUIERDA-, en ese orden de preferencia ya que partimos de que la salida está en la parte superior izquierda y la llegada en la inferior derecha, por lo que lo razonable es dar preferencia a los movimientos hacia abajo y a la derecha, respecto a los de hacia arriba y a la izquierda ya que estos últimos, así de entrada, tienden a alejarnos del objetivo. Ello no quiere decir que no los use ya que son necesarios  para caminar hacia atrás en caso de encerrona. Eso sí, no son movimientos al azar ni por capricho. Lo que hago es comparar cada posible movimiento hacia una posición con los otros tres posibles y camino hacia el de menor valor.

¿Hacia el de menor valor?. Pues sí, porque yo uso una segunda matriz numérica y cada pasito que doy incremento el valor del elemento de la matriz, y así voy buscando continuamente los de menos valor.

Y ya está bien de rollo y para botón una muestra de solución al laberinto que planteaste, con alguna pequeña modificación para que tuviera solución:

               Movimientos = 168

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 I 2 X X X X X X X X X X X X X X X X X X X X X X X 0
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X X X X X X X X X X X X X 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X X X X X X X X X X X X X 0 0 0 2 2 2 2 2 2 X 0
0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 2 0 0 0 0 0 X 0
0 X 0 X X X X X X X X X X 0 0 X 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X 0 0 0 0 0 0 0 0 X 0 0 X X X X X X X X X 0 X 0
0 X 0 X X X X X X X 0 0 X 0 0 0 0 0 0 0 0 0 0 X 0 X 0
0 X 0 0 0 0 0 0 0 X 0 0 X X X X X X X X X X X X 0 X 0
0 X X X X X X X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 0 0 0 0 0 0 X 0 X 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 X 0
0 0 0 0 0 0 0 X X X 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 2 2 2 2 2 2 2 2 2 2 X 0
0 2 2 2 2 2 2 2 2 2 2 2 2 0 0 2 0 0 0 0 0 0 0 0 0 X 0
0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2 2 2 0 X 0 X 0
0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 2 0 X 0 X 0
0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 0 0 0 0 2 0 X 0 X 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 X X X X X 0
0 2 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 X 0 0 0 0 0
0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X X X X X 0
0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 X X 0 0 F 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Presione una tecla para continuar . . .

Process returned 0 (0x0)   execution time : 0.586 s

Observa que de de I y llega a F.

Y el  código que me van a comer y con algunas explicaciones incluidas:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

void mostrar_b(int b[][27]);
void mostrar(char a[][28]);

int main (){
   char a[24][28]={
   "000000000000000000000000000",
   "012222222222222222222222220",
   "020200000000000000000000020",
   "020222222222222200000000020",
   "020200000000000000000000020",
   "020222222222222200022222220",
   "020000000000000200020000020",
   "020222222222200200000000020",
   "020200000000200222222222020",
   "020222222200200000000002020",
   "020000000200222222222222020",
   "022222220200000000000000020",
   "000000020200222222222222220",
   "000000022200200000000000020",
   "000000000000200222222222220",
   "022222222222200200000000020",
   "020000000000000222222202020",
   "020000000000000200000202020",
   "022222222222222200000202020",
   "000000000000000200000222220",
   "020222222222222222222200000",
   "020000000000000000000222220",
   "022222222222222222222220010",
   "000000000000000000000000000"
   };
   int i,j,cont=0;
    int b[24][27];
       for( i=0;i<24;i++) {
           for( j=0;j<27;j++) {
               b[i][j]=(int)(a[i][j]-48);
               if (b[i][j]==0)
                   b[i][j]=9;
       }
   }
   i=1,j=1;
   b[1][1]=3;
   a[i][j]='I';
   //mostrar_b(b);//activalo para ver como se rellena la matriz de numeros
   mostrar (a);
   system ("cls");
   while (1){
//De los cuatro que rodean al b[i][j] tomo uno y comparo los otros tres
       if     (i+1<24 && b[i+1][j]>0 && b[i+1][j]<=b[i-1][j]
                 && b[i+1][j]<=b[i][j-1] && b[i+1][j]<=b[i][j+1]){
               a[i+1][j]='X';     //   en esta condicion
               if (b[i+1][j]==1){ //elijo  hacua ABAJO si es menor o igual
                   a[i+1][j]='F'; //que los otros tres que rodean a b[i][j]
                   break;
               }
               b[i+1][j]++;
               i++;
       }
       else if (j+1<27 && b[i][j+1]>0 && b[i][j+1]<=b[i][j-1]
                 && b[i][j+1]<=b[i-1][j] && b[i][j+1]<=b[i+1][j]){
               a[i][j+1]='X';     //    en esta condicion
               if (b[i][j+1]==1){ //elijo  hacia la DERECHA si es menor o igual
                   a[i][j+1]='F'; //que los otros tres que rodean a b[i][j]
                   break;
               }
               b[i][j+1]++;
               j++;
       }
       else if (i-1>=0 && b[i-1][j]>0 && b[i-1][j]<=b[i+1][j]
                 && b[i-1][j]<=b[i][j-1] && b[i-1][j]<=b[i][j+1]){
               a[i-1][j]='X';     //    en esta condicion
               if (b[i-1][j]==1){ //elijo  hacia la ARRIBA si es menor o igual
                   a[i-1][j]='F'; //que los otros tres que rodean a b[i][j]
                   break;
               }
               b[i-1][j]++;
               i--;
       }
       else if (j-1>0 && b[i][j-1]>0 && b[i][j-1]<=b[i][j+1]
                 && b[i][j-1]<=b[i-1][j] && b[i][j-1]<=b[i+1][j]){
               a[i][j-1]='X';     //    en esta condicion
               if (b[i][j-1]==1){ //elijo  hacia la IZQUIERDA si es menor o igual
                   a[i][j-1]='F';  //que los otros tres que rodean a b[i][j]
                   break;
               }
               b[i][j-1]++;
               if (j-1>0){
               j--;
               }
       }
       //mostrar_b( b);//activalo para ver como se rellena la matriz de numeros
       cont++;//
   }
   printf ("\n\n\t\tMovimientos = %d\n\n",cont);
   mostrar_b(b);//activalo para ver como queda al fimal la matriz de numeros
   mostrar(a);
   return 0;
}

void mostrar_b(int b[][27]){
   system ("cls");
   int i,j;
   for( i=0;i<24;i++) {
       for( j=0;j<27;j++) {
           printf("%d ",b[i][j]);
           fflush(stdout);
       }
       puts("");
   }
   system ("pause");
}

void mostrar(char a[][28]){
   system ("cls");
   int i,j;
   for( i=0;i<24;i++) {
       for( j=0;j<27;j++) {
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       puts("");
   }
   puts("");
   system ("pause");
}


Mis observaciones respecto al mismo:

* Está poco testeado, apenas una decena de variantes sobre ese laberinto.

* Queda por pulir la presentación final a fin de que sólo salga el camino directo y no los delante y atrás de cuando se queda rodeado por una muralla. Por cierto, observa que aunque eso ocurra saldrá de la misma el solito  

* Los cuatro casos son muy semejantes por lo que pienso que podría reducirse el código con una función. Aunque para lo corto que es no se si merece la pena.

* La idea propuesta es la más cortita respecto a otras soluciones que hacían lo mismo pero con más código, incluso me planteo el uso de una sola función para  ambas matrices.

Espero no haberla pifiado demasiado .

Como he dicho, estoy aún en pañales así que serán bienvenidas correcciones, observaciones y sugerencias y, ¿por qué no?, espero ansiosamente que alguien más haga aportaciones con códigos seguramente mucho más eficientes e ingeniosos que el mío. Se me ocurre con recursividad y esas cosas.

Y ya está. UUUFFFFF....... menudo rollo les he metido.Sorry, nada como tener un ratito de tiempo libre.

P.D: Se pueden tener más soluciones cambiando el orden de los if y eslse  .

Saluditos! ..... !!!!        

[no se pueden ingresar cifras muy altas ?]

osea que no se pueden ingresar cifras muy altas ? porque si por ejemplo, lo cambiara a tipo int o long y le ingreso un numero de 10 cifras sale un resultado loco

Sí se pueden ingresar cifras muy altas, pero en formato float o double con la consiguiente notación exponencial. Otra cosa es la limitación de los enteros.

En mi máquina el entero máximo es  2147483647. Lo puedes consultar en la librería climits.

De todas formas en C se puede controlar el número de cifras significativas y decimales, pero no sé como sería en C++.

Saluditos! ..... !!!!       

[Saluditos! ..... !!!!]

La salida es la clásica notación científica para un double de ese tamaño, sólo hasta seis cifras un float o double salen como entero y para mayores cifras usa la mencionada notación científica. Si lo cambias como INT te saldrá 1234567.

Saluditos! ..... !!!!        

[Saluditos! ..... !!!!]

De nada, encantado de poder ayudar a un colega como tú.



Saluditos! ..... !!!!