int a[4] = {arriba, izquierda, derecha, abajo};
void (*f[])() = {go_arriba, go_izquierda, go_derecha, go_abajo}; 
if(a[0] + a[1] + a[2] + a[3] > 0){ 
int primos = {2, 3, 5, 7};
int mayor=0;
int temp=1;
int cont=1;
for(int i=0;i<4;i++)
    if(a[i] > mayor){mayor=a[i];temp=primos[i];} //Miramos cual es el mayor
for(int i=0; i<4; i++)
    if(temp%primos[i]!=0 && a[i]==mayor){temp*=primos[i]; ++cont;} //Miramos cuales son iguales al mayor
switch(cont){
    case 1: for(int i=0;i<4;i++) if(temp%primos[i] == 0){(*f[i])();break;}break;
    case 2: //Aqui sería ver cuales son los elegidos, y elegir al azar cual usar.
    case 3: //idem
}
}

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:

#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.