Eine Zeichenfolge, deren Länge eine positive Dreieckszahl ist (1, 3, 6, 10, 15 ...), kann zu einem "gleichseitigen Textdreieck" angeordnet werden, indem Leerzeichen und Zeilenumbrüche hinzugefügt werden (und die Lesereihenfolge beibehalten wird).

Beispielsweise wird die Zeichenfolge mit der Länge 10 ABCDEFGHIJzu:

   A
  B C
 D E F
G H I J

Schreiben Sie ein Programm oder eine Funktion, die eine solche Zeichenfolge akzeptiert, mit der Ausnahme, dass sie nur die Zeichen 0und enthält 1. (Sie können davon ausgehen, dass die Eingabe gültig ist.)

Geben Sie für das resultierende "gleichseitige Textdreieck" eine der vier Zahlen aus (Drucken oder Zurückgeben), die den Typ der gezeigten Symmetrie angibt:

• Ausgabe, 2wenn das Dreieck bilateral symmetrisch ist. dh es hat eine Symmetrielinie von einer Ecke zum Mittelpunkt der gegenüberliegenden Seite.

  Beispiele:

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

• Ausgabe, 3wenn das Dreieck rotationssymmetrisch ist. dh es könnte ohne optische Veränderung um 120 ° gedreht werden.

  Beispiele:

     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
  

• Ausgabe, 6wenn das Dreieck sowohl bilateral als auch rotationssymmetrisch ist. dh es entspricht den Bedingungen für die Ausgabe von sowohl 2und 3.

  Beispiele:

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

• Ausgabe, 1wenn das Dreieck weder bilateral noch rotationssymmetrisch ist.

  Beispiele:

    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
  

Der kürzeste Code in Bytes gewinnt. Tiebreaker ist frühere Antwort.

Abgesehen von einer optionalen nachgestellten Newline darf die Eingabezeichenfolge keine Leerzeichen / Newline-Auffüllung oder -Struktur aufweisen - es sollte sich um ein einfaches 0und ein einfaches Zeichen handeln 1.

Falls gewünscht, können Sie anstelle von und zwei verschiedene druckbare ASCII- Zeichen verwenden .01

Testfälle

Direkt aus Beispielen entnommen.

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

Wenn Sie einen Eingang um 120 ° drehen, erhalten Sie natürlich den gleichen Ausgang.

CJam, 37 29 28 27 Bytes

Danke an Sp3000 für das Speichern von 3 Bytes.

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

Testsuite.

Dadurch werden einige Tricks der Dreiecksrotation aus dieser Herausforderung wiederverwendet .

Dies funktioniert auch für die gleiche Byteanzahl:

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

Erläuterung

Zuerst ein kurzer Rückblick auf den Dreieckspfosten, den ich oben verlinkt habe. Wir stellen ein Dreieck als zweidimensionale (zerlumpte) Liste dar, z

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

Die Symmetriegruppe des Dreiecks besteht aus 6 Elementen. Es gibt Zyklen der Länge 3 durch Drehen des Dreiecks und Zyklen der Länge 2 durch Spiegeln entlang einer Achse. Zweckmäßigerweise entsprechen die Drehungen zwei unterschiedlichen Reflexionen. Wir werden dazu folgende Überlegungen anstellen:

1. Transponieren Sie die Liste, indem Sie sie entlang der Hauptdiagonale spiegeln. So erhalten Sie:

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

2. Das Umkehren jeder Reihe stellt eine Reflexion dar, die die oberen beiden Ecken vertauscht. Wenn wir dies auf das Ergebnis der Umsetzung anwenden, erhalten wir:

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

Mit diesen beiden Transformationen und unter Beibehaltung des Zwischenergebnisses können wir alle sechs Symmetrien der Eingabe erzeugen.

Ein weiterer wichtiger Punkt ist das Umsetzungsverhalten auf einer Liste wie dieser:

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

Denn das ist, was wir am Ende haben, nachdem wir die Eingabe aufgeteilt haben. Praktischerweise werden nach dem Transponieren von CJam alle Zeilen nach links gespült, was bedeutet, dass das Fremde tatsächlich entfernt []und in eine Form gebracht wird, die für die obigen beiden Transformationen nützlich ist (alles ohne das tatsächliche Layout des Dreiecks über die Reflexionssymmetrie hinaus zu ändern):

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

Nach alledem ist hier der 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.