A tarefa aqui é ler de um .rle
arquivo Golly ou de texto sem formatação (sua escolha) cujo nome de arquivo seja fornecido (no STDIN ou como um argumento de linha de comando) e identificar e contar os padrões comuns na grade codificada nele.
Como alternativa, você pode optar por fornecer o conteúdo do arquivo diretamente sobre STDIN.
Seu programa deve ser capaz de identificar e distinguir pelo menos as quinze naturezas-mortas estritas mais comuns e os cinco osciladores mais comuns , além de planadores .
Todas as fases desses osciladores devem ser reconhecidas, assim como as quatro fases do planador.
Ele deve gerar uma lista contendo a contagem final de cada padrão, com o nome e a quantidade de cada padrão em uma linha separada. Seu programa pode incluir na lista de saída todos esses padrões ou apenas aqueles nos quais pelo menos um foi encontrado.
Padrões que fazem parte de outros padrões contados não devem ser contados. (por exemplo, a fase de 8 células de um farol também não deve ser contada como dois blocos, e um empate de navio também não deve ser contado como dois navios)
Você pode supor que a entrada já tenha estabilizado e não contém padrões que não estejam no conjunto mencionado acima. Você também pode supor que a grade de entrada caiba dentro de uma caixa de 1024x1024.
Isso é código-golfe , então o programa mais curto vence.
Descrição de formato de arquivo RLE
Um arquivo RLE contém uma grade de vida codificada na duração. Todas as linhas que começam com #
são comentários e devem ser ignoradas.
A primeira linha não-vazia e sem comentários é do formulário x=<width>,y=<height>,rule=<rule>
. Para os fins desta tarefa, a regra sempre será B3/S23
. Pode conter espaços que devem ser removidos antes do processamento desta linha (é claro, não é necessário processar esta linha).
As linhas sem comentários após o primeiro devem ser tratadas como uma única sequência. Este deve consistir apenas de dígitos decimais, os personagens $
, b
e o
, e quebras de linha, e não vai terminar com um dígito. As quebras de linha devem ser ignoradas, mas você pode assumir que as quebras de linha não interromperão as seqüências de dígitos.
Isso pode ser encerrado por um único !
.
b
representa uma célula morta, o
representa uma célula viva e $
representa o fim de uma linha. Qualquer número decimal indica que o símbolo a seguir deve ser tratado como repetição várias vezes.
Codificação de padrão de texto sem formatação
A outra opção é ler o padrão em outro formato de texto sem formatação descrito aqui. Nesta codificação, as células off são representadas com hífens e as células são representadas com O maiúsculo, com novas linhas separando linhas.
Você pode supor que todas as linhas sem comentários serão preenchidas com o mesmo comprimento de hífens.
As linhas que começam com !
são comentários e devem ser ignoradas.
Alguns casos de teste
RLE:
#This is a comment
x = 35, y = 16, rule = B3/S23
bo$2o$obo5$22bo$22bo$22bo2$18b3o3b3o2$22bo$22bo10b2o$22bo10b2o!
Texto simples:
!This is a comment
-O---------------------------------
OO---------------------------------
O-O--------------------------------
-----------------------------------
-----------------------------------
-----------------------------------
-----------------------------------
----------------------O------------
----------------------O------------
----------------------O------------
-----------------------------------
------------------OOO---OOO--------
-----------------------------------
----------------------O------------
----------------------O----------OO
----------------------O----------OO
Resultados:
Glider 1
Blinker 4
Block 1
RLE:
x = 27, y = 15, rule = B3/S23
5b2o$5b2o9$11bo$o9bobo$o9bobo$o10bo12b3o!
#Here's a comment at the end
Texto simples:
-----OO--------------------
-----OO--------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
-----------O---------------
O---------O-O--------------
O---------O-O--------------
O----------O------------OOO
!Here's a comment at the end
Resultados:
Block 1
Blinker 2
Beehive 1
RLE:
#You may have multiple comments
#As shown here
x = 13, y = 11, rule = B3/S23
2o$2o2$12bo$12bo$12bo$2b2o$2b2o4b2o$7bo2bo$7bobo$8bo!
Texto simples:
!You may have multiple comments
!As shown here
OO-----------
OO-----------
-------------
------------O
------------O
------------O
--OO---------
--OO----OO---
-------O--O--
-------O-O---
--------O----
Resultados:
Block 2
Blinker 1
Loaf 1
RLE:
# Pentadecathlon
# Discovered by John Conway
# www.conwaylife.com/wiki/index.php?title=Pentadecathlon
x = 10, y = 3, rule = B3/S23
2bo4bo2b$2ob4ob2o$2bo4bo!
Texto simples:
! Pentadecathlon
! Discovered by John Conway
! www.conwaylife.com/wiki/index.php?title=Pentadecathlon
--O----O--
OO-OOOO-OO
--O----O--
Resultados:
Pentadecathlon 1
Bônus
Se você suporta os dois formatos de entrada (usando a extensão de arquivo [ .rle
para arquivos rle e .cells
texto sem formatação - como outras extensões devem ser lidas é indefinida] ou um sinalizador de linha de comando para distinguir entre elas), você pode subtrair 5% da sua pontuação.
fonte
OOO.OO\n....OO
Respostas:
Haskell, 2417 bytes
Isso levou um bom tempo e ainda existem alguns bugs, mas eu tenho vários truques trabalhando, então valeu a pena.
Notas:
Combina algumas ideias-chave:
Aqui está o código:
Aqui está o código do Mathematica usado para compactar uma matriz de 0,1 no formato posteriormente descompactado pelo programa haskell:
Aqui está uma descrição muito mais completa do código:
fonte