एंटीस्ट्रेसिंग को संकुचित करें

Question

इस चुनौती में आपको इनपुट के रूप में एक अक्षर स्ट्रिंग दी जाएगी। हम दिए गए इनपुट के "एंटी-स्ट्रिंग" को सभी अक्षरों के मामले के साथ स्ट्रिंग होने के लिए परिभाषित करेंगे। उदाहरण के लिए

AaBbbUy -> aAbBBuY

आपको एक प्रोग्राम लिखना चाहिए जो इनपुट के रूप में एक स्ट्रिंग लेता है और सबसे लंबे समय तक सन्निहित विकल्प की खोज करता है जिसका एंटी-स्ट्रिंग भी एक सन्निहित विकल्प है। दो पदार्थों को ओवरलैप नहीं करना चाहिए।

एक उदाहरण के रूप में यदि आपको स्ट्रिंग दिया गया था

fAbbAcGfaBBagF

बोल्ड किए गए भाग सबसे लंबे समय तक स्ट्रिंग विरोधी स्ट्रिंग जोड़ी होगी।

आपका कार्यक्रम, एक बार यह जोड़ी मिल जाने के बाद, उन्हें एक-एक पात्र में समेट दें। इसे सभी को हटाकर ऐसा करना चाहिए लेकिन प्रत्येक स्थानापन्न का पहला वर्ण। उदाहरण के लिए ऊपर स्ट्रिंग

fAbbAcGfaBBagF

बन जाएगा

fAcGfagF

आपके कार्यक्रम को तब तक इस प्रक्रिया को दोहराना चाहिए जब तक कि सबसे लंबी स्ट्रिंग एंटी-स्ट्रिंग जोड़ी एकल वर्ण या छोटी न हो।

उदाहरण के लिए एक ही तार के साथ काम करने के बाद पतन के बाद सबसे लंबी जोड़ी है

fAcGfagF

तो हम फिर से स्ट्रिंग को ध्वस्त करते हैं

fAcGag

अब स्ट्रिंग को और ढहाया नहीं जा सकता है इसलिए हमें इसका उत्पादन करना चाहिए।

उम्मीदवार जोड़े (उदाहरण AvaVA) के बीच एक टाई के मामले में आप या तो कमी कर सकते हैं ( AaAया AvV, लेकिन नहीं Aa)।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

fAbbAcGfaBBagF  ->  fAcGag
AvaVA ->  AaA / AvV
QQQQQQQ -> QQQQQQQ
fAbbAcQQQQaBBacqqqqA -> fAbcQBcq
gaq -> gaq
fAbbAcGfaBBagFaBBa -> fcGaBBag

मंशा

जबकि यह समस्या मनमाने ढंग से हो सकती है, यह वास्तव में एक समस्या है जिसे मैंने मौलिक बहुभुज को संसाधित करने के लिए कोड बनाते समय सामना किया था। इस प्रक्रिया का उपयोग एक मौलिक बहुभुज को छोटे n- भग को कम करने के लिए किया जा सकता है । मैंने कोशिश करने के बाद सोचा कि यह एक अच्छा सा गोल्फ बना देगा।

Comments

यदि एंटी-स्ट्रिंग सबस्ट्रिंग के साथ सबसे बड़े सबस्ट्रिंग में एक से अधिक ऐंट-स्ट्रिंग सबस्ट्रिंग हैं, तो क्या सभी सब्सट्रिंग को ढह जाना चाहिए या केवल पहले दो को ही बदल देना चाहिए?

— जोनाथन फ्रीच

@JonathanFrech कोई भी दो। यह एक ऐसा मामला है जहां उम्मीदवार जोड़े के बीच एक टाई है।

— गेहूं जादूगर

तो aaaAAAaaa -> aAaaa?

— जोनाथन फ्रीच

इस समस्या के एक सबसेट के बारे में कुछ क्वीन चिल्लाता है, लेकिन मैं उस पर अपनी उंगली नहीं डाल सकता।

— मैजिक ऑक्टोपस मूत्र

@MagicOctopusUrn कुछ इस तरह लिखें कि दो-चक्र वाला क्वीन कहां लिखें, जहां प्रोग्राम का आउटपुट इसकी एंटीक्योरिंग है ?

— जोनाथन फ्रीच

Answer 1

पर्ल, 64 61 बाइट्स

के लिए शामिल +1हैp

perl -pE 's/(.\K.{$%})(.*)(?=(.))(??{$1^$"x$%.$"})/$2$3/ while$%=--pos' <<< fAbbAcGfaBBagFaBBa

Answer 2

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

I / O के लिए वर्णों के सरणियों का उपयोग करता है।

f=a=>(m=M=C=>a.map((_,i)=>a.map((_,j)=>C(i,j-i+1))))(I=>M((i,j)=>a.slice(i,i+j).some((n,k)=>n[c='charCodeAt']()^(a[I+k]||'')[c]()^32)|I+j>i|j<m||(x=[i,I],m=j)))&&m-->1?f(a,x.map(p=>a.splice(p+1,m))):a

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

Answer 3

रेटिना , 119 बाइट्स

.+
$&¶$&
T`Ll`lL`.*¶
/(.).*¶.*\1/^&0A`
¶&Lv$`(?<=(.)*)((.)(.)*).*¶(?>((?<-1>.)*.)(?<-4>.)*)(.*)\2
$5$6$3$'
N$`
$.&
}0G`

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
$&¶$&
T`Ll`lL`.*¶

इनपुट को डुप्लिकेट करें और पहली प्रति के मामले को फ्लिप करें।

/(.).*¶.*\1/^&0A`

यदि बिल्कुल भी एंटी-स्ट्रिंग्स नहीं हैं, तो फ़्लिप किए गए डुप्लिकेट को हटा दें।

¶&Lv$`(?<=(.)*)((.)(.)*).*¶(?>((?<-1>.)*.)(?<-4>.)*)(.*)\2
$5$6$3$'

सभी संभावित ध्वस्त विरोधी तारों की सूची बनाएं।

N$`
$.&
}0G`

लंबाई के क्रम में उन्हें क्रमबद्ध करें, सबसे छोटा (यानी सबसे लंबा एंटी-स्ट्रिंग) लें, और तब तक दोहराएं जब तक कि सभी विरोधी तार ध्वस्त न हो जाएं।

Answer 4

पायथन 3 , 189 181 बाइट्स

इसे शुद्ध वन-लाइनर बनाने के लिए जोनाथन फ्रेच को श्रेय।

f=lambda s,x=set():any(u in s[j+i:]and(x.add(s[:j+1]+s[j+i:].replace(u,u[0],1))or 1)for i in range(len(s),1,-1)for j in range(len(s))for u in[s[j:j+i].swapcase()])and f(x.pop())or s

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

मेरा अपना संस्करण, अब अप्रचलित (189 बाइट्स):

x=set()
def f(s):
 while any(u in s[j+i:]and(x.add(s[:j+1]+s[j+i:].replace(u,u[0],1))or 1)for i in range(len(s),1,-1)for j in range(len(s))for u in[s[j:j+i].swapcase()]):s=x.pop()
 return s

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

any()नेस्टेड छोरों को जल्दी से तोड़ने के set()लिए , और समझ में आने योग्य वैश्विक वस्तु के लिए। बाकी का उपयोग कर आवश्यकताओं का सीधा कार्यान्वयन है str.swapcase।

पायथन 2 , 160 बाइट्स

def f(s):
 for i in range(len(s),1,-1):
	for j in range(len(s)):
	 u=s[j:j+i].swapcase()
	 if u in s[j+i:]:return f(s[:j+1]+s[j+i:].replace(u,u[0],1))
 return s

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

जल्दी से टूटने के साथ पाश के लिए नियमित नेस्टेड return"चालाक" चाल से कम रास्ता है any।

Comments

181 बाइट्स ; पुनरावर्ती दृष्टिकोण। setफ़ंक्शन डिफॉल्ट के रूप में परिवर्तनशील आगे की कॉल के साथ नहीं टकराएगा, क्योंकि मुझे लगता है कि आपका कोड पूरी तरह से खाली होने के लिए सेट को पॉप करता है।

— जोनाथन फ्रीच

क्षमा करें, मैंने सोचा कि xखाली नहीं रहने के पीछे छोड़ दिया जाएगा। जैसा कि आपके पास है, मुझे लगता है कि यह अनुपालन करता है।

— जोनाथन फ्रीच

यह ठीक है, और सुधार के लिए धन्यवाद।

— बुबलर

Answer 5

C (gcc) , 240 238 227 225 222 216 बाइट्स

• दो बाइट्स बचाए; एक आवारा चर परिभाषा को हटा दिया।
• सहेजा गया ग्यारह तेरह बाइट्स; golfed b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64करने b|=abs(S[p+m]-S[q+m])-32के लिए b|=32-S[p+m]+S[q+m]&63।
• तीन बाइट्स बचाए; को गोल्फ for(...;...;p++)S[p+1]=S[p+L];दिया for(...;...;S[++p]=S[p+L]);।
• छत की छत के लिए धन्यवाद छह बाइट्स सहेजे गए ।

p,P,q,Q,l,L,b,m;f(char*S){for(p=0;S[p];p++)for(l=0;S[l+++p];)for(q=0;b=S[q+~-l];!b&p+l<=q&l>L?L=l,P=p,Q=q:0,q++)for(b=0,m=l;m--;)b|=32-S[p+m]+S[q+m]&63;for(;b-2;)for(p=b++?-~Q-L:P;S[p];S[++p]=S[L+p]);~-L?L=0,f(S):0;}

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

Comments

@ceilingcat धन्यवाद।

— जोनाथन फ्रीच

Answer 6

पायथन 2 , 180 बाइट्स

def f(s):
 L=len(s)
 for x,y in[(i,i+j)for j in range(L,1,-1)for i in range(L-j)]:
	t=s[x:y];T=t.swapcase()
	if T in s[y:]:return f(s.replace(t,t[0],1).replace(T,T[0],1))
 return s

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

Answer 7

स्टैक्स , 30 बाइट्स

î☼fúΩ§☺æ╒ºê@Ñ▀'╫Iqa{d]∟Sa5♦⌂─╚

इसे चलाएं और डीबग करें

इसी कार्यक्रम का संबंधित एएससीआई प्रतिनिधित्व है।

c%Dc:e{%orF..*:{_{32|^mY++_h.$1yh++R

यह एक रेगेक्स दृष्टिकोण का उपयोग करता है। यह बार-बार रेगेक्स स्ट्रिंग रिप्लेसमेंट करता है। यह वर्तमान मूल्य के प्रत्येक सन्निहित प्रतिस्थापन से इनका निर्माण करता है। उदाहरण के लिए इनपुट के लिए fAbbAcGfaBBagF, सबस्ट्रिंग में से एक है AbbA, जिस स्थिति में रेगेक्स AbbA(.*)aBBaको बदल दिया जाएगा A$1a।

c                                       get number of characters
 %D                                     repeat rest of program that many times
   c:e                                  get all substrings
      {%or                              order substrings longest to shortest
          F                             for each substring, execute the rest
           ..*:{                        build the string "(.*)"
                _{32|^m                 current substring with case inverted
                       Y                save the inverted case in register y
                        ++              concatenate search regex together
                                            e.g. "aBc(.*)AbC"
                          _h            first character of substring
                            .$1         "$1"
                               yh       first character of inverted case
                                 ++     concatenate replacement regex together
                                            e.g. "a$1A"
                                   R    do regex replacement

Answer 8

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 148 बाइट्स

#//.s_:>MinimalBy[StringReplaceList[s,a:(p_~~__)~~x___~~b:(q_~~__)/;(32==##&@@Abs[(t=ToCharacterCode)@a-t@b]):>p<>x<>q]/.{}->{s},StringLength][[1]]&

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

Answer 9

जाप -h , 33 बाइट्स

à ñÊÅÔ£=rX+"(.*)"+Xc^H ÈÎ+Y+XÎc^H

कोशिश करो

à ñÊÅÔ£=rX+"(.*)"+Xc^H ÈÎ+Y+XÎc^H     :Implicit input of string U
à                                     :Combinations
  ñ                                   :Sort by
   Ê                                  :  Length
    Å                                 :Remove first element (the empty string)
     Ô                                :Reverse
      £                               :Map each X
       =                              :  Reassign to U
        r                             :  Global replacement
         X+"(.*)"+                    :  Append "(.*)" to X and then append
                  Xc                  :    Charcodes of X
                    ^H                :    XORed with 32
                      È               :  Pass each match X, with captured group Y, through the following function
                       Î+Y+           :    Append Y to the first character of X and then append
                           XÎc^H      :      The charcode of the first character of X XORed with 32