बुरी खबर, कोई

Question

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

चुनौती

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

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

उदाहरण

[('A','B'),('C','D')] -> [('A','C'),('B','D'),('A','D'),('B','C')]

['A','B'] -> ['C','D','A','C','B','D','A','D','B','C']

[('A','B'),('C','D'),('A','C'),('A','D')] -> [('B', 'E'), ('A', 'E'), ('C', 'B'), ('C', 'E')]

"A\nB\nC\nD\n" -> "A\nC\nB\nD\nA\nD\nB\nC\n"

शो से एक:

[("Amy","Hubert"),("Bender","Amy"),("Hubert","Turanga"),("Amy","Wash Bucket"),("Wash Bucket","Nikolai"),("Phillip","John"),("Hermes","Turanga")]

नीचे दिया गया शो का समाधान अमान्य है:

[("Clyde","Phillip"),("Ethan","John"),("Clyde","John"),("Ethan",Phillip"),("Clyde","Hubert"),("Ethan","Wash Bucket"),("Clyde","Leela"),("Ethan","Nikolai"),("Clyde","Hermes"),("Ethan","Bender"),("Clyde","Amy"),("Ethan","Hubert"),("Clyde","Wash Bucket")]

इसका कारण यह है एतान अमान्य है, और क्लाइड की वजह से कितना कम अनावश्यक हैं फ्राई फिलिप, Zoidberg जॉन और हेमीज़ हेमीज़ मशीन का इस्तेमाल किया। इस मामले के लिए एक वैध समाधान नीचे दिया गया है:

[("Philip","Hubert"),("John","Wash Bucket"),("Philip","Turanga"),("John","Nikolai"),("Philip","Hermes"),("John","Bender"),("Philip","Amy"),("John","Hubert"),("Philip","Wash Bucket")]

ध्यान दें कि किसी भी वैध इनपुट के लिए स्पष्ट रूप से कई संभावित उत्तर हैं। कोई भी मान्य है।

Comments

क्या कुछ नाम हैं जिन्हें हम मान सकते हैं कि उनका उपयोग नहीं किया जाएगा?

— feersum

@ फेरेसम नोप, चुनौती का हिस्सा;)

— फ्राईमईएग्गमैन

@ Faersum आपका मतलब है कि क्या आपने पूरे इनपुट को एक स्ट्रिंग के रूप में लिया है? फिर, हां, आप यह मान सकते हैं कि नाम उनके बीच नई कड़ियाँ नहीं होंगे। (इसे अभी संपादित करते हुए)

— फ्राईअमईएग्गमैन

शो के इनपुट के लिए आपका समाधान काम नहीं करता है। एमी और बेंडर अंत में बदली हैं। एक सही समाधान होगा[('Nikolai', 'Phillip'), ('Nikolai', 'Hubert'), ('Nikolai', 'Turanga'), ('Nikolai', 'Bender'), ('Phillip', 'Amy'), ('John', 'Wash Bucket'), ('Nikolai', 'John'), ('Phillip', 'Wash Bucket'), ('Hubert', 'John'), ('Bender', 'Hermes')]

— जकुब

@Jakube क्षमा करें, ऐसा लगता है कि मैंने शो के लिए स्थिति में प्रवेश करते समय एक टाइपो बनाया। मेरा मानना ​​है कि यह अब ठीक हो गया है, और समाधान ठीक है।

— FryAmTheEggman

Answer 1

अजगर 3: 328 वर्ण (धीमा), 470 वर्ण (तेज)

शायद एक गंभीर जवाब के लिए थोड़ा बहुत लंबा है।

धीमा और छोटा कोड:

from itertools import*
def d(u,s):i,j=map(u.index,s);u[i],u[j]=u[j],u[i]
def f(Q):
 n=set()
 for s in Q:n|=set(s)
 n=list(n)
 while 1:
  for t in permutations(i for i in combinations(n,2)if not set((i,i[::-1]))&set(Q)):
   u=n[:];j=0
   for s in Q:d(u,s)
   for s in t:
    j+=1;d(u,s)
    if n==u:return t[:j]
  n+=[''.join(n)]

d(u,s)एक स्वैप लागू होता है sकरने के लिए u। मुख्य विधि में f(Q), मैं पहले nसेट संचालन का उपयोग करके सभी व्यक्तियों की सूची तैयार करता हूं और परिणाम को एक सूची में परिवर्तित करता हूं । while 1-Loop बिल्कुल नहीं एक अनंत लूप के है। इसमें, मैं उन लोगों का उपयोग करके समस्या को हल करने की कोशिश करता हूं जो मेरे पास हैं n। यदि यह सफल नहीं होता है, तो मैं सभी नामों को मिलाकर एक अन्य व्यक्ति को जोड़ता हूं n+=[''.join(n)]। इसलिए while 1-लूप को अधिकतम 3 बार निष्पादित किया जाता है (प्रश्न में प्रमाण देखें)।

समस्या का समाधान क्रूरता से किया जाता है। मैं सभी स्वैप उत्पन्न करता हूं जो कानूनी हैं और सभी क्रमपरिवर्तन की कोशिश करते हैं for t in permutations(i for i in combinations(n,2)if not set((i,i[::-1]))&set(Q))। यदि प्रत्येक व्यक्ति अपने शरीर में है, तो मैं स्वैप के अनुक्रम को वापस करता हूं।

उपयोग:

print(f([('A','B'),('C','D')]))
print(f([('A','B')]))
print(f([('A','B'),('C','D'),('A','C'),('A','D')]))

भविष्य से उदाहरण बहुत लंबा रास्ता तय करता है। 9 व्यक्ति हैं, इसलिए 36 संभावित स्वैप हैं और उनमें से 28 कानूनी हैं। तो २६ हैं! कानूनी अनुमति।

तेज़ कोड

def w(u,s):i,j=map(u.index,s);u[i],u[j]=u[j],u[i]
def f(Q):
 n=set()
 for s in Q:n|=set(s)
 while 1:
  n=list(n);u=n[:];l=len(n)
  for s in Q:w(u,s)
  for d in range((l*l-l)//2-len(Q)+1):r(n,u,Q,[],d)
  n+=[''.join(n)]
def r(n,u,Q,t,d):
 m=0;v=u[:];l=len(u)
 for i in range(l):
  if n[i]!=v[i]:m+=1;w(v,(n[i],v[i]))
 if m<1:print(t);exit()
 for i in range(l*l):
  s=n[i//l],n[i%l]
  if m<=d and i//l<i%l and not set([s,s[::-1]])&set(Q+t):v=u[:];w(v,s);r(n,v,Q,t+[s],d-1)

फ़ंक्शन f(Q)में पुनरावृत्त गहनता दृष्टिकोण है। यह पहले गहराई = 0, फिर गहराई = 1, जब तक गहराई = (l * ll) // 2-len (Q) की कोशिश करता है, जो कि कानूनी चालों की अधिकतम संख्या है। धीमे कोड की तरह यह फिर दूसरे व्यक्ति को जोड़ता है और फिर से कोशिश करता है।

पुनरावर्ती फ़ंक्शन स्वैप के साथ r(n,u,Q,t,d)वर्तमान स्थिति को हल करने की कोशिश करता है । हल की स्थिति है, इनपुट चलता रहता है और पहले से ही चलता रहता है। यह पहले आवश्यक स्वैप की एक निचली सीमा की गणना करता है (कानूनी और अवैध स्वैप के साथ राज्य को हल करके)। यदि == 0, सभी व्यक्ति सही निकाय में हैं, तो यह समाधान प्रिंट करता है । अन्यथा यह सब संभव स्वैप की कोशिश करता है, (प्रूनिंग), (जो पहले से ही में शामिल है , (अनुमति नहीं देते जैसे स्वैप या और ) और ( अभी तक प्रदर्शन किया नहीं किया गया है)।udnQtmmtsm<dd>1m<di//l<i%l('A','A')('A','B')('B','A')not set([s,s[::-1]])&set(Q+t)s

उपयोग:

f([("Amy","Hubert"),("Bender","Amy"),("Hubert","Turanga"),("Amy","Wash Bucket"),("Wash Bucket","Nikolai"),("Philip","John"),("Hermes","Turanga")])

यह मेरे लैपटॉप पर pypy का उपयोग कर के बारे में 17 सेकंड में और pypy के बारे में 2 मिनट के बारे में भविष्य की समस्या के लिए इष्टतम स्वैप पाता है। ध्यान दें कि दोनों एल्गोरिदम एक ही पैरामीटर के साथ कॉल करने पर विभिन्न समाधानों का आउटपुट देते हैं। यह एक python- की हैशिंग एल्गोरिथ्म की वजह से है set। nहर बार एक अलग क्रम में व्यक्ति को संग्रहीत करता है। इसलिए एल्गोरिथ्म तेजी से या प्रत्येक रन धीमा हो सकता है।

संपादित करें: मूल भविष्य परीक्षण मामला गलत था, सही किए गए परीक्षण मामले में 10 के बजाय 9 का इष्टतम समाधान है, और इसलिए यह तेज है। Pypy के साथ 2 सेकंड, बिना 7 सेकंड।