Le roi Julian doit traverser la jungle, mais il se sent paresseux. Il veut qu'un ordinateur puisse lui calculer un itinéraire à travers la jungle.

En utilisant STDIN, obtenez une carte de la jungle pour que l'ordinateur se fissure. Il suivra le format suivant:

01001E
010110
000P00
1100J1
S00111

Le fonctionnement de la carte de la jungle est le suivant:

0 est un terrain sur lequel Julian peut se déplacer.

1 est une jungle dense infranchissable.

P est une zone avec des prédateurs, que vous devez éviter à tout prix.

Jest une jungle relativement épaisse. Les serviteurs de Julian peuvent percer l'un d'eux avant de se fatiguer.

Sc'est là que Julian commence. Cela peut être n'importe où sur la carte.

Eest où Julian veut aller; la fin du chemin. Il peut également être n'importe où sur la carte, comme n'importe quelle autre tuile.

Chaque personnage est une tuile sur la carte. Les sauts de ligne indiquent une nouvelle rangée de tuiles. Si STDIN dans votre langue ne prend pas en charge les sauts de ligne, le saut de ligne doit être remplacé par un espace pour signifier une nouvelle ligne.

Pour vous déplacer entre les tuiles, vous devez sortir une chaîne en utilisant STDOUT contenant les caractères spéciaux suivants:

F - Vers l'avant

B - En arrière

L - Tourner Julian vers la gauche (90 degrés dans le sens antihoraire)

R - Tourner Julian à droite (90 degrés dans le sens des aiguilles d'une montre)

M- Les serviteurs détruisent une Jtuile 1 tuile en avant de Julian, s'il y en a une ( Mefface simplement la tuile, vous devez toujours y passer)

Une sortie possible serait:

RFFLFRFMFLFRFLFF

Ce qui résout la carte ci-dessus.

Remarques:

• Si votre programme génère une solution qui frappe les prédateurs, game over.

• Si vous frappez une jungle infranchissable, vous rebondissez simplement là où vous étiez avant de vous heurter à une jungle dense, face à la même manière. (Vers la jungle)

• Julian commence à faire face vers le haut. (^ De cette façon ^)

• La sortie ne doit pas nécessairement être la solution la plus rapide FFFet FBFBFBFBFBFFFest la même. Cependant, la sortie de la solution la plus rapide possible donne un bonus de décompte de -10%.

• Si une carte n'est pas valide, STDOUT «Carte non valide». (Cela inclut si la carte est insoluble)

• Une carte ne peut pas avoir de lignes ou de colonnes de longueurs différentes; cela le rend invalide.

Votre réponse devrait quelque peu suivre ce format:

#Language name, *n* bytes

    code

Explanation (optional)

Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

Groovy, 656 octets

C'était trop long ...

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

Sortie pour le labyrinthe:

RFFLFRFMFLFRFLFF

Non 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"

Je vais essayer de nouveau cela en python bientôt pour voir si je peux le raccourcir davantage.