प्रसंग के साथ तार

इस चुनौती के प्रयोजनों के लिए, संदर्भ के साथ एक स्ट्रिंग तार का एक ट्रिपल है, जिसे बाएं संदर्भ , डेटा भाग और सही संदर्भ कहा जाता है । यह एक लंबी स्ट्रिंग के एक विकल्प का प्रतिनिधित्व करता है। हम ऊर्ध्वाधर पाइप |को विभाजक के रूप में उपयोग करते हैं , इसलिए संदर्भ के साथ एक स्ट्रिंग का एक उदाहरण है cod|e-go|lf, जहां बाएं संदर्भ है cod, डेटा है e-go, और सही संदर्भ है lf। यह उदाहरण के विकल्प का प्रतिनिधित्व करता e-goहै code-golf।

अब, संदर्भ के साथ दो तारों को संक्षिप्त करने के लिए, हम निम्नानुसार, उदाहरण के रूप में aa|bcc|deeऔर आगे बढ़ते cc|de|eeeहैं। हम स्ट्रिंग्स को आरेख के रूप में संरेखित करते हैं

a a|b c c|d e e
      c c|d e|e e e

ताकि उनके डेटा भाग आसन्न हों। इस मामले में, डेटा भाग का डेटा भाग का भाग है bccde। बाएं संदर्भ वह हिस्सा है जो इस मामले में, पहले डेटा भाग के बाईं ओर के पंखों का विस्तार करता है aa। इसी तरह, सही संदर्भ है eee, इसलिए संदर्भ के साथ संयोजन स्ट्रिंग है aa|bccde|eee। एक दूसरे उदाहरण के लिए, विचार करें a|bb|cdऔर aabb|cd|, जहां दूसरे शब्द का खाली सही संदर्भ है। संरेखण आरेख है

  a|b b|c d
a a b b|c d|

जहाँ दूसरे शब्द का बायाँ संदर्भ पहले की तुलना में अधिक विस्तृत है। संघात है aa|bbcd|।

लेकिन रुको, वहाँ एक गोत्र है: यदि संरेखण आरेख के अक्षर मेल नहीं खाते हैं, तो संघनन मौजूद नहीं है! एक उदाहरण के रूप में, का आरेख aa|bb|ccऔर c|c|cहै

a a|b b|c c
      c|c|c

जहां bऔर cचौथे स्तंभ पर असहमत हैं, इसलिए उन्हें सहमति नहीं दी जा सकती है।

काम

आपका काम एक ऐसा प्रोग्राम लिखना है जो दो स्ट्रिंग्स में संदर्भ के साथ लेता है, जिनके हिस्से |ऊपर से अलग हो जाते हैं , और अगर यह मौजूद है, तो उनके कॉन्सेप्टेशन को आउटपुट करता है, और अगर नहीं तो कुछ और। "कुछ और" कोई भी मूल्य हो सकता है, जिसमें कोई आउटपुट नहीं है, जब तक कि यह संदर्भ के साथ एक वैध स्ट्रिंग नहीं है, और यह सभी मामलों में समान है। हालांकि, एक त्रुटि फेंकना स्वीकार्य नहीं है। आप या तो एक STDIN-to-STDOUT कार्यक्रम या एक फ़ंक्शन दे सकते हैं, और अनाम फ़ंक्शन भी स्वीकार किए जाते हैं। सबसे छोटी बाइट गिनती जीतती है, और मानक खामियों को रोक दिया जाता है।

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

aa|bcc|dee cc|de|eee -> aa|bccde|eee
a|bb|cd    aabb|cd|  -> aa|bbcd|
a|b|cccd   aab|cc|c  -> aa|bcc|cd
a|b|c      b||cd     -> a|b|cd
aa|bb|cc   c|c|c     -> None
aaa|b|c    abb|cd|d  -> None
|bb|cd     abb|c|ed  -> None
a|b|c      a||cd     -> None

code-golf string

— Zgarb
स्रोत

4

हास्केल, 184 182 201 199 155

s&t|(a,'|':b)<-f t,(x,'|':y)<-f$r s,x#b,a#y=r(y!r a)++b!r x|0<1=""
r=reverse
a!b=a++drop(length a-1)b
(#)a=and.zipWith(==)(r a).filter h
f=span h
h=(/='|')

उदाहरण रन:

"|a|"&"|b|" -- returns "|ab|"
"|a|x"&"|b|" -- returns ""

अगर कोई मैच नहीं होता है तो एक खाली स्ट्रिंग लौटा दी जाएगी। अन्यथा परिणाम वापस आ जाएगा।

आंशिक स्पष्टीकरण:

# एक ऐसा फंक्शन है जिसमें दो तार मिलते हैं, और वे मैच करते हैं या नहीं।

! दो तार हो जाते हैं और दूसरे से अतिरिक्त चरित्र के साथ पहले वाले को लौटा दिया जाता है (यदि कोई हो)।

मुख्य फ़ंक्शन इनपुट को दो भागों में विभाजित करने के लिए &उपयोग करता span (/='|')है, a|b|cकरने के लिए a, b|c, अगर संदर्भों से मेल खाता है, और फिर !आउटपुट को इकट्ठा करने के लिए दो बार उपयोग करता है ।

संपादित करें: दाना-देर से regolfing बहुत प्रभावी लगता है।

— गर्वित हेकलर
स्रोत

हम्म, मुझे डर है कि एक त्रुटि फेंकना एक स्वीकार्य आउटपुट विधि नहीं है, खासकर एक फ़ंक्शन के लिए। |1<2=""की परिभाषा में &इसे जोड़ना चाहिए। मुझे खेद है कि मैंने ऐनक में इसे अधिक स्पष्ट रूप से निर्दिष्ट नहीं किया है, मैं इसे संपादित करूँगा।

— ज़र्गब

@Zgarb वास्तव में, यह इसे ठीक नहीं करेगा। '|'जब स्ट्रिंग ठीक से मेल नहीं खाती है तो क्या बहुत सारे संकेतों के साथ एक स्ट्रिंग वापस आ रही है ?

— गर्वित हैकेलर

निश्चित रूप से, जब तक यह सभी गैर-मिलान इनपुट के लिए समान स्ट्रिंग है।

— जगरब

3

पायथन (242 बाइट्स)

import itertools as i
s='|'
j=''.join
r=reversed
m=lambda a,b:j(j(*set(p+q))for p,q in i.izip_longest(a,b,fillvalue=''))
def c(A,B):
 u,v,w,x,y,z=(A+s+B).split(s)
 try:return j(r(m(r(u+v),r(x))))[:-len(v)]+s+v+y+s+m(w,y+z)[len(y):]
 except:0

व्याख्या

mजब तक वे एक सामान्य उपसर्ग साझा करते हैं , लंबोदर फ़ंक्शन दो स्ट्रिंग्स के लंबे समय तक लौटाता है। यह रिक्त स्ट्रिंग श्रृंखलाबद्ध करके करता है ''किसी भी लापता मूल्यों के स्थान पर, तो परिणाम बदल (जो रूप ले सकता है aa, ab, a, या bमैच / बेमेल / असमान लंबाई की मामलों में) प्रत्येक स्थिति पर विशेष अक्षर के एक सेट में। joinएकल तर्क की अपेक्षा करता है, इसलिए एक सेट को एक से अधिक तत्वों के साथ अनपैक करने से यह एक को बढ़ाएगा TypeError।

मुख्य समारोह तब

बाएं संदर्भ और डेटा भागm को जोड़ने के लिए दूसरे के बाएं संदर्भ के साथ पहले शब्द का उपयोग करता है (दाएं से बाएं बाएं उलटा तार)
डेटा भागों को सम्मिलित करता है,
और फिर से पहले शब्द के सही संदर्भ को डेटा भाग और दूसरे के सही संदर्भ के साथ mजोड़ देता है

दो मूल शब्दों के डेटा भागों को नए संदर्भों के दाएं और बाएं पक्षों से छंटनी की जाती है।

चूँकि हम जानते हैं कि मिसलिग्न्मेंट एक कारण mको पैदा करते हैं TypeError, इन मामलों में हम अपवाद को पकड़ते हैं और स्पष्ट रूप से वापसी करते हैं None।

परिक्षण

TESTCASES = [
    ('aa|bcc|dee', 'cc|de|eee', 'aa|bccde|eee'),
    ('a|bb|cd', 'aabb|cd|', 'aa|bbcd|'),
    ('a|b|cccd', 'aab|cc|c', 'aa|bcc|cd'),
    ('a|b|c', 'b||cd', 'a|b|cd'),
    ('aa|bb|cc', 'c|c|c', None),
    ('aaa|b|c', 'abb|cd|d', None),
    ('|bb|cd', 'abb|c|ed', None),
    ('a|b|c', 'a||cd', None),
]

for A, B, R in TESTCASES:
    print '{:<10} {:<9} -> {}'.format(A, B, c(A, B))

उत्पादन

aa|bcc|dee cc|de|eee -> aa|bccde|eee
a|bb|cd    aabb|cd|  -> aa|bbcd|  
a|b|cccd   aab|cc|c  -> aa|bcc|cd 
a|b|c      b||cd     -> a|b|cd    
aa|bb|cc   c|c|c     -> None      
aaa|b|c    abb|cd|d  -> None      
|bb|cd     abb|c|ed  -> None      
a|b|c      a||cd     -> None

— ग्रेग
स्रोत

कॉन्टेक्ट के साथ कॉन्टेनेट स्ट्रिंग्स