मुझे यहां से बाहर निकालो

Question

चुनौती

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

---

इनपुट

• एन : ग्रिड आकारN x N
• P : खिलाड़ी की स्थिति[playerposx, playerposy]
• T : लक्ष्य की स्थिति[targetposx, targetposy]
• O : बाधाओं की स्थिति[[x1, y1], [x2, y2],...,[xn, yn]]

---

उत्पादन

पथ : एक पथ खिलाड़ी लक्ष्य तक पहुंचने के लिए उपयोग कर सकता है[[x1, y1], [x2, y2],...,[xn, yn]]

---

नियम

1. बिंदु [0,0]ग्रिड के ऊपरी-बाएँ कोने पर है।
2. खिलाड़ी की स्थिति हमेशा ग्रिड के बाईं ओर होगी।
3. लक्ष्य की स्थिति हमेशा ग्रिड के दाईं ओर होगी।
4. ग्रिड में हमेशा कम से कम एक बाधा होगी।
5. आप मान सकते हैं कि कोई भी बाधा खिलाड़ी या लक्ष्य की स्थिति को ओवरलैप नहीं करती है।
6. जरूरी नहीं कि आपको मिनिमम पाथ मिल जाए।
7. खिलाड़ी केवल बाएं, दाएं, ऊपर और नीचे तिरछे नहीं चल सकता है।
8. आप किसी भी सुविधाजनक तरीके से इनपुट ले सकते हैं।
9. आप मान सकते हैं कि खिलाड़ी के निशाने पर आने का रास्ता हमेशा मौजूद रहेगा।
10. जाहिर है, प्रत्येक इनपुट के लिए कई वैध रास्ते मौजूद हैं, एक को चुनें।
11. मान लीजिए N > 2कि ग्रिड कम से कम होगा 3 x 3।

---

उदाहरण

इनपुट: 9, [6, 0], [3, 8], [[0, 5], [2, 2], [6, 4], [8, 2], [8, 7]]
संभावित आउटपुट:[[6, 0], [6, 1], [6, 2], [6, 3], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [5, 8], [4, 8], [3, 8]]

इनपुट: 6, [1, 0], [3, 5], [[1, 2], [2, 5], [5, 1]]
संभावित आउटपुट:[[1, 0], [1, 1], [2, 1], [2, 2], [2, 3], [2, 4], [3, 4], [3, 5]]

---

ध्यान दें

नोटिस जो Xपंक्तियों के लिए और Yबछड़ों के लिए है। एक छवि में निर्देशांक के साथ उन्हें भ्रमित न करें।

संपादित करें

जैसा कि @digEmAll ने बताया, नियमों के कारण #2और #3, playerY = 0और targetY = N-1। इसलिए, यदि आप चाहते हैं कि आप केवल इनपुट के रूप में ले सकते हैं playerXऔर targetX(यदि वह आपके कोड को छोटा बनाता है)।

Comments

"खिलाड़ी की स्थिति हमेशा बाईं ओर होगी और दाईं ओर लक्षित होगी": क्या इसका मतलब यह है कि खिलाड़ी-वाई = 0 और लक्ष्य-वाई = एन -1? यदि हां, तो क्या हम केवल खिलाड़ी और लक्ष्य के लिए x- समन्वय (एक नंबर) को स्वीकार कर सकते हैं?

— 9E23 में digEmAll

@digEmAll अच्छा बिंदु। ईमानदारी से, मैंने इसके बारे में नहीं सोचा था और हाँ आप इसे संपादित कर सकते हैं।

— डिमच्ज़ज़

संबंधित लेकिन आसान। संबंधित लेकिन कठिन।

— user202729

क्या पथ को शुरू से अंत तक होना चाहिए, या क्या यह रिवर्स ऑर्डर में हो सकता है?

— kamoroso94

@ kamoroso94 हां, लक्ष्य के लिए शुरू (खत्म) :)

— DimChtz

Answer 1

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

इनपुट के रूप में लेता है (width, [target_x, target_y], obstacles)(source_x, source_y), जहां बाधाएं"X,Y" प्रारूप में तार की एक सरणी होती हैं ।

"X,Y"स्वरूप में स्ट्रिंग्स की एक सरणी देता है ।

(n,t,o)=>g=(x,y,p=[],P=[...p,v=x+','+y])=>v==t?P:~x&~y&&x<n&y<n&[...o,...p].indexOf(v)<0&&[0,-1,0,1].some((d,i)=>r=g(x+d,y-~-i%2,P))&&r

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

टिप्पणी की गई

(n, t, o) =>              // n = width of maze, t[] = target coordinates, o[] = obstacles
  g = (                   // g() = recursive search function taking:
    x, y,                 //   (x, y) = current coordinates of the player
    p = [],               //   p[] = path (a list of visited coordinates, initially empty)
    P = [                 //   P[] = new path made of:
      ...p,               //     all previous entries in p
      v = x + ',' + y     //     the current coordinates coerced to a string v = "x,y"
    ]                     //
  ) =>                    //
    v == t ?              // if v is equal to the target coordinates:
      P                   //   stop recursion and return P
    :                     // else:
      ~x & ~y             //   if neither x nor y is equal to -1
      && x < n & y < n    //   and both x and y are less than n
      & [...o, ...p]      //   and neither the list of obstacles nor the path
        .indexOf(v) < 0   //   contains a position equal to the current one:
      && [0, -1, 0, 1]    //     iterate on all 4 possible directions
        .some((d, i) =>   //     for each of them:
          r = g(          //       do a recursive call with:
            x + d,        //         the updated x
            y - ~-i % 2,  //         the updated y
            P             //         the new path
          )               //       end of recursive call
        ) && r            //     if a solution was found, return it

Answer 2

आर , 227 बाइट्स

function(N,P,G,O){M=diag(N+2)*0
M[O+2]=1
b=c(1,N+2)
M[row(M)%in%b|col(M)%in%b]=1
H=function(V,L){if(all(V==G+2))stop(cat(L))
M[t(V)]=2
M<<-M
for(i in 0:3){C=V+(-1)^(i%/%2)*(0:1+i)%%2
if(!M[t(C)])H(C,c(L,C-2))}}
try(H(P+2,P),T)}

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

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

आउटपुट स्वरूपण में सुधार के लिए JayCe का धन्यवाद

Comments

+1 मुझे यह पसंद है कि आप आउटपुट प्रिंट करते हैं (सूचियों की सामान्य बोरिंग सूची नहीं) :)

— डिमच्ज़ज़

@DimChtz: अच्छी तरह से धन्यवाद, लेकिन ... यह सहायक कार्य है, कोड-गोल्फ फ़ंक्शन केवल निर्देशांक की एक सूची प्रिंट करता है x1 y1 x2 y2 ... xn yn: D

— digEmAll

हाँ, मुझे पता है: P लेकिन फिर भी अच्छा है।

— डिमचिट्ज़

@DimChtz से सहमत ... और मैं इसे भले ही आप बेहतर लग रहा है लगता है write(t(mx),1,N)के बजाय printing :)

— Jayce

@ जयके: अच्छा विचार, बदल गया!

— digEmAll

Answer 3

पायथन 2 , 151 149 बाइट्स

N,s,e,o=input()
P=[[s]]
for p in P:x,y=k=p[-1];k==e>exit(p);P+=[p+[[x+a,y+b]]for a,b in((0,1),(0,-1),(1,0),(-1,0))if([x+a,y+b]in o)==0<=x+a<N>y+b>-1]

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

Answer 4

हास्केल , 133 131 130 बाइट्स

• बीडब्ल्यूओ को -1 बाइट

(n!p)o=head.(>>=filter(elem p)).iterate(\q->[u:v|v@([x,y]:_)<-q,u<-[id,map(+1)]<*>[[x-1,y],[x,y-1]],all(/=u)o,x`div`n+y`div`n==0])

इसे ऑनलाइन आज़माएं! (कुछ परीक्षण के साथ)

एक फ़ंक्शन !इनपुट के रूप में ले रहा है

• n :: Int ग्रिड का आकार
• p :: [Int] एक सूची के रूप में खिलाड़ी की स्थिति [xp, yp]
• o :: [[Int]] एक सूची के रूप में बाधाओं की स्थिति [[x1, y1], [x2, y2], ...]
• t :: [[[Int]]]एक सूची के रूप में (निहित) लक्ष्य की स्थिति [[[xt, yt]]](सुविधा के लिए ट्रिपल सूची)

और एक सूची के रूप में एक वैध रास्ता लौटाना [[xp, yp], [x1, y1], ..., [xt, yt]]।

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

व्याख्या

(n ! p) o =                                                         -- function !, taking n, p, o and t (implicit by point-free style) as input
    head .                                                          -- take the first element of
    (>>= filter (elem p)) .                                         -- for each list, take only paths containing p and concatenate the results
    iterate (                                                       -- iterate the following function (on t) and collect the results in a list
        \q ->                                                       -- the function that takes a list of paths q...
            [u : v |                                                -- ... and returns the list of paths (u : v) such that:
                v@([x, y] : _) <- q,                                -- * v is an element of q (i.e. a path); also let [x, y] be the first cell of v
                u <- [id, map (+ 1)] <*> [[x - 1,y], [x, y - 1]],   -- * u is one of the neighbouring cells of [x, y]
                all (/= u) o,                                       -- * u is not an obstacle
                x `div` n + y `div` n == 0                          -- * [x, y] is inside the grid
            ]
    )

iterate$k$$k-1$[[xt, yt]]

जाहिरा तौर पर अस्पष्ट अभिव्यक्ति [id, map (+ 1)] <*> [[x - 1,y], [x, y - 1]]का सिर्फ एक "गोल्फ" (-1 बाइट) संस्करण है [[x + 1, y], [x, y + 1], [x - 1, y], [x, y - 1]]।

Comments

PPCG में आपका स्वागत है! अच्छा पहला जवाब!

— Arnauld

@ अरनल्ड धन्यवाद! मैं वास्तव में कई घंटे बिताए अपने समाधान से बाहर कुछ बाइट्स को निचोड़ने की कोशिश कर रहा था बस अपने 135 ^ ^ को हरा

— Delfad0r

अच्छा गोल्फ! आप एक बाइट को एक फ़ंक्शन के बजाय एक ऑपरेटर का उपयोग करके बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— ।

@BWO टिप के लिए धन्यवाद। मैं यहाँ नया हूँ, इसलिए कई ऐसे ट्रिक्स हैं जिनके बारे में मैंने कभी नहीं सुना

— Delfad0r

Btw। वहाँ विशेष रूप से हास्केल के लिए सुझाव आप इस और कई और अधिक चाल कहां मिल सकता के साथ एक अनुभाग। ओह और हमेशा चैट भी होती है: मोनाड्स और मेन

— '

Answer 5

रेटिना 0.8.2 , 229 बाइट्स

.
$&$&
@@
s@
##
.#
{`(\w.)\.
$1l
\.(.\w)
r$1
(?<=(.)*)\.(?=.*¶(?<-1>.)*(?(1)$)\w)
d
}`\.(?=(.)*)(?<=\w(?(1)$)(?<-1>.)*¶.*)
u
+T`.`#`.(?=(.)*)(?<=d#(?(1)$)(?<-1>.)*¶.*)|(?<=(.)*.).(?=.*¶(?<-2>.)*(?(2)$)u#)|(?<=#r).|.(?=l#)
.(.)
$1

इसे ऑनलाइन आज़माएं! यह सुनिश्चित नहीं है कि I / O प्रारूप योग्य है या नहीं। स्पष्टीकरण:

.
$&$&

प्रत्येक सेल को डुप्लिकेट करें। बाईं प्रतिलिपि का उपयोग अस्थायी कार्य क्षेत्र के रूप में किया जाता है।

@@
s@

विज़िट के दौरान भूलभुलैया की शुरुआत को चिह्नित करें।

##
.#

खाली होने के रूप में भूलभुलैया के अंत को चिह्नित करें।

{`(\w.)\.
$1l
\.(.\w)
r$1
(?<=(.)*)\.(?=.*¶(?<-1>.)*(?(1)$)\w)
d
}`\.(?=(.)*)(?<=\w(?(1)$)(?<-1>.)*¶.*)
u

जबकि उपलब्ध कामकाजी कोशिकाएं मौजूद हैं, उन्हें पहले से देखे गए कोशिकाओं से सटे हुए बिंदु पर इंगित करें।

+T`.`#`.(?=(.)*)(?<=d#(?(1)$)(?<-1>.)*¶.*)|(?<=(.)*.).(?=.*¶(?<-2>.)*(?(2)$)u#)|(?<=#r).|.(?=l#)

एक गाइड के रूप में काम करने वाली कोशिकाओं का उपयोग करके बाहर निकलने से शुरू होने तक के पथ को ट्रेस करें।

.(.)
$1

कार्यशील कोशिकाओं को हटाएं।

Answer 6

जावास्क्रिप्ट, 450 बाइट्स

के रूप में इनपुट लेता है (n, {playerx, playery}, {targetx, targety}, [{obstaclex, obstacley}])। की एक सरणी देता है {hopx, hopy}।

j=o=>JSON.stringify(o);l=a=>a.length;c=(a,o)=>{let i=l(a);while(i>0){i--;if(j(a[i])==j(o)){return 1;}}return 0;}h=(p,t,o)=>{if(p.y<t.y&&!c(o,{x:p.x,y:p.y+1})){return{x:p.x,y:p.y+1};}if(p.y>t.y&&!c(o,{x:p.x,y:p.y-1})){return{x:p.x,y:p.y-1};}if(p.x<t.x&&!c(o,{x:p.x+1,y:p.y})){return{x:p.x+1,y:p.y};}if(p.x>t.x&&!c(o,{x:p.x-1,y:p.y})){return{x:p.x-1,y:p.y};}return t;}w=(n,p,t,o)=>{let r=[];r.push(p);while(j(p)!==j(t)){p=h(p,t,o);r.push(p);}return r;}

यहाँ मेरी गड़बड़ी पर एक अविकसित संस्करण है:

// defining some Array's function for proper comparaisons
json = (object) => { return JSON.stringify(object) };
length = (array) => { return array.length; }
contains = (array, object) => {
    let i = length(array);
    while (i > 0) {
    i--;
        if (json(array[i]) == json(object)) { return true; }
    }
    return false;
}
//return next found hop
getNextHop = (player, target, obstacles) => {
    //uggly serie of conditions
    //check where do we have to go and if there is an obstacle there
    if(player.y<target.y && !contains(obstacles, [x:player.x, y:player.y+1])) { return [x:player.x, y:player.y+1]; }
    if(player.y>target.y && !contains(obstacles, [x:player.x, y:player.y-1])) { return [x:player.x, y:player.y-1]; }
    if(player.x<target.x && !contains(obstacles, [x:player.x+1, y:player.y])) { return [x:player.x+1, y:player.y]; }
    if(player.x>target.x && !contains(obstacles, [x:player.x-1, y:player.y])) { return [x:player.x-1, y:player.y]; }
    return target;
}
//return found path
getPath = (gridsize, player, target, obstacles) => {
    let path = [];
    path.push(player);
    //while player is not on target
    while(json(player)!=json(target)) {
        player = getNextHop(player, target, obstacles); //gridsize is never used as player and target are in the grid boundaries
        path.push(player);
    }
    return path;
}