जांचें कि क्या एक तार जुड़वा बच्चों का फेरबदल है

Question

व्याख्या

नई स्ट्रिंग बनाने के लिए अपने अक्षरों को एक दूसरे से जोड़कर दो तारों को हिलाया जा सकता है, जैसे कि दो ढेर कार्ड को एक ढेर बनाने के लिए फेरबदल किया जा सकता है।

उदाहरण के लिए, तार HELLO और WORLDफार्म का फेरबदल किया जा सकता है HWEOLRLLOD, या HEWORLLLDO, या शायद बस HELLOWORLD।

यह है नहीं एक फेरबदल करता है, तो पत्र की मूल आदेश को संरक्षित नहीं किया गया है। उदाहरण के लिए, DमेंWORLD पहले कभी नहीं देखा जा सकता Rफेरबदल किए जाने के बाद। इसका मतलब यह है कि EHLLOWRDLO, उदाहरण के लिए, एक फेरबदल नहीं है HELLOऔर WORLDभले ही इसमें सभी मूल अक्षर शामिल हों।

एक तार जुड़वा बच्चों का एक फेरबदल है अगर इसे दो समान तारों को फेरकर बनाया जा सकता है। उदाहरण के लिए, ABACBDECDEजुड़वा बच्चों का एक फेरबदल है क्योंकि यह फेरबदल ABCDEऔर द्वारा गठित किया जा सकता है ABCDE। DBEACBCADEयह जुड़वा बच्चों का फेरबदल नहीं है क्योंकि इसे दो समान तारों के फेरबदल से नहीं बनाया जा सकता है।

कार्यक्रम का विवरण

इनपुट स्ट्रिंग को देखते हुए, आउटपुट 0यदि यह जुड़वाँ का फेरबदल नहीं है, और जुड़वाँ तारों में से एक का उत्पादन करता है यदि यह जुड़वाँ का फेरबदल है।

आप मान सकते हैं कि इनपुट स्ट्रिंग में चार और बीस अक्षरों के बीच की लंबाई है और पूरी तरह से अपरकेस वर्णमाला से बना है। इसे 10 मिनट के भीतर, उचित समय पर चलाने में सक्षम होना चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा समाधान जीतता है।

उदाहरण I / O

> ABACBDECDE
ABCDE

> DBEACBCADE
0

> FFFFFF
FFF

> FFGGG
0

> ABBA
0

> AABB
AB

> AABAAB
AAB

मेरे पास एक उदाहरण (गैर-गोल्फ) कार्यान्वयन है ।

Comments

उदाहरण स्ट्रिंग FGG मुखरता का उल्लंघन करती है that the input string has a length inclusively between four and twenty characters, और मुझे "उपयोगकर्ता इनपुट पर कभी भरोसा न करें!", "चश्मे पर कभी भरोसा न करें।"

— उपयोगकर्ता अज्ञात

@userunknown इतना शर्मनाक है! मैंने FFGGGइसे सुसंगत बनाने के लिए इसे संपादित किया ।

— पीटर ओल्सन

जिज्ञासा से बाहर, क्या कोई भी उप-घातीय सबसे खराब स्थिति समय जटिलता के साथ एक समाधान के साथ आ सकता है, या साबित कर सकता है कि कोई भी नहीं है?

— इल्मरी करोनें 17

Answer 1

हास्केल, 114

main=getLine>>=putStrLn.f.p;f x=head$[a|(a,b)<-x,a==b]++["0"]
p[]=[([],[])];p(x:y)=do(a,b)<-p y;[(x:a,b),(a,x:b)]

Ungolfed:

main :: IO ()
main = getLine >>= putStrLn . findMatch . partitions

-- | Find the first partition where the two subsequences are
-- equal. If none are, return "0".
findMatch :: [(String, String)] -> String
findMatch ps = head $ [a | (a,b) <- ps, a == b] ++ ["0"]

-- | Return all possible partitions of the input into two
-- subsequences. Preserves the order of each subsequence.
--
-- Example:
-- partitions "AB" == [("AB",""),("B","A"),("A","B"),("","AB")]
partitions :: [a] -> [([a], [a])]
partitions []     = [([], [])]
partitions (x:xs) = do (a, b) <- partitions xs
                       [(x:a, b), (a, x:b)]

स्पष्टीकरण:

ज्यादातर काम partitionsफंक्शन में हो रहे हैं। यह (a, b)सूची की पूंछ के सभी विभाजनों को पुन: उत्पन्न करके काम करता है , और फिर प्रारंभिक तत्व को प्रस्तुत करने के लिए सूची का उपयोग करता हैx उनमें से प्रत्येक के लिए करता है और सभी परिणामों को इकट्ठा करता है।

findMatchइस सूची को फ़िल्टर करके काम करता है ताकि केवल विभाजन जहां बाद में बराबर रहें। यह पहले विभाजन में पहली बाद की वापसी देता है। यदि कोई नहीं रहता है, तो सूची खाली है, इसलिए "0"अंत में संलग्न इसके बजाय वापस आ जाता है।

main बस इनपुट पढ़ता है, इसे इन दो कार्यों के माध्यम से फ़ीड करता है और इसे प्रिंट करता है।

Comments

हम में से जो हास्केल नहीं पढ़ सकते, क्या आप उनके बारे में स्पष्टीकरण देंगे?

— श्री। छिपकली

@ Mr.Wizard: संपादित देखें।

— हम्मीर

मुझे लगता है कि मैं काफी कुछ इसी तरह से आया था, हालांकि कम नहीं था, लेकिन मैं एक मूर्खतापूर्ण तरह से फेंक दिया जिसने इसे पूरी तरह से विफल कर दिया। क्या आपको बुरा लगता है अगर मैं इस एल्गोरिथ्म को गणितज्ञों में लागू करता हूं?

— श्री। छिपकली

Answer 2

आर, 113 वर्ण

l=length(x<-charToRaw(scan(,'')));max(apply(combn(l,l/2),2,function(i)if(all(x[i]==x[-i]))rawToChar(x[i])else 0))

Ungolfed (और इसके बजाय एक फ़ंक्शन जो स्ट्रिंग लेता है):

untwin <- function(x) {
  x <- charToRaw(x)
  indMtx <- combn(length(x),length(x)/2)
  res <- apply(indMtx, 2, function(i) {
    if (all(x[i]==x[-i]))
      rawToChar(x[i])
    else
      0
  })
  max(res)
}

untwin("ABACBDECDE") # "ABCDE"
untwin("DBEACBCADE") # 0

समाधान उस combnफ़ंक्शन पर निर्भर करता है जो एक मैट्रिक्स में कॉलम के रूप में सूचकांक के सभी संयोजनों को उत्पन्न करता है। applyफिर 2मैट्रिक्स में प्रत्येक कॉलम (आयाम ) पर एक फ़ंक्शन लागू करता है और स्ट्रिंग्स या जीरो का एक वेक्टर देता है। maxफिर सबसे बड़ी स्ट्रिंग ढूंढें (जो ट्रम्प 0)।

आर में एक शांत विशेषता एक वेक्टर के उपसमुच्चय का चयन करने की क्षमता है जो कि सूचकांकों का एक सदिश दिया गया है, और फिर सूचकांकों की उपेक्षा करके उस उपसमुच्चय के पूरक का चयन करें :x[i] == x[-i]

Comments

कुछ वृद्धिशील सुधार किए और चार गिनती कम की।

— टॉमी

Answer 3

गणितज्ञ, 87

यह सीधे हमार की पोस्ट पर आधारित है, लेकिन उम्मीद है कि यह मेरिट पोस्टिंग के लिए पर्याप्त है।

<<Combinatorica`

f=Catch[Cases[Characters@#~KSetPartitions~2,{x_,x_}:>Throw[""<>x]];0]&

परीक्षा:

f /@ {"ABACBDECDE", "DBEACBCADE", "FFFFFF", "FGG", "ABBA", "AABB", "AABAAB"}

{"ABCDE", 0, "FFF", 0, 0, "AB", "AAB"}

Answer 4

डी

string c(string in,string a=[],string b=[]){
    if(in.length==0)return a==b?a;"0";
    auto r=c(in[1..$],a~in[0],b);
    return r=="0"?c(in[1..$],a,b~in[0]):r;
}
void main(){writeln(c(readline));}

पहले पुनरावर्ती खोज में गहराई का उपयोग करना

मैं इसे एक int i = min(a.length,b.length);if(a[0..i]!=b[0..i])return "0";गार्ड क्लॉज के साथ तेज कर सकता हूं

Comments

IDEONE पर, मैं इस कार्यक्रम को शुरू करने में विफल रहा void main(){writeln(c("ABCADABCAD"));}- डी का एक अलग संस्करण, मेरी गलती, कुछ और? "ABCABCA" के बारे में क्या है?

— उपयोगकर्ता अज्ञात

आपको std.stdio आयात करने की आवश्यकता होगी; IO के लिए

— शाफ़्ट सनकी

Answer 5

रूबी, 89 वर्ण

s=->a,x,y{a=="\n"?x==y ?x:?0:[s[b=a[1..-1],x+c=a[0],y],s[b,x,y+c]].max}
$><<s[gets,'','']

यह कोड एक सादे पुनरावर्ती खोज एल्गोरिथ्म को लागू करता है। इनपुट STDIN पर दिया जाना चाहिए।

Answer 6

पर्ल, 68 वर्ण

/^((.+)(?{local($x,$,)=($,,$x.$^N)}))+$(?(?{$o=$,eq$x&&$,})|x)/?$o:0

इनपुट स्ट्रिंग को $_चर में माना जाता है , आउटपुट अभिव्यक्ति का मूल्य है। इनपुट में अनुगामी न्यूलाइन्स को अनदेखा किया जाता है। आप इसे कमांड लाइन से इस तरह चला सकते हैं:

perl -lne 'print /^((.+)(?{local($x,$,)=($,,$x.$^N)}))+$(?(?{$o=$,eq$x&&$,})|x)/?$o:0'

यह कोड Backling करने के लिए Perl के regexp इंजन (और विशेष रूप से इसकी एम्बेडेड कोड निष्पादन सुविधा) का उपयोग करता है। मूल रूप से, यह regexp के विरुद्ध इनपुट स्ट्रिंग से मेल खाता है , और दोनों में समान नहीं होने पर ^((.+))+$ऑड-ईवन $xऔर समान संख्या में सबमैच को ट्रैक करता है और $,अंत में मैच को अस्वीकार कर देता है।

Comments

क्या इसके लिए सही परिणाम है AABAAB?

— पीटर ओल्सन

हाँ यह करता है। (वास्तव में, AABAABइस समाधान के लिए एक आसान मामला है, क्योंकि बाहरी समूह को केवल दो बार मिलान करने की आवश्यकता है। मुझे इसे AABBसही तरीके से संभालने में अधिक समय लगा ।)

— इल्मरी करोनन

Answer 7

अजगर, १६, अक्षर

def f(s):
 c=s[0]
 d=i=r=0
 if s==c+c:r=c
 while i+1 and i<=len(s)/2 and not r:
  if i:d=f(s[1:i]+s[i+1:])
  if d:r=c+d
  i=s.find(c,i+1)
 return r
print f(raw_input())