La tartaruga vuole muoversi lungo la griglia per raggiungere il suo cibo. Vuole sapere quante mosse ci vorranno per arrivarci.

Inoltre, poiché è lento, ha dei teletrasporti installati intorno al suo dominio che utilizzerà se questo accorcia il suo percorso. O evitali se allunga il suo cammino.

Incontra la tartaruga

🐢

La tartaruga vive su una griglia

$$\begin{matrix} X&X&X&X&X\\ X&X&X&X&X\\ X&X&🐢&X&X\\ X&X&X&X&X\\ X&X&X&X&X\\ \end{matrix}$$ La tartaruga può spostarsi in qualsiasi quadrato adiacente ... $$\begin{matrix} X&X&X&X&X\\ X&\nwarrow&\uparrow&\nearrow&X\\ X&\leftarrow&🐢&\rightarrow&X\\ X&\swarrow&\downarrow&\searrow&X\\ X&X&X&X&X\\ \end{matrix}$$

Tuttavia, la tartaruga non può spostarsi in un quadrato con una montagna

$$\begin{matrix} X&🌄&X&X&X\\ X&\nwarrow&\uparrow&\nearrow&X\\ X&🌄&🐢&\rightarrow&X\\ X&🌄&\downarrow&\searrow&X\\ X&🌄&X&X&X\\ \end{matrix}$$

La tartaruga vuole mangiare la fragola, e vorrebbe sapere quanto tempo ci vorrà per arrivare al suo Fragola

$$\begin{matrix} X&🌄&🍓\\ 🐢&🌄&X\\ X&🌄&X\\ X&X&X\\ \end{matrix}$$ Questo esempio potrebbe prendere la tartaruga $5$ giri $$\begin{matrix} X&🌄&🍓\\ \downarrow&🌄&\uparrow\\ \searrow&🌄&\uparrow\\ X&\nearrow&X\\ \end{matrix}$$ Fortunatamente, la tartaruga ha trovato un teletrasporto! Ci sono due teletrasporti sulla griglia che si mappano l'un l'altro. Fare un passo sul teletrasporto sposta immediatamente la tartaruga sul corrispondente teletrasporto. I teletrasporto sono molto instabili e dopo averli usati una volta, scompaiono e non sono più utilizzabili. $$\begin{matrix} 🔵&🌄&🍓\\ 🐢&🌄&🔴\\ X&🌄&X\\ X&X&X\\ \end{matrix}$$ Ora è più veloce per la tartaruga risalire due volte. Ora il percorso più breve per le tartarughe è$2$ $$\begin{matrix} 🔵&🌄&🐢\\ \uparrow&🌄&🔴\uparrow\\ X&🌄&X\\ X&X&X\\ \end{matrix}$$

La sfida

Data una configurazione iniziale della griglia, il numero di mosse impiegherà la tartaruga a raggiungere la sua fragola.

Regole

• Si può presumere che la griglia di input abbia una soluzione

• Ogni griglia avrà solo uno strawberrye due portalse unoturtle

• La griglia di input può essere inserita in qualsiasi formato conveniente

• Dovresti trattare teleporterssono oggetti monouso

• Il turno in cui la tartaruga si sposta su un teleporterquadrato è già sul corrispondente teleporter. Non si sposta mai su una teleportere rimane lì per una mossa

• Il percorso più breve non ha bisogno di utilizzare il portale

• La tartaruga non può passare nelle tessere di montagna

• È possibile utilizzare qualsiasi carattere ASCII o un numero intero di rappresentare mountains, turtle, empty grid square,strawberry

• È possibile utilizzare lo stesso carattere o due diversi caratteri ASCII o numeri interi per rappresentare le teleportercoppie

• Una griglia può avere più di un percorso con la stessa lunghezza del percorso più breve

• Questo è code-golf

Chiarimenti alle regole

• Dovresti trattare teleporterssono oggetti monouso.

$$\begin{matrix} 🐢&X&🔵&X&🍓\\ 🌄&🌄&🌄&🌄&🌄&\\ 🔴&X&X&X&X \end{matrix}$$

Potrebbe essere risolto solo entrando ed uscendo dai portali due volte. Al momento di fare questo chiarimento, entrambe le soluzioni hanno agito supponendo che fossero o monouso, oppure non vi era motivo di provare i quadrati precedentemente utilizzati. Per evitare di rompere le loro soluzioni laboriose, questo sembrava il modo migliore per spiegare questa configurazione. Pertanto, questa sarebbe considerata una griglia non valida.

Casi di test formattati come elenchi

[ ['T', 'X', 'X', 'S', 'X'], ['X', 'X', 'X', 'X', 'X'], ['X', 'X', 'X', 'X', 'X'] ] --> 3
[ ['T', 'M', 'X', 'S', 'X'], ['X', 'M', 'X', 'X', 'X'], ['O', 'X', 'X', 'X', 'O'] ] --> 4
[ ['T', 'M', 'X', 'S', 'O'], ['O', 'M', 'X', 'X', 'X'], ['X', 'X', 'X', 'X', 'X'] ] --> 2
[ ['T', 'M', 'X', 'S', 'X'], ['O', 'M', 'X', 'X', 'X'], ['O', 'X', 'X', 'X', 'X'] ] --> 4
[ ['T', 'M', 'S', 'X', 'O'], ['X', 'M', 'M', 'M', 'M'], ['X', 'X', 'X', 'X', 'O'] ] --> 7
[ ['T', 'X', 'X', 'S', 'X'], ['O', 'M', 'M', 'M', 'X'], ['X', 'X', 'O', 'X', 'X'] ] --> 3

Casi di test formattati per l'uomo

T X X S X
X X X X X
X X X X X --> 3

T M X S X
X M X X X
O X X X O --> 4

T M X S O
O M X X X
X X X X X --> 2

T M X S X
O M X X X
O X X X X --> 4

T M S X O
X M M M M
X X X X O --> 7

T X X S X
O M M M X
X X O X X --> 3

Crediti

Design e struttura tramite: Mouse affamato di Arnauld

Sfide proposte Modifica consiglio: Kamil-drakari , carne di manzo

Consigli generali per la modifica: okx nedla2004 mbomb007

JavaScript (ES7),  140 139  138 byte

Prende l'input come una matrice di numeri interi con la seguente mappatura:

• $-1$ = 🔵 (qualsiasi portale)
• $0$ = $X$ (vuoto)
• $1$ = 🌄 (montagna)
• $2$ = 🐢 (tartaruga)
• $3$ = 🍓 (fragola)

m=>(R=g=(t,X,Y,i)=>m.map((r,y)=>r.map((v,x)=>r[(u=0,t?v-t:(x-X)**2+(y-Y)**2<3?v-3?~v?v:u--:R=R<i?R:i:1)||g(u,x,y,u-~i,r[x]=1),x]=v)))(2)|R

Provalo online!

Come?

La principale funzione di ricerca ricorsiva $g$ è in grado di cercare una tessera specifica $t$ alla lavagna (se chiamato con $t\ne 0$) o per qualsiasi tessera a $(x,y)$ che può essere raggiunto dalla posizione corrente $(X,Y)$.

Tiene traccia della lunghezza del percorso corrente in $i$ e aggiorna il risultato migliore $R$ a $\min(R,i)$ ogni volta che la tartaruga trova la fragola.

Viene prima chiamato con $t=2$ per trovare la posizione iniziale della tartaruga.

Si chiama con $t=-1$se viene raggiunto un portale, in modo tale che la tartaruga venga teletrasportata sull'altro portale. Non incrementiamo$i$ durante tale iterazione.

Ogni tessera visitata viene temporaneamente impostata su una montagna per impedire alla tartaruga di spostarsi due volte sulla stessa tessera nello stesso percorso. Se rimaniamo intrappolati in un vicolo cieco, la ricorsione si ferma semplicemente senza aggiornamento$R$.

Commentate

m => (                        // m[] = input matrix
  R =                         // initialize R to a non-numeric value
  g = (t, X, Y, i) =>         // g = recursive search function taking t = expected tile,
                              //     (X, Y) = current coordinates, i = path length
    m.map((r, y) =>           // for each row r[] at position y in m[]:
      r.map((v, x) =>         //   for each tile v at position x in r[]:
        r[                    //     this statement will eventually restore r[x] to v
          ( u = 0,            //     u = next tile to look for, or 0 if none
            t ?               //     if we're looking for a specific tile:
              v - t           //       test whether we've found it
            :                 //     else:
              (x - X) ** 2 +  //       compute the squared Euclidean distance between
              (y - Y) ** 2    //       (x, y) and (X, Y)
              < 3 ?           //       if it's less than 3 (i.e. reachable from (X, Y)):
                v - 3 ?       //         if v is not equal to 3:
                  ~v ?        //           if v is not equal to -1:
                    v         //             test if v = 0
                  :           //           else (v = -1):
                    u--       //             set u = -1 to find the other portal
                :             //         else (v = 3):
                  R = R < i ? //           we've found the strawberry: set R = min(R, i)
                      R : i   //
              :               //       else (this tile can't be reached):
                1             //         yield 1
          ) ||                //     if the above result is falsy:
          g(                  //       do a recursive call:
            u,                //         t = u
            x, y,             //         move to (x, y)
            u - ~i,           //         unless u is set to -1, increment i
            r[x] = 1          //         set this tile to a mountain
          ),                  //       end of recursive call
          x                   //     restore r[x] ...
        ] = v                 //     ... to v
    ))                        // end of both map() loops
)(2) | R                      // initial call to g with t = 2; return R

Python 2 , 441 431 341 byte

from itertools import*
G=input()
W=len(G[0])
H=len(G)
A=[0]*5
E=enumerate
for y,r in E(G):
 for x,C in E(r):A[C]=[x,y]
for L in count():
 for M in product(*[zip('UDLR'*2,'LRDU    ')]*L):
  x,y=A[0]
  for m in M:
    x+='R'in m;x-='L'in m;y+='D'in m;y-='U'in m
    if(x,y)==A[3]:x,y=A[2]
    if 1-(W>x>-1<y<H)or G[y][x]>3:break
  if[x,y]==A[1]:exit(L)

Provalo online!

Immettere come elenchi, ma utilizzando numeri anziché caratteri (grazie a Quintec) e un valore separato per la destinazione del teletrasporto. Tali rientri di grandi dimensioni dovrebbero essere caratteri di tabulazione se Stack Exchange li rimuove. Eventuali suggerimenti o idee sono particolarmente apprezzati, poiché ritengo che questo potrebbe essere molto più breve.

La tabella dei personaggi usati nella sfida ai numeri usati per il mio programma è sotto, ma puoi anche usare questo programma .

Challenge | My program
T         | 0
S         | 1
E         | 2
O         | 3
M         | 4
X         | -1

-10 byte grazie a Quintec modificando l'input dall'uso dei caratteri ai numeri.

-Un sacco di byte grazie a Jonathan Frech, ElPedro e Jonathan Allan.

Python 2 , 391 397 403 422 byte

M=input()
from networkx import*
a=b=c=d=0
N,h,w,S=[-1,0,1],len(M),len(M[0]),[]
for i in range(h):
 for j in range(w):
  I,m=(i,j),M[i][j]
  if m>7:c,d=a,b;a,b=I
  if m<0:Z=I
  if m==5:F=I
  S+=[I+I]
S+=[(a,b,c,d),(c,d,a,b)]
print len(shortest_path(from_edgelist([((A+p,B+q),(C,D))for A,B,C,D in S for p,q in[(p,q)for p in N for q in N]if-1<A+p<h and-1<B+q<w and M[C][D]*M[A+p][B+q]]),Z,F))-1

Provalo online!

Il problema è tradotto in un grafico e la soluzione è trovare il percorso più breve dalla tartaruga alla fragola.

Challenge | This code
T         | -1
S         |  5
O         |  8
M         |  0
X         |  1