Una cadena cuya longitud es un número triangular positivo (1, 3, 6, 10, 15 ...) se puede organizar en un "triángulo de texto equilátero" agregando algunos espacios y nuevas líneas (y manteniéndolo en el mismo orden de lectura).

Por ejemplo, la cadena de longitud 10 se ABCDEFGHIJconvierte en:

   A
  B C
 D E F
G H I J

Escriba un programa o función que tome dicha cadena, excepto que solo contendrá los caracteres 0y 1. (Puede suponer que la entrada es válida).

Para el "triángulo de texto equilátero" resultante, imprima (imprima o devuelva) uno de los cuatro números que denota el tipo de simetría exhibida:

• Salida 2si el triángulo tiene simetría bilateral. es decir, tiene una línea de simetría desde cualquier esquina hasta el punto medio del lado opuesto.

  Ejemplos:

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

• Salida 3si el triángulo tiene simetría rotacional. es decir, podría rotarse 120 ° sin cambio visual.

  Ejemplos:

     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
  

• Salida 6si el triángulo tiene simetría tanto bilateral como rotacional. es decir, coincide con las condiciones para generar ambos 2y 3.

  Ejemplos:

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

• Salida 1si el triángulo no tiene simetría bilateral ni rotacional.

  Ejemplos:

    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
  

El código más corto en bytes gana. Tiebreaker es la respuesta anterior.

Aparte de una nueva línea final opcional, la cadena de entrada puede no tener espacio o nueva línea de relleno o estructura, debe ser simple 0y 1's.

Si lo desea, puede usar dos caracteres ASCII imprimibles distintos en lugar de 0y 1.

Casos de prueba

Tomado directamente de ejemplos.

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" cualquier entrada en 120 °, por supuesto, dará como resultado la misma salida.

CJam, 37 29 28 27 bytes

Gracias a Sp3000 por guardar 3 bytes.

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

Banco de pruebas.

Esto reutiliza algunos trucos de rotación de triángulos de este desafío .

Esto también funciona para el mismo número de bytes:

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

Explicación

Primero, una breve recapitulación de la publicación triangular que he vinculado anteriormente. Representamos un triángulo como una lista 2D (irregular), p. Ej.

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

El grupo de simetría del triángulo tiene 6 elementos. Hay ciclos de longitud 3 al girar el triángulo y ciclos de 2 al reflejarlo a lo largo de algún eje. Convenientemente, las rotaciones corresponden a realizar dos reflexiones diferentes. Usaremos las siguientes reflexiones para hacer esto:

1. Transponer la lista significa reflejarla a lo largo de la diagonal principal, para obtener:

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

2. Invertir cada fila representa un reflejo que intercambia las dos esquinas superiores. Aplicando esto al resultado de la transposición obtenemos:

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

Usando estas dos transformaciones y manteniendo el resultado intermedio, podemos generar las seis simetrías de la entrada.

Otro punto a destacar es el comportamiento de la transposición en una lista como esta:

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

Porque eso es lo que terminaremos después de dividir la entrada. Convenientemente, después de la transposición, CJam limpia todas las líneas a la izquierda, lo que significa que esto realmente elimina lo extraño []y lo lleva a una forma útil para las dos transformaciones anteriores (todo sin cambiar el diseño real del triángulo más allá de la simetría de reflexión):

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

Con eso fuera del camino, aquí está el 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.