O rei Julian precisa atravessar a selva, mas está com preguiça. Ele quer que um computador seja capaz de calcular uma rota pela floresta para ele.

Usando STDIN, obtenha um mapa da floresta para o computador quebrar. Ele seguirá o seguinte formato:

01001E
010110
000P00
1100J1
S00111

A maneira como o mapa da selva funciona é:

0 é motivo que Julian pode se mover.

1 é selva intransitável densa.

P é uma área com predadores, que você deve evitar a todo custo.

Jé selva relativamente grossa. Os servos de Julian podem romper um desses antes de se cansar.

Sé onde Julian começa. Pode estar em qualquer lugar do mapa.

Eé para onde Julian quer ir; o fim do caminho. Também pode estar em qualquer lugar do mapa, como qualquer outro bloco.

Cada personagem é um bloco no mapa. Quebras de linha indicam uma nova linha de blocos. Se o STDIN no seu idioma não suportar quebras de linha, a quebra de linha deverá ser substituída por um espaço para indicar uma nova linha.

Para mover-se entre os blocos, você deve gerar uma string usando STDOUT contendo os seguintes caracteres especiais:

F - Frente

B - Para trás

L - Gire Julian para a esquerda (90 graus no sentido anti-horário)

R - Gire Julian para a direita (90 graus no sentido horário)

M- Lacaios destroem um Jladrilho 1 lado a frente de Julian, se houver um ( Mapenas limpa o ladrilho, você ainda precisa avançar)

Uma saída possível seria:

RFFLFRFMFLFRFLFF

O que resolve o mapa acima.

Notas:

• Se o seu programa apresentar uma solução que atinja predadores, passe o jogo.

• Se você bater na selva intransitável, basta voltar para onde estava antes de correr para a densa floresta, de frente para o mesmo caminho. (Em direção à selva)

• Julian começa a olhar para cima. (^ Dessa maneira ^)

• A saída não precisa ser a solução mais rápida FFFe FBFBFBFBFBFFFé a mesma. No entanto, a saída da solução mais rápida possível oferece um bônus de 10% na contagem de bytes.

• Se um mapa for inválido, STDOUT 'Mapa inválido'. (Isso inclui se o mapa for insolúvel)

• Um mapa não pode ter linhas ou colunas de diferentes comprimentos; isso a torna inválida.

Sua resposta deve seguir um pouco este formato:

#Language name, *n* bytes

    code

Explanation (optional)

Isso é código-golfe , então o código mais curto em bytes vence.

Groovy, 656 bytes

Isso foi muito longo ...

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

Saída para o labirinto:

RFFLFRFMFLFRFLFF

Ungolfed:

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"

Em breve, tentarei novamente em python para ver se posso reduzi-lo ainda mais.