एकॉर्डियन गेम को हल करें

Question

अकॉर्डियन एक सॉलिटेयर कार्ड गेम है जो मैं हाल ही में आया था जहां लगभग हर लेआउट सॉल्व है, लेकिन अविश्वसनीय रूप से कठिन है। आप इसे यहाँ खेल सकते हैं ।

नियम

52 फेस कार्ड एक यादृच्छिक क्रम में आमने-सामने रखे जाते हैं। प्रत्येक मोड़, आप एक कार्ड को बाद के कार्ड से बदल देते हैं, जहाँ दो कार्ड होते हैं :

• एक सूट या संख्या और साझा करें
• 1 (आसन्न) या 3 (बीच में दो कार्ड ) की दूरी पर हैं ।

खेल तब जीता जाता है जब केवल 1 कार्ड शेष होता है । आप मान सकते हैं कि प्रत्येक इनपुट सॉल्व है। प्रतिस्थापित कार्ड को हमेशा प्रतिस्थापित कार्ड से पहले होना चाहिए।

उदाहरण

एक उदाहरण के रूप में, निम्नलिखित लेआउट पर विचार करें:

2H,2S,1S,2D  (H: Hearts, S: Spades, D: Diamonds)

यहां 3 संभावित चालें हैं:

1. 2Hआसन्न के साथ बदलें 2S, इसलिए हम समाप्त करते हैं2S,1S,2D
2. 2Sआसन्न के साथ बदलें 1S, इसलिए हम समाप्त करते हैं2H,1S,2D
3. (3 की दूरी पर) के 2Hसाथ बदलें 2D, इसलिए हम साथ समाप्त करते हैं2D,2S,1S

उन 3 चालों में से, केवल अंतिम की जीत की संभावना है (आप जगह से जीतते हैं 2D <- 2S, फिर 2S <- 1S)।

इनपुट आउटपुट

आपका काम एक अकॉर्डियन सॉल्वर लिखना है । आपको कार्ड की एक सूची दी गई है, और आपको गेम को हल करने के लिए चाल की एक सूची वापस करने की आवश्यकता है।

आपको कार्ड की एक सूची अल्पविराम-सीमांकित स्ट्रिंग के रूप में पारित की जाती है, जहां प्रत्येक कार्ड को उनके संख्यात्मक मान का प्रतिनिधित्व करने वाले पूर्णांक के रूप में पारित किया जाता है, फिर एक पात्र उनके सूट का प्रतिनिधित्व करता है।

आपको कॉमा-सीमांकित स्ट्रिंग के रूप में प्रतिस्थापन की एक सूची वापस करनी चाहिए, जहां प्रत्येक प्रतिस्थापन प्रारूप में है Card <- Card(ऊपर वर्णित कार्ड प्रारूप के बाद)। प्रत्येक जोड़ी में पहला कार्ड प्रतिस्थापित किया जा रहा कार्ड है।

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

5H,1C,12S,9C,9H,2C,12C,11H,10C,13S,3D,8H,1H,12H,4S,1D,7H,1S,13D,13C,7D,12D,6H,10H,4H,8S,3H,5D,2D,11C,10S,7S,4C,2H,3C,11S,13H,3S,6C,6S,4D,11D,8D,8C,6D,5C,7C,5S,9D,10D,2S,9S
5H,9C,11H,7S,7D,12D,6H,10S,3H,4D,12C,2S,3C,5C,7H,6S,1H,8S,2H,11S,4C,10D,12H,9H,2D,4H,6C,13H,11C,2C,10H,8C,1S,11D,3S,12S,7C,5D,13S,8D,4S,6D,13C,3D,8H,13D,1D,9D,9S,1C,5S,10C
7H,11C,8C,7S,10D,13H,4S,10C,4D,2C,4H,13D,3C,2H,12C,6C,9H,4C,12H,11H,9S,5H,8S,13S,8H,6D,2S,5D,11D,10S,1H,2D,5C,1C,1S,5S,3H,6S,7C,11S,9C,6H,8D,12S,1D,13C,9D,12D,3D,7D,10H,3S

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

Comments

क्या आपके नियमों का उल्लेख है कि चालें केवल एक ही दिशा में बनाई जा सकती हैं?

— feersum

मेज पर प्रत्येक कार्ड में औसतन 0.25 + 0.25 = 0.5 कानूनी चालें हैं। इसलिए खोज स्थान लगभग 52 है! * 0.5 = 4E67। लिखित (कोड गोल्फ टैग के साथ) के रूप में चुनौती को केवल इस पूरे स्थान की खोज करने और किसी भी समाधान (या "कोई भी" समाप्त होने पर) की रिपोर्ट करने के लिए आवश्यक समझा जा सकता है, जो सरलता के लिए बहुत कम जगह छोड़ता है और खगोलीय समय की आवश्यकता होती है। मेरा सुझाव है कि आप सफलता की दर और समय को देखते हुए इसे एक कोड चुनौती बनाते हैं, और या तो स्कोर पर कोड की लंबाई के प्रभाव को कम करते हैं या इसे पूरी तरह से खत्म कर देते हैं।

— लेवल रिवर सेंट

@ Pietu1998 और उसमें समस्या निहित है। मुझे लगता है कि मेमोराइज़र आपको बाइट्स की लागत दे रहा है, इसलिए आपको गोल्फर संस्करण के रूप में मेमोराइज़र के बिना संस्करण प्रस्तुत करना चाहिए, लेकिन फिर 52 कार्ड डेक पर परीक्षण करना असंभव हो जाता है। कोडगॉल्फ बड़े खोज स्थानों के साथ समस्याओं पर स्कोरिंग प्रणाली के रूप में अच्छी तरह से काम नहीं करता है।

— लेवल रिवर सेंट

मैं कोड-गोल्फ प्रतिस्पर्धी बनने के इच्छुक लोगों के लिए खगोलीय runtimes के साथ ठीक हूं। हालाँकि, लोग निश्चित रूप से उत्तर देने में सक्षम (और प्रोत्साहित) हैं जो प्रतिस्पर्धी नहीं हैं, और रन-टाइम के बारे में हैं।

— नाथन मेरिल

इसके अलावा, यदि आप कोड-गोल्फ समाधान का परीक्षण करना चाहते हैं, तो 52-कार्ड डेक की आवश्यकता नहीं है। एक 16-कार्ड (4 सूट) डेक को छोटे रनटाइम प्रदान करने और शुद्धता की पुष्टि करनी चाहिए।

— नाथन मेरिल

Answer 1

पायथन 3, 274 272 271 बाइट्स

2 बाइट्स @orlp की बदौलत बच गए ।

def g(p):
 q=lambda a:[[i,a]for i in range(len(p)-a)if p[i][:-1]==p[i+a][:-1]or p[i][-1]in p[i+a]]
 for n in q(1)+q(3):
  s=sum(n);c=p[:s]+p[s+1:];c[n[0]]=p[s]
  if g(c):return p[n[0]]+' <- '+p[s]+','+g(c)
 return' 'if len(p)<2else[]
print(g(input().split(','))[:-2]or'')

यह बेहद धीमी है। हालाँकि, आप इसे एक मेमो के साथ आज़मा सकते हैं । यह कुछ अतिरिक्त है list- tupleरूपांतरण, लेकिन अन्यथा बराबर है।

import functools
@functools.lru_cache(maxsize=None)
def g(p):
 q=lambda a:[[i,a]for i in range(len(p)-a)if p[i][:-1]==p[i+a][:-1]or p[i][-1]in p[i+a]]
 for n in q(1)+q(3):
  s=sum(n);c=list(p[:s]+p[s+1:]);c[n[0]]=p[s]
  if g(tuple(c)):return p[n[0]]+' <- '+p[s]+','+g(tuple(c))
 return' 'if len(p)<2else[]
print(g(tuple(input().split(',')))[:-2]or'')

यहां तक ​​कि यह एक विशेष इनपुट के साथ खगोलीय रूप से धीमा है।

कोड स्ट्रिंग का उपयोग करता है, संख्याओं का नहीं, इसलिए यह नोटेशन का भी समर्थन करता है जैसे KHकि 13H।

उदाहरण:

$ python accordion.py
5H,9C,11H,7S,7D,12D,6H,10S,3H,4D,12C,2S,3C,5C,7H,6S,1H,8S,2H,11S,4C,10D,12H,9H,2D,4H,6C,13H,11C,2C,10H,8C,1S,11D,3S,12S,7C,5D,13S,8D,4S,6D,13C,3D,8H,13D,1D,9D,9S,1C,5S,10C
7S <- 7D,7D <- 12D,3C <- 5C,12H <- 9H,11C <- 2C,3S <- 12S,13D <- 1D,1D <- 9D,9D <- 9S,2S <- 6S,7H <- 1H,6S <- 8S,1H <- 2H,8S <- 11S,2H <- 9H,10D <- 2D,9H <- 4H,4H <- 4C,5C <- 4C,4D <- 4C,4C <- 12C,10S <- 11S,11H <- 11S,6H <- 3H,12D <- 2D,12C <- 2C,2C <- 6C,6C <- 8C,12S <- 13S,5D <- 6D,6D <- 8D,8D <- 3D,4S <- 9S,13S <- 9S,11D <- 3D,7C <- 1C,1S <- 1C,1C <- 13C,8C <- 13C,13C <- 13H,13H <- 10H,2D <- 3D,3D <- 3H,3H <- 8H,8H <- 10H,11S <- 5S,5H <- 10H,5S <- 9S,10H <- 10C,10C <- 9C,9C <- 9S

Comments

functools.lru_cacheअपने लिखने के बजाय उपयोग करें ।

— orlp

@orlp मैं करूँगा, लेकिन जैसा listकि यह उपलब्ध नहीं है, यह काम नहीं करता है।

— पुरकाकूदरी

इसके बाद टुपल्स का इस्तेमाल करें।

— orlp

@orlp ठीक है, लेकिन इसके लिए कोड में परिवर्तन की आवश्यकता होगी (उदाहरण के लिए str.splitरिटर्न list)। मैं दो कार्यक्रमों को कार्यात्मक रूप से समतुल्य बनाना पसंद करूंगा।

— पुरकाकूदरी

आप कर सकते थे h=lambda p:lru_cache(None)(g)(''.join(p))।

— orlp