La strana vita di un alveare

I ricercatori hanno recentemente scoperto un'interessante colonia di api che vive in un campo infinito di favi:

Ogni cellula può ospitare un'ape o no. In effetti, la vita di quelle creature sembra essere un po '... caotica. Si potrebbe calcolare che una colonia inizia sempre con il seguente schema:

_{(Ape disegnata da Emmanuel Boutet su Wikimedia Commons . Questa immagine a nido d'ape e le api viene quindi rilasciata sotto CC-By-SA . Brontola )}

Successivamente i cicli di vita dell'ape si dividono in cosiddette generazioni. Le vecchie api di ogni generazione muoiono e quelle nuove si schiudono e dipende principalmente dai vicini delle loro cellule:

• Se un'ape ha meno di due vicini, muore a causa della solitudine.
• Se un'ape ha più di tre vicini, muore a causa del sovraffollamento.
• Se una cellula ha due, tre o quattro api viventi nelle celle vicine, una nuova ape si schiude lì nella generazione successiva.

Le api morenti non muoiono fino alla fine di una generazione, quindi influenzano ancora le cellule circostanti che potrebbero schiudere le api nella generazione successiva.

Ora che sappiamo come funziona una tale colonia, possiamo simularla attraverso un numero qualsiasi di generazioni.

Ingresso

L'input è un singolo numero N , dato sull'input standard, terminato da un'interruzione di riga. 0 ≤ N ≤ 150. Questo è il numero di generazioni da simulare.

Produzione

L'output è un singolo numero, sull'output standard e facoltativamente seguito da una singola interruzione di riga, che rappresenta il numero di api viventi dopo N generazioni.

L'output aggiuntivo in caso di errore standard viene ignorato.

Ingressi campione

0
5
42
100

Output di esempio

6
44
1029
5296

Condizioni vincenti

Vince il codice più corto, come è consuetudine nel golf. In caso di pareggio, vince la soluzione precedente.

Casi test

Esistono due script di test, contenenti casi di test identici:

• bash
• PowerShell

Invocazione è in entrambi i casi: <test script> <my program> [arguments]ad esempio ./test ruby beehive.rbo ./test.ps1 ./beehive.exe.

So che ci sono solo 22 test invece di 151 (principalmente perché le soluzioni sono spesso piuttosto lente). Si prega di astenersi dall'incorporare i casi di test esatti invece di risolvere l'attività. Questi script sono utili per testare se una modifica provoca ancora il corretto funzionamento del programma; non che puoi adattare il tuo codice a specifici casi di test.

Un'altra nota

Questo compito faceva parte di una gara di golf tenutasi nella mia università durante il 2011-W24. I punteggi e le lingue dei nostri concorrenti erano i seguenti:

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

La nostra soluzione era

• 230 - Rubino

Rubino, 181 163 153 146 caratteri

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

Questa implementazione segue un approccio standard usando un array h(dimensioni 200x 200appiattite), in cui ogni elemento è 0(senza ape) o 1(ape inclusa). La matrice [0,-200,201,202,2,3]descrive le posizioni iniziali delle api (relative a qualsiasi cella iniziale).

Input e output come specificato sopra, supera tutti i casi di test definiti.

Modifica 1: ripristinato in una soluzione di wrapping anziché nella versione "spazio aggiuntivo" (che era più corta in una versione intermedia ma ora è più lunga di alcuni caratteri).

Modifica 2: rimosso bcompletamente la variabile .

Modifica 3: avviso: questa modifica ha reso il programma orribilmente lento. Ho quindi ridotto le dimensioni a 200 ciascuna, che è ancora sufficiente per un massimo di 150 iterazioni. Invece di indicizzare l'array in base a una variabile, ruotiamo costantemente l'array in avanti. Design davvero non buono, ma ora siamo notevolmente al di sotto dei 150.

Python, 152 caratteri

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)

Questa soluzione tiene traccia delle posizioni delle api con una serie di numeri complessi. È piuttosto lento perché il ciclo interno è quadratico nel numero di api. Ho testato fino a 50 e funziona.

Python, 171 169 158 caratteri

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)

Ho modellato il mondo come un array 1D 300 * 300 = 900000 (in hrealtà è più grande, ma la fine non viene utilizzata), dove un'ape è 1 e vuota è 0. La dimensione di 300 va bene perché al massimo la crescita sarebbe di 2 in ogni dimensione per ogni generazione e non ci sono più di 150 generazioni.

Ecco una versione leggermente non golfata e commentata:

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)