मुझे लगता है कि आप शायद अन्य उत्तरों से जिस्ट मिल गए हैं, लेकिन यह एक मजेदार सवाल था और मुझे ऐसा लगा कि मैं थोड़ा पायथन कोडिंग कर रहा हूं। यह मेरा वस्तु-उन्मुख दृष्टिकोण है। इंडेंटेशन गुंजाइश को परिभाषित करता है।
ग्राफ प्रतिनिधित्व
ग्राफ को आसानी से एक कुंजी, मान डिक्शनरी के रूप में संग्रहीत किया जा सकता है जहां कुंजी रूम आईडी है, और मूल्य उन कमरों का एक सरणी है जो इसे ले जाता है।
map = {
1:[5, 2],
2:[1, 3, 5],
3:[2, 4],
4:[3, 5, 6],
5:[2, 4, 1],
6:[4]
}
एजेंट इंटरफ़ेस
पहले हमें इस बारे में सोचना चाहिए कि एजेंट को पर्यावरण से कौन सी जानकारी सीखने में सक्षम होना चाहिए, और ऑपरेशन जो इसे करने में सक्षम होना चाहिए। यह एल्गोरिथ्म के बारे में सोच को सरल करेगा।
इस मामले में एजेंट को उस कमरे की आईडी के लिए वातावरण को क्वेरी करने में सक्षम होना चाहिए, जिसमें वह उस कमरे के दरवाजों की एक गिनती प्राप्त करने में सक्षम होना चाहिए जो इसमें है ( ध्यान दें कि यह कमरे का आईडी नहीं है दरवाजे का नेतृत्व करते हैं! ) और उसे दरवाजे के सूचकांक को निर्दिष्ट करके एक दरवाजे से गुजरने में सक्षम होना चाहिए। एक एजेंट को जो कुछ भी पता चलता है उसे एजेंट द्वारा ही पता लगाना होता है।
class AgentInterface(object):
def __init__(self, map, starting_room):
self.map = map
self.current_room = starting_room
def get_door_count(self):
return len(self.map[self.current_room])
def go_through_door(self, door):
result = self.current_room = self.map[self.current_room][door]
return result
एजेंट ज्ञान
जब एजेंट पहली बार नक्शे में प्रवेश करता है तो उसे केवल कमरे में दरवाजों की मात्रा पता होती है, और कमरे की आईडी जो वर्तमान में है। मुझे एक ऐसी संरचना बनाने की जरूरत है जो जानकारी को संग्रहीत करती है जो एजेंट ने सीखा था जैसे कि यह कौन से दरवाजे नहीं थे। के माध्यम से, और जहां के दरवाजे के माध्यम से किया गया है।
यह वर्ग एकल कमरे के बारे में जानकारी का प्रतिनिधित्व करता है। मैंने एक setऔर एक के रूप में देखे गए दरवाज़ों को एक के रूप में संग्रहीत करने के लिए चुना dictionary, जहाँ कुंजी दरवाजा आईडी है और मूल्य उस कमरे की आईडी है जिसके लिए वह जाता है।
class RoomKnowledge(object):
def __init__(self, unvisited_door_count):
self.unvisited_doors = set(range(unvisited_door_count))
self.visited_doors = {}
एजेंट एल्गोरिथ्म
हर बार जब एजेंट कमरे में प्रवेश करता है तो वह कमरे के बारे में जानकारी के लिए अपना ज्ञानकोष खोजता है। अगर इस कमरे के लिए कोई प्रविष्टि नहीं है, तो यह एक नया बनाता है RoomKnowledgeऔर इसे इसे ज्ञान शब्दकोश में जोड़ता है।
यह देखने के लिए जांचता है कि क्या वर्तमान कमरा लक्ष्य कक्ष है, यदि ऐसा है तो यह वापस आ जाता है।
अगर इस कमरे में दरवाजे नहीं हैं, जहां हम नहीं गए हैं, तो हम उस दरवाजे और स्टोर से गुजरते हैं जहां यह जाता है। हम फिर लूप जारी रखते हैं।
अगर किसी भी तरह के बिना दरवाजे वाले दरवाजे नहीं थे, तो हम उन कमरों से गुजरते हैं, जिन्हें हम बिना दरवाजे वाले किसी एक को खोजने के लिए गए थे।
Agentसे वर्ग inherits AgentInterfaceवर्ग।
class Agent(AgentInterface):
def find_exit(self, exit_room_id):
knowledge = { }
room_history = [] # For display purposes only
history_stack = [] # Used when we need to backtrack if we've visited all the doors in the room
while True:
room_knowledge = knowledge.setdefault(self.current_room, RoomKnowledge(self.get_door_count()))
room_history.append(self.current_room)
if self.current_room==exit_room_id:
return room_history
if len(room_knowledge.unvisited_doors)==0:
# I have destination room id. I need door id:
door = find_key(room_knowledge.visited_doors, history_stack.pop())
self.go_through_door(door)
else:
history_stack.append(self.current_room)
# Enter the first unopened door:
opened_door = room_knowledge.unvisited_doors.pop()
room_knowledge.visited_doors[opened_door]=self.go_through_door(opened_door)
सहायक कार्य
मुझे एक ऐसा फंक्शन लिखना था, जिसमें एक डिक्शनरी में एक की-वर्ड दिया गया हो, जिसकी वैल्यू देने के बाद से हम जानते हैं कि जिस कमरे में हम जाने की कोशिश कर रहे हैं, उस कमरे की आईडी तो है, लेकिन इसे पाने के लिए कौन से दरवाजे का इस्तेमाल नहीं करना है।
def find_key(dictionary, value):
for key in dictionary:
if dictionary[key]==value:
return key
परिक्षण
मैंने ऊपर दिए गए नक्शे में प्रारंभ / समाप्ति स्थिति के सभी संयोजनों का परीक्षण किया। प्रत्येक संयोजन के लिए यह विज़िट किए गए कमरों को प्रिंट करता है।
for start in range(1, 7):
for exit in range(1, 7):
print("start room: %d target room: %d"%(start,exit))
james_bond = Agent(map, start)
print(james_bond.find_exit(exit))
टिप्पणियाँ
बैकट्रैकिंग बहुत कुशल नहीं है - सबसे खराब स्थिति में यह हर कमरे के माध्यम से बगल के कमरे में जा सकता है, लेकिन बैकट्रैकिंग काफी दुर्लभ है - उपरोक्त परीक्षणों में यह केवल तीन बार बैकट्रैक है। मैंने कोड को संक्षिप्त रखने के लिए अपवाद हैंडलिंग से परहेज किया है। मेरी अजगर पर कोई टिप्पणी की सराहना की :)
