Aiutami a spremere i miei avocado

In questa sfida, ho un campo di avocado che vorrei spremere il più rapidamente e completamente possibile. Puoi scrivere un programma o una funzione per aiutarmi a capire come spremere perfettamente tutti gli avocado?

Come input, otterrai gli avocado come una griglia quadrata mx m, dove mc'è un numero intero compreso tra 3 e 6. Ogni quadrato contiene esattamente un avocado. Gli avocado hanno diverse fasi di succosità:

Fase 1: l'avocado non è stato affatto spremuto.
Fase 2: l'avocado è stato parzialmente spremuto.
Fase 3: l'avocado è stato completamente spremuto.
Fase 4: l'avocado è esploso a causa dell'eccesso di succo.

Quando si utilizza uno strumento di spremitura, gli avocado nell'area di effetto dello strumento di spremitura passano alla fase successiva. Gli avocado che esplodono hanno molta forza e distruggeranno l'intero campo di avocado, quindi assicurati che nessuno degli avocado esploda!

Ecco un esempio di una griglia di avocado. In questi esempi, ho usato le coordinate 0,0per l'angolo in basso a sinistra e le coordinate 2,2per l'angolo in alto a destra, sebbene sia possibile regolare il sistema di coordinate in base alla propria lingua.

112
221
231

L'obiettivo è quello di rendere tutti gli avocado perfettamente spremuti (cioè fase 3). Per raggiungere questo obiettivo hai tre diversi strumenti di spremitura in tuo possesso. Ogni strumento di spremitura ha una diversa area di effetto, ma tutti aumentano la succosità degli avocado colpiti di 1.

Ecco tutti gli strumenti che hai a tua disposizione. Si utilizzano gli spremiagrumi specificando la prima lettera dello strumento, quindi le coordinate che si desidera estrarre. Ad esempio, per utilizzare Slicer su square 5,2, si dovrebbe produrre S 5,2.

Affettatrice : succhi la coordinata bersaglio e l'avocado su entrambi i lati.

112     112     112
221 --> XXX --> 332
231     231     231

Grattugia : succhi la coordinata bersaglio e l'avocado sopra e sotto.

112     1X2     122
221 --> 2X1 --> 231 --> kaboom!
231     2X1     241

Lanciarazzi : succhi la coordinata bersaglio e tutti gli avocado adiacenti.

112     1X2     122
221 --> XXX --> 332
221     2X1     231

Ingressi e uscite di esempio

code-golf

— Assenzio
fonte

Non sembra che tu lo dica esplicitamente, ma la soluzione deve assolutamente fare il minor numero di mosse?

— FryAmTheEggman

Ciò ha ignorato alcuni commenti costruttivi dalla sandbox. Eccone uno: suppongo che dovresti consentire all'utente in modo flessibile di scegliere il proprio sistema di coordinate (ad esempio, dove si trova l'origine, 0-indicizzato o 1-indicizzato).

— Greg Martin

@Pavel grazie mille per non averlo pubblicato come risposta o domanda.

— NoOneIsHere

Ho visto questa domanda ed ero pronto a votare, VTC e contrassegnare come spam. Invece +1.

— NoOneIsHere

@Pavel Ero così tentato di fare il titolo ...

— assenzio il

Mathematica - 350 byte

Non è una soluzione molto breve, ma migliore di nessuna soluzione, giusto?

t[x_]:=Flatten@Table[x/@{G,S,R},{i,n},{j,n}];""<>Cases[StringReplace[(First@Solve[(Table[G[i,j]+G[i-1,j]+G[i+1,j]+S[i,j]+S[i,j-1]+S[i,j+1]+R[i,j]+R[i-1,j]+R[i+1,j]+R[i,j-1]+R[i,j+1],{i,n=Length@#},{j,n}]/.(G|S|R)[___,0|n+1,___]->0)==3-#&&And@@t[#[i,j]>=0&],t[#[i,j]&],Integers])/.{(x_->m_):>ToString[m x]},{"["->" ","]"->"\n",", "->","}],Except@"0"]&

Una versione più leggibile (con spazi e rientri extra e altro):

t[x_] := Flatten@Table[x /@ {G, S, R}, {i, n}, {j, n}]; 
"" <> Cases[
   StringReplace[(First@
       Solve[(Table[
             G[i, j] + G[i - 1, j] + G[i + 1, j] + S[i, j] + 
              S[i, j - 1] + S[i, j + 1] + R[i, j] + R[i - 1, j] + 
              R[i + 1, j] + R[i, j - 1] + R[i, j + 1], {i, 
              n = Length@#}, {j, n}] /. (G | S | R)[___, 
              0 | n + 1, ___] -> 0) == 3 - # && 
         And @@ t[#[i, j] >= 0 &], t[#[i, j] &], 
        Integers]) /. {(x_ -> m_) :> ToString[m x]}, {"[" -> " ", 
     "]" -> "\n", ", " -> ","}], Except@"0"] &

L'input è un array (ad es. {{3,2,3},{2,2,2},{3,2,3}}), L'output è una stringa (con una nuova riga finale - se ciò è inaccettabile, racchiudere la funzione StringDrop[...,-1]per altri 15 byte). Ho usato il sistema di coordinate che dice (1,1) è l'angolo in alto a sinistra, (n, n) è in basso a destra (dove n è la dimensione della matrice). A volte, se la soluzione richiede di eseguire la stessa operazione più volte, l'output include cose come 3 G 2,2(per "usare la grattugia a (2,2) tre volte") - dal momento che non hai detto cosa fare in questo caso, spero va bene.

Spiegazione:

Table[G[i,j]+G[i-1,j]+G[i+1,j]+S[i,j]+S[i,j-1]+S[i,j+1]+R[i,j]+R[i-1,j]+R[i+1,j]+R[i,j-1]+R[i,j+1],{i,n=Length@#},{j,n}]crea un array con le variabili G [i, j] in ciascun punto interessato utilizzando la grattugia in (i, j) e in modo simile per S [i, j] e R [i, j]. Queste variabili rappresentano il numero di volte in cui lo strumento viene utilizzato in quella posizione.
.../.(G|S|R)[___,0|n+1,___]->0 rimuove gli effetti dell'uso degli strumenti in posizioni esterne al campo di avocado.
...==3-# confronta questo con la differenza tra l'input e un campo di avocado perfettamente spremuti.
...&&And@@t[#[i,j]>=0&]dice che le variabili G [i, j], S [i, j], R [i, j] devono essere non negative (non è possibile estrarre gli avocado!), usando la scorciatoia t[x_]:=Flatten@Table[x/@{G,S,R},{i,n},{j,n}].
First@Solve[...,t[#[i,j]&],Integers] trova la prima soluzione intera alle nostre equazioni in termini di variabili G [i, j], S [i, j], R [i, j].
/.{(x_->m_):>ToString[m x]} nasconde le variabili che equivalgono a zero, mettendo anche la soluzione in una bella forma di stringa.
StringReplace[...,{"["->" ","]"->"\n",", "->","}]trasforma le stringhe come "2 G[1, 4]"in stringhe simili "2 G 1,4"e aggiunge una nuova riga alla fine.
""<>Cases[...,Except@"0"]rimuove tutte le rimanenti "0"e unisce tutte le stringhe.

— Non un albero
fonte