Esta postagem é pouco inspirada por esta postagem do mathoverflow .

Um Vanisher é qualquer padrão no jogo da vida de Conway que desaparece completamente após um passo. Por exemplo, o padrão a seguir é um Vanisher tamanho 9.

Uma propriedade interessante dos Vanishers é que qualquer padrão pode ser transformado em desaparecido simplesmente adicionando mais células vivas. Por exemplo, o padrão a seguir pode ser completamente incluído em um padrão de fuga como esse

No entanto, podemos transformar esse padrão em um Vanisher adicionando ainda menos células vivas.

Sua tarefa é escrever um programa que faça essa tarefa para nós. Isso recebe um padrão à medida que a entrada encontra e gera um padrão de fuga que contém a entrada. Você não precisa necessariamente encontrar o padrão ideal apenas um padrão que funcione.

Pontuação

Para pontuar o seu programa, você terá que executá-lo em todos os 6 polipletos de tamanho 6 (sem contar dobro os casos simetricamente equivalentes). Aqui está uma pasta que contém cada polipleto em sua própria linha. Deve haver 524 deles no total. Eles são representados como uma lista de seis coordenadas ( (x,y)tuplas), cada uma sendo a localização de uma célula viva.

Sua pontuação será o número total de novas células adicionadas para transformar todos esses polyplets em Vanishers.

Laços

No caso de gravatas, irei fornecer uma lista do tamanho 7 de polipletos para os programas serem executados.

IO

Gostaria que o IO fosse bastante flexível. Você pode receber entradas e saídas em formatos razoáveis, mas provavelmente desejará receber as entradas no mesmo formato que os dados brutos de entrada que forneci. Seu formato deve ser consistente em várias execuções.

Cronometragem

Seu programa deve ser executado em um período de tempo razoável (aproximadamente <1 dia) em uma máquina razoável. Eu realmente não vou impor muito isso, mas eu preferiria se todos jogássemos bem.

Python + Z3 , pontuação = 3647

É executado em 14 segundos no meu sistema de oito núcleos.

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)

Saída total