Soy un gran fanático del juego Creeper World, y especialmente la secuela. No necesitas saber cómo funciona este juego para responder la pregunta, solo quería mencionar de dónde se originó mi pregunta.

En el juego, tu objetivo es destruir los Emisores que están engendrando Creeper, usando un arma conocida como anuladora.

Los anuladores pueden destruir cualquier emisor en este radio:

 eee
eeeee
eenee
eeeee
 eee

Cada anulador PUEDE apuntar a múltiples Emisores.

Su objetivo

Dado un conjunto que simula un mapa 2D que consta de nada y emisores con los caracteres que desee, podrían ser espacios y e o números; solo asegúrese de que sean distinguibles, genere el mismo mapa con la cantidad óptima de anuladores n (o lo que desea ) colocado, de modo que los emisores se destruyan con la menor cantidad de anuladores.

Si hay varias formas óptimas de hacerlo, simplemente generar una estaría bien. Sin embargo, si la tarea no se puede resolver, digamos que hay tantos emisores que ningún diseño los alcanzará a todos, debe generar algo diferente, suficiente será nulo

Reglas rápidas:

• Entrada: matriz multidimensional
• La entrada contendrá dos caracteres, es decir, nada y emisor , incluye qué es qué en tu respuesta
• Salida: matriz multidimensional
• La salida contendrá tres caracteres, es decir, nada , emisor y anulador O una salida distinguible si la entrada no tiene solución
• Solo puede reemplazar el carácter de nada con un anulador
• Un anulador puede golpear a múltiples emisores, y siempre golpeará a todos los que estén dentro del rango
• Un anulador puede golpear en el área especificada anteriormente, y siempre golpeará a todos los emisores a los que pueda apuntar
• Las respuestas más cortas en bytes ganan
• lagunas estándar prohibidas

Ejemplos

Entrada:

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

Salida:

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

Entrada:

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

Salida:

[[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, ]]

Salida (esta salida está hecha a mano, y podría no ser la salida óptima):

[[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]]

Salida:

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))

Pruébalo en línea!

Es muy complicado, pero no sé lo suficiente sobre Python para optimizarlo aún más. Aprendí algunas cosas de la respuesta de Ovs, así que fue divertido.

La entrada (modificada para facilitar la escritura de casos de prueba ) espera '' o 'e', ​​mientras que la salida usa '', 'n' para el anulador y 'x' para un emisor anulado. La función toma la entrada esperada que se describió en la pregunta.

Establecí las variables e, w, ny d afuera porque podrían reemplazarse fácilmente con números y, si la entrada y la salida se modificaran para usar números también, imprimiría lo mismo. Usé letras porque lo hicieron más legible mientras trabajaba en él.

¡Pregunta divertida, OP! Creeper World es genial y fue una gran inspiración para la pregunta :)

Editar: -47 bytes gracias a Erik the 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)

Pruébalo en línea!

0para emisor, 2para anulador y 1para espacio vacío.

Wolfram Language (Mathematica) , 173168 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]]]

Pruébalo en línea!

Resuelve el caso de prueba más grande en 1 segundo .

Programa completo Como función, es más corto, solo 130 bytes .

Use 0para  , 1para ny 2para e.

Este programa se puede usar para convertir desde el formato de entrada en el desafío.

Si no hay solución, imprimirá un mensaje de error lpdimcomo este o lpsnfcomo este .

La versión que usa Outer(aunque más legible) es 2 bytes más larga, a pesar del nombre corto de Outer: ¡ Pruébelo en línea!

Explicación.

Tenga en cuenta que esto puede reducirse a un problema de programación lineal de enteros.

Cada ecelda se fija en 2, cada celda vacía es una variable entera, que puede ser 0(vacía) o 1(anuladora). La lista de coordenadas de variables se almacena en variable p. (la Positions en tque está 0)

El objetivo es minimizar el número de anuladores utilizados, por lo que la suma de esas variables enteras debe minimizarse. ( 1&/@p, un vector consiste en todos 1y con una longitud igual a pla longitud, indica la función objetivo)

2q$\sqrt 6$

Esto se formula con la matriz m= (xBoole[Norm[x-#]^2<6]&/@p)/@q(para cada elemento en q, cree una fila con elementos 1si la distancia al cuadrado ( Norm) a la coordenada correspondiente pes menor que 6) y el vector b= 1&/@q.

Después de eso ReplaceParty Thread"aplica" los valores de las variables te imprímelo.