Ciąg, którego długość jest dodatnią liczbą trójkątną (1, 3, 6, 10, 15 ...), można ułożyć w „równoboczny trójkąt tekstowy”, dodając spacje i znaki nowej linii (i utrzymując go w tej samej kolejności czytania).

Na przykład ciąg o długości 10 ABCDEFGHIJstaje się:

   A
  B C
 D E F
G H I J

Napisz program lub funkcję, która pobiera taki ciąg, z wyjątkiem tego, że zawiera tylko znaki 0i 1. (Możesz założyć, że dane wejściowe są prawidłowe.)

Dla wynikowego „równobocznego trójkąta tekstowego” wyprowadzaj (drukuj lub zwracaj) jedną z czterech liczb oznaczających rodzaj wykazywanej symetrii:

• Dane wyjściowe, 2jeśli trójkąt ma dwustronną symetrię. tzn. ma linię symetrii od dowolnego rogu do punktu środkowego przeciwnej strony.

  Przykłady:

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

• Wyjście, 3jeśli trójkąt ma symetrię obrotową. tzn. można go obrócić o 120 ° bez zmiany wizualnej.

  Przykłady:

     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
  

• Wyjście, 6jeśli trójkąt ma symetrię zarówno dwustronną, jak i obrotową. tzn. odpowiada warunkom wyprowadzania zarówno 2i 3.

  Przykłady:

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

• Wyprowadzane, 1jeśli trójkąt nie ma symetrii dwustronnej ani obrotowej.

  Przykłady:

    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
  

Najkrótszy kod w bajtach wygrywa. Tiebreaker to wcześniejsza odpowiedź.

Oprócz opcjonalnej końcowym znakiem nowej linii, ciąg wejściowy nie może mieć przestrzeń / lub struktury dopełnienie nowej linii - powinna to być zwykły 0„s i 1” s.

W razie potrzeby możesz użyć dowolnych dwóch odrębnych drukowalnych znaków ASCII zamiast 0i 1.

Przypadki testowe

Zaczerpnięte bezpośrednio z przykładów.

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

„Obracanie” dowolnego wejścia o 120 ° spowoduje oczywiście tę samą moc wyjściową.

CJam, 37 29 28 27 bajtów

Dzięki Sp3000 za oszczędność 3 bajtów.

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

Zestaw testowy.

Powoduje to ponowne wykorzystanie niektórych sztuczek obracania trójkąta z tego wyzwania .

Działa to również dla tej samej liczby bajtów:

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

Wyjaśnienie

Po pierwsze, krótkie podsumowanie z trójkątnego postu, do którego linkowałem powyżej. Reprezentujemy trójkąt jako listę 2D (nierówną), np

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

Grupa symetrii trójkąta ma 6 elementów. Istnieją cykle o długości 3 poprzez obrót trójkąta i cykle o wartości 2 poprzez odbicie lustrzane wzdłuż pewnej osi. Dogodnie obroty odpowiadają dwóm różnym odbiciom. W tym celu wykorzystamy następujące refleksje:

1. Transpozycja listy oznacza odzwierciedlenie jej wzdłuż głównej przekątnej, aby uzyskać:

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

2. Odwrócenie każdego wiersza reprezentuje odbicie, które zamienia dwa górne rogi. Stosując to do wyniku transpozycji otrzymujemy:

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

Korzystając z tych dwóch transformacji i zachowując wynik pośredni, możemy wygenerować wszystkie sześć symetrii wejścia.

Kolejnym ważnym punktem jest zachowanie transpozycji na takiej liście:

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

Ponieważ po tym podzielimy dane wejściowe. Dogodnie, po transpozycji, CJam opróżnia wszystkie linie w lewo, co oznacza, że ​​faktycznie pozbywa się obcych []i nadaje mu formę przydatną dla powyższych dwóch transformacji (wszystko bez zmiany faktycznego układu trójkąta poza symetrię odbicia):

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

Poza tym oto kod:

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.