A estranha vida de uma colméia

Pesquisadores descobriram recentemente uma colônia de abelhas interessante que vive em um campo infinito de favo de mel:

Cada célula pode abrigar uma abelha ou não. De fato, a vida dessas criaturas parece um pouco ... caótica. Pode-se calcular que uma colônia sempre começa com o seguinte padrão:

_{(Abelha desenhada por Emmanuel Boutet no Wikimedia Commons . Esta imagem de favo de mel e abelhas é divulgada sob CC-By-SA . Resmunga )}

Depois disso, os ciclos de vida das abelhas são divididos nas chamadas gerações. Cada geração de abelhas velhas morre e as novas eclodem e depende principalmente dos vizinhos de suas células:

• Se uma abelha tem menos de dois vizinhos, morre devido à solidão.
• Se uma abelha tem mais de três vizinhos, morre devido à superlotação.
• Se uma célula possui duas, três ou quatro abelhas vivas nas células vizinhas, uma nova abelha eclode na próxima geração.

As abelhas moribundas não morrem até o final de uma geração, portanto ainda afetam as células circundantes que podem chocar as abelhas na próxima geração.

Agora que sabemos como essa colônia funciona, podemos simulá-la por várias gerações.

Entrada

A entrada é um número único N , fornecido na entrada padrão, terminado por uma quebra de linha. 0 ≤ N ≤ 150. Este é o número de gerações para simular.

Resultado

A saída é um número único, na saída padrão e, opcionalmente, seguida por uma única quebra de linha, que representa o número de abelhas vivas após N gerações.

Saída adicional com erro padrão é ignorada.

Entradas de Amostra

0
5
42
100

Saídas de amostra

6
44
1029
5296

Condição vencedora

O código mais curto vence, como é habitual no golfe. Em caso de empate, a solução anterior vence.

Casos de teste

Existem dois scripts de teste, contendo casos de teste idênticos:

• bater
• PowerShell

A invocação ocorre nos dois casos:, <test script> <my program> [arguments]por exemplo, ./test ruby beehive.rbou ./test.ps1 ./beehive.exe.

Eu sei que existem apenas 22 testes em vez de 151 (principalmente porque as soluções costumam ser bastante lentas). Evite incorporar os casos de teste exatos em vez de resolver a tarefa. Esses scripts são uma conveniência para você testar se uma alteração ainda faz com que o programa se comporte corretamente; não que você possa adaptar seu código aos casos de teste específicos.

Outra nota

Esta tarefa fez parte de um concurso de golfe realizado na minha universidade durante o período 2011-W24. As pontuações e idiomas de nossos concorrentes foram os seguintes:

• 336 - C
• 363 - C
• 387 - C
• 389 - Haskell
• 455 - C

Nossa própria solução foi

• 230 - Ruby

Rubi, 181 163 153 146 caracteres

h=[0]*4e4
[0,-200,201,202,2,3].map{|i|h[i]=1}
gets.to_i.times{h=h.map{[g=1,200,201].map{|x|g+=h[x]+h[-x]};g>5-h.rotate![-1]||g<3?0:1}}
p h.count 1

Essa implementação segue uma abordagem padrão usando uma matriz h(dimensões 200x 200achatadas), em que cada elemento é 0(sem abelha) ou 1(abelha incluída). A matriz[0,-200,201,202,2,3] descreve as posições iniciais das abelhas (em relação a qualquer célula inicial).

A entrada e saída, conforme especificado acima, passa em todos os casos de teste definidos.

Editar 1: alterado novamente para uma solução de agrupamento em vez da versão "espaço adicional" (que era mais curta em uma versão intermediária, mas agora tem vários caracteres mais).

Edição 2: variável removida bcompletamente.

Editar 3: aviso: esta edição tornou o programa terrivelmente lento. Assim, reduzi as dimensões para 200 cada uma, o que ainda é suficiente para até 150 iterações. Em vez de indexar a matriz por uma variável, constantemente giramos a matriz para frente. Design não muito bom, mas agora estamos consideravelmente abaixo dos 150.

Python, 152 caracteres

P=[0,2,3,1j,1+1j,1-1j]
for i in' '*input():Q=[p+d for d in(1,-1,1j,-1j,1j-1,1-1j)for p in P];P=set(p for p in Q if 1<Q.count(p)<5-(p in P))
print len(P)

Esta solução controla os locais das abelhas com um conjunto de números complexos. É bem lento porque o loop interno é quadrático no número de abelhas. Eu testei até 50 e funciona.

Python, 171 169 158 caracteres

w=300
s=w*w
x=[0]*297
h=[1,1,0]+x+[1,0,1,1]+x+[1]+x*s
exec('h=[1<sum(h[(i+x)%s]for x in[-1,-w-1,-w,1,w+1,w])<5-h[i]for i in range(s)];'*input())
print sum(h)

Eu modelo o mundo como uma matriz 300 * 300 = 900000 1D ( hna verdade é maior, mas o final não é usado), onde uma abelha é 1 e vazia é 0. O tamanho de 300 é bom porque, no máximo, o crescimento seria de 2 em cada dimensão para cada geração, e não há mais de 150 gerações.

Aqui está uma versão ligeiramente não-gasta e comentada:

w=300 # width and height of the world
s=w*w
# create initial grid
l=[1,1]+[0]*298+[1,0,1,1]+[0]*297+[1]+[0]*s

for k in range(input()):
  h=l[:]

  for i in range(s):

    # for each point, compute the number of neighbors
    n=sum(map(lambda x:h[(i+x)%s],[-1,-w-1,-w,1,w+1,w]))

    # if that number verifies the conditions, put 1 here, if not put 0
    l[i]=1<n<5-h[i]

print sum(l)