Sua tarefa é criar uma simulação de Jogo da Vida representando um relógio digital, que satisfaça as seguintes propriedades:

1. O relógio mostra as horas e minutos em decimal (por exemplo 12:00, 3:59, 7:24) com um estado diferente para cada um dos 1.440 minutos do dia - ou as horas vão de 0 a 23 ou de 1 a 12 com um indicador de PM.

2. O padrão é periódico, e o estado circula sem nenhuma interação externa.

3. Os minutos são atualizados em intervalos regulares - de uma mudança de minuto para a próxima leva o mesmo número de gerações.

4. Um espectador anônimo é capaz de dizer rapidamente que a tela deve ser um relógio digital. Em particular, isso implica:

   • Os dígitos são visíveis e claramente distinguíveis. Você deve ser capaz de dizer rapidamente com que horas está sendo exibida.

   • Os dígitos são atualizados no local. Cada novo número aparece no mesmo local que o número anterior e há pouco ou nenhum movimento das caixas delimitadoras dos dígitos. (Em particular, um dígito não contém 10 dígitos diferentes em lugares diferentes que são descobertos toda vez que os dígitos mudam.)

   • Os dígitos aparecem próximos um do outro, sem uma quantidade excessiva de espaço entre eles.

Seu programa será pontuado das seguintes maneiras, em ordem (com critérios mais baixos atuando como desempate para critérios mais altos):

• Tamanho da caixa delimitadora - vence a caixa retangular com a menor área que contém completamente a solução fornecida.

• Execução mais rápida - o menor número de gerações para avançar um minuto vence.

• Contagem inicial de células vivas - menor número de vitórias.

• Primeiro a postar - post anterior vence.

11.520 gerações por contagem de clock / 10.016 x 6.796 caixas / 244.596 pop count

Lá vai você ... Foi divertido.

Bem, o design certamente não é o ideal. Nem do ponto de vista da caixa delimitadora (esses dígitos de 7 segmentos são enormes ), nem da contagem inicial da população (existem algumas coisas inúteis e outras que certamente poderiam ser simplificadas) e a velocidade de execução - bem ... não tenho certeza.

Mas, ei, é lindo. Veja:

Executá-lo!

Obtenha o design desta essência . Copie o texto completo do arquivo para a área de transferência.

Novo : aqui está uma versão com indicadores AM e PM para os exigentes.

Acesse o simulador de vida JavaScript Conway online . Clique em importar , cole o texto do design. Você deve ver o design. Em seguida, vá para configurações e defina a etapa de geração como 512, ou algo parecido com essas linhas, ou você terá que esperar uma eternidade para ver o relógio sendo atualizado.

Clique em Executar , espere um pouco e se surpreenda!

Link direto para a versão do navegador.

Observe que o único algoritmo que torna esse enorme design utilizável é o hashlife. Mas com isso, você pode alcançar o relógio inteiro em segundos. Com outros algoritmos, é impraticável até mesmo ver a hora mudar.

Como funciona

Ele usa a tecnologia p30. Apenas coisas básicas, planadores e naves espaciais leves. Basicamente, o design vai de cima para baixo:

• No topo, há o relógio. É um relógio do período 11520. Observe que você precisa de cerca de 10.000 gerações para garantir que a exibição seja atualizada adequadamente, mas o design ainda deve ser estável com um relógio de período menor (cerca de 5.000 ou mais - o relógio precisa ser múltiplo de 60).
• Depois, há o estágio de distribuição do relógio. O planador do relógio é copiado em uma árvore equilibrada; portanto, no final, existem 32 planadores que chegam exatamente no mesmo momento do estágio dos contadores.
• O estágio do contador é feito usando uma trava RS para cada estado e para cada dígito (estamos contando em decimal). Portanto, existem 10 estados para o dígito direito dos minutos, 6 estados para o dígito esquerdo dos minutos e 12 estados para as horas (os dois dígitos das horas são mesclados aqui). Para cada um desses grupos, o contador se comporta como um registro de turno.
• Após a etapa de contagem, existem as tabelas de pesquisa. Eles convertem os pulsos de estado para exibir as ações ON / OFF dos segmentos.
• Então, a própria exibição. Os segmentos são simplesmente criados com várias seqüências de caracteres do LWSS. Cada segmento possui sua própria trava para manter seu estado. Eu poderia ter feito um OR lógico simples dos estados dos dígitos para saber se um segmento deve estar LIGADO ou DESLIGADO e livrar-me dessas travas, mas haveria falhas para segmentos que não mudam, quando os dígitos estão mudando (por causa de atrasos de sinal). E haveria longos fluxos de planadores saindo da tabela de pesquisa para os segmentos de dígitos. Portanto, não seria tão bonito. E precisava ser. Sim.

De qualquer forma, não há realmente nada de extraordinário nesse design. Não há reações surpreendentes que foram descobertas nesse processo, nem combinações realmente inteligentes que ninguém pensava antes. Apenas alguns pedaços aqui e acolá e juntos (e eu nem tenho certeza se fiz isso da maneira "certa" - eu era realmente completamente nova nisso). Exigiu muita paciência, no entanto. Fazer com que todos aqueles planadores aparecessem no momento certo e na posição correta era um arranhão na cabeça.

Otimizações possíveis:

• Em vez de copiar e distribuir o mesmo clock raiz para as n células contrárias, eu poderia simplesmente colocar o mesmo bloco de relógio n vezes (uma vez para cada célula contrária). Isso seria realmente muito mais simples. Mas então eu não seria capaz de ajustá-lo tão facilmente alterando o relógio em um único ponto ... E eu tenho um histórico em eletrônica e, em um circuito real, isso seria terrivelmente errado.
• Cada segmento possui sua própria trava RS. Isso requer que as tabelas de pesquisa produzam os pulsos R e S. Se tivéssemos uma trava que apenas alternasse seu estado de um pulso de entrada comum, poderíamos tornar as tabelas de pesquisa metade do tamanho. Existe uma trava para o ponto PM, mas é enorme e não consigo pensar em algo mais prático.
• Diminua a exibição. Mas isso não seria tão bonito. E precisava ser. Sim.