Aidez-moi à extraire mes avocats

Dans ce défi, j'ai un champ d'avocats que j'aimerais extraire le plus rapidement et complètement possible. Pouvez-vous écrire un programme ou une fonction pour m'aider à comprendre comment extraire parfaitement tous les avocats?

En entrée, vous obtiendrez les avocats sous forme d'une grille carrée mx m, où mest un entier compris entre 3 et 6. Chaque carré contient exactement un avocat. Les avocats ont plusieurs étapes de jutosité:

Étape 1: L'avocat n'a pas du tout été extrait.
Étape 2: L'avocat a été partiellement extrait.
Étape 3: L'avocat a été complètement extrait.
Étape 4: L'avocat a explosé en raison d'un excès de jus.

Lorsque vous utilisez un outil d'extraction de jus, les avocats de la zone d'effet de cet outil d'extraction passent à l'étape suivante. Les avocats qui explosent ont beaucoup de force et détruiront tout le champ de l'avocat, alors assurez-vous qu'aucun des avocats n'explose!

Voici un exemple de grille d'avocats. Dans ces exemples, j'ai utilisé les coordonnées 0,0du coin inférieur gauche et les coordonnées 2,2du coin supérieur droit, bien que vous puissiez ajuster le système de coordonnées en fonction de votre langue.

112
221
231

Le but est de rendre tous les avocats parfaitement jus (ie stade 3). Pour ce faire, vous disposez de trois outils d'extraction différents. Chaque outil d'extraction a une zone d'effet différente, mais ils augmentent tous la jutosité des avocats affectés de 1.

Voici tous les outils dont vous disposez. Vous utilisez les centrifugeuses en spécifiant la première lettre de l'outil, puis les coordonnées que vous souhaitez extraire. Par exemple, pour utiliser le Slicer sur square 5,2, vous devez sortir S 5,2.

Slicer : Jus la coordonnée cible et l'avocat de chaque côté.

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

Râpe : Jus la coordonnée cible et l'avocat au-dessus et en dessous.

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

Rocket Launcher : extrait la coordonnée cible et tous les avocats adjacents.

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

Exemples d'entrées et de sorties

code-golf

— Absinthe
source

Vous ne semblez pas le dire explicitement, mais la solution doit-elle définitivement prendre le moins de coups?

— FryAmTheEggman

Cela a ignoré certains commentaires constructifs du bac à sable. En voici une: je suppose que vous devez autoriser de manière flexible l'utilisateur à choisir son système de coordonnées (par exemple, où se trouve l'origine, indexé 0 ou indexé 1).

— Greg Martin

@ Pavel merci beaucoup de ne pas l'avoir posté comme réponse ou question.

— NoOneIsHere

J'ai vu cette question et j'étais prêt à voter contre, VTC et à signaler comme spam. Au lieu de cela, +1.

— NoOneIsHere

@Pavel J'étais tellement tenté de faire que le titre ...

— absinthe

Mathematica - 350 octets

Pas une solution très courte, mais mieux que pas de solution du tout, non?

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"]&

Une version plus lisible (avec des espaces supplémentaires, des retraits et d'autres choses):

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'entrée est un tableau (par exemple {{3,2,3},{2,2,2},{3,2,3}}), la sortie est une chaîne (avec un retour à la ligne de fin - si cela est inacceptable, entourez la fonction StringDrop[...,-1]pour 15 octets supplémentaires). J'ai utilisé le système de coordonnées qui dit (1,1) est le coin supérieur gauche, (n, n) est le coin inférieur droit (où n est la dimension de la matrice). Parfois, si la solution nécessite de faire plusieurs fois la même opération, la sortie inclut des choses comme 3 G 2,2(pour "utiliser la râpe à (2,2) trois fois") - puisque vous n'avez pas dit quoi faire dans ce cas, j'espère c'est bon.

Explication:

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}]crée un tableau avec les variables G [i, j] à chaque endroit affecté par l'utilisation de la râpe en (i, j), et de même pour S [i, j] et R [i, j]. Ces variables représentent le nombre de fois où l'outil est utilisé à cette position.
.../.(G|S|R)[___,0|n+1,___]->0 supprime les effets de l'utilisation d'outils à des positions en dehors du champ d'avocat.
...==3-# compare cela à la différence entre l'entrée et un champ d'avocats parfaitement jus.
...&&And@@t[#[i,j]>=0&]dit que les variables G [i, j], S [i, j], R [i, j] doivent être non négatives (vous ne pouvez pas extraire les avocats!), en utilisant la sténographie t[x_]:=Flatten@Table[x/@{G,S,R},{i,n},{j,n}].
First@Solve[...,t[#[i,j]&],Integers] trouve la première solution entière de nos équations en termes de variables G [i, j], S [i, j], R [i, j].
/.{(x_->m_):>ToString[m x]} masque les variables égales à zéro, tout en mettant la solution sous une forme de chaîne agréable.
StringReplace[...,{"["->" ","]"->"\n",", "->","}]transforme les chaînes comme "2 G[1, 4]"en chaînes comme "2 G 1,4", et ajoute une nouvelle ligne à la fin.
""<>Cases[...,Except@"0"]supprime tous les restes "0"et joint toutes les chaînes ensemble.

— Pas un arbre
source