Sebuah string yang panjangnya adalah bilangan segitiga positif (1, 3, 6, 10, 15 ...) dapat disusun menjadi "segitiga teks sama sisi" dengan menambahkan beberapa spasi dan baris baru (dan menjaganya dalam urutan bacaan yang sama).

Misalnya, string 10 panjang ABCDEFGHIJmenjadi:

   A
  B C
 D E F
G H I J

Tulis program atau fungsi yang menggunakan string seperti itu, kecuali itu hanya akan berisi karakter 0dan 1. (Anda dapat menganggap input tersebut valid.)

Untuk "segitiga teks sama sisi" yang dihasilkan, output (cetak atau kembalikan) salah satu dari empat angka yang menunjukkan jenis simetri yang ditunjukkan:

• Keluaran 2jika segitiga memiliki simetri bilateral. yaitu memiliki garis simetri dari salah satu sudut ke titik tengah sisi yang berlawanan.

  Contoh:

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

• Output 3jika segitiga memiliki simetri rotasi. yaitu bisa diputar 120 ° tanpa perubahan visual.

  Contoh:

     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
  

• Output 6jika segitiga memiliki kedua simetri bilateral dan rotasi. yaitu cocok dengan kondisi untuk menghasilkan keduanya 2dan 3.

  Contoh:

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

• Keluaran 1jika segitiga tidak memiliki simetri bilateral atau rotasi.

  Contoh:

    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
  

Kode terpendek dalam byte menang. Tiebreaker adalah jawaban sebelumnya.

Selain dari baris baru tambahan opsional, string input mungkin tidak memiliki ruang / baris baru atau struktur - itu harus polos 0dan 1's.

Jika diinginkan, Anda dapat menggunakan dua karakter ASCII yang dapat dicetak untuk menggantikan 0dan 1.

Uji Kasus

Diambil langsung dari contoh.

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

"Memutar" setiap input dengan 120 ° tentu saja akan menghasilkan output yang sama.

CJam, 37 29 28 27 byte

Terima kasih kepada Sp3000 untuk menghemat 3 byte.

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

Suite uji.

Ini menggunakan kembali beberapa trik rotasi segitiga dari tantangan ini .

Ini juga berfungsi untuk jumlah byte yang sama:

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

Penjelasan

Pertama, rekap cepat dari pos segitiga yang saya tautkan di atas. Kami mewakili segitiga sebagai daftar 2D (compang-camping), misalnya

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

Grup simetri segitiga memiliki 6 elemen. Ada siklus panjang 3 dengan memutar segitiga dan siklus 2 dengan memantulkannya di sepanjang beberapa sumbu. Dengan mudah, rotasi sesuai untuk melakukan dua refleksi berbeda. Kami akan menggunakan refleksi berikut untuk melakukan ini:

1. Transpose daftar berarti memantulkannya di sepanjang diagonal utama, jadi kami akan mendapatkan:

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

2. Membalik setiap baris mewakili refleksi yang menukar dua sudut atas. Menerapkan ini pada hasil transposisi yang kita dapatkan:

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

Dengan menggunakan dua transformasi ini, dan menjaga hasil antara, kita dapat menghasilkan semua enam simetri input.

Poin selanjutnya adalah perilaku transposisi pada daftar seperti ini:

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

Karena itulah yang akan kita akhiri setelah membagi input. Mudahnya, setelah transposing, CJam menyiram semua garis ke kiri, yang berarti ini benar-benar menghilangkan yang asing []dan membawanya ke bentuk yang berguna untuk dua transformasi di atas (semua tanpa mengubah tata letak sebenarnya dari segitiga di luar simetri reflektif):

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

Dengan demikian, inilah kodenya:

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.