Một chuỗi có độ dài là một số tam giác dương (1, 3, 6, 10, 15 ...) có thể được sắp xếp thành một "tam giác văn bản bằng nhau" bằng cách thêm một số khoảng trắng và dòng mới (và giữ nó theo cùng thứ tự đọc).

Ví dụ: chuỗi 10 độ dài ABCDEFGHIJtrở thành:

   A
  B C
 D E F
G H I J

Viết chương trình hoặc hàm có trong một chuỗi như vậy, ngoại trừ nó sẽ chỉ chứa các ký tự 0và 1. (Bạn có thể cho rằng đầu vào là hợp lệ.)

Đối với "tam giác văn bản bằng nhau" kết quả, đầu ra (in hoặc trả về) một trong bốn số biểu thị loại đối xứng được trưng bày:

• Đầu ra 2nếu tam giác có đối xứng hai bên. tức là nó có một đường đối xứng từ bất kỳ một góc nào đến trung điểm đối diện.

  Ví dụ:

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

• Đầu ra 3nếu tam giác có đối xứng quay. tức là nó có thể xoay 120 ° mà không thay đổi hình ảnh.

  Ví dụ:

     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
  

• Đầu ra 6nếu tam giác có cả đối xứng song phương và quay. tức là nó phù hợp với các điều kiện để xuất cả hai 2và 3.

  Ví dụ:

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

• Đầu ra 1nếu tam giác không có đối xứng song phương hoặc quay.

  Ví dụ:

    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
  

Mã ngắn nhất tính bằng byte thắng. Tiebreaker là câu trả lời trước đó.

Ngoài một dòng mới theo dõi tùy chọn, chuỗi đầu vào có thể không có cấu trúc hoặc phần đệm không gian / dòng mới - nó phải là đơn giản 0và 1của.

Nếu muốn, bạn có thể sử dụng bất kỳ hai ký tự ASCII có thể in riêng biệt nào thay cho 0và 1.

Các trường hợp thử nghiệm

Lấy trực tiếp từ các ví dụ.

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

"Xoay" bất kỳ đầu vào nào bằng 120 ° tất nhiên sẽ dẫn đến cùng một đầu ra.

CJam, 37 29 28 27 byte

Cảm ơn Sp3000 vì đã tiết kiệm 3 byte.

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

Bộ thử nghiệm.

Điều này tái sử dụng một số thủ thuật xoay tam giác từ thử thách này .

Điều này cũng hoạt động cho cùng một số byte:

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

Giải trình

Đầu tiên, một bản tóm tắt nhanh từ bài tam giác tôi liên kết đến ở trên. Chúng tôi biểu thị một hình tam giác dưới dạng danh sách 2D (ragged), vd

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

Nhóm đối xứng của tam giác có 6 phần tử. Có các chu kỳ có độ dài 3 bằng cách xoay tam giác và chu kỳ 2 bằng cách phản chiếu nó dọc theo một số trục. Thuận tiện, các phép quay tương ứng để thực hiện hai phản xạ khác nhau. Chúng tôi sẽ sử dụng các phản xạ sau đây để làm điều này:

1. Chuyển danh sách có nghĩa là phản ánh nó dọc theo đường chéo chính, vì vậy chúng tôi sẽ nhận được:

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

2. Đảo ngược mỗi hàng đại diện cho một sự phản chiếu hoán đổi hai góc trên cùng. Áp dụng điều này vào kết quả của sự hoán vị chúng ta nhận được:

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

Sử dụng hai phép biến đổi này và giữ kết quả trung gian, chúng ta có thể tạo ra tất cả sáu phép đối xứng của đầu vào.

Một điểm đáng chú ý nữa là hành vi hoán vị trong danh sách như thế này:

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

Bởi vì đó là những gì chúng ta sẽ kết thúc sau khi tách đầu vào. Thuận tiện, sau khi hoán vị, CJam gạt tất cả các dòng sang bên trái, điều đó có nghĩa là điều này thực sự thoát khỏi ngoại lai []và đưa nó thành một dạng hữu ích cho hai phép biến đổi ở trên (tất cả mà không thay đổi bố cục thực của tam giác ngoài đối xứng phản xạ):

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

Ngoài ra, đây là mã:

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.