Il re Julian deve attraversare la giungla, ma si sente pigro. Vuole che un computer sia in grado di calcolare un percorso attraverso la giungla per lui.

Usando STDIN ottieni una mappa della giungla per il crack del computer. Seguirà il seguente formato:

01001E
010110
000P00
1100J1
S00111

Il modo in cui funziona la mappa della giungla è:

0 è il terreno che Julian può percorrere.

1 è una fitta giungla invalicabile.

P è un'area in cui sono presenti i predatori, che devi evitare a tutti i costi.

Jè una giungla relativamente fitta. I servi di Julian possono sfondare uno di questi prima di stancarsi.

Sè dove inizia Julian. Può essere ovunque sulla mappa.

Eè dove Julian vuole andare; la fine del percorso. Può anche essere ovunque sulla mappa, proprio come qualsiasi altra tessera.

Ogni personaggio è una tessera sulla mappa. Le interruzioni di riga indicano una nuova riga di riquadri. Se STDIN nella tua lingua non supporta le interruzioni di riga, l'interruzione di riga deve essere sostituita da uno spazio per indicare una nuova riga.

Per spostarsi tra i riquadri, è necessario emettere una stringa utilizzando STDOUT contenente i seguenti caratteri speciali:

F - Avanti

B - Indietro

L - Ruota Julian a sinistra (90 gradi in senso antiorario)

R - Ruota Julian a destra (90 gradi in senso orario)

M- I servi distruggono una Jtessera 1 tessera in avanti da Julian, se ce n'è una ( Mcancella solo la tessera, devi ancora spostarti su di essa)

Un possibile output sarebbe:

RFFLFRFMFLFRFLFF

Che risolve la mappa sopra.

Appunti:

• Se il tuo programma genera una soluzione che colpisce i predatori, game over.

• Se colpisci la giungla invalicabile, ritorni a dove eri prima di imbatterti nella fitta giungla, affrontando la stessa strada. (Verso la giungla)

• Julian inizia a guardarsi verso l'alto. (^ In questo modo ^)

• L'output non deve essere la soluzione più veloce FFFe FBFBFBFBFBFFFsono gli stessi. Tuttavia, l'output della soluzione più veloce possibile offre un bonus di conteggio dei byte del -10%.

• Se una mappa non è valida, STDOUT "Mappa non valida". (Ciò include se la mappa è irrisolvibile)

• Una mappa non può avere righe o colonne di lunghezze diverse; questo lo rende non valido.

La tua risposta dovrebbe in qualche modo seguire questo formato:

#Language name, *n* bytes

    code

Explanation (optional)

Questo è code-golf , quindi vince il codice più breve in byte.

Groovy, 656 byte

Era troppo lungo ...

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

Uscita per il 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"

Proverò di nuovo questo in Python presto per vedere se posso accorciarlo ulteriormente.