पाइथन (दो-आयामी)

Question

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

वैसे भी, सवाल यह है:

यादृच्छिक सैर पर दो आयामी भिन्नता इस तरह के एक 11 से 11 सरणी के रूप में, एक ग्रिड के बीच में शुरू होता है। प्रत्येक चरण में नशे में चार विकल्प होते हैं: ऊपर, नीचे, बाएं या दाएं। इससे पहले अध्याय में हमने संख्याओं की एक द्वि-आयामी सरणी बनाने का वर्णन किया था। इस डेटा का उपयोग प्रकार, दो-आयामी यादृच्छिक चलने का अनुकरण लिखें।

ठीक है, मुझे क्या पता है; मैं जानता हूँ कि अजगर में दो आयामी सरणी बनाने का तरीका:

times = [0] * 11 
for i in range(0,11): 
    times[i] = [0] * 11 

और मैं "randint" समारोह का विचार आया:

और यह भी मैं हाल ही में इस समस्या का एक आयामी भिन्नता लिखा है। लेकिन यह एक स्पेगेटी कोड कोड है और यह बहुत गंदा है और मुझे यकीन नहीं है कि यह सही है या नहीं।

मेरे कोड यहाँ है:

''' 
Created on Feb 11, 2012 

@author: msarialp 
''' 
from random import randint 

def drunken_man(): 
    steps = 0 
    times = [0] * 11 
    left_move = 0 
    right_move = 0 
    i = 0 
    while left_move < 5 or right_move < 5: 
     value = randint(0,1) 
     times[5] = 1 
     if value == 1: 
      steps += 1 
      print("He moved left") 
      left_move += 1 
      if right_move > 0: 
       right_move -= 1 
      if left_move == 1: 
       times[4] += 1 
      elif left_move == 2: 
       times[3] += 1 
      elif left_move == 3: 
       times[2] += 1 
      elif left_move == 4: 
       times[1] += 1 
      #elif left_move == 5: 
       #times[0] += 1 
     elif value == 0: 
      steps += 1 
      print("He moved right") 
      right_move += 1 
      if left_move > 0: 
       left_move -= 1 
      if right_move == 1: 
       times[6] += 1 
      elif right_move == 2: 
       times[7] += 1 
      elif right_move == 3: 
       times[8] += 1 
      elif right_move == 4: 
       times[9] += 1 
      #elif right_move == 5: 
       #times[10] += 1 
     times[i] += 1     
    for i in range(1,10): 
     print("He took {steps} steps until he reaches end of the sidewalk.".format(steps = steps), "He stood on {1} square at {0} times".format(times[i], i)) 

def main(): 
    drunken_man() 

    return 0 
if __name__ == '__main__': 
    main() 

संपादित एक

दान Gerhardsson से कुछ अच्छी सलाह लेने के बाद। मैंने अपना प्रश्न संपादित करने का निर्णय लिया है। तो मैं इस प्रश्न पर कहां हूं: मैं समझता हूं कि मैं अपने शराबी आदमी के चरणों को दो-बार में कैसे देख सकता हूं और जांच सकता हूं।

यह अभ्यास को हल करने के लिए ट्यूपल का उपयोग करने के लिए बहुत समझदार और स्पष्ट था।

तो, मेरे सभी कोड सेगमेंट के बाद, कृपया जांचें और मुझे कोई प्रतिक्रिया दें।

def two_dimensional_random_walk(): 
    steps = 0 
    times = [0] * 11 
    for i in range(0,11): 
     times[i] = [0] * 11 
    x = 5 
    y = 5 
    moves = [(1,0), (0,1), (-1,0), (0,-1)] 
    while x<11 and x >= 0 or y < 11 and y >= 0: 
     dx, dy = moves[randint(0,3)] 
     x += dx 
     y += dy 
     if dx == 1 and dy == 0: 
      print("He moved right") 
     elif dx == 0 and dy == 1: 
      print("He moved up") 
     elif dx == -1 and dy == 0: 
      print("He moved left") 
     elif dx == 0 and dy == -1: 
      print("He moved down") 
     try: 
      times[x][y] += 1 
      steps += 1 
     except IndexError: 
      break 

और मेरे प्रिंट समारोह है:

for i in range(0,11): 
    for j in range(0,11): 
     print("He took {steps} steps until he reaches end of the sidewalk.".format(steps = steps), "He stood on {1}x{2} square at {0} times".format(times[i][j], i+1,j+1)) 

तो सब सब मैं के साथ लगता है में मदद करता है दान Gerhardsson से, मैं व्यायाम को हल किया।

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

def drunken_man(): 
steps = 0 
x = 6 
times = [0] * 11 
moves = [(1), (-1)] 

while x < 11 and x >= 0: 
    dx = moves[randint(0,1)] 
    print(dx, x) 
    x += dx 
    try: 
     times[x] += 1 
     steps += 1 
    except IndexError: 
     break   
for i in range(1,11): 
    print("He took {0} steps until he reaches end of the sidewalk.".format(steps), "He stood on {1} square at {0} times".format(times[i], i)) 

संपादित दो (अंतिम रूप)

मुझे यकीन है कि क्या यह दान Gerhardsson द्वारा संकेत लागू करने के लिए अपनी पोस्ट संपादित करने के लिए आवश्यक है नहीं कर रहा हूँ। मेरे जैसे बिंदुओं को याद करने वाले किसी व्यक्ति की मदद करने के लिए, मैंने सब कुछ एक साथ जोड़ने का फैसला किया।

तो यहाँ मेरी समारोह है कि दान Gerhardsson द्वारा संकेत के साथ संयुक्त है है:

def two_dimensional_random_walk(): 
steps = 0 # Steps counter for understand how many steps that our drunken man take 
grid_size = 11 # Grid size variable, 
# Creating Two dimensional array by using lists 
times = [0] * grid_size 
for i in range(0,grid_size): 
    times[i] = [0] * grid_size 
# Initial variables to start in the middle of grid 
x = 5 
y = 5 
# Tuples to get directions and decide where to go 
moves = [(1,0, "right"), (0,1, "up"), (-1,0, "left"), (0,-1, "down")] 
# My loop for evaluate the steps 
while True: 
    dx, dy, position = moves[randint(0,3)] # By using randint I could make decision randomly 
    x += dx 
    y += dy 
    print("He moved", position) 
    try: 
     times[x][y] += 1 # And here is, how many times have he stood on each square 
     steps += 1 
    except IndexError: # The exit of loop 
     break 
# My print function which answers these questions (How long will it be until he reaeches the end of the sidewalk, and how many times will he have stood on each square) 
for i in range(0,11): 
    for j in range(0,11): 
     print("He took {steps} steps until he reaches end of the sidewalk.".format(steps = steps), "He stood on {1}x{2} square at {0} times".format(times[i][j], i+1,j+1)) 

अपने बड़े के लिए धन्यवाद दान Gerhardsson मदद करता है। मुझे लगता है कि अंत में मुझे समाधान मिल गया है।

Answer 1

मैं कम से कम आपको कुछ संकेत दे सकता हूं। तो आपके पास चार संभावित चाल हैं।

moves = [(0, 1), (1, 0), (0, -1), (-1, 0)] 

केंद्र में प्रारंभ स्थिति सेट करने के लिए:

grid_size = 11 
x = grid_size // 2 
y = grid_size // 2 

स्टोर शराबी आदमी की स्थिति और प्रत्येक चाल के एक टपल जो x और y दिशाओं में विस्थापन है द्वारा प्रतिनिधित्व किया जा सकता है सिमुलेशन के प्रत्येक चरण में इसे अद्यतन करें। कुछ इस तरह:

# Displacement: 
dx, dy = random.choice(moves) 

# Update position: 
x += dx 
y += dy 

यह शुरुआत स्तर कोड नहीं हो सकता है, लेकिन एक अगर बयान के साथ सीमाओं की जाँच के बजाय, आप गिनती अद्यतन करने के लिए कोशिश कर सकते हैं, और अपवाद है, जो स्थिति है, तो उठाया है संभाल ग्रिड के बाहर है:

try: 
    # Update counter. 
    times[x][y] += 1 
except IndexError: 
    # Exit the simulation loop. 
    break 

उम्मीद है कि इससे मदद मिलती है।

जब से तुम हर कदम में दिशा प्रिंट करना चाहते हैं, तो आप टपल है कि जोड़ सकते हैं::

moves = [(0, 1, 'up'), (1, 0, 'right'), (0, -1, 'down'), (-1, 0, 'left')] 

तो फिर तुम अगर जगह ले सकता है -

संपादित दूसरे संस्करण पर टिप्पणियाँ -statement जहां दिशा प्रिंट:

dx, dy, direction = random.choice(moves) 
print('He moved', direction) 

जब आप कोशिश को छोड़कर अपने वर्तमान समाधान में के रूप में उपयोग करते हैं, आप के लिए बाध्य की जाँच करने की जरूरत नहीं है वक्तव्य में मेष राशि। तुम सिर्फ कर सकते हैं:

while True: 
    ... 

के बाद से अपवाद संचालक में तोड़ पाश बाहर निकल जाएगा।

सलाह का मेरा अंतिम भाग वैरिएबल के साथ कुछ संख्याओं को प्रतिस्थापित करना है। ग्रिड आकार उदा। एक से अधिक स्थानों में प्रकट होता है। आप एक चर बनाने और कोड के बाकी हिस्सों में को देखना चाहिए:

grid_size = 11 
times = [0] * grid_size 
    for i in range(grid_size): 
     times[i] = [0] * grid_size 

का उपयोग संख्या शाब्दिक के बजाय एक चर का मतलब है कि तुम सिर्फ अगर तुम साथ कोड चलाना चाहते हैं एक स्थान पर परिवर्तन करने के लिए है एक अलग ग्रिड आकार।

Answer 2

मैंने एक समान यादृच्छिक चलने का कार्यक्रम बनाया जिसने शराबी व्यक्ति को गोलाकार निर्देशांक का उपयोग करके तीन आयामी अंतरिक्ष में किसी भी दिशा में चलने की अनुमति दी।

import random 
import math 
def rw3(n,tries): 
    s = 0 
    for m in range(1,tries+1): 
     x = 0 
     y = 0 
     z = 0 
     pi = math.pi 
     for step in range(1,n+1): 
      t = random.uniform(0,2*pi) 
      f = random.uniform(0,2*pi) 
      p = 1 
      x += p*math.sin(f)*math.cos(t) 
      y += p*math.sin(f)*math.sin(t) 
      z += p*math.cos(f) 
     s += (x**2+y**2+z**2)**.5 
    return s/tries 
life = 42 
while life: 
    n = int(input("Please enter the number of steps: ")) 
    tries = int(input("How many times should I perform the experiment? ")) 
    print() 
    print(rw3(n,tries)) 
    print()