চ্যালেঞ্জ

গ্রিডের আকার, বাধাগুলির অবস্থান, প্লেয়ারের অবস্থান এবং লক্ষ্যের অবস্থান দেওয়া আপনার কাজটি প্লেয়ারের লক্ষ্য অর্জনের জন্য একটি পথ খুঁজে পাওয়া এবং একই সাথে (যদি প্রয়োজন হয়) বাধাগুলি এড়ানোর জন্য হয়।

ইনপুট

এন : গ্রিডের আকারN x N
পি : প্লেয়ারের অবস্থান[playerposx, playerposy]
টি : টার্গেটের অবস্থান[targetposx, targetposy]
ও : বাধা 'অবস্থান[[x1, y1], [x2, y2],...,[xn, yn]]

আউটপুট

পাথ : একটি পাথ প্লেয়ার লক্ষ্য অর্জনে ব্যবহার করতে পারে[[x1, y1], [x2, y2],...,[xn, yn]]

বিধি

পয়েন্টটি [0,0]গ্রিডের উপরের-বাম কোণে।
প্লেয়ারের অবস্থান সর্বদা গ্রিডের বাম দিকে থাকবে।
টার্গেটের অবস্থান সর্বদা গ্রিডের ডানদিকে থাকবে।
গ্রিডে সর্বদা কমপক্ষে একটি বাধা থাকবে।
আপনি ধরে নিতে পারেন যে কোনও বাধা প্লেয়ার বা লক্ষ্য অবস্থানকে ওভারল্যাপ করে না।
অগত্যা আপনার ন্যূনতম পথটি সন্ধান করার দরকার নেই।
খেলোয়াড়টি কেবল বাম, ডান, উপরে এবং নীচে ত্রিভুজ নয় move
আপনি যে কোনও সুবিধাজনক উপায়ে ইনপুট নিতে পারেন।
আপনি ধরে নিতে পারেন যে খেলোয়াড়ের লক্ষ্যবস্তুতে পৌঁছানোর পথে সর্বদা অস্তিত্ব থাকবে।
স্পষ্টতই, প্রতিটি ইনপুট জন্য একাধিক বৈধ পাথ বিদ্যমান, একটি চয়ন করুন।
ধরে নিন 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(যদি এটি আপনার কোডকে আরও ছোট করে তোলে)।

code-golf grid path-finding

— DimChtz
সূত্র

1

"প্লেয়ারের অবস্থান সর্বদা বাম পাশে থাকবে এবং ডানদিকে লক্ষ্য করবে": এর অর্থ কী প্লেয়ার-y = 0 এবং লক্ষ্য-y = এন -1? যদি তা হয়, তবে আমরা কী খেলোয়াড় এবং টার্গেটের জন্য x- সমন্বিত (এক নম্বর) গ্রহণ করতে পারি?

— digEmAll

1

@ ডিগেম সমস্ত ভাল পয়েন্ট। সত্যিই, আমি এটি ভাবিনি এবং হ্যাঁ আপনি এটি সম্পাদনা করতে পারেন will

— DimChtz

সম্পর্কিত কিন্তু সহজ। সম্পর্কিত কিন্তু শক্ত।

— ব্যবহারকারী 202729

পথটি কি শুরু থেকে শেষ করতে হবে, বা এটি বিপরীত ক্রমে হতে পারে?

— kamoroso94

1

@ কামোরসো94 হ্যাঁ, লক্ষ্য করা শুরু করুন (সমাপ্ত) :)

— ডিমচটজ

5

জাভাস্ক্রিপ্ট (ES6), 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

— Arnauld
সূত্র

5

আর , 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)}

এটি অনলাইন চেষ্টা করুন!

আসলেই সংক্ষিপ্ত নয় এবং অবশ্যই সবচেয়ে সংক্ষিপ্ততম পথটি দিচ্ছেন না (যেমন প্রথম উদাহরণটি দেখুন)।
এটি মূলত পুনরাবৃত্ত গভীরতা-প্রথম অনুসন্ধান করে এবং লক্ষ্যটি পৌঁছানোর সাথে সাথে পথটি মুদ্রণ করে।

আউটপুট ফর্ম্যাটিংয়ের উন্নতির জন্য জ্যাকিকে ধন্যবাদ

— digEmAll
সূত্র

+1 আপনি আউটপুটটি যেভাবে মুদ্রণ করেছেন তা পছন্দ (তালিকার সাধারণ বিরক্তিকর তালিকা নয়) :)

— DimChtz

@ ডিমচ্যাটজ: ভাল ধন্যবাদ তবে ... এটি হেল্পার ফাংশন, কোড-গল্ফ ফাংশন কেবল স্থানাঙ্কের একটি তালিকা x1 y1 x2 y2 ... xn yn

— ছাপায়

1

হ্যাঁ, আমি জানি: পি তবে এখনও দুর্দান্ত।

— DimChtz

1

@ ডিমচ্যাটজ এর সাথে একমত ... এবং আমি মনে করি আপনি write(t(mx),1,N)print

— ইঙ্গির

@ জাসি: ভাল ধারণা, পরিবর্তিত!

— digEmAll সমস্ত

4

পাইথন 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]

এটি অনলাইন চেষ্টা করুন!

— ovs
সূত্র

3

হাস্কেল , 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লক্ষ্য থেকে শুরু করে প্লেয়ারের শুরুর অবস্থানে পৌঁছানোর মাধ্যমে পুনরাবৃত্ত বিএফএস সম্পাদন করে । দৈর্ঘ্য পথ দৈর্ঘ্যের বৈধ পাথ যথাযথ কোষ prepending দ্বারা প্রাপ্ত হয় , দৈর্ঘ্য 1 মাত্র বৈধ পথ, পথ যে দিয়ে শুরু । $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]]।

— Delfad0r
সূত্র

2

পিপিসিজিতে আপনাকে স্বাগতম! প্রথম উত্তর!

— আর্নল্ড

1

@ আরনাউল্ড ধন্যবাদ! আমি আপনার সমাধান থেকে কয়েক বাইট বার করার চেষ্টা করে আসলে আপনার 135

— ডিগ্রি মারার

1

দুর্দান্ত গল্ফ! আপনি কোনও ফাংশনের পরিবর্তে অপারেটর ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারেন: এটি অনলাইনে চেষ্টা করুন!

— 25

@ বিডব্লিউও টিপটির জন্য ধন্যবাদ। আমি এখানে নতুন, তাই এমন অনেক কৌশল আছে যা আমি কখনও শুনিনি

— ডেল্ফ্যাড0

1

BTW। আছে বিশেষ করে Haskell, জন্য টিপস আপনি এই এবং আরো অনেক ঠাট কোথায় পাওয়া যাবে সঙ্গে একটি অধ্যায়। ওহ এবং সর্বদা চ্যাটও হয়:

— মনডস

1

রেটিনা 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

এটি অনলাইন চেষ্টা করুন! আই / ও ফর্ম্যাটটি যোগ্য কিনা তা নিশ্চিত নয়। ব্যাখ্যা:

.
$&$&

প্রতিটি ঘরে নকল করুন। বাম কপিটি অস্থায়ী কর্মক্ষেত্র হিসাবে ব্যবহৃত হয়।

@@
s@

গোলকধাঁধাটির শুরু হিসাবে চিহ্নিত হিসাবে চিহ্নিত করুন।

##
.#

গোলকধাঁধার শেষে শূন্য বলে চিহ্নিত করুন।

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

উপলভ্য কার্যকরী ঘরগুলি বিদ্যমান থাকাকালীন তাদের পূর্ববর্তী পরিদর্শন করা কক্ষগুলিতে নির্দেশ করুন।

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

কার্যকারী সেলগুলি গাইড হিসাবে ব্যবহার করে প্রস্থান থেকে শুরু করার পথটি সনাক্ত করুন।

.(.)
$1

কার্যকারী কক্ষগুলি মুছুন।

— নিল
সূত্র

1

জাভাস্ক্রিপ্ট, 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;
}

— MinerBigWhale
সূত্র

আমাকে এখান থেকে বের কর

চ্যালেঞ্জ

ইনপুট

আউটপুট

বিধি

উদাহরণ

জাভাস্ক্রিপ্ট (ES6), 135 বাইট

মন্তব্য

আর , 227 বাইট

পাইথন 2 , 151 149 বাইট

হাস্কেল , 133 131 130 বাইট

ব্যাখ্যা

রেটিনা 0.8.2 , 229 বাইট

জাভাস্ক্রিপ্ট, 450 বাইট