สตริงที่มีความยาวคือตัวเลขสามเหลี่ยมบวก(1, 3, 6, 10, 15 ... ) สามารถจัดเรียงเป็น "สามเหลี่ยมข้อความรูปสามเหลี่ยมด้านเท่า" โดยการเพิ่มช่องว่างและบรรทัดใหม่ (และเก็บไว้ในลำดับการอ่านเดียวกัน)

ตัวอย่างเช่นความยาว 10 สตริงABCDEFGHIJกลายเป็น:

   A
  B C
 D E F
G H I J

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้ในสตริงเช่นยกเว้นจะมีเพียงตัวละครและ0 1(คุณอาจสมมติว่าอินพุตถูกต้อง)

สำหรับผลลัพธ์ "สามเหลี่ยมข้อความด้านเท่ากันหมด" ผลลัพธ์ (พิมพ์หรือส่งคืน) หนึ่งในสี่หมายเลขที่แสดงถึงประเภทของสมมาตรที่จัดแสดง:

• เอาท์พุท2ถ้าสามเหลี่ยมมีสมมาตรทวิภาคี นั่นคือมันมีเส้นสมมาตรจากมุมหนึ่งไปยังจุดกึ่งกลางของฝั่งตรงข้าม

  ตัวอย่าง:

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

• เอาต์พุต3ถ้าสามเหลี่ยมมีสมมาตรแบบหมุน นั่นคือสามารถหมุนได้ 120 °โดยไม่มีการเปลี่ยนแปลงภาพ

  ตัวอย่าง:

     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
  

• เอาท์พุท6ถ้าสามเหลี่ยมมีทั้งสมมาตรทวิภาคีและการหมุน คือมันตรงกับเงื่อนไขสำหรับการแสดงผลทั้งในและ23

  ตัวอย่าง:

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

• เอาท์พุท1ถ้าสามเหลี่ยมไม่มีทั้งสองข้างและสมมาตรการหมุน

  ตัวอย่าง:

    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
  

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ Tiebreaker เป็นคำตอบก่อนหน้า

นอกเหนือจากการขึ้นบรรทัดใหม่ต่อท้ายตัวเลือกสายป้อนอาจไม่ได้มีพื้นที่ / padding ขึ้นบรรทัดใหม่หรือโครงสร้าง - มันควรจะเป็นธรรมดา0'และ1' s

ถ้าต้องการคุณอาจใช้ใด ๆ ที่แตกต่างกันสองASCII พิมพ์ตัวอักษรในสถานที่และ01

กรณีทดสอบ

ถ่ายโดยตรงจากตัวอย่าง

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

"การหมุน" อินพุตใด ๆ ที่ 120 °จะส่งผลให้ผลลัพธ์เดียวกัน

CJam, 37 29 28 27 bytes

ขอบคุณ Sp3000 สำหรับการบันทึก 3 ไบต์

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

ชุดทดสอบ

นี่จะใช้เทคนิคการหมุนรูปสามเหลี่ยมบางส่วนจาก การท้าทายนี้

วิธีนี้ใช้ได้กับจำนวนไบต์เดียวกันด้วย:

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

คำอธิบาย

ก่อนอื่นสรุปอย่างรวดเร็วจากโพสต์รูปสามเหลี่ยมที่ฉันลิงค์ไปด้านบน เราแสดงสามเหลี่ยมเป็นรายการ 2D (มอมแมม) เช่น

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

กลุ่มสมมาตรของสามเหลี่ยมมีองค์ประกอบ 6 อย่าง มีวัฏจักรของความยาว 3 โดยหมุนสามเหลี่ยมและรอบที่ 2 โดยการสะท้อนไปตามแกน การหมุนจะสอดคล้องกับการสะท้อนสองแบบที่แตกต่างกัน เราจะใช้ภาพสะท้อนต่อไปนี้เพื่อทำสิ่งนี้:

1. เปลี่ยนรายการหมายความว่าสะท้อนตามแนวทแยงมุมดังนั้นเราจะได้:

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

2. การย้อนกลับแต่ละแถวแสดงถึงการสะท้อนซึ่งสลับมุมทั้งสองด้านบน การนำสิ่งนี้ไปใช้กับผลลัพธ์ของการขนย้ายที่เราได้รับ:

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

การใช้การแปลงสองรูปแบบนี้และรักษาผลกลางเราสามารถสร้างสมมาตรทั้งหกของอินพุตได้

อีกจุดของการบันทึกคือพฤติกรรมของการขนย้ายในรายการเช่นนี้:

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

เพราะนั่นคือสิ่งที่เราจะลงเอยด้วยหลังจากแยกอินพุต สะดวกหลังจากทำการแปลง CJam ล้างทุกบรรทัดไปทางซ้ายซึ่งหมายความว่านี่เป็นการกำจัดสิ่งที่ไม่เกี่ยวข้อง[]และนำมาไว้ในรูปแบบที่มีประโยชน์สำหรับการแปลงสองครั้งข้างต้น (ทั้งหมดโดยไม่ต้องเปลี่ยนเค้าโครงจริงของสามเหลี่ยมเลย

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

ด้วยวิธีการที่นี่รหัสนี่คือ:

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.