शाब्दिक भूलभुलैया सॉल्वर

Question

स्टड पर एक चक्रव्यूह और एक प्रवेश बिंदु को देखते हुए, एक प्रोग्राम लिखें जो स्टडआउट पर बाहर निकलने के लिए एक मार्ग प्रिंट करता है। कोई भी रास्ता स्वीकार्य है, जब तक कि आपका कार्यक्रम हर भूलभुलैया के लिए तुच्छ पथ (भूलभुलैया में हर बिंदु से गुजरना) उत्पन्न नहीं करता है।

इनपुट में, दीवारों को ए #और एंट्री पॉइंट द्वारा चिह्नित किया गया है @। आप किसी भी वर्ण का उपयोग भूलभुलैया और आउटपुट में पथ को आकर्षित करने के लिए कर सकते हैं, जब तक कि वे सभी अलग-अलग हों।

आप मान सकते हैं कि:

• प्रवेश और निकास बिंदु इनपुट के किनारों पर हैं
• इनपुट की हर लाइन की लंबाई समान होती है
• चक्रव्यूह हल है और कोई चक्र नहीं है
• केवल एक निकास बिंदु है

(यूनिकोड) वर्ण गणना से सबसे छोटा समाधान जीत जाता है।

उदाहरण

(ध्यान दें कि इनपुट रिक्त स्थान के साथ गद्देदार हैं)

####   
#  #   
@ #####
#     #
#      
#######

####
#  #
@*#####
#*    #
#******
#######

### ###################
###         #         #
##  #########      #  #
 #             #####  #
 ###############   #@##

###*###################
###*********#*********#
## *#########*     # *#
 # *********** #####**#
 ###############   #@##

Comments

क्या मैं समापन बिंदु के लिए एक चरित्र जोड़ सकता हूं, भी? यह मेरे कार्यक्रम के लिए यह जानना बहुत आसान बना देगा कि कब समाप्त होना है।

— पीटर ओल्सन

@ पेटर ऑफ द कॉर्न: श्योर। आपको पूरे पथ को खींचने के लिए एक ही वर्ण का उपयोग करने की आवश्यकता नहीं है, बस इसे बाकी आउटपुट से अलग करना होगा।

— लोजैकर

Answer 1

रूबी 1.9, 244 वर्ण

l=*$<
i=l*""
e=[]
d=[1,-1,x=l[0].size,-x]
r=[f=9e9]*s=x*b=l.size;r[i=~/@/]=0
r.map{i.gsub(/ /){r[p=$`.size]=d.map{|u|p>-u&&r[u+p]||f}.min+1;e<<p if p%x%~-~-x*(p/-~x%~-b)<1}}
r[g=e.find{|i|r[i]<f}].times{i[g]=?*;g+=d.find{|l|r[g]>r[g+l]}}
puts i

दो उदाहरणों के लिए आउटपुट:

####   
#  #   
@*#####
#*    #
#******
#######

###*###################
###*        #     *** #
## *######### *****#* #
 # ************#####* #
 ###############   #@##

संपादन:

• (२४ (-> २४५) ई को झुकाया और इसका नाम बदलकर जी रखा
• (245 -> 249) एक बग को ठीक करें जब निकास सीधे प्रवेश द्वार से ऊपर है
• (२४ ९ -> २४६) Inlining + सरलीकरण
• (246 -> 244) हर क्षेत्र पर पुनरावृति करने के लिए छोटा रास्ता

Answer 2

ANSI C ( 384 373 368 वर्ण)

यहाँ मेरा सी प्रयास है। संकलित और मैक ओएस एक्स पर चलाएँ।

m[9999],*r=m,*s=m,c,R=0,*a,L;
P(){while(*s++)putchar(*(s-1));}
C(int*l){if((l-s+2)%R==0||(l-s)%R==0||l-s<R||l>r-R)*l=42,P(),exit(0);}
e(int*l){if(*l==32)C(l),*l=42,e(l-1),*l=32,*l=42,e(l-R),*l=32,*l=42,e(l+1),*l=32,*l=42,e(l+R),*l=32;}
main(){while(~(c=getchar()))*r++=c,R=!R&&c==10?r-s:R,L=c==64?r-s-1:L;L%R==0&&e(s+L+1);(L+2)%R==0&&e(s+L-1);L<R&&e(s+L+R);e(s+L-R);}

परीक्षण के एक जोड़े के लिए नमूना उत्पादन:

####   
#  #   
@*#####
#*****#
#    *#
#####*#

###*###################
###*        #******** #
##**#########**    #* #
 #*************#####* #
 ###############   #@##

सीमाएँ: केवल 1000 वर्णों तक मेज़ों के लिए काम करती है, लेकिन इसे आसानी से बढ़ाया जा सकता है। मैंने सिर्फ Malloc / remalloc को परेशान करने के बजाय एक मनमाना नंबर उठाया।

इसके अलावा, यह सबसे अधिक चेतावनी से भरा कोड है जो मैंने कभी लिखा है। 19 चेतावनियाँ, हालांकि यह XCode कोड हाइलाइटिंग के साथ और भी अधिक लग रहा है। : डी

संपादित करें: संपादित किया और परीक्षण किया मुख्य से int ड्रॉप करने के लिए, ~ के बजाय का उपयोग करने के लिए! = प्रिंट के बजाय EOF और putchar। टिप्पणियों के लिए धन्यवाद!

Comments

आप 9999 का उपयोग कर सकते हैं - यह उसी तरह के पात्रों की संख्या है

— Lowjacker

बहुत बढ़िया! int पहले " " Omit करें mainऔर 4 वर्ण सहेजें। इसके अलावा 4 और बचाने putchar(*(s-1))के printf("%c",*(s-1))लिए उपयोग करें ।

— केसी

तुम भी बदल सकते हैं 0xAद्वारा 10और !=द्वारा ^।

— लोजैकर

इससे भी बेहतर: आप ~while(~(c=getchar())

— ईओएफ की

मैं L की स्थापना पर L & L && गार्ड को भी ड्रॉप कर सकता हूं, '@' के भूलभुलैया में स्थान।

— जोनाथन वॉटम

Answer 3

अजगर, 339 चरस

import sys
M=list(sys.stdin.read())
L=len(M)
R=range(L)
N=M.index('\n')+1
D=2*L*[9e9]
D[M.index('@')+N]=0
J=(1,-1,N,-N)
for x in R:
 for i in[N+i for i in R if' '==M[i]]:D[i]=min(1+D[i+j]for j in J)
e=[i+N for i in R[:N]+R[::N]+R[N-2::N]+R[-N:]if 0<D[i+N]<9e9][0]
while D[e]:M[e-N]='*';e=[e+j for j in J if D[e+j]<D[e]][0]
print''.join(M)

भूलभुलैया के माध्यम से एक छोटा रास्ता बनाता है।

उदाहरण के लिए उत्पादन mazes:

####   
#  #   
@*#####
#*    #
#******
#######

###*###################
###*        #     *** #
## *######### *****#* #
 # ************#####* #
 ###############   #@##

Comments

एन द्वारा सभी जोड़ और घटाव क्यों?

— लोजैकर

यह डी 10 में अनुक्रमणिका [i + j] को नकारात्मक होने से रोकता है। और D [e + j] पंक्ति 12 में

— कीथ रान्डेल

Answer 4

अजगर - 510 421 वर्ण

m=[]
i=raw_input
l=i()
x=y=-1
while l:
 if y<0:x+=1;y=l.find('@')
 m.append(list(l));l=i()
s=(x,y)
t={}
q=[s]
v={s:1}
while 1:
 try:(i,j),q=q[0],q[1:];c=m[i][j]
 except:continue
 if c==' 'and(i*j==0)|(i+1==len(m))|(j+1==len(m[0])):break
 for d,D in(-1,0),(0,-1),(1,0),(0,1):
  p=(i+d,j+D)
  if not p in v and'#'!=c:v[p]=0;q.append(p);t[p]=(i,j)
while(i,j)!=s:m[i][j]='*';i,j=t[(i,j)]
print'\n'.join(''.join(l)for l in m)

Comments

मैं *नीचे-दाएं कोने पर मिल रहा हूं , पहले परीक्षण मामले पर (अजगर 2.6.1)। कोई विचार?

— लोजैकर

@Lowjacker धन्यवाद, ऐसा लगता है कि गोल्फ करते समय मैंने एक बग जोड़ा जो इसे काम करने जैसा दिखता है, लेकिन सिर्फ परीक्षण के मामलों के लिए, और फिर भी मुश्किल से: पी

— जुआन

अच्छा है, अब यह काम करता है। लेकिन आप print b,rऔर बाहर ले जाने के लिए भूल गए print (i,j), जो मुझे लगता है कि डिबगिंग के लिए थे :)

— लोवेज़र

Answer 5

पायथन 3 , 273 बाइट्स

import sys
def q(g,s=[]):w=len(g[0])+1;k='@'.join(g)+w*'@';*p,x=s or[k.find('#')];return'@'>k[x]and{x}-{*p}and[p,min((q(g,s+[x+a])or k for a in(-1,1,-w,w)),key=len)]['*'>k[x]]
g=''.join(sys.stdin.read());s=q(g.split('\n'))
for i,c in enumerate(g):print(end=[c,'+'][i in s])

इसे ऑनलाइन आज़माएं!

एक ASCII सड़क पर सबसे छोटा रास्ता खोजने के लिए मेरे जवाब का पोर्ट ।

'#'शुरुआत के लिए, '*'अंत के लिए, '@'दीवार के लिए और ' 'खाली जगह के लिए उपयोग करता है। इसमें, फ़ंक्शन qएक सहायक फ़ंक्शन होता है जो भूलभुलैया में सबसे छोटे पथ के साथ एक आयामी सरणी देता है। fवैरिएबल न बताकर फ़ंक्शन को 4 बाइट्स छोटा किया जा सकता है s। यह अविश्वसनीय रूप से अक्षम है और संभावित रूप से समय समाप्त हो जाएगा, क्योंकि यह भूलभुलैया में प्रत्येक वर्ण के लिए पथ-खोज फ़ंक्शन को कॉल करता है।

Answer 6

05AB1E (विरासत) , 23 22 बाइट्स

[¾#4Føí„ *„@*δJ`:¬'*¢½

इसे ऑनलाइन आज़माएं!

आधुनिक 05AB1E , 26 बाइट्स

[¾#4F€SøíJ„ *„@*â2ô`:¬'*¢½

इसे ऑनलाइन आज़माएं!