Escreva dois blocos retangulares de código, cada um com w caracteres de largura e h caracteres de altura, que implementam o Jogo da Vida de Conway quando dispostos em uma grade. ( w e h podem ser inteiros positivos)
Por exemplo, os dois blocos de código podem ser: ( w = 3, h = 2, não código real)
XX|
--+
e
|
--+
Trate o primeiro bloco como se fosse a célula "viva" no Jogo da Vida e o segundo bloco como se fosse a célula "morta".
Agora organize várias cópias desses dois blocos em um programa maior que represente uma grade do Game of Life, como esta planadora :
| | | | |
--+--+--+--+--+
| |XX| | |
--+--+--+--+--+
| | |XX| |
--+--+--+--+--+
|XX|XX|XX| |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
Agora, aqui está o ponto principal: quando esse código é executado, a saída deve ser a grade do Game of Life que é a geração depois disso, usando os mesmos blocos de código ativo e morto para as células.
Portanto, a saída do programa acima seria a próxima geração do planador, que também serve como um programa executável:
| | | | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
|XX| |XX| |
--+--+--+--+--+
| |XX|XX| |
--+--+--+--+--+
| |XX| | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
Executar isso produziria a próxima geração:
| | | | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
| | |XX| |
--+--+--+--+--+
|XX| |XX| |
--+--+--+--+--+
| |XX|XX| |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
E assim por diante.
O processo deve ser indefinidamente repetível e funcionar para qualquer arranjo de seus blocos de códigos vivos e mortos em uma grade do Game of Life.
A grade de saída deve ter as mesmas dimensões do programa de origem (5 por 6 acima). Tamanhos de grade tão pequenos quanto 1 por 1 devem funcionar e podem ser arbitrariamente grandes. Naturalmente, uma grade vazia apenas produzirá a si mesma.
Atualizar: Ser capaz de simular grades de qualquer dimensão sem precisar alterar os "ladrilhos" seria o ideal, mas, como isso parece muito difícil, aceitarei respostas que pressupõem que a grade tenha um determinado tamanho (talvez em torno de 16 * 16).
As regras do Jogo da Vida são as seguintes:
- Qualquer célula viva com menos de 2 ou mais de 3 vizinhos vivos ( Moore ) morre.
- Qualquer célula morta com exatamente 3 vizinhos vivos ganha vida.
- Outras células não mudam.
Pontuação
O desafio é fazer isso na menor área possível de blocos de código. Sua pontuação é w * h . A pontuação mais baixa vence. Em caso de empate, a resposta mais votada vence.
Detalhes
- Além das novas linhas necessárias para tornar as coisas retangulares, seus dois blocos de código (e, portanto, seus programas de grade do Game of Life) devem conter apenas caracteres ASCII imprimíveis (códigos hexadecimais 20 a 7E, sem guias, sem novas linhas extras ).
- Ambos os blocos de código devem ter exatamente w * h caracteres (além das novas linhas necessárias) com pelo menos uma diferença de um caractere. Preenchê-los com espaços ou comentários é bom. Eles não devem mudar de uma geração para a seguinte.
- A saída deve ir para um arquivo ou para stdout. Não há entrada.
- As condições de contorno podem ser periódicas (onde a borda superior limita a parte inferior e a borda esquerda limita a direita) ou infinitas (onde todas as células fora dos limites estão sempre inoperantes). Escolha o que melhor lhe convier.
- A leitura do seu próprio código-fonte não é permitido .
- Qualquer idioma ou ferramenta que já faça isso não é permitido. (Apenas no caso de existir).
Nota: Os -|+
caracteres acima foram usados apenas para enfatizar as bordas da célula. Seus blocos não precisam de nenhuma borda distinguível. No entanto , ao exibir sua saída, seria útil se houvesse alguma separação distinguível entre os blocos, talvez feita com um caractere nunca usado no programa, por isso é fácil de remover. por exemplo
DD+DD+DD+DD
+++++++++++
AA+DD+AA+DD
ao invés de
DDDDDDDD
AADDAADD
fonte
__SOURCE_CODE__
.Respostas:
Perl, w * h = 233 * 1 = 233 (por célula)
As células funcionam em qualquer tamanho de grade (na verdade, mesmo com comprimento de linha irregular). As células fora do limite são consideradas mortas.
Célula morta
Célula viva
Planador
gera:
Explicação (não atual)
Perl, w * h = 140 * 2 = 280 (por célula)
A célula de várias linhas não é eficiente, mas pode ser eliminada
__LINE__
.Célula morta
Célula viva
fonte
JavaScript ES6 (239 x 1 caracteres por célula)
Célula morta:
Célula viva:
A única diferença é a
S[j]=0
deS[j]=1
células mortas e vivas.O tamanho da grade é controlado com as variáveis W (largura) e H (altura). As células fora da grade estão mortas.
Versão comentada
Planador (grade 5 x 6)
Produz a próxima geração:
fonte
|
é um operador bit a bit e funciona apenas com números.||
é um operador lógico que retorna o lado esquerdo se for "trueish", caso contrário, o lado direito.Python, 67x33 = 2.211
Observe que esta é minha versão bonita, onde adicionei uma linha de "#" a todas as outras linhas de uma célula vital e "" a todas as outras linhas de uma célula morta. Além disso, as células são separadas por "#" linhas. Dessa forma, você pode colocar uma configuração inicial em um arquivo de texto, por exemplo
GOL.py
, e observá-la com uma fonte minúscula para ver o que está acontecendo em cada etapa. Para chegar à próxima etapa, executepython GOL.py > GOL1.py;mv GOL1.py GOL.py
e dê uma olhada novamente.Minha solução funciona em uma grade de tamanho arbitrário e assume condições de contorno periódicas. Não testei larguras de linha variáveis, mas definitivamente há capacidade para isso.
Devo também mencionar que o sucesso desta solução depende de
__del__
ser chamado quandoa
é destruído no final do programa. A documentação do Python declaraEntão, eu apenas espero que isso não funcione apenas com meu intérprete.
Célula ao vivo:
Célula morta:
Python, 67x17 = 1.139 Para obter uma versão golfizada, ainda com alguma maneira de reconhecer células vitais de longe, a segunda declaração impressa nas linhas 19 e 31, assim como todas as outras linhas, é excluída.
Célula ao vivo:
Célula morta:
Se houver demanda, terei o prazer de explicar o funcionamento interno da minha solução quando encontrar tempo.
fonte
<sup><sub>...</sub></sup>
dentro de um<pre><code>
bloco. Isso não diminui a altura de uma linha, mas a fonte do texto é diminuída para cada ocorrência. Usar apenas subscrito ou somente sobrescrito fará com que o código flutue para cima ou para baixo fora da marcação, mas a alternância o manterá centralizado verticalmente.