स्पष्ट रूप से एपीएल ट्रेनों को छोटा करना

Question

एपीएल में, आप ट्रेक फ़ंक्शन लिख सकते हैं, जिन्हें ट्रेनें कहा जाता है । वे कैसे काम करते हैं इस चुनौती के लिए अप्रासंगिक है। ⍴फ़ंक्शन के रूप में उनका उपयोग अलग-अलग तरीकों से किया जा सकता है :

⍴      -> ⍴
⍴⍴     -> ⍴⍴
⍴⍴⍴    -> ⍴⍴⍴
⍴⍴⍴⍴   -> ⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴  -> ⍴⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴⍴ -> ⍴(⍴⍴(⍴⍴⍴))
...

आदेश वही रहता है। प्रक्रिया यह है कि जब तक कड़ाई से 3 से अधिक कार्य होते हैं, तब तक अंतिम 3 फ़ंक्शन एक फ़ंक्शन में समूहीकृत होते हैं। यदि हम एक नेस्टेड ट्रेन से मिलते हैं, तो हम जारी रखने से पहले उस को छोटा कर देते हैं। इस प्रक्रिया को यहां लागू किया गया है ⍴⍴⍴⍴⍴⍴:

Step 0: ⍴⍴⍴⍴⍴⍴
There are strictly more than 3 functions, repeat.
Step 1: ⍴⍴⍴(⍴⍴⍴)
There are strictly more than 3 functions, repeat.
Step 2: ⍴(⍴⍴(⍴⍴⍴))
There are 3 or less functions, we're done.

यहां एक ही प्रक्रिया लागू होती है ⍴⍴⍴(⍴⍴)⍴(⍴⍴⍴⍴(⍴⍴⍴))⍴⍴:

Step 0: ⍴⍴⍴(⍴⍴)⍴(⍴⍴⍴⍴(⍴⍴⍴))⍴⍴
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
  Step 0: ⍴⍴⍴⍴(⍴⍴⍴)
  There are strictly more than 3 functions, repeat.
  We have met a nested train, applying procedure to that first:
    Step 0: ⍴⍴⍴
    There are 3 or less functions, we're done.
  Step 1: ⍴⍴(⍴⍴(⍴⍴⍴))
  There are 3 or less functions, we're done.
Step 1: ⍴⍴⍴(⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴)
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
  Step 0: ⍴⍴
  There are 3 or less functions, we're done.
Step 2: ⍴⍴⍴((⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴))
There are strictly more than 3 functions, repeat.
Step 3: ⍴(⍴⍴((⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴)))
There are 3 functions or less, we're done.

इनपुट

इस चुनौती के लिए, इनपुट को सरल बनाया जाएगा। इसका मतलब है कि आप कोष्ठक खोलने और बंद करने के लिए 2 अलग-अलग चार्ट चुन सकते हैं और 1 चार्ट कार्य के लिए चुन सकते हैं, जो कोष्ठक के लिए चुने गए हैं। आपके द्वारा चुने गए चार्ट सुसंगत होने चाहिए। इनपुट खाली नहीं होगा, और इसमें बिना सामग्री (यानी ()) वाले कोष्ठक नहीं होंगे ।

उत्पादन

फिर से, आप 3 विभिन्न वर्णों को चुन सकते हैं, 2 कोष्ठक के लिए और 1 कार्य के लिए। ध्यान दें कि उन्हें इनपुट के लिए चुने गए समान नहीं होना चाहिए, लेकिन उन्हें सुसंगत होना चाहिए।

नियम

• यदि कोष्ठक हैं जो केवल इनपुट में उनके भीतर एक फ़ंक्शन को संलग्न करते हैं, तो आपको उन्हें आउटपुट में निकालना होगा। आपके आउटपुट में अनावश्यक कोष्ठक नहीं हो सकते हैं (अर्थात केवल एक फ़ंक्शन को संलग्न करना, या संपूर्ण आउटपुट को संलग्न करना)।
• जब तक आपका समाधान इस चुनौती के लिए मान्य है, तब तक आपको यहां उपयोग किए गए एल्गोरिदम को लागू करने की आवश्यकता नहीं है।
• इनपुट और आउटपुट इनपुट और आउटपुट अनुभागों में बताए गए प्रारूप में तार हैं। इनपुट में कम से कम एक वर्ण होगा।
• मानक खामियों का उपयोग करना सख्त वर्जित है।
• यह कोड-गोल्फ है , इसलिए सबसे कम उत्तर जीतता है। हालाँकि, कोई स्वीकृत उत्तर नहीं होगा, क्योंकि यह एक प्रति-भाषा प्रतियोगिता है, और उन भाषाओं में उत्तर देने को प्रोत्साहित करने के लिए जिनमें यह कार्य अन्य भाषाओं में लिखे गए कोड की तुलना में अधिक लंबा कोड होगा।

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

यहाँ इस्तेमाल किए गए चार्ट हैं ()⍴, आपको उन्हें अपने चुने हुए चार्ट के साथ बदलना चाहिए।

⍴                          -> ⍴
⍴                          -> ⍴
⍴⍴                         -> ⍴⍴
⍴⍴⍴                        -> ⍴⍴⍴
⍴⍴⍴⍴                       -> ⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴            -> ⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴⍴))))))
⍴⍴⍴⍴⍴(⍴⍴⍴)⍴⍴(⍴(⍴⍴⍴)⍴⍴⍴)⍴⍴⍴ -> ⍴(⍴⍴(⍴⍴((⍴⍴⍴)⍴(⍴(⍴(⍴⍴⍴)(⍴⍴⍴))(⍴⍴⍴)))))
(⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)            -> (⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)
(⍴⍴⍴)(⍴⍴⍴)⍴⍴⍴              -> (⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)
⍴⍴(⍴)⍴⍴                    -> ⍴⍴(⍴⍴⍴)
((⍴⍴))                     -> ⍴⍴
⍴⍴((⍴⍴))⍴⍴                 -> ⍴⍴((⍴⍴)⍴⍴)

_{यह चुनौती सैंडबॉक्स में पोस्ट की गई है। यदि आपके पास आवश्यक विशेषाधिकार हैं, तो आप यहां सैंडबॉक्स पोस्ट देख सकते हैं ।}

Comments

मुझे लगता है कि पूरी तरह से स्पष्ट रूप से एक बेहतर शीर्षक है ।

— आदम डे

किसी भी परीक्षण मामले का संदर्भ उत्तर।

— 18

@ Adám मुझे उम्मीद है कि संदर्भ उत्तर, यह हालांकि कई

— अपवित्र

@ शीर्षक में स्पष्ट रूप से हिस्सा इस तथ्य को संदर्भित करता है कि आपको अनावश्यक कोष्ठक को हटाना होगा। जब आप चुनौती का जवाब देते हैं, तो पूरी तरह से कुछ ऐसा होता है; पी

— एरिक आउटगॉल्फ

क्या यह सच है कि यह समारोह हमेशा सुस्पष्ट रहेगा?

— फलन

Answer 1

APL (Dyalog Classic) , 71 68 65 63 बाइट्स

0{⍵≡⍕⍵:⍵⋄⍬≡⍵:'⍬'⋄1=≢⍵:⍺∇⊃⍵⋄3≥≢⍵:⍺⌽')(',⍣⍺∊1∇¨⍵⋄⍺∇¯3(↓,∘⊂1∇↑)⍵}⍎

इसे ऑनलाइन आज़माएं!

पात्रों मैं आई / ओ के लिए चुना है '(', ')'और '⍬'।

यह समाधान स्वयं एक एपीएल ट्रेन है।

⍎इनपुट के रूप में यदि यह एक नेस्टेड सरणी है - ⍬पत्तियों के रूप में खाली संख्यात्मक वैक्टर ( ) के साथ एक पेड़ ।

Dfn (यानी लंबोदर - { }) पेड़ को पीछे की ओर धकेलता है और इसे एक उचित कोष्ठक में बदल देता है। बाएं तर्क यह ⍺नियंत्रित करता है कि क्या आवश्यक होने पर कोष्ठकों को वर्तमान स्तर पर जोड़ा जाना चाहिए या नहीं।

Dfn सही तर्क के आधार पर निम्नलिखित मामलों को संभालता है:

• यदि यह पहले से ही एक स्ट्रिंग ( ⍵≡⍕⍵) है, तो इसे वापस कर दें

• यदि यह है ⍬, तो चार वापस कर दें'⍬'

• यदि यह एक सिंगलटन है, तो बस गहरी खुदाई करें ( ∇पुनरावर्ती कॉल के लिए प्रतीक है)

• यदि इसकी लंबाई ,3 है, तो प्रत्येक आइटम के लिए पुनरावृत्ति करें और ()यदि आवश्यक हो तो घेर लें

• अन्यथा, 3-पूंछ के लिए पुनरावृत्ति करें, सभी को छोड़ दें, लेकिन 3-पूंछ, और फिर से पुनरावृत्ति करें

Comments

63 पात्रों की तरह दिखता है, उनमें से ज्यादातर यूनिकोड हैं। किस वर्ण एन्कोडिंग के लिए 63 बाइट्स का उत्पादन होता है? मैं इसे UTF8 में 141 बाइट करता हूं।

— कोरी

@ कोरी एपीएल का अपना 8-बिट कोड पेज है ।

— zwol

@ कोरी प्रासंगिक मेटा पोस्ट ।

— आदम डे

@ Adám इसके लिए धन्यवाद। मैंने देखा लेकिन पता नहीं था कि उस उत्तर को प्राप्त करने के लिए क्या खोजना है।

— कोरी

Answer 2

पायथन 2 , 224 208 204 बाइट्स

^{-16 बाइट्स धन्यवाद श्री एक्सकोडर -4 बाइट्स ओव्स के लिए धन्यवाद}

r=str.replace
p='p'
def c(l):
 while len(l)>3:l=l[:-3]+(l[-3:],)
 return l and map(c,l)or l
print r(r(r(r(r(`c(eval(r(r(r(input(),'(p)',p),p,'[],'),')','),')))`,'[]',p),*'[('),*'])'),' ',''),',','')[1:-1]

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों का प्रयास करें

कोड को 3 प्रमुख चरणों में विभाजित किया जा सकता है:
इनपुट को नेस्टेड सूची में बदलना और प्रतिस्थापित करना (p)->p। एकल फ़ंक्शन pको रिक्त सूची से बदल दिया जाएगा।

eval(r(r(r(input(),'(p)',p),p,'[],'),')','),'))

वर्तमान सूची पर "3 या उससे कम" नियम को लागू करने के लिए एक पुनरावर्ती कार्य और सभी-सब्लिस्ट पर खुद को कॉल करें।

def c(l):
 while len(l)>3:l=l[:-3]+(l[-3:],)
 return l and map(c,l)or l

वांछित आउटपुट प्रारूप में प्रारूप के लिए बहुत सारे

r(r(r(r(r(`c(...)`,'[]',p),*'[('),*'])'),' ',''),',','')[1:-1]

Comments

204 बाइट्स

— ओव्स

यह सरल नहीं है ((pp))(या p((pp))p)।

— मार्टिन एंडर

Answer 3

सीजेएम , 56 बाइट्स

^{APL धड़कता है!}

lW%~]]]{{_,{K_,({~}|}&}%{_,3>}{3/(aa\+:~}w}:K~~`1>W<W%S/

इसे ऑनलाइन आज़माएं!

यह काम करता है (मुझे लगता है) और मुझे पता नहीं क्यों ...

इनपुट चरित्र ][Tके लिए ()⍴, और उत्पादन चरित्र ][0के लिए ()⍴(हाँ, इस का मतलब है कि वे आप क्या उम्मीद करेंगे से उलट कर रहे हैं, उदाहरण के लिए, आप में पारित हो सकता है TTT]TT[T]TTTT]TTT[[TT)।

उच्च-स्तरीय अवलोकन

कार्यक्रम इनपुट के साथ पीछे की ओर काम करता है, क्योंकि यह अधिक सुविधाजनक है। इनपुट को पार्स करने के लिए, हम CJam के पार्सर का लाभ उठाते हैं - इनपुट को उलटने और निष्पादित करने से इनपुट का (पीछे) पार्स किया हुआ रूप प्रदान करता है।

हम तो एक प्रक्रिया को परिभाषित करते हैं K। Kहमारे प्रस्तुत करने के लिए अधिकांश काम करता है, और यह निम्नानुसार काम करता है:

• इनपुट सरणी शून्य और गैर-रिक्त उप-सरणियों का मिश्रण होगी। उप-सरणियों की पहचान करें और Kउन पर पुन: लागू करें। परिणाम एक और सरणी होना चाहिए, और यदि इस सरणी में सिर्फ एक ही तत्व होता है, तो इसे अनपैक करें (यह निरर्थक कोष्ठक से छुटकारा दिलाता है)।
• जब तक परिणाम में तीन से अधिक तत्व होते हैं, तब तक इसके पहले तीन (इसके अंतिम तीन नहीं) समूह को याद रखें कि इनपुट को एक ही सूची में पीछे की ओर संसाधित किया जा रहा है)।
• परिणाम लौटाओ।

Kइनपुट पर लागू होने से, हमें इनपुट का उचित रूप से संक्षिप्त रूप प्राप्त होता है (केवल ध्यान देने योग्य बात यह है कि हम वास्तव में इनपुट को एक सिंगलटन सूची में लपेटते हैं और बाद में इसे खोल देते हैं; इसका कारण यह है कि हम उस स्निपेट को सिंग्लेट को खोलना चाहते हैं; शीर्ष-स्तरीय कार्यक्रम पर लागू होने के लिए, और इसके उप-सरणियों में नहीं)। बाद में, हम अपना परिणाम प्राप्त करने के लिए कुछ न्यूनतम प्रारूपण लागू करते हैं।

गोल्फ वाले बिट्स के लिए कुछ स्पष्टीकरण

मुझे जिस गोल्फ पर सबसे अधिक गर्व है, वह ,पूर्णांकों और सरणियों के बीच जांच करने के लिए उपयोग कर रहा है।

• यदि शीर्ष-स्टैक एक पूर्णांक n है , ,तो रेंज [0..n) उत्पन्न करता है । चूंकि हमारा एकमात्र पूर्णांक होगा 0, यह हमेशा हमें खाली सूची देता है [], जो कि गलत है।
• यदि टॉप-ऑफ-स्टैक एक सरणी है, तो ,इसकी लंबाई लेता है। चूँकि हमारे सामने आने वाली सभी सरणियाँ गैर-रिक्त होंगी, यह हमेशा हमें एक सकारात्मक पूर्णांक देता है, जो कि सत्य है।

एक और गोल्फ जो ब्याज की हो सकती है वह विधि है जिसका उपयोग मैं सरणी के पहले तीन तत्वों को समूह में करने के लिए करता हूं; यह मेरे "ट्यूरिंग लैंग्वेज इंटरप्रेटर कोड गोल्फ" सबमिशन के समान है । CJam के पास दो टुकड़ों में एक सरणी को तोड़ने का एक छोटा तरीका नहीं है (आप पहले हिस्से और फिर दूसरे भाग को स्टैक पर मूल सरणी और इंडेक्स रखते हुए बंद करने की कोशिश कर सकते हैं, लेकिन यह बहुत अच्छा काम नहीं करता है) , इसलिए मैं इसके बजाय क्या उपयोग करता हूं 3/, जो कि एक सरणी को 3 के ब्लॉक में रखता है। फिर मैं पहले तत्व को पॉप कर सकता हूं (, दो बार सरणी में लपेट सकता हूं aa, और फिर सूची की शुरुआत में वापस संलग्न कर सकता हूं \+। दो बार सरणी में लपेटने का कारण यह है कि हमें एक परत को उतारना है :~, क्योंकि हमने बाकी सरणी को भी वर्गों में बांटा है।

Comments

नाइटपिक: यह बिना बिल के एपीएल को हरा देता है ।

— ३g पर आउटगॉल्फ को एरिक

@EriktheOutgolfer मेला काफी

— फल

Answer 4

जावास्क्रिप्ट (ईएस 6), 149 146 बाइट्स

i='a';f=s=>s==(s=s[R='replace'](/\((\w+)\)/,(q,t)=>(f[q=i+=0]=f(t),q)))&&s==(s=s[R](/(?!^)((a0+|p){3})$/,"($1)"))?s[R](/a0+/g,t=>`(${f[t]})`):f(s)

<textarea cols=80 id=I>ppp(pp)p(pppp(ppp))pp</textarea><br>
<button onclick=O.innerText=f(I.value)>Run</button><br>
<pre id=O></pre>

का उपयोग करता है ()p, हालांकि आप एक अलग पत्र का उपयोग करने के लिए आप बस pअंत की ओर बदल सकते हैं ।