Sono un grande fan del gioco Creeper World, e in particolare del sequel. Non è necessario sapere come funziona questo gioco per rispondere alla domanda, volevo solo menzionare l'origine della mia domanda.

Nel gioco, il tuo obiettivo è quello di distruggere gli Emettitori che generano Creeper, usando un'arma nota come nullificatore.

I nullifieri possono distruggere qualsiasi emettitore in questo raggio:

 eee
eeeee
eenee
eeeee
 eee

Ogni nullificatore può indirizzare più emettitori.

Il tuo obiettivo

Dato un array che simula una mappa 2D composta da nulla ed emettitori con qualunque carattere ti piaccia, potrebbero essere spazi ed e o numeri - assicurati solo che siano distinguibili, emetti la stessa mappa con la quantità ottimale di nullifiers n (o cosa vorresti ), in modo che gli emettitori vengano distrutti con il minor numero di nullifiers.

Se ci sono diversi modi ottimali per farlo, solo uscirne uno andrebbe bene. Se, tuttavia, l'attività non è risolvibile, supponiamo che ci siano così tanti emettitori che nessun layout potrà mai colpirli tutti, è necessario produrre qualcosa di decisamente diverso, nulla sarà sufficiente

Regole rapide:

• Input: matrice multidimensionale
• L'input conterrà due caratteri, che significa nulla ed emettitore , includendo ciò che è che cosa nella tua risposta
• Output: matrice multidimensionale
• L'output conterrà tre caratteri, che significa nulla , emettitore e nullificatore O un output distinguibile se l'input è irrisolvibile
• Puoi sostituire il carattere Nothing solo con un annullatore
• Un nullificatore può colpire più emettitori e colpirà sempre tutti quelli che si trovano nel raggio d'azione
• Un nullificatore può colpire nell'area sopra specificata e colpirà sempre tutti gli emettitori che può colpire
• Le risposte più brevi in ​​byte vincono
• scappatoie standard vietate

Esempi

Ingresso:

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

Produzione:

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

Ingresso:

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

Produzione:

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

Ingresso:

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

Output (questo output è fatto a mano e potrebbe non essere l'output ottimale):

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

Ingresso:

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

Produzione:

null

Python 3 , 558 511 509 byte

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

Provalo online!

È molto complicato, ma non so abbastanza su Python per ottimizzarlo ulteriormente. Ho imparato alcune cose dalla risposta di Ovs, quindi è stato divertente.

L'ingresso (modificato per facilitare la scrittura dei casi di test ) prevede '' o 'e', ​​mentre l'output utilizza '', 'n' per nullificatore e 'x' per un emettitore annullato. La funzione accetta l'input previsto descritto nella domanda.

Ho impostato le variabili e, w, n e d all'esterno perché potrebbero essere facilmente sostituite con numeri e, se l'input e l'output fossero modificati per utilizzare anche i numeri, verrebbero stampati la stessa cosa. Ho usato le lettere perché le hanno rese più leggibili mentre ci lavoravamo.

Domanda divertente, OP! Creeper World è fantastico ed è stata una bella fonte d'ispirazione per la domanda :)

Modifica: -47 byte grazie a Erik the Outgolfer

Python 2 , 267 263 byte

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)

Provalo online!

0per emettitore, 2per annullatore e 1per spazio vuoto.

Wolfram Language (Mathematica) , 173 168 byte

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

Provalo online!

Risolve il più grande caso di test in 1 secondo .

Programma completo. Come funzione, è più breve, solo 130 byte .

Utilizzare 0per  , 1per ne 2per e.

Questo programma può essere utilizzato per convertire dal formato di input nella sfida.

Se non ci sono soluzioni che stamperà il messaggio di errore lpdimcome questo , o lpsnfcome questo .

La versione che utilizza Outer(sebbene più leggibile) è più lunga di 2 byte, nonostante il nome breve di Outer: Provalo online!

Spiegazione.

Si noti che ciò può essere ridotto a un problema di programmazione lineare intera.

Ogni ecella è fissata a 2, ogni cella vuota è una variabile intera, che può essere 0(vuota) o 1(annullatore). L'elenco delle coordinate delle variabili sono archiviate in variabili p. (la Positions in tquella è 0)

L'obiettivo è ridurre al minimo il numero di annullatori utilizzati, pertanto è necessario ridurre al minimo la somma di tali variabili intere. ( 1&/@p, un vettore è composto da tutto 1e con lunghezza uguale alla plunghezza di, indica la funzione obiettivo)

2q$\sqrt 6$

Questo è formulato con la matrice m= (xBoole[Norm[x-#]^2<6]&/@p)/@q(per ogni elemento in q, crea una riga con gli elementi 1se la distanza al quadrato ( Norm) alla coordinata corrispondente in pè minore di 6) e il vettore b= 1&/@q.

Dopodiché ReplaceParte Thread"applica" i valori delle variabili te stamparli.