किंग जूलियन को जंगल में जाने की जरूरत है, लेकिन वह आलसी महसूस कर रहा है। वह चाहता है कि एक कंप्यूटर उसके लिए जंगल के माध्यम से एक मार्ग की गणना करने में सक्षम हो।

STDIN का उपयोग करने से कंप्यूटर में दरार पड़ने के लिए जंगल का नक्शा मिलता है। यह निम्नलिखित प्रारूप का पालन करेगा:

जंगल के नक्शे के काम करने का तरीका है:

0 जमीन है कि जूलियन साथ जा सकते हैं।

1 घने अगम्य जंगल है।

P इसमें शिकारियों के साथ एक क्षेत्र है, जिसे आपको हर कीमत पर बचना चाहिए।

Jअपेक्षाकृत घना जंगल है। थका देने से पहले जूलियन की मिनिंग्स इनमें से एक को तोड़ सकती हैं।

Sजूलियन शुरू होता है। यह मानचित्र पर कहीं भी हो सकता है।

Eजूलियन कहाँ जाना चाहता है; पथ का अंत। यह भी किसी भी अन्य टाइल की तरह, नक्शे पर कहीं भी हो सकता है।

हर पात्र नक्शे पर एक टाइल है। लाइन ब्रेक टाइल्स की एक नई पंक्ति को इंगित करते हैं। यदि आपकी भाषा में STDIN लाइन ब्रेक का समर्थन नहीं करता है, तो लाइन ब्रेक को एक नई पंक्ति को सूचित करने के लिए एक स्थान द्वारा प्रतिस्थापित किया जाना चाहिए।

टाइल्स के बीच जाने के लिए, आपको STDOUT का उपयोग करके एक स्ट्रिंग का उत्पादन करना होगा जिसमें निम्नलिखित विशेष वर्ण होंगे:

F - आगे

B - पिछड़ा

L - जूलियन को घुमाएं (90 डिग्री एंटीलॉकवाइज)

R - जूलियन दाएं घुमाएं (90 डिग्री दक्षिणावर्त)

M- मिनियन Jजूलियन से आगे एक टाइल को नष्ट कर देते हैं , अगर कोई है ( Mबस टाइल को साफ कर देता है, तो आपको अभी भी इसे चालू करना होगा)

एक संभावित उत्पादन होगा:

RFFLFRFMFLFRFLFF

जो ऊपर दिए गए नक्शे को हल करता है।

टिप्पणियाँ:

यदि आपका कार्यक्रम एक समाधान का उत्पादन करता है जो शिकारियों को मारता है, तो खेल खत्म हो जाता है।
यदि आप अगम्य जंगल से टकराते हैं, तो आप घने जंगल में दौड़ने से पहले वापस उसी स्थान पर पहुंच जाते हैं, जहां आप एक ही रास्ते का सामना कर रहे हैं। (जंगल की ओर)
जूलियन का सामना ऊपर की ओर होने लगता है। (^ वह रास्ता ^)
आउटपुट का सबसे तेज़ समाधान नहीं है, FFFऔर FBFBFBFBFBFFFसमान हैं। हालांकि, सबसे तेजी से संभव समाधान का आउटपुट एक -10% बाइट काउंट बोनस देता है।
यदि कोई नक्शा अमान्य है, तो STDOUT 'अवैध नक्शा।' (इसमें यह भी शामिल है कि अगर नक्शा बेकार है)
एक मानचित्र में विभिन्न लंबाई की पंक्तियाँ या स्तंभ नहीं हो सकते; जो इसे अमान्य बनाता है।

आपके उत्तर को इस प्रारूप का पालन करना चाहिए:

#Language name, *n* bytes

    code

Explanation (optional)

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf

— Tobsta
स्रोत

आपके समाधान उदाहरण में जूलियन सीधे शिकारी के रूप में घूम रहा है। RFFLFRFMFLFRFLFF जैसा कुछ इसके बजाय काम करना चाहिए।

— एमिगा

@Emigna, उफ़। मैं घने जंगल और एक शिकारी की मांद के बीच घुलमिल गया ...

— टोबस्टा

क्या एक Pटाइल वास्तव में एक 1टाइल से कुछ अलग जोड़ती है ? मैं वास्तव में एक प्रशंसनीय समाधान की कल्पना नहीं कर सकता जो उन्हें किसी भी अलग तरह से व्यवहार करता है।

@ d111111 पी टाइल जूलियन को मारता है जब वह उस पर यात्रा करता है। 1 टाइल जूलियन के पास से नहीं गुजर सकती है, लेकिन अगर जूलियन इसे मारता है तो वह मरता नहीं है, वह बस वापस उछलता है।

— तोबस्टा

@ टोबस्टा, हां, मैं समझता हूं। लेकिन क्या इससे कोई फर्क पड़ता है? ऐसा लगता है कि किसी भी सफल समाधान सिर्फ 1 और पी टाइल्स से बचना होगा।

ग्रूवी, 656 बाइट्स

वह बहुत लंबा था ...

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

भूलभुलैया के लिए आउटपुट:

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"

मैं जल्द ही फिर से अजगर में यह देखने की कोशिश करूंगा कि क्या मैं इसे और छोटा कर सकता हूं।

— जे एटकिन
स्रोत

मुझे नाचना पसंद है

ग्रूवी, 656 बाइट्स