टेरेन रीचैबिलिटी

Question

एडवांस वॉर्स, वॉरग्रोव और फायर एंबेल्म जैसे टर्न-आधारित रणनीति गेम प्रत्येक इलाके प्रकार के लिए अलग-अलग लागतों की आवश्यकता वाले अलग-अलग आंदोलन वर्गों की इकाइयों के साथ अलग-अलग इलाकों के एक वर्ग ग्रिड से बने होते हैं। हम उस समस्या के सबसेट की जांच करेंगे।

चुनौती

आपका कार्य यह निर्धारित करना है कि क्या एक स्थान दूसरे से लेकर इलाके की लागत और आंदोलन की गति को देखते हुए उपलब्ध है।

इकाइयां केवल ऑर्थोगोननली चल सकती हैं जहां एक वर्ग पर जाने की लागत ग्रिड पर संबंधित सेल का मूल्य है (मूविंग ऑफ फ्री है)। उदाहरण के लिए, एक सेल से 3 का मान एक सेल पर 1 मूवमेंट 1 की कीमत है, लेकिन दूसरे रास्ते पर जाने के लिए 3 की आवश्यकता होती है। कुछ वर्ग दुर्गम हो सकते हैं।

उदाहरण

1 [1] 1  1  1
1  2  2  3  1
2  3  3  3  4
1  3 <1> 3  4

से चलती [1]करने के लिए <1>नीचे तीन सही एक वर्ग और फिर ले जाकर 7 आंदोलन अंक की एक न्यूनतम आवश्यकता है। इस प्रकार, अगर आंदोलन की गति के रूप में 6 या उससे कम दिया जाता है, तो आपको एक झूठा जवाब देना चाहिए।

उदाहरण परीक्षण मामले

ये पार्सिंग को आसान बनाने के लिए प्रारंभ और अंत के लिए ब्रैकेटेड कोशिकाओं के बजाय शीर्ष-बाएँ-मूल-शून्य-अनुक्रमित (पंक्ति, स्तंभ) निर्देशांक का उपयोग करेंगे। अगम्य कोशिकाओं के साथ प्रतिनिधित्व किया जाएगाX

केस 1 ए

1 1 2 1 X
1 2 2 1 1
2 1 1 2 1
X X X 1 2
Speed: 5
From (2, 3) to (0, 1)

Output: True

केस 1 बी

1 1 2 1 X
1 2 2 1 1
2 1 1 2 1
X X X 1 2
Speed: 4
From (2, 3) to (0, 1)

Output: False

केस 1 सी

1 1 2 1 X
1 2 2 1 1
2 1 1 2 1
X X X 1 2
Speed: 5
From (0, 1) to (2, 3)

Output: False

केस 2 ए

3 6 1 1 X 4 1 2 1 X
5 1 2 2 1 1 1 X 1 5
2 1 1 1 2 1 1 1 X 1
2 1 1 3 1 2 3 4 1 2
1 1 2 1 1 4 1 1 1 2
3 2 3 5 6 1 1 X 1 4
Speed: 7
From (3, 4) to (2, 1)

Output: True

केस 2 बी

3 6 1 1 X 4 1 2 1 X
5 1 2 2 1 1 1 X 1 5
2 1 1 1 2 1 1 1 X 1
2 1 1 3 1 2 3 4 1 2
1 1 2 1 1 4 1 1 1 2
3 2 3 5 6 1 1 X 1 4
Speed: 4
From (3, 4) to (2, 1)

Output: False

केस 2 सी

3 6 1 1 X 4 1 2 1 X
5 1 2 2 1 1 1 X 1 5
2 1 1 1 2 1 1 1 X 1
2 1 1 3 1 2 3 4 1 2
1 1 2 1 1 4 1 1 1 2
3 2 3 5 6 1 1 X 1 4
Speed: 7
From (1, 8) to (2, 7)

Output: True

केस 3 ए

2 1 1 2
2 3 3 1
Speed: 3
From (0, 0) to (1, 1)

Output: False

केस 3 बी

2 1 1 2
2 3 3 1
Speed: 3
From (1, 1) to (0, 0)

Output: True

नियम, धारणाएँ, और नोट्स

• मानक खामियों पर प्रतिबंध लगा दिया गया है, I / O किसी भी सुविधाजनक प्रारूप में हो सकते हैं
• आप मान सकते हैं कि सभी निर्देशांक ग्रिड पर हैं
• आंदोलन की गति कभी भी 100 से अधिक नहीं होगी
• दुर्गम कोशिकाओं को बहुत बड़ी संख्या (जैसे 420, 9001, 1 मिलियन) या 0 या अशक्त के साथ प्रतिनिधित्व किया जा सकता है, जो भी आपके लिए सबसे सुविधाजनक है।
• सभी इनपुट में सकारात्मक पूर्णांक शामिल होंगे (जब तक कि अशक्त कोशिकाओं का प्रतिनिधित्व करने के लिए अशक्त या 0 का उपयोग न किया जाए)

Comments

@LuisfelipeDejesusMunoz "ये शीर्ष-बाएँ-मूल शून्य-अनुक्रमित (पंक्ति, स्तंभ) निर्देशांक का उपयोग करेंगे"

— बीफस्टर

आप कहते हैं कि I / O किसी भी सुविधाजनक प्रारूप में हो सकता है। क्या इसमें शामिल है, उदाहरण के लिए, आयामों के साथ एक सूची / सरणी? मेरा मानना ​​है कि आमतौर पर इसकी अनुमति है, लेकिन यह निश्चित रूप से एक स्ट्रिंग को पार्स करने पर बहुत सारे बाइट्स बचाता है।

— १

@ फ़ेडरर, हाँ बिलकुल

— बीफ़स्टर

मैंने अपने फोन एमुलेटर पर उन्नत युद्ध डाउनलोड किए ... मैं बहुत दुखी हूं कि यह आपको 13 ट्यूटोरियल स्तरों को करने के लिए मजबूर करता है ... मैं इसे बहुत बुरी तरह से फिर से खेलना चाहता था, लेकिन मेरा धैर्य पुराने सिस्टम पर ट्यूटोरियल के लिए पतला कागज है।

— मैजिक ऑक्टोपस यूरन

Answer 1

TSQL क्वेरी, 205 191 बाइट्स

इनपुट एक तालिका चर @t है

@ x = start xpos, @ y = start ypos @ i = end xpos, @ j = end ypos @ = गति

DECLARE @t table(x int,y int,v int)
INSERT @t
values
(0,0,1),(0,1,1),(0,2,2),(0,3,1),(0,4,null),
(1,0,1),(1,1,2),(1,2,2),(1,3,1),(1,4,1),
(2,0,2),(2,1,1),(2,2,1),(2,3,2),(2,4,1),
(3,0,null),(2,1,null),(2,2,null),(2,3,1),(2,4,2)

DECLARE @x INT=2,@y INT=3,@i INT=0,@j INT=1,@ INT=5;

WITH C as(SELECT @y f,@x r,@ s
UNION ALL
SELECT f+a,r+b,s-v FROM C
JOIN(values(1,0),(0,1),(-1,0),(0,-1))x(a,b)ON
s>0JOIN @t
ON f+a=x and r+b=y)SELECT
max(iif(S>=0and f=@j and r=@i,1,0))FROM c

यह ऑनलाइन ungolfed संस्करण का प्रयास करें

Answer 2

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

def f(m,a,w,h,r,c,R,C):
 T=[w*[999]for _ in' '*h];T[r][c]=0;P=[(r,c)];j,k=1,0
 for u,v in P:exec"U,V=u+j,v+k;j,k=-k,j\nif h>U>-1<V<w:q=T[U][V];T[U][V]=min(T[u][v]+m[U][V],q);P+=[(U,V)]*(q>T[U][V])\n"*4
 return a>=T[R][C]

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

mपूर्णांक की एक सरणी लेता है , 'X'एक बड़े-से -100 मान के साथ; एक गति a, mचौड़ाई wऔर ऊंचाई h; और जो भी हम शून्य-अनुक्रमित पंक्ति / स्तंभ सेल में शुरू कर सकते हैं (r,c)और अंतिम सेल में ला सकते हैं (R,C)।

एल्गोरिथ्म एक संशोधित बाढ़-भराव है। थोड़ा असम्बद्ध कोड:

def f(m,a,w,h,r,c,R,C):
 T = [w*[999]for _ in ' '*h] # make an array same size as m, with all 
                             #   values 999, whose values will represent
                             #   the cost of getting to each cell.
 T[r][c] = 0                 # set the starting location to a cost of 0
 P = [(r,c)]                 # initialize a set of cells whose neighbors'
                             #   cost might need to be be updated
 j,k = 1,0                   # and also j,k which will take on values:
                             #  (1,0), (0,1), (-1,0), (0,1), used to 
                             #  probe orthogonal neighbors
 for u,v in P:               # scan the cells in P
    for _ in '1234':         # look at each of 4 orthogonal positions
        U,V = u+j,v+k        # U and V get the indexes of a neighbor 
                             #   of the current cell.
        j,k = -k,j           # this 'rotates' the j,k pairing.
        if h>U>-1<V<w:       # if the coordinates are in bounds...
            q = T[U][V]      # save the current 'cost' of getting to cell (U,V)
                             # see if we can reduce that cost, which is calculated 
                             #   by taking the cost of the currently scanned cell 
                             #   + the value from m for the neighbor cell. 
            T[U][V] = min(T[u][v]+m[U][V] ,q)
                             # if we can reduce the cost, add the neighbor
                             #   to P because **it's** neighbors might,
                             #   in turn, need updating.
            P += [(U,V)]*(q>T[U][V])
 return a>=T[R][C]           # return if speed is enough for the cost.

Answer 3

जावास्क्रिप्ट (ईएस 7),  116  113 बाइट्स

(matrix)([endRow, endCol])(speed, startRow, startCol)$0$$1$

m=>e=>o=g=(s,y,x)=>m.map((r,Y)=>r.map((v,X)=>r[s<v|(x-X)**2+(y-Y)**2-1||g(s-v,Y,X,r[X]=1/0),X]=v),o|=y+[,x]==e)|o

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

टिप्पणी की गई

m =>                        // m[] = matrix
e =>                        // e[] = target coordinates
  o =                       // o   = success flag, initialized to a non-numeric value
  g = (                     // g   = recursive depth-first search function taking:
    s,                      //   s    = speed
    y, x                    //   y, x = starting coordinates
  ) =>                      //
    m.map((r, Y) =>         // for each row r[] at position Y in m[]:
      r.map((v, X) =>       //   for each value v at position X in r[]:
        r[                  //     this statement ultimately updates r[X]:
          s < v |           //       abort if s is less than v
          (x - X) ** 2 +    //       or the quadrance between (x, y)
          (y - Y) ** 2 - 1  //       and (X, Y) is not equal to 1
          || g(             //       otherwise, do a recursive call to g:
               s - v,       //         subtract v from s
               Y, X,        //         pass (Y, X) as the new coordinates
               r[X] = 1 / 0 //         temporarily make this cell unreachable
             ),             //       end of recursive call 
          X                 //       restore r[X] ...
        ] = v               //     ... to its original value
      ),                    //   end of inner map()
      o |= y + [, x] == e   //   set the flag o if (y + ',' + x) matches (e + '')
    ) | o                   // end of outer map(); return o

Answer 4

जेली , 59 बाइट्स

+2¦µ_2ịæ.ؽœị$Ʋ+5ịƲ$4¦01Ñḣ3Ḋ⁼/Ɗ?ḣ2=/ẸƊoF<0ẸƊƊ?
çⱮØ.,U$;N$¤Ẹ

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

बहुत तेजी से नहीं; गति पथ समाप्त होने तक सभी पथों को आज़माता है, यहां तक ​​कि इसके चरणों को पीछे हटाता है। हालांकि, यह जांचने की आवश्यकता से बचा जाता है कि रिक्त स्थान का दौरा किया जाता है या नहीं। इनपुट के रूप में प्रदान किया गया है[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

व्याख्या

हेल्पर लिंक

+2¦                                       | add the right argument to the second item in the left argument (current location)
   µ                                      | start a new monadic chain with the modified left argument
                    4¦                    | for the fourth item (speed)...
    _                                     |   subtract...
                 ịƲ$                      |     the item located at...
     2ịæ.ؽœị$Ʋ                           |       the dot product of the current position and (number of columns,
                                          |       right-padded with 1)
               +5                         |       plus five
                                        ? | Now, if...
                                       Ɗ  |   next three as a monad
                           ḣ2=/ẸƊ         |   either current row or current column are equal to nrows/ncolumns respectively
                                 o        | or
                                  F<0ẸƊ   |   any value is negative
                 0                        | return zero
                          ?               | else if...
                   ḣ3Ḋ⁼/Ɗ                 | the second and third items (current and end pos) are equal
                  1                       | return 1
                   Ñ                      | else pass the current list back to the main link

मुख्य लिंक

ç             | call the helper link with the current list...
 Ɱ            |   and each of
  Ø.,U$;N$¤   |   [0,1],[1,0],[0,-1],[-1,0]
           Ẹ  | Check if any are true

Answer 5

जेली , 38 बाइट्स

ạƝṢ€Ḅ’¬Ạ
ŒṪ’ḟŒPŒ!€ẎW€j¥@€ÇƇḊ€‘œị⁸§Ṃ’<⁵

एक अत्यंत अकुशल पूर्ण कार्यक्रम जिसमें इलाके को स्वीकार किया जाता है (101 के रूप में परिकल्पना के साथ) फिर प्रारंभ और अंत सह-निर्देश फिर गति।

इसे ऑनलाइन आज़माएं! (परीक्षण के अधिकांश मामलों की कोशिश नहीं कर रहा है!)

कैसे?

"प्रारंभ और अंत को छोड़कर सभी इलाके स्थानों" के पावर-सेट में से प्रत्येक के सभी क्रमपरिवर्तन की सूची बनाता है, इनमें से प्रत्येक को प्रारंभ और अंत के साथ घेरता है, उन लोगों को फ़िल्टर करता है जो केवल एक की ऑर्थोगोनल चाल बनाते हैं, प्रारंभ को छोड़ देता है प्रत्येक से, इलाके में वापस अनुक्रमित, प्रत्येक प्रत्येक रकम, न्यूनतम लेता है, एक घटाता है और परीक्षण करता है कि यह गति से कम है।