Ayúdame a jugo de aguacate

En este desafío, tengo un campo de aguacates que me gustaría jugo lo más rápido y completo posible. ¿Puedes escribir un programa o función que me ayude a resolver cómo exprimir a la perfección todos los aguacates?

Como entrada, obtendrá los aguacates como una cuadrícula mx mcuadrada, donde mhay un número entero entre 3 y 6. Cada cuadrado contiene exactamente un aguacate. Los aguacates tienen varias etapas de jugosidad:

Etapa 1: El aguacate no ha sido exprimido en absoluto.
Etapa 2: el aguacate ha sido parcialmente exprimido.
Etapa 3: El aguacate ha sido completamente exprimido.
Etapa 4: El aguacate ha explotado debido al exceso de jugo.

Cuando usas una herramienta de extracción de jugo, los aguacates en el área de efecto de esa herramienta pasan a la siguiente etapa. La explosión de los aguacates tiene mucha fuerza y destruirá todo el campo de aguacate, ¡así que asegúrese de que ninguno de los aguacates explote!

Aquí hay un ejemplo de una cuadrícula de aguacates. En estos ejemplos, he usado la coordenada 0,0para la esquina inferior izquierda y la coordenada 2,2para la esquina superior derecha, aunque puede ajustar el sistema de coordenadas para adaptarlo a su idioma.

112
221
231

El objetivo es hacer que todos los aguacates estén perfectamente exprimidos (es decir, la etapa 3). Para lograr esto, tiene tres herramientas de jugo diferentes en su poder. Cada herramienta de jugo tiene un área de efecto diferente, pero todos aumentan la jugosidad de los aguacates afectados en 1.

Aquí están todas las herramientas que tiene a su disposición. Utiliza los exprimidores especificando la primera letra de la herramienta, luego las coordenadas que deseas exprimir. Por ejemplo, para usar el Slicer en cuadrado 5,2, debería generar S 5,2.

Rebanadora : Exprime la coordenada objetivo y el aguacate a cada lado.

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

Rallador : Exprime la coordenada objetivo y el aguacate arriba y abajo.

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

Lanzacohetes : Exprime la coordenada objetivo y todos los aguacates adyacentes.

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

Entradas y salidas de muestra

code-golf

— Ajenjo
fuente

No parece decir esto explícitamente, pero ¿la solución tiene que tomar definitivamente la menor cantidad de movimientos?

— FryAmTheEggman

Esto ha ignorado algunos comentarios constructivos del sandbox. Aquí hay uno: supongo que debe permitir al usuario elegir con flexibilidad su sistema de coordenadas (por ejemplo, dónde está el origen, indexado en 0 o indexado en 1).

— Greg Martin

@Pavel muchas gracias por no publicar eso como una respuesta o una pregunta.

— NoOneIsHere

Vi esta pregunta y estaba listo para votar, VTC y marcar como spam. En cambio, +1.

— NoOneIsHere

@Pavel Estaba tan tentado de hacer que el título ...

— ajenjo

Mathematica - 350 bytes

No es una solución muy corta, pero mejor que ninguna solución, ¿verdad?

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 versión más legible (con espacios y sangrías adicionales y demás):

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

La entrada es una matriz (p {{3,2,3},{2,2,2},{3,2,3}}. Ej. ), La salida es una cadena (con una nueva línea final; si esto es inaceptable, encierre la función StringDrop[...,-1]por 15 bytes adicionales). Usé el sistema de coordenadas que dice (1,1) es la esquina superior izquierda, (n, n) es la esquina inferior derecha (donde n es la dimensión de la matriz). A veces, si la solución requiere hacer la misma operación varias veces, la salida incluye cosas como 3 G 2,2(para "usar el rallador en (2,2) tres veces"), ya que no dijiste qué hacer en este caso, espero está bien.

Explicación:

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 una matriz con las variables G [i, j] en cada lugar afectado al usar el rallador en (i, j), y de manera similar para S [i, j] y R [i, j]. Estas variables representan el número de veces que se usa la herramienta en esa posición.
.../.(G|S|R)[___,0|n+1,___]->0 elimina los efectos del uso de herramientas en posiciones fuera del campo de aguacate.
...==3-# compara esto con la diferencia entre la entrada y un campo de aguacates con jugo perfecto.
...&&And@@t[#[i,j]>=0&]dice que las variables G [i, j], S [i, j], R [i, j] no deben ser negativas (¡no se puede quitar el jugo de los aguacates!), usando la taquigrafía t[x_]:=Flatten@Table[x/@{G,S,R},{i,n},{j,n}].
First@Solve[...,t[#[i,j]&],Integers] encuentra la primera solución entera a nuestras ecuaciones en términos de las variables G [i, j], S [i, j], R [i, j].
/.{(x_->m_):>ToString[m x]} oculta las variables que son iguales a cero, al tiempo que pone la solución en una buena forma de cadena.
StringReplace[...,{"["->" ","]"->"\n",", "->","}]convierte cadenas similares "2 G[1, 4]"en cadenas similares "2 G 1,4"y agrega una nueva línea al final.
""<>Cases[...,Except@"0"]elimina todas las sobras "0"y une todas las cadenas juntas.

— No un arbol
fuente