दिलचस्प पोस्ट
JSON फ़ॉर्म डेटा को सीरियल करें स्पार्क: RDD से सभी संभव संयोजनों के ] उत्पादन करें एक स्थानीय डेटाबेस / फोनगैप / कॉर्डोबा / आईओएस में कैमरे के साथ ली गई तस्वीर को कैप्चर करना और संग्रहीत करना LINQ से SQL बाएं बाहरी सहभागी जो कंप्रेसर विधि PHP में उपयोग करने के लिए है? 4 * 0.1 का फ्लोटिंग-प्वाइंट मान पायथन 3 में अच्छा क्यों दिखता है लेकिन 3 * 0.1 नहीं है? Ggplot2 पौराणिक प्रदर्शन आदेश को नियंत्रित करना OS X "El Capitan" पर रत्न स्थापित नहीं कर सकता jquery $ .ajax से कोण $ http एक स्थान के साथ कई स्थान बदलने के लिए Regex एसक्यूएल: बनाम <= और> = संग्रह में अटल बदलने का आसान तरीका श्रोताओं का उपयोग करते हुए एएनएएनएलआरआर में / अगर अन्य बयान कन्वर्ट शब्दकोश <स्ट्रिंग, वस्तु> अनाम वस्तु पर? ज्यूनेट असेंशन

इस कोड के प्रदर्शन में सुधार करने के लिए कैसे?

यहां से लोगों की कुछ मदद के लिए धन्यवाद, मैं अपना कोड तस्मानियन ऊंटों के लिए काम करने में सक्षम था। हालांकि, यह बहुत धीमी है (मुझे लगता है। मुझे यकीन नहीं है क्योंकि यह अजगर में मेरा पहला प्रोग्राम है)। कोड के निचले भाग में चलने वाला उदाहरण मेरी मशीन में हल करने के लिए एक लंबा समय लगता है:

dumrat@dumrat:~/programming/python$ time python camels.py [['F', 'F', 'F', 'G', 'B', 'B', 'B'], ['F', 'F', 'G', 'F', 'B', 'B', 'B'], ['F', 'F', 'B', 'F', 'G', 'B', 'B'], ['F', 'F', 'B', 'F', 'B', 'G', 'B'], ['F', 'F', 'B', 'G', 'B', 'F', 'B'], ['F', 'G', 'B', 'F', 'B', 'F', 'B'], ['G', 'F', 'B', 'F', 'B', 'F', 'B'], ['B', 'F', 'G', 'F', 'B', 'F', 'B'], ['B', 'F', 'B', 'F', 'G', 'F', 'B'], ['B', 'F', 'B', 'F', 'B', 'F', 'G'], ['B', 'F', 'B', 'F', 'B', 'G', 'F'], ['B', 'F', 'B', 'G', 'B', 'F', 'F'], ['B', 'G', 'B', 'F', 'B', 'F', 'F'], ['B', 'B', 'G', 'F', 'B', 'F', 'F'], ['B', 'B', 'B', 'F', 'G', 'F', 'F']] real 0m20.883s user 0m20.549s sys 0m0.020s 

यहां कोड है:

 import Queue fCamel = 'F' bCamel = 'B' gap = 'G' def solution(formation): return len([i for i in formation[formation.index(fCamel) + 1:] if i == bCamel]) == 0 def heuristic(formation): fCamels, score = 0, 0 for i in formation: if i == fCamel: fCamels += 1; elif i == bCamel: score += fCamels; else: pass return score def getneighbors (formation): igap = formation.index(gap) res = [] # AB_CD --> A_BCD | ABC_D | B_ACD | ABD_C def genn(i,j): temp = list(formation) temp[i], temp[j] = temp[j], temp[i] res.append(temp) if(igap > 0): genn(igap, igap-1) if(igap > 1): genn(igap, igap-2) if igap < len(formation) - 1: genn(igap, igap+1) if igap < len(formation) - 2: genn(igap, igap+2) return res class node: def __init__(self, a, g, p): self.arrangement = a self.g = g self.parent = p def astar (formation, heuristicf, solutionf, genneighbors): openlist = Queue.PriorityQueue() openlist.put((heuristicf(formation), node(formation, 0, None))) closedlist = [] while 1: try: f, current = openlist.get() except IndexError: current = None if current is None: print "No solution found" return None; if solutionf(current.arrangement): path = [] cp = current while cp != None: path.append(cp.arrangement) cp = cp.parent path.reverse() return path #arr = current.arrangement closedlist.append(current) neighbors = genneighbors(current.arrangement) for neighbor in neighbors: if neighbor in closedlist: pass else: openlist.put((current.g + heuristicf(neighbor), node(neighbor, current.g + 1, current))) #sorted(openlist, cmp = lambda x, y : xf > yf) def solve(formation): return astar(formation, heuristic, solution, getneighbors) print solve([fCamel, fCamel, fCamel, gap, bCamel, bCamel, bCamel]) #print solve([fCamel, fCamel, fCamel, fCamel, gap, bCamel, bCamel, bCamel, bCamel]) 

यह सिर्फ 3 ऊंटों के लिए है मैं कम से कम 4 के लिए ऐसा करना चाहता था यह परीक्षण केस अभी भी चल रहा है (यह लगभग 5 मिनट का है :()। मैं इसे अपडेट करूँगा और जब यह खत्म होगा।

इस कोड को सुधारने के लिए मुझे क्या करना चाहिए? (ज्यादातर प्रदर्शन-वार, अन्य सुझाव भी स्वागत है)

धन्यवाद।

Solutions Collecting From Web of "इस कोड के प्रदर्शन में सुधार करने के लिए कैसे?"

मैं भी इस से पहले भी जा चुका हूं वास्तव में बाधा यह है if neighbor in closedlist

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

यदि बंद closedlist का ऑर्डर एल्गोरिदम के लिए महत्वपूर्ण है, तो आप ऑपरेटर के लिए एक सेट का उपयोग कर सकते हैं और अपने परिणामों के लिए एक समानांतर सूची रख सकते हैं।

मैंने इस के एक साधारण क्रियान्वयन की कोशिश की जिसमें एक हारोरसलिंग का नामित टुप्ले चाल था और यह आपकी पहली उदाहरण के लिए 0.2 सेकंड और आपके दूसरे के लिए 2.1 सेकंड में किया गया, लेकिन मैंने परिणामों को दूसरी लंबे समय तक के लिए सत्यापित करने का प्रयास नहीं किया है।

पहले मुझे बताएं कि समस्या कैसे खोजनी है I तब मैं आपको बताता हूँ कि यह कहां है:

मैंने आपके कोड को समझने की कोशिश करने के लिए भी परेशान नहीं किया है। मैं बस भाग गया और 3 यादृच्छिक-समय स्टैक नमूने ले लिया। मैंने नियंत्रण-सी लिखकर और परिणामी स्टैकट्र्रेस को देखकर ऐसा किया।

इसे देखने का एक तरीका है: यदि कोई बयान यादृच्छिक स्टैक निशान के एक्स% पर प्रदर्शित होता है, तो यह समय के बारे में एक्स% के लिए स्टैक पर है, इसलिए यही है कि इसके लिए जिम्मेदार है। यदि आप इसे निष्पादित करने से बच सकते हैं, तो आप कितनी बचत करेंगे

ठीक है, मैंने 3 स्टैक नमूनों को लिया वे यहाँ हैं:

 File "camels.py", line 87, in <module> print solve([fCamel, fCamel, fCamel, gap, bCamel, bCamel, bCamel]) File "camels.py", line 85, in solve return astar(formation, heuristic, solution, getneighbors) File "camels.py", line 80, in astar openlist.put((current.g + heuristicf(neighbor), node(neighbor, current.g + 1, current))) File "camels.py", line 87, in <module> print solve([fCamel, fCamel, fCamel, gap, bCamel, bCamel, bCamel]) File "camels.py", line 85, in solve return astar(formation, heuristic, solution, getneighbors) File "camels.py", line 80, in astar openlist.put((current.g + heuristicf(neighbor), node(neighbor, current.g + 1, current))) File "camels.py", line 87, in <module> print solve([fCamel, fCamel, fCamel, gap, bCamel, bCamel, bCamel]) File "camels.py", line 85, in solve return astar(formation, heuristic, solution, getneighbors) File "camels.py", line 80, in astar openlist.put((current.g + heuristicf(neighbor), node(neighbor, current.g + 1, current))) 

नोटिस, इस मामले में स्टैक नमूने सभी समान हैं। दूसरे शब्दों में, इन सभी तीन पंक्तियों में से हर एक समय के लिए व्यक्तिगत रूप से जिम्मेदार है। तो उनको देखें:

 line 87: print solve([fCamel, fCamel, fCamel, gap, bCamel, bCamel, bCamel]) line solve: 85: return astar(formation, heuristic, solution, getneighbors) line astar: 80: openlist.put((current.g + heuristicf(neighbor), node(neighbor, current.g + 1, current))) 

स्पष्ट रूप से लाइन 87 एक नहीं है आप निष्पादित करने से बच सकते हैं, और शायद 85 नहीं तो या तो यह 80 पत्ते, openlist.put । कॉल कॉल अब, आप यह नहीं बता सकते हैं कि समस्या + ऑपरेटर, heuristicf फोन, node कॉल, या कॉल किए गए कॉल में है या नहीं। आप यह पता लगा सकते हैं कि क्या आप अलग-अलग लाइनों पर उनको अलग कर सकते हैं

इसलिए मुझे आशा है कि आप अपनी कार्यक्षमता समस्याओं को जानने के लिए इस त्वरित और आसान तरीके से उठा सकते हैं।

टकरविन सही है कि आपको बंद सूची के लिए एक सेट का उपयोग करना चाहिए, जो चीजों को बहुत बढ़ाता है, लेकिन यह अभी भी हर तरफ 4 ऊंटों के लिए धीमी गति से है अगली समस्या यह है कि आप बहुत सारे समाधान की अनुमति दे रहे हैं जो संभव नहीं हैं क्योंकि आप एफसीएमेल को पीछे की तरफ जाने की अनुमति दे रहे हैं और आगे बढ़ने के लिए बीकैमल्स। इसे ठीक करने के लिए, लाइनों को बदलें,

 if(igap > 0): genn(igap, igap-1) if(igap > 1): genn(igap, igap-2) if igap < len(formation) - 1: genn(igap, igap+1) if igap < len(formation) - 2: genn(igap, igap+2) 

साथ में

 if(igap > 0 and formation[igap-1] == fCamel): genn(igap, igap-1) if(igap > 1 and formation[igap-2] == fCamel): genn(igap, igap-2) if (igap < len(formation) - 1) and formation[igap+1] == bCamel: genn(igap, igap+1) if (igap < len(formation) - 2) and formation[igap + 2] == bCamel: genn(igap, igap+2) 

तो मुझे प्रत्येक पक्ष की समस्या पर 4 ऊंटों का समाधान मिलता है जैसे कि 0 0 सेकेंड की बजाय 10 सेकंड। मैंने प्रत्येक पक्ष पर 5 ऊंटों की भी कोशिश की और यह 0.09 सेकंड ले गया। मैं कतार के बजाय बंद लिस्ट और हापक के लिए एक सेट का उपयोग कर रहा हूं।

अतिरिक्त गति-अप

आप अपने अनुमानी सही ढंग से उपयोग करके एक अतिरिक्त गति प्राप्त कर सकते हैं वर्तमान में, आप लाइन का उपयोग कर रहे हैं

 openlist.put((current.g + heuristicf(neighbor), node(neighbor, current.g + 1, current))) 

(या उस का हैप संस्करण) लेकिन आपको इसे बदलना चाहिए

 openlist.put((heuristicf(neighbor), node(neighbor, current.g + 1, current))) 

यह आवश्यक कदमों की संख्या में कारक नहीं है, लेकिन यह ठीक है। इस पहेली के साथ (और ऊँटों को गलत दिशा में ले जाने वाली चाल से बाहर की जांच), आपको चाल की संख्या की चिंता करने की आवश्यकता नहीं है – या तो कोई कदम आपको समाधान की ओर बढ़ाता है या यह एक मृत अंत में आ जाएगा । दूसरे शब्दों में, सभी संभावित समाधानों में उसी संख्या की चाल होती है यह एक परिवर्तन 13 सेकंड से प्रत्येक पक्ष के मामले में 12 ऊंटों के समाधान का पता लगाने के लिए समय लेता है (यहां तक ​​कि हेपैक, बंद लिस्ट के लिए सेट और ऊपर पड़ोसियों को खोजने के लिए भी) 0.389 सेकंड तक। बुरा नहीं है।

वैसे, यह पता लगाने का एक बेहतर तरीका है कि आपको समाधान मिल गया है, यह जांचना है कि क्या पहले एफकैम का सूचकांक संरचना / 2 + 1 (इंट डिवीजन का उपयोग) के बराबर है और इससे पहले सूचकांक अंतराल के बराबर

की जगह

 class node: def __init__(self, a, g, p): self.arrangement = a self.g = g self.parent = p 

साथ में

 node = collections.namedtuple('node', 'arrangement, g, parent') 

इनपुट के बारे में 340-600 मिसेज से 11.4 1.89 1 मिसेज तक का समय गिरा। [fCamel, fCamel, gap, bCamel, bCamel] । यह एक ही आउटपुट उत्पन्न हुआ।

यह स्पष्ट रूप से किसी भी एल्गोरिथम समस्याओं के साथ मदद नहीं करता लेकिन जहां तक ​​माइक्रो-ऑप्टिमाइजेशन जाते हैं, यह बुरा नहीं है।

1 मेरे पास गलत इनपुट था एक अतिरिक्त fCamel था जो इसे धीमी गति से चला रहा था

नीचे दिए गए कोड को हल करने के लिए 1 से कम का उपयोग करना

 from itertools import permutations GAP='G' LEFT='F' RIGHT='B' BEGIN=('F','F','F','F','G','B','B','B','B') END=('B','B','B','B','G','F','F','F','F') LENGTH=len(BEGIN) ALL=set(permutations(BEGIN)) def NextMove(seq): g=seq.index(GAP) ret = set() def swap(n): return seq[:n]+seq[n:n+2][::-1]+seq[n+2:] if g>0 and seq[g-1]==LEFT: ret.add(swap(g-1)) if g<LENGTH-1 and seq[g+1]==RIGHT: ret.add(swap(g)) if g<LENGTH-2 and seq[g+1]==LEFT and seq[g+2]==RIGHT: ret.add(seq[:g]+seq[g+2:g+3]+seq[g+1:g+2]+seq[g:g+1]+seq[g+3:]) if g>1 and seq[g-1]==RIGHT and seq[g-2]==LEFT: ret.add(seq[:g-2]+seq[g:g+1]+seq[g-1:g]+seq[g-2:g-1]+seq[g+1:]) return ret AllMoves={state:NextMove(state) for state in ALL} def Solve(now,target): if now==target: return True for state in AllMoves[now]: if Solve(state,target): print(now) return True return False Solve(BEGIN,END) 

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

 """ notation: a game state is a string containing angle brackets ('>' and '<') and blanks '>>> <<<' """ def get_moves(game): result = [] lg = len(game) for i in range(lg): if game[i] == '>': if i < lg-1 and game[i+1] == ' ': # '> ' -> ' >' result.append(game[:i]+' >'+game[i+2:]) if i < lg-2 and game[i+1] != ' ' and game[i+2] == ' ': # '>< ' -> ' <>' result.append(game[:i]+' '+game[i+1]+'>'+game[i+3:]) if game[i] == '<': if i >= 1 and game[i-1] == ' ': # ' <' -> '< ' result.append(game[:i-1]+'< '+game[i+1:]) if i >= 2 and game[i-1] != ' ' and game[i-2] == ' ': # ' ><' -> '<> ' result.append(game[:i-2]+'<'+game[i-1]+' '+game[i+1:]) return result def wander(start, stop): fringe = [start] paths = {} paths[start] = () def visit(state): path = paths[state] moves = [move for move in get_moves(state) if move not in paths] for move in moves: paths[move] = paths[state] + (state,) fringe.extend(moves) while stop not in paths: visit(fringe.pop()) print "still open: ", len(fringe) print "area covered: " , len(paths) return paths[stop] + (stop,) if __name__ == "__main__": start = '>>>> <<<<' stop = '<<<< >>>>' print start, " --> ", stop pathway = wander(start,stop) print len(pathway), "moves: ", pathway 

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

 A-star: 14.76 seconds Depth-first search: 1.30 seconds 

यदि आप रुचि रखते हैं तो यह मेरा गहराई-पहला तरीका कोड है:

 from sys import argv fCamel = 'F' bCamel = 'B' gap = 'G' def issolution(formlen): def solution(formation): if formation[formlen2] == gap: return formation.index(fCamel) == x return 0 x = formlen/2 + 1 formlen2 = formlen/2 return solution def solve(formation): def depthfirst(form, g): if checksolution(form): return [tuple(form)], g + 1 else: igap = form.index(gap) if(igap > 1 and form[igap-2] == fCamel): form[igap-2],form[igap] = form[igap],form[igap-2] res = depthfirst(form,g+1) form[igap-2],form[igap] = form[igap],form[igap-2] if res != 0: return [tuple(form)]+res[0],res[1] if (igap < flen - 2) and form[igap + 2] == bCamel: form[igap+2],form[igap] = form[igap],form[igap+2] res = depthfirst(form,g+1) form[igap+2],form[igap] = form[igap],form[igap+2] if res != 0: return [tuple(form)]+res[0],res[1] if(igap > 0 and form[igap-1] == fCamel): form[igap-1],form[igap] = form[igap],form[igap-1] res = depthfirst(form,g+1) form[igap-1],form[igap] = form[igap],form[igap-1] if res != 0: return [tuple(form)]+res[0],res[1] if (igap < flen - 1) and form[igap+1] == bCamel: form[igap+1],form[igap] = form[igap],form[igap+1] res = depthfirst(form,g+1) form[igap+1],form[igap] = form[igap],form[igap+1] if res != 0: return [tuple(form)]+res[0],res[1] return 0 flen = len(formation) checksolution = issolution(flen) res = depthfirst(list(formation), 0) return res L = lambda x: tuple([fCamel]*x + [gap] + [bCamel]*x) print solve(L(int(argv[1])))