Uma string cujo comprimento é um número triangular positivo (1, 3, 6, 10, 15 ...) pode ser organizada em um "triângulo de texto equilateral" adicionando alguns espaços e novas linhas (e mantendo-os na mesma ordem de leitura).

Por exemplo, a cadeia de comprimento 10 ABCDEFGHIJse torna:

   A
  B C
 D E F
G H I J

Escreva um programa ou função que aceite essa sequência, exceto que ela conterá apenas os caracteres 0e 1. (Você pode assumir que a entrada é válida.)

Para o "triângulo de texto equilateral" resultante, imprima (imprima ou retorne) um dos quatro números que denota o tipo de simetria exibida:

• Saída 2se o triângulo tiver simetria bilateral. isto é, tem uma linha de simetria de qualquer canto até o ponto médio do lado oposto.

  Exemplos:

   0
  1 1
  
   1
  0 1
  
    0
   0 1
  0 1 0
  
     1
    1 1
   1 0 1 
  0 1 1 1
  

• Saída 3se o triângulo tiver simetria rotacional. isto é, poderia ser girado 120 ° sem alteração visual.

  Exemplos:

     0
    1 0
   0 1 1
  0 1 0 0
  
     0
    0 1
   1 0 0
  0 0 1 0
  
      1
     0 1
    1 1 1
   1 1 1 0
  1 0 1 1 1
  
       1
      0 1
     0 0 1
    1 0 0 0
   1 0 0 0 0
  1 0 0 1 1 1
  

• Saída 6se o triângulo tem tanto simetria bilateral e rotação. isto é, corresponde às condições para a saída de ambos 2e 3.

  Exemplos:

  0
  
  1
  
   0
  0 0
  
    1
   0 0
  1 0 1
  
     0
    0 0
   0 1 0
  0 0 0 0
  

• Saída 1se o triângulo não tiver simetria bilateral nem rotacional.

  Exemplos:

    1
   1 0
  0 0 0
  
    0
   0 1
  1 0 1
  
     1
    1 0
   1 1 1 
  1 1 1 1
  
      1
     1 1
    1 1 1 
   0 0 0 1
  1 1 1 1 1
  

O código mais curto em bytes vence. O desempatador é a resposta anterior.

Além de uma nova linha à direita opcional, a sequência de entrada pode não ter preenchimento de espaço / nova linha ou estrutura - ela deve ser simples 0e simples 1.

Se desejar, você pode usar dois caracteres ASCII imprimíveis distintos no lugar de 0e 1.

Casos de teste

Tomado diretamente de exemplos.

011 -> 2
101 -> 2
001010 -> 2
1111010111 -> 2
0100110100 -> 3
0011000010 -> 3
101111111010111 -> 3
101001100010000100111 -> 3
0 -> 6
1 -> 6
000 -> 6
100101 -> 6
0000100000 -> 6
110000 -> 1
001101 -> 1
1101111111 -> 1
111111000111111 -> 1

"Girar" qualquer entrada em 120 ° resultará obviamente na mesma saída.

CJam, 37 29 28 27 bytes

Agradecimentos ao Sp3000 por salvar 3 bytes.

q{T):T/(\s}h]{z_Wf%_}3*])e=

Suíte de teste.

Isso reutiliza alguns truques de rotação de triângulo desse desafio .

Isso também funciona para a mesma contagem de bytes:

q{T):T/(\s}h]3{;z_Wf%_}%)e=

Explicação

Primeiro, uma rápida recapitulação do post do triângulo a que vinculei acima. Representamos um triângulo como uma lista 2D (irregular), por exemplo

[[0 1 1]
 [0 0]
 [0]]

O grupo de simetria do triângulo possui 6 elementos. Existem ciclos de comprimento 3 girando o triângulo e ciclos de 2 espelhando-o ao longo de algum eixo. Convenientemente, as rotações correspondem a duas reflexões diferentes. Usaremos as seguintes reflexões para fazer isso:

1. Transpor a lista significa refleti-la na diagonal principal, para obtermos:

   [[0 0 0]
    [1 0]
    [1]]
   

2. A reversão de cada linha representa uma reflexão que alterna os dois cantos superiores. Aplicando isso ao resultado da transposição, obtemos:

   [[0 0 0]
    [0 1]
    [1]]
   

Usando essas duas transformações e mantendo o resultado intermediário, podemos gerar todas as seis simetrias da entrada.

Um outro ponto de observação é o comportamento da transposição em uma lista como esta:

[[0]
 [1 0]
 [1 0 0]
 []]

Porque é assim que acabaremos depois de dividir a entrada. Convenientemente, após a transposição, o CJam libera todas as linhas para a esquerda, o que significa que isso se livra do estranho []e o traz para uma forma útil para as duas transformações acima (todas sem alterar o layout real do triângulo além da simetria reflexiva):

[[0 1 1]
 [0 0]
 [0]]

Com isso fora do caminho, aqui está o código:

q       e# Read input.
{       e# While the input string isn't empty yet...
  T):T  e#   Increment T (initially 0) and store it back in T.
  /     e#   Split input into chunks of that size.
  (     e#   Pull off the first chunk.
  \s    e#   Swap with remaining chunks and join them back together
        e#   into a single string.
}h
]       e# The stack now has chunks of increasing length and an empty string
        e# as I mentioned above. Wrap all of that in an array.
{       e# Execute this block 3 times...
  z_    e#   Transpose and duplicate. Remember that on the first iteration
        e#   this gets us a triangle of the desired form and on subsequent
        e#   iterations it adds one additional symmetry to the stack.
  Wf%_  e#   Reverse each row and duplicate.
}3*
        e# The stack now has all 6 symmetries as well as a copy of the
        e# last symmetry.
]       e# Wrap all of them in a list.
)       e# Pull off the copy of the last symmetry.
e=      e# Count how often it appears in the list of symmetries.