Uzunluğu pozitif bir üçgen sayı (1, 3, 6, 10, 15 ...) olan bir dize, bazı boşluklar ve satırlar ekleyerek (ve aynı okuma düzeninde tutularak) "eşkenar metin üçgeni" olarak düzenlenebilir.

Örneğin, uzunluk 10 dizesi şöyle ABCDEFGHIJolur:

   A
  B C
 D E F
G H I J

Yalnızca karakterler içeriyor olacaktır hariç böyle bir dizede götüren bir program veya fonksiyon yazın 0ve 1. (Girişin geçerli olduğunu varsayabilirsiniz.)

Ortaya çıkan "eşkenar metin üçgeni" için, sergilenen simetri türünü gösteren dört sayıdan birini çıktılayın (yazdırın veya döndürün):

• 2Üçgenin bilateral simetrisi varsa çıktı . yani herhangi bir köşeden karşı tarafın orta noktasına kadar bir simetri çizgisine sahiptir.

  Örnekler:

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

• 3Üçgenin dönme simetrisi varsa çıktı . yani görsel değişiklik olmadan 120 ° döndürülebilir.

  Örnekler:

     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
  

• Çıktı 6üçgen varsa hem ikili ve dönme simetrisi. yani her iki çıkışı koşullarını maçları 2ve 3.

  Örnekler:

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

• 1Üçgenin iki taraflı veya dönme simetrisi yoksa çıktı .

  Örnekler:

    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
  

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha önce cevap.

İsteğe bağlı bir son satırsonu dışında, girdi dizesi boşluk / satırsonu dolgusu veya yapısına sahip olmayabilir - düz 0ve 1s olmalıdır.

İstenirse herhangi iki farklı kullanabilir yazdırılabilir ASCII yerine karakterleri 0ve 1.

Test Durumları

Doğrudan örneklerden alınmıştır.

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

Herhangi bir girişin 120 ° döndürülmesi elbette aynı çıkışla sonuçlanacaktır.

CJam, 37 29 28 27 bayt

3 bayt tasarruf için Sp3000'e teşekkürler.

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

Test odası.

Bu, bu meydan okumadan bazı üçgen dönüş hilelerini yeniden kullanır .

Bu aynı bayt sayısı için de geçerlidir:

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

açıklama

İlk olarak, yukarıda bağladığım üçgen direğin hızlı bir özeti. Bir üçgeni 2D (düzensiz) liste olarak gösteririz, ör.

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

Üçgenin simetri grubu 6 elemente sahiptir. Üçgeni döndürerek uzunluk 3 döngüleri ve bir eksen boyunca aynalayarak 2 döngüleri vardır. Uygun şekilde, dönüşler iki farklı yansımaya karşılık gelir. Bunu yapmak için aşağıdaki yansımaları kullanacağız:

1. Listeyi ana diyagonal boyunca yansıtmak anlamına gelir, böylece şunu elde ederiz:

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

2. Her satırı ters çevirmek, en üstteki iki köşeyi değiştiren bir yansımayı temsil eder. Bunu transpozisyonun sonucuna uygulayarak:

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

Bu iki dönüşümü kullanarak ve ara sonucu koruyarak, girdinin altı simetrisini de üretebiliriz.

Dikkat edilmesi gereken diğer bir nokta, böyle bir listede yer değiştirmenin davranışıdır:

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

Çünkü girdiyi böldükten sonra bunu başaracağız. Uygun bir şekilde, transpozisyondan sonra CJam, tüm çizgileri sola temizler, bu da aslında yabancıdan kurtulur []ve yukarıdaki iki dönüşüm için yararlı olan bir forma getirir (hepsi üçgenin yansıma simetrisinin ötesinde gerçek düzenini değiştirmeden):

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

Yoldan çekilince, işte 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.