El rey Julián necesita atravesar la jungla, pero se siente vago. Quiere una computadora para poder calcular una ruta a través de la jungla para él.

Usando STDIN, obtenga un mapa de la jungla para que la computadora se rompa. Seguirá el siguiente formato:

01001E
010110
000P00
1100J1
S00111

La forma en que funciona el mapa de la jungla es:

0 es terreno por el que Julian puede moverse.

1 Es densa selva infranqueable.

P es un área con depredadores, que debes evitar a toda costa.

JEs una jungla relativamente gruesa. Los secuaces de Julian pueden atravesar uno de estos antes de cansarse.

Ses donde comienza Julian. Puede estar en cualquier parte del mapa.

Ees donde Julian quiere ir; El final del camino. También puede estar en cualquier parte del mapa, como cualquier otro mosaico.

Cada personaje es un mosaico en el mapa. Los saltos de línea indican una nueva fila de mosaicos. Si STDIN en su idioma no admite saltos de línea, el salto de línea debe reemplazarse por un espacio para indicar una nueva fila.

Para moverse entre los mosaicos, debe generar una cadena usando STDOUT que contenga los siguientes caracteres especiales:

F - Adelante

B - hacia atrás

L - Gire a Julian a la izquierda (90 grados en sentido antihorario)

R - Gire Julian a la derecha (90 grados en el sentido de las agujas del reloj)

M- Los esbirros destruyen una Jficha 1 ficha hacia delante de Julian, si hay una (M solo despeja el azulejo, aún tienes que moverte sobre él)

Un posible resultado sería:

RFFLFRFMFLFRFLFF

Lo que resuelve el mapa de arriba.

Notas:

• Si su programa genera una solución que afecta a los depredadores, se acabó el juego.

• Si golpeas la jungla infranqueable, simplemente regresas a donde estabas antes de toparte con la jungla densa, mirando de la misma manera. (Hacia la jungla)

• Julian comienza a mirar hacia arriba. (^ De esa manera ^)

• La salida no tiene que ser la solución más rápida, FFFy FBFBFBFBFBFFFson iguales. Sin embargo, generar la solución más rápida posible proporciona un bono de recuento de bytes de -10%.

• Si un mapa no es válido, STDOUT 'Mapa no válido'. (Eso incluye si el mapa no tiene solución)

• Un mapa no puede tener filas o columnas de diferentes longitudes; eso lo hace inválido.

Su respuesta debería seguir este formato:

#Language name, *n* bytes

    code

Explanation (optional)

Este es el código de golf , por lo que gana el código más corto en bytes.

Groovy, 656 bytes

Eso fue demasiado largo ...

i={println"Invalid map."
System.exit(1)}
m=[]
q=System.in.newReader()
r=q.readLine()
while(r!=''){m<<r
r=q.readLine()}
o=m[0].size()
m.each{if(it.size()!=o)i()}
f=[0]*4
m.eachWithIndex{l,n->s=l.indexOf('S')
e=l.indexOf('E')
if(s!=-1){f[0]=s;f[1]=n}
if(e!=-1){f[2]=e;f[3]=n}}
v=[]
t={x,y,d->if(d.contains([x,y])|y>=m.size()|x>=o|x<0|y<0)return
a=m[y][x]
def p=d+[[x,y]]
if(a=='E')v=p
if(a=='J'|a=='0'|a=='S'){t(x-1,y,p)
t(x+1,y,p)
t(x,y+1,p)
t(x,y-1,p)}}
t(f[0],f[1],[])
if(!v)i()
o=0
p=''
v.inject{t,s->
c=m[s[1]][s[0]]
k=[t[0]-s[0],t[1]-s[1]]
z=[[0,1]:0,[1,0]:1,[0,-1]:2,[-1,0]:3][k]
p+=((((o-z)==0)?'':(z>0?'R':'L'))+(c=='J'?'M':'')+'F')
o=z
s}
println p

Salida para el laberinto:

RFFLFRFMFLFRFLFF

Sin golf:

invalid = {
    println "Invalid map."
    System.exit(1)
}
map = """01001E
010110
000P00
1110J1
S00111""".split('\n')

//map = [""]// TODO remove this, this is type checking only
//map.remove(0)
//reader = System.in.newReader()
//line = reader.readLine()
//while (line != '') {
//    map << line.replace('P','1')
//    line = reader.readLine()
//}

size = map[0].size()
map.each {if(it.size() != size) invalid()}

startAndEnd = [0,0,0,0]
map.eachWithIndex {it, idx -> s=it.indexOf('S');e=it.indexOf('E');
    if(s!=-1){ startAndEnd[0]=s; startAndEnd[1]=idx}
    if(e!=-1){ startAndEnd[2]=e; startAndEnd[3]=idx}}

def validPath = []

testMove = {x, y, visited ->// visited is an array of x y pairs that we have already visited in this tree
    if (visited.contains([x,y]) || y>=map.size() || x>=size || x<0 || y<0)
        return;

    def valueAtPos = map[y][x]
    def newPath = visited + [[x,y]]

    if (valueAtPos == 'E') validPath = newPath
    if ((valueAtPos == 'J' || valueAtPos == '0' || valueAtPos == 'S') && !validPath) {
        testMove(x-1, y, newPath)
        testMove(x+1, y, newPath)
        testMove(x, y+1, newPath)
        testMove(x, y-1, newPath)
    }
}
if (!validPath) invalid()
testMove(startAndEnd[0],startAndEnd[1], [])

println validPath

orintation = 0
path = ''
validPath.inject {first, second ->
    def chr = map[second[1]][second[0]]
    def sub = [first[0]-second[0],first[1]-second[1]]
    println "acc:$first, second:$second"
    def newOrin = [[0,1]:0, [1,0]:1, [0,-1]:2, [-1,0]:3][sub]
    path += ((((orintation - newOrin)==0)?'':(newOrin>0?'R':'L')) + (chr=='J'?'M':'') + 'F')
    orintation = newOrin
    second
}
println "path: $path"

Intentaré esto nuevamente en Python pronto para ver si puedo acortarlo aún más.