König Julian muss durch den Dschungel, aber er fühlt sich faul. Er möchte, dass ein Computer für ihn eine Route durch den Dschungel berechnen kann.

Mit STDIN erhalten Sie eine Karte des Dschungels, die der Computer knacken kann. Es wird folgendes Format haben:

Die Funktionsweise der Dschungelkarte ist:

0 ist der Grund, warum Julian sich fortbewegen kann.

1 ist dichter unpassierbarer Dschungel.

P ist ein Gebiet mit Raubtieren, das Sie unbedingt meiden müssen.

Jist relativ dicker Dschungel. Julians Schergen können eine davon durchbrechen, bevor sie ermüden.

SHier beginnt Julian. Es kann überall auf der Karte sein.

Eist, wohin Julian gehen will; das Ende des Weges. Es kann sich auch überall auf der Karte befinden, genau wie bei jeder anderen Kachel.

Jedes Zeichen ist eine Kachel auf der Karte. Zeilenumbrüche kennzeichnen eine neue Kachelreihe. Wenn STDIN in Ihrer Sprache keine Zeilenumbrüche unterstützt, muss der Zeilenumbruch durch ein Leerzeichen ersetzt werden, um eine neue Zeile zu kennzeichnen.

Um zwischen den Kacheln zu wechseln, müssen Sie eine Zeichenfolge mit STDOUT ausgeben, die die folgenden Sonderzeichen enthält:

F - Nach vorne

B - Rückwärts

L - Julian nach links drehen (90 Grad gegen den Uhrzeigersinn)

R - Julian nach rechts drehen (90 Grad im Uhrzeigersinn)

M- Günstlinge zerstören ein JPlättchen 1 vorwärts von Julian, wenn es eines gibt ( Mräumt das Plättchen einfach aus, du musst immer noch darauf ziehen)

Eine mögliche Ausgabe wäre:

RFFLFRFMFLFRFLFF

Welches löst die Karte oben.

Anmerkungen:

Wenn Ihr Programm eine Lösung ausgibt, die Raubtiere trifft, ist das Spiel vorbei.
Wenn Sie auf unpassierbaren Dschungel treffen, springen Sie einfach dorthin zurück, wo Sie sich befanden, bevor Sie in den dichten Dschungel gerieten und auf die gleiche Weise dastanden. (In Richtung Dschungel)
Julian fängt an nach oben zu schauen. (^ Auf diese Weise ^)
Die Ausgabe muss nicht die schnellste Lösung sein FFFund FBFBFBFBFBFFFist dieselbe. Die Ausgabe der schnellstmöglichen Lösung bietet jedoch einen Bonus von -10% für die Bytezahl.
Wenn eine Karte ungültig ist, STDOUT "Ungültige Karte". (Das schließt ein, wenn die Karte unlösbar ist)
Eine Karte kann keine Zeilen oder Spalten unterschiedlicher Länge haben. das macht es ungültig.

Ihre Antwort sollte ungefähr so aussehen:

#Language name, *n* bytes

    code

Explanation (optional)

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

code-golf Tobsta
quelle

In Ihrem Lösungsbeispiel stößt Julian direkt auf ein Raubtier. So etwas wie RFFLFRFMFLFRFLFF sollte stattdessen funktionieren.

Emigna

@Emigna, Hoppla. Ich habe mich zwischen dickem Dschungel und einem Raubtierhort

verwechselt

Fügt eine PKachel wirklich etwas anderes als eine 1Kachel hinzu? Ich kann mir keine plausible Lösung vorstellen, die sie anders behandelt.

@ dan1111 Das P-Plättchen tötet Julian, wenn er darüber reist. Die 1 Fliese, die Julian nicht passieren kann, aber wenn Julian sie trifft, stirbt er nicht, er prallt einfach zurück.

Tobsta

@ Tobsta, ja, ich verstehe. Aber macht das einen Unterschied? Es scheint, als würde jede erfolgreiche Lösung nur die Kacheln 1 und P vermeiden.

Groovy, 656 Bytes

Das war zu lang

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

Ausgabe für das Labyrinth:

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"

Ich werde es in Kürze in Python erneut versuchen, um zu sehen, ob ich es weiter verkürzen kann.

J Atkin
quelle

Ich mag es, es zu bewegen, es zu bewegen

Antworten:

Groovy, 656 Bytes