Ajude-me a suco meus abacates

Neste desafio, tenho um campo de abacates que gostaria de suco o mais rápido e completamente possível. Você pode escrever um programa ou função para me ajudar a descobrir como suco de todos os abacates perfeitamente?

Como entrada, você obterá os abacates como uma grade quadrada mx m, onde mé um número inteiro entre 3 e 6. Cada quadrado contém exatamente um abacate. Abacates têm vários estágios de suculência:

Fase 1: O abacate não foi espremido.
Etapa 2: O abacate foi parcialmente espremido.
Etapa 3: O abacate foi completamente espremido.
Etapa 4: O abacate explodiu devido ao excesso de sucos.

Quando você usa uma ferramenta de sumo, os abacates na área de efeito dessa ferramenta de sumo passam para o próximo estágio. Abacates explosivos têm muita força e destruirão todo o campo de abacate, portanto, certifique-se de que nenhum deles apodreça!

Aqui está um exemplo de uma grade de abacates. Nestes exemplos, usei a coordenada 0,0para o canto inferior esquerdo e a coordenada 2,2para o canto superior direito, embora você possa ajustar o sistema de coordenadas para se adequar ao seu idioma.

112
221
231

O objetivo é fazer todos os abacates perfeitamente sumos (ou seja, estágio 3). Para conseguir isso, você tem três ferramentas diferentes de sucos em sua posse. Cada ferramenta de sucos tem uma área de efeito diferente, mas todas aumentam a suculência dos abacates afetados em 1.

Aqui estão todas as ferramentas que você tem à sua disposição. Você usa os espremedores especificando a primeira letra da ferramenta e as coordenadas que deseja sumarizar. Por exemplo, para usar o Slicer no quadrado 5,2, você produziria S 5,2.

Slicer : Sucos da coordenada alvo e abacate de cada lado.

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

Ralador : Sucos da coordenada alvo e abacate acima e abaixo.

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

Lançador de foguetes : Sucos da coordenada alvo e todos os abacates adjacentes.

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

Amostras de entradas e saídas

code-golf absinto
fonte

Você não parece dizer isso explicitamente, mas a solução precisa definitivamente fazer o menor número possível de movimentos?

FryAmTheEggman

Isso ignorou alguns comentários construtivos da sandbox. Aqui está um: suponho que você deva permitir que o usuário escolha com flexibilidade seu sistema de coordenadas (por exemplo, onde a origem é, indexada 0 ou indexada 1).

Greg Martin

@Pavel muito obrigado por não postar isso como uma resposta ou uma pergunta.

precisa saber é o seguinte

Vi essa pergunta e estava pronto para fazer um voto negativo, VTC e sinalizar como spam. Em vez disso, +1.

NoOneIsHere

@Pavel eu estava tão tentado a fazer que o título ...

o absinto

Respostas:

Mathematica - 350 bytes

Não é uma solução muito curta, mas é melhor do que nenhuma solução, certo?

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

Uma versão mais legível (com espaços extras, travessões e outras coisas):

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

Input é uma matriz (por exemplo {{3,2,3},{2,2,2},{3,2,3}}), output é uma string (com uma nova linha à direita - se isso for inaceitável, coloque a função StringDrop[...,-1]por mais 15 bytes). Eu usei o sistema de coordenadas que diz (1,1) é o canto superior esquerdo, (n, n) é o canto inferior direito (onde n é a dimensão da matriz). Às vezes, se a solução exigir a mesma operação várias vezes, a saída incluirá coisas como 3 G 2,2(para "usar o ralador em (2,2) três vezes") - já que você não disse o que fazer nesse caso, espero isso está ok.

Explicação:

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}]cria uma matriz com as variáveis G [i, j] em cada local afetado usando o ralador em (i, j) e da mesma forma para S [i, j] e R [i, j]. Essas variáveis representam o número de vezes que a ferramenta é usada nessa posição.
.../.(G|S|R)[___,0|n+1,___]->0 remove os efeitos do uso de ferramentas em posições fora do campo de abacate.
...==3-# compara isso com a diferença entre a entrada e um campo de abacates perfeitamente suculentos.
...&&And@@t[#[i,j]>=0&]diz que as variáveis G [i, j], S [i, j], R [i, j] devem ser não-negativas (você não pode desfazer o abacate!), usando a abreviação t[x_]:=Flatten@Table[x/@{G,S,R},{i,n},{j,n}].
First@Solve[...,t[#[i,j]&],Integers] encontra a primeira solução inteira para nossas equações em termos das variáveis G [i, j], S [i, j], R [i, j].
/.{(x_->m_):>ToString[m x]} oculta as variáveis iguais a zero, enquanto também coloca a solução em uma boa forma de string.
StringReplace[...,{"["->" ","]"->"\n",", "->","}]transforma seqüências de caracteres como "2 G[1, 4]"em seqüências de caracteres "2 G 1,4"e adiciona uma nova linha no final.
""<>Cases[...,Except@"0"]remove todas as sobras "0"e junta todas as cordas.

Não é uma árvore
fonte