I giochi di tattiche a turni come Advance Wars, Wargroove e Fire Emblem sono costituiti da una griglia quadrata di terreno variabile con unità di classi di movimento diverse che richiedono costi diversi per ogni tipo di terreno. Indagheremo un sottoinsieme di quel problema.

Sfida

Il tuo compito è determinare se una posizione è raggiungibile da un'altra data una griglia di costi del terreno e una velocità di movimento.

Le unità possono muoversi ortogonalmente solo dove il costo di spostamento su un quadrato è il valore della cella corrispondente sulla griglia (lo spostamento è libero). Ad esempio, spostarsi da una cella valutata 3 in una cella valutata 1 costa 1 movimento, ma andare nell'altra direzione richiede 3. Alcuni quadrati potrebbero essere inaccessibili.

Esempio

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

Il passaggio da [1]a <1>richiede un minimo di 7 punti movimento spostandosi a destra di un quadrato e poi di tre in basso. Quindi, se dato 6 o meno come velocità di movimento, dovresti dare una risposta falsa.

Esempi di casi di test

Questi utilizzeranno coordinate indicizzate a zero (riga, colonna) di origine superiore sinistra anziché celle tra parentesi per l'inizio e la fine per facilitare l'analisi. Le celle non raggiungibili verranno rappresentate conX

Caso 1a

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

Caso 1b

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

Caso 1c

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

Caso 2a

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

Caso 2b

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

Caso 2c

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

Caso 3a

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

Output: False

Caso 3b

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

Output: True

Regole, ipotesi e note

• Le scappatoie standard sono vietate, l'I / O può essere in qualsiasi formato conveniente
• Si può presumere che le coordinate siano tutte sulla griglia
• La velocità di movimento non sarà mai superiore a 100
• Le celle inaccessibili possono essere rappresentate con numeri molto grandi (ad es. 420, 9001, 1 milione) o con 0 o null, a seconda di quale sia la più conveniente per te.
• Tutti gli input saranno costituiti da numeri interi positivi (a meno che non si utilizzi null o 0 per rappresentare celle non raggiungibili)

Interrogazione TSQL, 205 191 byte

L'input è una variabile di tabella @t

@ x = inizio xpos, @ y = inizio ypos @ i = fine xpos, @ j = fine ypos @ = velocità

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

Provalo online versione non golfata

Python 2 , 220 byte

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]

Provalo online!

Accetta una matrice mdi numeri interi, con 'X'un valore maggiore di 100 ;, una velocità a, mcon larghezza we altezza h; e ritorna quando possiamo iniziare dalla cella di riga / colonna con indice zero (r,c)e arrivare alla cella finale (R,C).

L'algoritmo è un riempimento flood modificato. Codice leggermente non golfato:

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.

JavaScript (ES7),  116  113 byte

(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

Provalo online!

Commentate

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

Gelatina , 59 byte

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

Provalo online!

Non terribilmente veloce; prova tutti i percorsi fino a quando le unità di velocità sono esaurite, anche ripercorrendo i suoi passi. Tuttavia, questo evita la necessità di verificare se gli spazi sono visitati. L'input è fornito come[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

Spiegazione

Link di aiuto

+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

Collegamento principale

ç             | 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

Gelatina , 38 byte

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

Un programma completo estremamente inefficiente che accetta il terreno (con invisibili come 101), quindi l'inizio e la fine coordinano quindi la velocità.

Provalo online! (non ha molto senso provare la maggior parte dei casi di test!)

Come?

Crea un elenco di tutte le permutazioni di ciascuna delle serie di potenze di "tutte le posizioni del terreno tranne l'inizio e la fine", circonda ognuna di queste con l'inizio e la fine, filtra a quelle che fanno solo mosse ortogonali di distanza una, lascia cadere l'inizio da ciascuno, torna indietro nel terreno, somma ciascuno, prende il minimo, sottrae uno e prova che questo è inferiore alla velocità.