Sou um grande fã do jogo Creeper World, e principalmente da sequela. Você não precisa saber como esse jogo funciona para responder à pergunta. Eu só queria mencionar de onde minha pergunta se originou.

No jogo, seu objetivo é destruir os Emissores que estão gerando o Creeper, usando uma arma conhecida como anuladora.

Os anuladores podem destruir qualquer emissor neste raio:

 eee
eeeee
eenee
eeeee
 eee

Cada anulador PODE direcionar vários Emissores.

Seu objetivo

Dado que uma matriz que simula um mapa 2D que consiste em nada e emissores com os caracteres que você quiser, pode ser espaços e e ou números - apenas certifique-se de que sejam distinguíveis, produza o mesmo mapa com a quantidade ideal de nulificadores n (ou o que você gostaria ) colocados, para que os emissores sejam destruídos com a menor quantidade de anuladores.

Se houver várias maneiras ótimas de fazê-lo, apenas a saída de uma seria boa. Se, no entanto, a tarefa não for solucionável, digamos que haja tantos emissores que nenhum layout atinja todos eles, você deve gerar algo distintamente diferente; nulo será suficiente

Regras rápidas:

• Entrada: matriz multidimensional
• A entrada conterá dois caracteres, significando nada e emissor , inclua o que é o que está na sua resposta
• Saída: matriz multidimensional
• A saída conterá três caracteres, significando nada , emissor e anulador OU uma saída distinguível se a entrada for insolúvel
• Você só pode substituir o caractere nada por um nulo
• Um nulo pode atingir vários emissores e sempre atingirá todos os que estiverem dentro do alcance
• Um nulo pode atingir a área especificada acima e sempre atingirá todos os emissores que pode atingir
• As respostas mais curtas em bytes ganham
• brechas padrão proibidas

Exemplos

Entrada:

[[ , ,e, , ],
 [ , , , , ],
 [e, , , ,e],
 [ , , , , ],
 [ , ,e, , ]]

Resultado:

 [[ , ,e, , ],
  [ , , , , ],
  [e, ,n, ,e],
  [ , , , , ],
  [ , ,e, , ]]

Entrada:

[[e,e,e,e,e],
 [e, , , ,e],
 [e, , , ,e],
 [e, , , ,e],
 [e,e,e,e,e]]

Resultado:

[[e,e,e,e,e],
 [e, ,n, ,e],
 [e, , , ,e],
 [e, ,n, ,e],
 [e,e,e,e,e]]

Entrada:

[[e, , , , , , ,e, ,e, , , ,e, ,e, ,e, ,e],
 [ , ,e, , ,e, , , ,e,e, , , , ,e, , , , ],
 [ , ,e, , , ,e, ,e, ,e, ,e, ,e, ,e, , , ],
 [e, , , ,e, ,e, , , , , , , , , , , ,e, ],
 [e, , ,e, , , , , ,e, ,e, ,e, ,e, , , ,e],
 [ , , ,e, ,e, ,e, , , , , , , , , ,e, , ],
 [ ,e,e, ,e, , , ,e, ,e,e, ,e, ,e, ,e, , ],
 [ , ,e, , , ,e, , , , , , , , ,e,e, ,e, ],
 [ , , ,e, , , , ,e,e, , , , , , , , ,e, ],
 [e, , , , , , ,e, , , ,e,e, ,e, , , , , ],
 [ ,e,e, , ,e, , , , ,e, , , , , , ,e, , ],
 [ , , ,e,e, ,e, ,e, , , ,e,e, ,e, ,e, ,e],
 [e,e, , , , ,e, , , ,e, , , , , , , , , ],
 [ , , ,e, , , , , ,e, , ,e, ,e, ,e, ,e, ],
 [ , , , ,e, ,e, , , , , , , , , , , , , ],
 [e,e, , ,e,e, , ,e, , ,e, ,e, ,e, ,e, ,e],
 [e, ,e, ,e, , ,e,e,e, , ,e, , , ,e, , ,e],
 [ , , , ,e, , , , , ,e, , , ,e, , , , , ],
 [ , ,e, , , ,e, ,e, , , ,e, , , , ,e, , ],
 [ , , ,e, ,e, ,e, , ,e,e, , ,e,e, , ,e, ]]

Saída (esta saída é feita à mão e pode não ser a saída ideal):

[[e, , , , , , ,e, ,e, , , ,e, ,e, ,e, ,e],
 [ , ,e, , ,e, , ,n,e,e, , , ,n,e, , , , ],
 [ ,n,e, , ,n,e, ,e, ,e, ,e, ,e, ,e, ,n, ],
 [e, , , ,e, ,e, , , , , , , , , , , ,e, ],
 [e, , ,e, , , , , ,e, ,e, ,e, ,e, , , ,e],
 [ , ,n,e, ,e, ,e, , , ,n, , , , , ,e, , ],
 [ ,e,e, ,e, ,n, ,e, ,e,e, ,e, ,e,n,e, , ],
 [ , ,e, , , ,e, , , , , , , , ,e,e, ,e, ],
 [ , , ,e, , , , ,e,e, , , , , , , , ,e, ],
 [e, ,n, , , , ,e, , , ,e,e, ,e, , , , , ],
 [ ,e,e, , ,e,n, , ,n,e, , , ,n, , ,e,e, ],
 [ , , ,e,e, ,e, ,e, , , ,e,e, ,e, ,e, ,e],
 [e,e, , , , ,e, , , ,e, , , , , , , , , ],
 [ , , ,e, ,n, , , ,e, , ,e, ,e, ,e, ,e, ],
 [ ,n, , ,e, ,e, , , , , , , ,n, , , ,n, ],
 [e,e, , ,e,e, , ,e,n, ,e, ,e, ,e, ,e, ,e],
 [e, ,e, ,e, , ,e,e,e, , ,e, , , ,e, , ,e],
 [ , , , ,e, , , , , ,e, ,n, ,e, , ,n, , ],
 [ , ,e, ,n, ,e, ,e, , , ,e, ,n, , ,e, , ],
 [ , , ,e, ,e, ,e, ,n,e,e, , ,e,e, , ,e, ]]

Entrada:

[[e,e],
 [e,e]]

Resultado:

null

Python 3 , 558 511 509 bytes

from itertools import*
E=enumerate
L=len
def s(s):
 q=[(x,y)for y,r in E(s)for x,k in E(r)if k==w]
 for i in range(1,L(q)):
  for c in combinations(q,i):
   m=[l*1for l in s]
   for p in c:
    m[p[1]][p[0]]=n
    for y,r in E([list(r) for r in' xxx ,xxxxx,xxnxx,xxxxx, xxx '.split(',')]):
     for x,k in E(r):
      o=(p[0]-x+2,p[1]-y+2)
      if k==d and-1<o[0]<L(m[0])and-1<o[1]<L(m)and m[o[1]][o[0]]==e:
       m[p[1]-y+2][p[0]-x+2]=d
   if e not in ','.join([''.join(r)for r in m]):return(m)
print(s(m))

Experimente online!

É muito maluco, mas não sei o suficiente sobre o Python para otimizá-lo ainda mais. Eu aprendi algumas coisas com a resposta da ovs, então isso foi divertido.

A entrada (modificada para facilitar a gravação de casos de teste ) espera '' ou 'e', ​​enquanto a saída usa '', 'n' para o nulo e 'x' para um emissor nulo. A função aceita a entrada esperada que foi descrita na pergunta.

Defino as variáveis ​​e, w, ne de fora, porque elas poderiam ser facilmente substituídas por números e, se a entrada e a saída fossem modificadas para usar números também, seria impressa a mesma coisa. Eu usei letras porque elas tornaram mais legível enquanto trabalhava nela.

Pergunta divertida, OP! O Creeper World é ótimo e foi uma inspiração legal para a pergunta :)

Edit: -47 bytes graças a Erik, o Outgolfer

Python 2 , 267 263 bytes

from itertools import*
m=input()
E=enumerate
e=[(x,y)for y,a in E(m)for x,e in E(a)if e]
for n in count():
 for p in combinations(e,n):
	k=[l*1for l in m]
	for x,y in p:k[y][x]=2
	all(e+any(8>(y-Y)**2+(x-X)**2for X,Y in p)for y,a in E(m)for x,e in E(a))>0>exit(k)

Experimente online!

0para emissor, 2para nullifier e 1para espaço vazio.

Wolfram Language (Mathematica) , 173 168 bytes

t=ToExpression@$ScriptInputString
P=Position
p=t~P~0
q=t~P~2
Print@ReplacePart[t,Thread[p->LinearProgramming[1&/@p,(xBoole[Norm[x-#]^2<6]&/@p)/@q,1&/@q,0,Integers]]]

Experimente online!

Resolve o maior caso de teste em 1 segundo .

Programa completo. Como função, é mais curto, apenas 130 bytes .

Use 0para  , 1para ne 2para e.

Este programa pode ser usado para converter do formato de entrada no desafio.

Se não houver nenhuma solução vai imprimir mensagem de erro lpdimcomo este , ou lpsnfcomo este .

A versão que usa Outer(embora seja mais legível) tem mais 2 bytes, apesar do nome abreviado de Outer: Experimente online!

Explicação.

Observe que isso pode ser reduzido a um problema de programação linear inteira.

Cada ecélula é fixada em 2, cada célula vazia é uma variável inteira, que pode ser 0(vazia) ou 1(anuladora). A lista de coordenadas de variáveis são armazenados na variável p. (o Positions em tque é 0)

O objetivo é minimizar o número de nulificador usado, portanto, a soma dessas variáveis ​​inteiras deve ser minimizada. ( 1&/@p, um vetor consiste em todos 1e com comprimento igual ao pcomprimento, indica a função objetivo)

2q$\sqrt 6$

Isso é formulado com a matriz m= (xBoole[Norm[x-#]^2<6]&/@p)/@q(para cada elemento em q, crie uma linha com elementos sendo 1se a distância ao quadrado ( Norm) da coordenada correspondente em pfor menor que 6) e o vetor b= 1&/@q.

Depois disso ReplaceParte Thread"aplica" os valores da variável te a imprime.