पाइथ पायथन पर आधारित एक गोल्फ भाषा है। यह उपसर्ग संकेतन का उपयोग करता है, जिसके प्रत्येक कमांड में एक अलग अरेटी (इसे स्वीकार करने वाले तर्कों की संख्या) होती है।
आपका कार्य एक (गैर-मौजूद) पायथ-जैसी भाषा, पिथ के लिए एक सिंटैक्स चेकर लिखना है।
पिट का वाक्य विन्यास
Pith में केवल 8 सिंगल-चार कमांड हैं:
01234()"
01234
प्रत्येक में संबंधित संख्या की समानता है, और इसलिए उम्मीद है कि इसके बाद कई तर्क हैं। उदाहरण के लिए,
400010
एक सही पिथ कार्यक्रम है क्योंकि 4
चार तर्कों के बाद 0
0
0
और 10
, जिनमें से अंतिम 1
एक तर्क के बाद है 0
। इसकी कल्पना करने के लिए, हम निम्नलिखित पेड़ को देख सकते हैं:
R
|
4
|
-------------
| | | |
0 0 0 1
|
0
R
रूट नोड कहां है इस बारे में सोचने का एक वैकल्पिक तरीका यह है कि प्रत्येक संख्या से संबंधित बच्चों की संख्या ऊपर के पेड़ में होती है।
यहाँ एक से अधिक बेस कमांड के साथ एक और मान्य पिथ प्रोग्राम है:
210010
तदनुसार
R
|
-------------
| |
2 1
| |
--------- 0
| |
1 0
|
0
दूसरी ओर,
3120102100
है न एक सही मज्जा कार्यक्रम क्योंकि प्रारंभिक 3
केवल दो तर्क है, जो हम नीचे पेड़ को देखकर देख सकते हैं:
R
|
3
|
------------------------ ??
| |
1 2
| |
2 ------
| | |
------ 1 0
| | |
0 1 0
|
0
अगला (
एक अनबाउंड शुरू होता है, और )
एक अनबाउंड समाप्त होता है। एक अनबाउंड किसी भी तर्क (लालच) को लेता है, और किसी भी पैरेंट कमांड को एक ही तर्क के रूप में गिना जाता है। प्रोग्राम के अंत तक खुलने वाले कोई भी अनबाउंड स्वचालित रूप से बंद हो जाते हैं। )
अगर कोई भी खुला नहीं है तो एक कमांड एक त्रुटि नहीं है - यह सिर्फ कुछ नहीं करता है। *
उदाहरण के लिए, पिथ कार्यक्रम
)31(0)0(201000100
पेड़ से मेल खाती है
R
|
3
|
------------------------------
| | |
1 0 (
| |
( -----------------------------
| | | | | |
0 2 0 0 1 0
| |
------- 0
| |
0 1
|
0
खाली अनबाउंड्स ठीक हैं, इसलिए ()
एक मान्य पिथ प्रोग्राम है।
एक अनबाउंड के साथ एक अमान्य Pith प्रोग्राम है
12(010
चूँकि 2
केवल एक तर्क (अनबाउंड) प्राप्त होता है।
अंत में, "
एक स्ट्रिंग को शुरू करता है और समाप्त होता है, जो हमेशा 0 होता है और एक ही तर्क के रूप में गिना जाता है, उदा
2"010""44)()4"
जो सिर्फ 2
दो कड़े तर्कों के साथ पारित किया जा रहा है "010"
और "44)()4"
। अनबाउंड्स की तरह, स्ट्रिंग्स भी खाली हो सकती हैं, और प्रोग्राम के अंत तक किसी भी असंगत तार स्वचालित रूप से बंद हो जाते हैं।
* यह हिस्सा मूल पायथ से अलग है जो वास्तव में एक मामले में कुछ करता है जैसे 1)
, 1-धमनी को समाप्त करना और एक त्रुटि उठाना।
इनपुट आउटपुट
इनपुट एक एकल गैर-रिक्त स्ट्रिंग होगी जिसमें केवल वर्ण होंगे 01234()"
। आप वैकल्पिक रूप से मान सकते हैं कि एक अतिरिक्त अनुगामी न्यूलाइन हमेशा मौजूद है। आप इस चुनौती के लिए एक समारोह या एक पूर्ण कार्यक्रम लिख सकते हैं।
यदि इनपुट कृत्रिम रूप से वैध पिथ, या मिथ्या मूल्य है, तो आपको एक सत्य मान का उत्पादन करना चाहिए। सच्चाई और झूठे मूल्यों को तय किया जाना चाहिए, ताकि आप 1
एक वैध कार्यक्रम और 2
दूसरे के लिए आउटपुट न कर सकें ।
स्कोरिंग
यह कोड-गोल्फ है, इसलिए सबसे कम बाइट्स में कोड जीतता है।
परीक्षण के मामलों
Truthy:
0
)
(
"
()
""
10
400010
210010
("")00
3"""""
(0)))0)1)0
2(2(2(0)0)0)0
2"010""44)()4"
)31(0)0(201000100
())2)1))0"3())"))
3("4321("301(0)21100"4")"123"00)40"121"31000""01010
Falsy:
1
1(310
(1)0)
12(010
4"00010"
3120102100
20(2((0)(0)))
2(2(2(0)0)0)01)
4(0102)00)00000
2"00"("00"2(""))
())2)1))0"3())"))
(जो सच होना चाहिए, मुझे लगता है)।
()210""
से बहुत सारे ऑप्स के साथ है)
[( [2 [0] [1 [0] ] ] [0] [1 [0]] [0] ]
? आपके पास 2, 0, 0, 1 और 0 की शाखाएँ हैं - दूसरा वहाँ नहीं होना चाहिए।