सिमे-ट्राई दिस ट्राएंगल ट्रायल

Question

एक स्ट्रिंग जिसकी लंबाई एक सकारात्मक है त्रिकोणीय संख्या है (1, 3, 6, 10, 15 ...) कुछ रिक्त स्थान और newlines जोड़कर "समतुल्य पाठ त्रिकोण" में व्यवस्थित किया जा सकता है (और इसे एक ही पढ़ने के क्रम में रखते हुए)।

उदाहरण के लिए, लंबाई 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यदि त्रिभुज में दोनों हों तो आउटपुट द्विपक्षीय और घूर्णी समरूपता। यानी यह दोनों के आउटपुट के लिए शर्तों से मेल खाता है2 और 3।

  उदाहरण:

  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
  

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले जवाब है।

एक वैकल्पिक अनुगामी न्यूलाइन के अलावा, इनपुट स्ट्रिंग में स्थान / न्यूलाइन पैडिंग या संरचना नहीं हो सकती है - यह सादे होना चाहिए 0और1 के।

यदि आप चाहें तो किसी भी दो अलग-अलग मुद्रण योग्य ASCII वर्णों का उपयोग कर सकते हैं 0और1 ।

परीक्षण के मामलों

उदाहरणों से प्रत्यक्ष लिया।

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 ° तक किसी भी इनपुट को "घूर्णन" करने से समान आउटपुट प्राप्त होगा।

Comments

यह शीर्षक सिर्फ दर्दनाक है ......

— Rɪᴋᴇʀ

@ E @sᴛᴇʀʟʏIʀᴋ इसे अनदेखा करने के लिए सिर्फ त्रि।

— केल्विन के

@ हेल्कोहम्बा क्यों ... क्यों ...

— क्लिम्सिक

Answer 1

CJam, 37 29 28 27 बाइट्स

3 बाइट बचाने के लिए Sp3000 के लिए धन्यवाद।

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

परीक्षण सूट।

यह इस चुनौती से कुछ त्रिकोण रोटेशन की चाल का पुन: उपयोग करता है ।

यह भी एक ही बाइट गिनती के लिए काम करता है:

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

व्याख्या

सबसे पहले, ऊपर पोस्ट से जुड़े त्रिकोण पोस्ट से एक त्वरित पुनर्कथन। हम एक त्रिकोण को 2 डी (रैग्ड) सूची के रूप में दर्शाते हैं, जैसे

[[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.