Une chaîne dont la longueur est un nombre triangulaire positif (1, 3, 6, 10, 15 ...) peut être arrangée en un "triangle de texte équilatéral" en ajoutant des espaces et des retours à la ligne (et en les conservant dans le même ordre de lecture).

Par exemple, la chaîne de longueur 10 ABCDEFGHIJdevient:

   A
  B C
 D E F
G H I J

Écrivez un programme ou une fonction qui accepte une telle chaîne, sauf qu'elle ne contiendra que les caractères 0et 1. (Vous pouvez supposer que l'entrée est valide.)

Pour le "triangle de texte équilatéral" résultant, sortez (impression ou retour) l'un des quatre nombres qui dénote le type de symétrie affiché:

• Sortie 2si le triangle a une symétrie bilatérale. c'est-à-dire qu'il a une ligne de symétrie depuis n'importe quel coin jusqu'au milieu du côté opposé.

  Exemples:

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

• Sortie 3si le triangle a une symétrie de rotation. c'est-à-dire qu'il pouvait être tourné de 120 ° sans changement visuel.

  Exemples:

     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
  

• Sortie 6si le triangle a la fois une symétrie bilatérale et de rotation. c'est-à-dire qu'il correspond aux conditions de sortie de 2et 3.

  Exemples:

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

• Sortie 1si le triangle n'a ni symétrie bilatérale ni rotationnelle.

  Exemples:

    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
  

Le code le plus court en octets gagne. Tiebreaker est une réponse antérieure.

Mis à part un retour à la ligne facultatif, la chaîne d'entrée peut ne pas avoir d'espace ou de structure de remplissage de nouvelle ligne - il doit s'agir de simples 0et 1de.

Si vous le souhaitez, vous pouvez utiliser deux caractères ASCII imprimables distincts à la place de 0et 1.

Cas de test

Tiré directement d'exemples.

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

"Faire tourner" n'importe quelle entrée de 120 ° entraînera bien sûr la même sortie.

CJam, 37 29 28 27 octets

Merci à Sp3000 pour avoir économisé 3 octets.

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

Suite de tests.

Cela réutilise quelques astuces de rotation de triangle de ce défi .

Cela fonctionne également pour le même nombre d'octets:

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

Explication

Tout d'abord, un bref récapitulatif du message triangulaire que j'ai lié à ci-dessus. Nous représentons un triangle comme une liste 2D (irrégulière), par exemple

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

Le groupe de symétrie du triangle a 6 éléments. Il y a des cycles de longueur 3 en faisant tourner le triangle et des cycles de 2 en le reflétant le long d'un axe. De manière pratique, les rotations correspondent pour effectuer deux réflexions différentes. Nous utiliserons les réflexions suivantes pour ce faire:

1. Transposer la liste signifie la refléter le long de la diagonale principale, donc on aurait:

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

2. Inverser chaque ligne représente un reflet qui permute les deux coins supérieurs. En appliquant cela au résultat de la transposition, nous obtenons:

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

En utilisant ces deux transformations et en conservant le résultat intermédiaire, nous pouvons générer les six symétries de l'entrée.

Un autre point à noter est le comportement de transposition sur une liste comme celle-ci:

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

Parce que c'est ce que nous nous retrouverons après avoir divisé l'entrée. Commodément, après la transposition, CJam vide toutes les lignes vers la gauche, ce qui signifie que cela supprime réellement les étrangers []et les amène dans une forme utile pour les deux transformations ci-dessus (le tout sans changer la disposition réelle du triangle au-delà de la symétrie de réflexion):

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

Avec cela à l'écart, voici le code:

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.