Questo post è liberamente ispirato a questo post di mathoverflow .

Un Vanisher è uno schema nel gioco della vita di Conway che scompare completamente dopo un passo. Ad esempio, il modello seguente è un Vanisher taglia 9.

Una proprietà interessante di Vanishers è che qualsiasi modello può essere trasformato in uno che scompare semplicemente aggiungendo più cellule vive. Ad esempio, il modello seguente può essere completamente racchiuso in un modello che scompare in questo modo

Tuttavia, possiamo trasformare quel modello in un Vanisher aggiungendo ancora meno celle vive.

Il tuo compito è quello di scrivere un programma che fa questo compito per noi. A questo viene dato un modello come input trova ed emette un pattern evanescente contenente l'input. Non è necessario trovare il modello ottimale solo un modello che funziona.

punteggio

Per assegnare un punteggio al tuo programma dovrai eseguirlo su tutti i poliplet di dimensione 6 (non doppio conteggio di casi simmetrici equivalenti). Ecco un pastebin contenente ogni poliplet sulla propria riga. Dovrebbero essere 524 in totale. Sono rappresentati come un elenco di sei coordinate ( (x,y)tuple), ciascuna delle quali rappresenta la posizione di una cella viva.

Il tuo punteggio sarà il numero totale di nuove celle aggiunte per trasformare tutti questi polipi in Vanishers.

Cravatte

Nel caso di legami fornirò un elenco dei poliplet di dimensione 7 per i programmi su cui eseguire.

IO

Vorrei che IO fosse abbastanza flessibile, puoi prendere input e output in formati ragionevoli, ma probabilmente vorrai prendere input nello stesso formato dei dati di input grezzi che ho fornito. Il formato deve essere coerente su più corse.

sincronizzazione

Il programma dovrebbe essere eseguito in un periodo di tempo ragionevole (circa <1 giorno) su una macchina ragionevole. Non lo farò davvero troppo, ma preferirei che suonassimo tutti bene.

Python + Z3 , punteggio = 3647

Funziona in 14 secondi sul mio sistema a otto core.

from __future__ import print_function

import ast
import multiprocessing
import sys
import z3

def solve(line):
    line = ast.literal_eval(line)
    x0, x1 = min(x for x, y in line) - 2, max(x for x, y in line) + 3
    y0, y1 = min(y for x, y in line) - 2, max(y for x, y in line) + 3
    a = {(x, y): z3.Bool('a_{}_{}'.format(x, y)) for x in range(x0, x1) for y in range(y0, y1)}
    o = z3.Optimize()
    for x in range(x0 - 1, x1 + 1):
        for y in range(y0 - 1, y1 + 1):
            s = z3.Sum([
                z3.If(a[i, j], 1 + ((i, j) != (x, y)), 0)
                for i in (x - 1, x, x + 1) for j in (y - 1, y, y + 1) if (i, j) in a
            ])
            o.add(z3.Or(s < 5, s > 7))
    o.add(*(a[i, j] for i, j in line))
    o.minimize(z3.Sum([z3.If(b, 1, 0) for b in a.values()]))
    assert o.check() == z3.sat
    m = o.model()
    return line, {k for k in a if z3.is_true(m[a[k]])}

total = 0
for line, cells in multiprocessing.Pool().map(solve, sys.stdin):
    added = len(cells) - len(line)
    print(line, added)
    x0, x1 = min(x for x, y in cells), max(x for x, y in cells) + 1
    y0, y1 = min(y for x, y in cells), max(y for x, y in cells) + 1
    for y in range(y0, y1):
        print(''.join('#' if (x, y) in line else '+' if (x, y) in cells else ' ' for x in range(x0, x1)))
    total += added
print('Total:', total)

Uscita completa