पथ और समय बर्बाद कर रहे हैं

Question

परिसर

इसलिए हाल ही में मैं एक नियुक्ति के लिए लगभग आधे घंटे पहले था, और बाहर इंतजार करने का फैसला किया। मैंने यह भी निर्धारित किया कि यह अजीब लगेगा अगर मैं घर के सामने बस बिना रुके खड़ा रहा। इसलिए, मैंने एक सीमित क्षेत्र के भीतर, जल्दी चलने का फैसला किया। मैंने यह भी निष्कर्ष निकाला कि अगर मैं हलकों में चलना शुरू कर दूं तो यह स्पष्ट हो जाएगा कि मैं घृणा कर रहा था। इसलिए मुझे अपना पहला कोड गोल्फ चैलेंज बनाने के लिए प्रेरित किया गया।

विशिष्टता

आपको एक सूची दी जाएगी, क्षेत्र का एक नक्शा, जिसमें " "या तो शामिल होंगे या "#", जो रिक्त स्थान और कुछ प्रकार की बाधाओं का प्रतिनिधित्व करेंगे । खाली स्थानों को केवल एक बार पार किया जा सकता है, और इसे पार करने में 1 मिनट लगता है। आपकी प्रारंभिक स्थिति "@"प्रति रूग्युलाइक परंपरा के साथ दर्शाई जाएगी, और लक्ष्य का प्रतिनिधित्व इस "$"कारण से किया जाएगा कि आप वहां क्या खोने जा रहे हैं। आपको एक पूर्णांक भी दिया जाएगा जो यह दर्शाता है कि आपको घुसपैठ न करने के पहले कितने मिनट बर्बाद करने होंगे। जब आप भूमि पर"$", यह सटीक राशि मिनट रहा होगा (इसलिए यदि आप नीचे गिनती कर रहे थे, तो यह एक निकटवर्ती टाइल पर 1 होना चाहिए, और टाइल पर 0 होना चाहिए)। गंतव्य तक पहुंचना हमेशा संभव होगा। आपके कार्यक्रम या फ़ंक्शन को चार संभावित दिशाओं का प्रतिनिधित्व करने के लिए <,>, ^, और v के साथ सबसे छोटा रास्ता दिखाने वाली सूची वापस करनी होगी।

उदाहरण

इनपुट:

[[" ", " ", " ", " "],
 ["@", " ", " ", "$"],
 [" ", " ", " ", " "],
 [" ", " ", " ", " "]]

तथा

5

ouput:

[[">", ">", ">", "v"],
 ["^", " ", " ", "$"],
 [" ", " ", " ", " "],
 [" ", " ", " ", " "]]

इनपुट:

[[" ", "#", " ", " ", " "],
 [" ", "#", " ", " ", " "],
 ["@", "#", " ", "$", " "],
 [" ", " ", " ", " ", " "],
 [" ", "#", " ", " ", " "],
 [" ", "#", " ", " ", " "]]

तथा

7

आउटपुट:

[[" ", "#", " ", " ", " "],
 [" ", "#", ">", "v", " "],
 ["v", "#", "^", "$", " "],
 [">", ">", "^", " ", " "],
 [" ", "#", " ", " ", " "],
 [" ", "#", " ", " ", " "]]

इनपुट:

[[" ", "#", " ", " ", " "],
 [" ", "#", " ", " ", " "],
 ["@", "#", " ", "$", " "],
 [" ", " ", " ", " ", " "],
 [" ", "#", " ", " ", " "],
 [" ", "#", " ", " ", " "]]

तथा

17

आउटपुट:

[[" ", "#", " ", "v", "<"],
 [" ", "#", " ", "v", "^"],
 ["v", "#", " ", "$", "^"],
 [">", ">", "v", ">", "^"],
 [" ", "#", "v", "^", "<"],
 [" ", "#", ">", ">", "^"]]

नियम

• मानक खामियां लागू होती हैं
• प्रत्येक टाइल को केवल एक बार स्थानांतरित किया जाना चाहिए
• सही समय बोर्ड पर खर्च किया जाना चाहिए
• केवल एक पथ को कई पथों के मामले में प्रदर्शित करने की आवश्यकता है
• यह एक कोड गोल्फिंग प्रश्न है, इसलिए सबसे छोटी उत्तर जीत है
• टिप्पणियों में user202729 के प्रश्न के अनुसार, आप मान्य इनपुट मान सकते हैं।

यदि कोई और स्पष्टीकरण चाहिए तो टिप्पणी जोड़ें

Comments

क्या यह गारंटी है कि " निर्दिष्ट समय में गंतव्य तक पहुंचना हमेशा संभव होगा "?

— user202729

हां, यह हमेशा एक तरीका होगा, भले ही

— दोषी हो

PPCG में आपका स्वागत है! :) अच्छी पहली चुनौती।

— ग्यूसेप

प्रत्येक छोर पर आधे मिनट के लिए क्या हुआ ?! (अगर यह स्पष्ट नहीं है तो कुछ भी बदलने की आवश्यकता नहीं है)

— जोनाथन एलन

Answer 1

जावास्क्रिप्ट (ईएस 6), 171 बाइट्स

करी सिंटैक्स में इनपुट लेता है (a)(n)। इनपुट मैट्रिक्स को संशोधित करके आउटपुट ।

a=>g=(n,y=a[F='findIndex'](r=>~(i=r[F](v=>v>'?'))),x=i,R=a[y])=>!n--|[-1,0,1,2].every(d=>(R[x]='<^>v'[d+1],(c=(a[Y=y+~-d%2]||0)[X=x+d%2])<1?g(n,Y,X):n|c!='$')&&(R[x]=' '))

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

टिप्पणी की गई

a =>                           // a[] = input matrix
g = (                          // g = recursive function taking:
  n,                           //   n = number of remaining moves
                               //   (x, y) = current coordinates, initialized as follows:
  y = a[F = 'findIndex'](r =>  //     y = index of the row containing the starting point,
    ~(i = r[F](v => v > '?'))  //         found by iterating over all rows r until we
  ),                           //         find some i such that r[i] > '?'
  x = i,                       //     x = index of the column of the starting point
  R = a[y]                     //   R[] = current row
) =>                           //
  !n-- |                       // decrement n; force failure if we're out of moves
  [-1, 0, 1, 2].every(d =>     // for each direction d, where -1 = left, 0 = up,
    (                          // 1 = right and 2 = down:
      R[x] = '<^>v'[d + 1], (  //   update the current cell with the direction symbol
        c = (                  //   c = content of the new cell at (X, Y) with:
          a[Y = y + ~-d % 2]   //     Y = y + dy
          || 0                 //     (use a dummy value if this row does not exist)
        )[X = x + d % 2]       //     X = x + dx
      ) < 1 ?                  //   if c is a space:
        g(n, Y, X)             //     we can go on with a recursive call
      :                        //   else:
        n | c != '$'           //     return false if n = 0 and we've reached the target
    ) &&                       //   unless the above result is falsy,
    (R[x] = ' ')               //   restore the current cell to a space
  )                            // end of every()

Answer 2

पायथन 2 , 310 256 बाइट्स

शुक्रिया @cairdcoinheringaahing except:0-3 बाइट्स
के लिए
धन्यवाद @
मेनमोनिक फॉर -8 बाइट्स

G,L=input()
R=[]
def S(x,y,G,c,R):
 try:
	if x>-1<y<G[y][x]in' @':i=0;exec"T=[r[:]for r in G];T[y][x]='<v^>'[i];S(x+~-i/2,y+~-(i^2)/2,T,c-1,R);i+=1;"*4
	R+=[G]*(0==c<'$'==G[y][x])
 except:0
for i,y in enumerate(G):"@"in y>S(y.index("@"),i,G,L,R)
print R[0]

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

कुछ स्पष्टीकरण:

try-exceptयह सुनिश्चित करने के लिए उपयोग किया जाता है कि दोनों xऔर yनिर्देशांक सीमाओं में हैं। अपवाद का उपयोग करने पर उठाया जाएगा G[y][x]। अजगर बहुत अच्छा है और नकारात्मक संकेत स्वीकार्य हैं, इसलिए चेक x>-1<yजोड़ा जाता है।

T=[r[:]for r in G]Gमूल्यों द्वारा प्रतिलिपि बनाने के लिए उपयोग किया जाता है

~-i/2और ~-(i^2)/2जोड़े उत्पन्न करने के लिए उपयोग किए जाते हैं (-1, 0), (0, 1), (0, -1), (1, 0), जो ग्रिड में स्थानांतरित करने के लिए उपयोग किया जाता है (वहां अभी भी कम रास्ता होना चाहिए!)

R+=[G]*(0==c<'$'==G[y][x])जाँच करें, कि '$'आवश्यक चरणों में पहुँच गया है। Rइस परिणाम को पुनरावर्ती फ़ंक्शन कॉल से प्राप्त करने के लिए उपयोग किया जाता है।

for i,y in enumerate(G):"@"in y>S(y.index("@"),i,G,L,R)मिले xऔर yके '@'इनपुट और कॉल समारोह में S।

print R[0] R इसमें एक समाधान अधिक हो सकता है, इसलिए आउटपुट पहले

Comments

-4 निवाले

— caird coinheringaahing

आप को बदल कर एक बाइट बचा सकता है if G[y][x]=='$':के साथ if'$'==G[y][x]:।

दरअसल, उस पूरी स्थिति को R+=(G[y][x]=='$')*(c==0)*[G]दूसरे बाइट के साथ बदल दिया जा सकता है ।

हुह, निश्चित नहीं कि मैं क्या देख रहा था। आप पहली शर्त में एक युगल बाइट बचा सकते हैंif(x>-1<y)*(G[y][x]in' @'):

आपके लिए एक छोटा तरीका y+cmp(i%2,i/2)होगा y+~-(i^2)/2; अभी भी अच्छी तरह से कम हो सकता है।

— जोनाथन एलन

Answer 3

अजगर 2 , 264 261 251 249 बाइट्स

def f(a,n,r=-1,s=0):
 j=len(a[0]);x=1;z=y=0
 if r<0:s,r=divmod(sum(a,[]).index('@'),j)
 for c in'>v<^':
	u=r+x;v=s+y;x,y=-y,x
	if j>u>-1<v<len(a):b=[e[:]for e in a];b[s][r]=c;w=a[v][u];z=n*(w<'!')and f(b,n-1,u,v)or n==1and w=='$'and b
	if z:return z

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

Comments

@ अरनल्ड: उफ़! थोड़ा बहुत समझ भी आया। फिक्स्ड।

— चेस ब्राउन