[已解决]Python：乌龟和鱼，改后，运行不正常

Peteryo01223

原题： 游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏

• 假设游戏场景为范围（x, y）为0<=x<=10，0<=y<=10
• 游戏生成1只乌龟和10条鱼
• 它们的移动方向均随机
• 乌龟的最大移动能力是2（Ta可以随机选择1还是2移动），鱼儿的最大移动能力是1
• 当移动到场景边缘，自动向反方向移动
• 乌龟初始化体力为100（上限）
• 乌龟每移动一次，体力消耗1
• 当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
• 鱼暂不计算体力
• 当乌龟体力值为
• 当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束
  
  我建议的修改：
  小甲鱼的答案中，乌龟的移动即 x 轴和 y 轴的随机选择，分别是【1，2，-1，-2】，即 16种可能：【1、1】、【1、2】、【1、-1】、【1，-2】、【2、1】、【2、2】、【2、-1】、【2、-2】、【-1、1】、【-1、2】、【-1、-1】、【-1、-2】、【-2、1】、【-2、2】、【-2、-1】、【-2、-2】。
  
  但，我觉得，根据题干中乌龟的最大”移动能力是2”的意思，按说应该是以下这 12 种可能：【0, 1】, 【1, 0】, 【0, 2】, 【2, 0】, 【0, -1】, 【-1, 0】, 【0, -2】, 【-2, 0】, 【1, 1】, 【-1, -1】, 【1, -1】, 【-1, 1】。因为，每次位移总量不能超过2，x 或 y 其中可有一个为零。
  
  我的问题：
  假定我的读题是对的，那么我利用绝对值函数 abs()，改动小甲鱼的 code ，如下第15-22行，40和41行。
  可惜，run 后，不报错，但结果不稳定，有时候出不来，有时候出两行，也不明确地结束~
  为何？是不是第 41 行，我写的有误呢？谢谢指点~
  
  1. import random as r
     
  2. 
     
  3. legal_x = [0,10]
     
  4. legal_y = [0,10]
     
  5. 
     
  6. class Turtle:
     
  7.     def __init__(self):
     
  8.         self.power = 100 # 初始体力
     
  9.         self.x = r.randint(legal_x[0], legal_x[1])
     
  10.         # x 的初始随机位置在1和10之间, legal_x[0] 是最小边界，legal_x[1] 是最大边界
      
  11.         self.y = r.randint(legal_x[0], legal_y[1])
      
  12.         # y 的初始随机位置
      
  13. 
      
  14.     def move(self):
      
  15.         temp_1 = r.choice([1,2,-1,-2])
      
  16.         temp_2 = r.choice([1,2,-1,-2])
      
  17.         sum = abs(temp_1)+abs(temp_2)
      
  18.         if sum <= 2:
      
  19.             # 随机计算方向并移动到新的位置（x, y）
      
  20.             new_x = self.x + temp_1
      
  21.             # 导入 random 模块后，可调用choice()方法,即：返回一个列表、元组或字符串的随机项
      
  22.             new_y = self.y + temp_2
      
  23.       
      
  24.             # 检查移动后是否超出场景 x 轴边界
      
  25.             if new_x < legal_x[0]:
      
  26.                 self.x = legal_x[0] - (new_x - legal_x[0])
      
  27.             elif new_x > legal_x[1]:
      
  28.                 self.x = legal_x[1] - (new_x - legal_x[1])
      
  29.             else:
      
  30.                 self.x = new_x
      
  31. 
      
  32.             # 检查移动后是否超出场景 y 轴边界
      
  33.             if new_y < legal_y[0]:
      
  34.                 self.y = legal_y[0] - (new_y - legal_y[0])
      
  35.             elif new_y > legal_y[1]:
      
  36.                 self.y = legal_y[1] - (new_y - legal_y[1])
      
  37.             else:
      
  38.                 self.y = new_y
      
  39. 
      
  40.         else:
      
  41.             Turtle.move(self)
      
  42.             # 即，当出现 x轴 和 y轴的绝对值之和，大于 2 时，重新取值，直到符合要求为止。但此处，我写的不对吧？为什么？这个递归调用，我好像没有防止死循环。
      
  43. 
      
  44.         # 体力消耗
      
  45.         self.power -= 1
      
  46. 
      
  47.         # 返回移动后的新位置
      
  48.         return (self.x, self.y)            
      
  49. 
      
  50.     def eat(self):
      
  51.         self.power += 20
      
  52.         if self.power > 100:
      
  53.             self.power = 100
      
  54. 
      
  55. class Fish:
      
  56.     def __init__(self):
      
  57.         self.x = r.randint(legal_x[0], legal_x[1])
      
  58.         self.y = r.randint(legal_x[0], legal_x[1])
      
  59. 
      
  60.     def move(self):
      
  61.         # 随机计算方向并移动到新的位置（x, y）
      
  62.         new_x = self.x + r.choice([1,-1])
      
  63.         new_y = self.y + r.choice([1,-1])
      
  64. 
      
  65.         # 检查移动后是否超出场景 x 轴边界
      
  66.         if new_x < legal_x[0]:
      
  67.             self.x = legal_x[0] - (new_x - legal_x[0])
      
  68.         elif new_x > legal_x[1]:
      
  69.             self.x = legal_x[1] - (new_x - legal_x[1])
      
  70.         else:
      
  71.             self.x = new_x
      
  72. 
      
  73.         # 检查移动后是否超出场景 y 轴边界
      
  74.         if new_y < legal_y[0]:
      
  75.             self.y = legal_y[0] - (new_y - legal_y[0])
      
  76.         elif new_y > legal_y[1]:
      
  77.             self.y = legal_y[1] - (new_y - legal_y[1])
      
  78.         else:
      
  79.             self.y = new_y
      
  80. 
      
  81.         # 返回移动后的新位置
      
  82.         return (self.x, self.y)
      
  83. 
      
  84. turtle = Turtle()
      
  85. fish = []
      
  86. for i in range(10):
      
  87.     new_fish = Fish()
      
  88.     fish.append(new_fish)
      
  89. 
      
  90. while True:
      
  91.     if not len(fish):
      
  92.         print("鱼儿都吃完了，游戏结束！")
      
  93.         break
      
  94.     if not turtle.power:
      
  95.         print("乌龟体力耗尽，挂掉了！")
      
  96.         break
      
  97. 
      
  98.     pos = turtle.move()
      
  99.     # 在迭代器中删除列表元素是非常危险的，经常会出现意想不到的问题，因为迭代器是直接引用列表的数据进行引用
      
  100.     # 这里我们把列表拷贝给迭代器，然后对原列表进行删除操作就不会有问题了^_^
       
  101. 
       
  102.     for each_fish in fish[:]:
       
  103.         if each_fish.move() == pos:
       
  104.             # 鱼儿被吃掉了
       
  105.             turtle.eat()
       
  106.             fish.remove(each_fish)
       
  107.             print("有一条鱼儿被吃掉了...")

  复制代码
  
  
  连续三次 run， 结果如下：
  
  1. ======================================================== RESTART: C:/Users/user/AppData/Local/Programs/Python/Python38/202101125a.py =======================================================
     
  2. 有一条鱼儿被吃掉了...
     
  3. 有一条鱼儿被吃掉了...
     
  4. 
     
  5. ======================================================== RESTART: C:/Users/user/AppData/Local/Programs/Python/Python38/202101125a.py =======================================================
     
  6. 
     
  7. ======================================================== RESTART: C:/Users/user/AppData/Local/Programs/Python/Python38/202101125a.py =======================================================
     
  8. 有一条鱼儿被吃掉了...
     
  9. 有一条鱼儿被吃掉了...

  复制代码
  
  
  最佳答案

  月排行榜 / 总排行榜

  

  小甲鱼的铁粉

  2021-2-8 18:07:13

  Turtle.move(self)

  
  看不懂你这个递归，你递归之后对self.power的判断出错误了，应该不再是power == 0, 而是power <= 0，因为他在递归栈里面一直减power，导致power可能小于零，正确的代码如下
  

  1. import random as r
     
  2. 
     
  3. legal_x = [0,10]
     
  4. legal_y = [0,10]
     
  5. 
     
  6. class Turtle:
     
  7.     def __init__(self):
     
  8.         self.power = 100 # 初始体力
     
  9.         self.x = r.randint(legal_x[0], legal_x[1])
     
  10.         # x 的初始随机位置在1和10之间, legal_x[0] 是最小边界，legal_x[1] 是最大边界
      
  11.         self.y = r.randint(legal_x[0], legal_y[1])
      
  12.         # y 的初始随机位置
      
  13. 
      
  14.     def move(self):
      
  15.         if self.power <= 0:
      
  16.             return
      
  17.         temp_1 = r.choice([1,2,-1,-2])
      
  18.         temp_2 = r.choice([1,2,-1,-2])
      
  19.         sum = abs(temp_1)+abs(temp_2)
      
  20.         if sum <= 2:
      
  21.             # 随机计算方向并移动到新的位置（x, y）
      
  22.             new_x = self.x + temp_1
      
  23.             # 导入 random 模块后，可调用choice()方法,即：返回一个列表、元组或字符串的随机项
      
  24.             new_y = self.y + temp_1
      
  25.       
      
  26.             # 检查移动后是否超出场景 x 轴边界
      
  27.             if new_x < legal_x[0]:
      
  28.                 self.x = legal_x[0] - (new_x - legal_x[0])
      
  29.             elif new_x > legal_x[1]:
      
  30.                 self.x = legal_x[1] - (new_x - legal_x[1])
      
  31.             else:
      
  32.                 self.x = new_x
      
  33. 
      
  34.             # 检查移动后是否超出场景 y 轴边界
      
  35.             if new_y < legal_y[0]:
      
  36.                 self.y = legal_y[0] - (new_y - legal_y[0])
      
  37.             elif new_y > legal_y[1]:
      
  38.                 self.y = legal_y[1] - (new_y - legal_y[1])
      
  39.             else:
      
  40.                 self.y = new_y
      
  41. 
      
  42.         else:
      
  43.             self.move()
      
  44.             # 即，当出现 x轴 和 y轴的绝对值之和，大于 2 时，重新取值，直到符合要求为止。但此处，我写的不对吧？为什么？
      
  45. 
      
  46.         # 体力消耗
      
  47.         self.power -= 1
      
  48.             
      
  49.         # 返回移动后的新位置
      
  50.         return (self.x, self.y)            
      
  51. 
      
  52.     def eat(self):
      
  53.         self.power += 20
      
  54.         if self.power > 100:
      
  55.             self.power = 100
      
  56. 
      
  57. class Fish():
      
  58.     def __init__(self):
      
  59.         self.x = r.randint(legal_x[0], legal_x[1])
      
  60.         self.y = r.randint(legal_y[0], legal_y[1])
      
  61. 
      
  62.     def move(self):
      
  63.         new_x = self.x + r.choice([-1, 1])
      
  64.         new_y = self.y + r.choice([-1, 1])
      
  65. 
      
  66.         if new_x < legal_x[0]:
      
  67.             self.x = -new_x
      
  68.         elif new_x > legal_x[1]:
      
  69.             self.x = legal_x[1] - (new_x - legal_x[1])
      
  70.         else:
      
  71.             self.x = new_x
      
  72. 
      
  73.         if new_y < legal_y[0]:
      
  74.             self.y = -new_y
      
  75.         elif self.y > legal_y[1]:
      
  76.             self.y = legal_y[1] - (new_y - legal_y[1])
      
  77.         else:
      
  78.             self.y = new_y
      
  79.         print("这个鱼的位置在(" + str(self.x) + ',' + str(self.y) + ')')
      
  80.         return (self.x, self.y)
      
  81. 
      
  82. turtle = Turtle()
      
  83. fish = []
      
  84. for i in range(10):
      
  85.     new_fish = Fish()
      
  86.     fish.append(new_fish)
      
  87. 
      
  88. while True:
      
  89.     if not len(fish):
      
  90.         print("鱼儿都吃完了，游戏结束！")
      
  91.         break
      
  92.     if turtle.power <= 0:
      
  93.         print("乌龟体力耗尽，挂掉了！")
      
  94.         break
      
  95. 
      
  96.     pos = turtle.move()
      
  97.     # 在迭代器中删除列表元素是非常危险的，经常会出现意想不到的问题，因为迭代器是直接引用列表的数据进行引用
      
  98.     # 这里我们把列表拷贝给迭代器，然后对原列表进行删除操作就不会有问题了^_^
      
  99.     for each_fish in fish:
      
  100.         #print(str(each_fish.move()) + "   " + str(pos))
       
  101.         if each_fish.move() == pos:
       
  102.             # 鱼儿被吃掉了
       
  103.             turtle.eat()
       
  104.             fish.remove(each_fish)
       
  105.             print("有一条鱼儿被吃掉了...")
       
  106.             
       

  复制代码

  跳转到最佳答案楼层

小甲鱼的铁粉

Turtle.move(self)

看不懂你这个递归，你递归之后对self.power的判断出错误了，应该不再是power == 0, 而是power <= 0，因为他在递归栈里面一直减power，导致power可能小于零，正确的代码如下

1. import random as r
   
2. 
   
3. legal_x = [0,10]
   
4. legal_y = [0,10]
   
5. 
   
6. class Turtle:
   
7.     def __init__(self):
   
8.         self.power = 100 # 初始体力
   
9.         self.x = r.randint(legal_x[0], legal_x[1])
   
10.         # x 的初始随机位置在1和10之间, legal_x[0] 是最小边界，legal_x[1] 是最大边界
    
11.         self.y = r.randint(legal_x[0], legal_y[1])
    
12.         # y 的初始随机位置
    
13. 
    
14.     def move(self):
    
15.         if self.power <= 0:
    
16.             return
    
17.         temp_1 = r.choice([1,2,-1,-2])
    
18.         temp_2 = r.choice([1,2,-1,-2])
    
19.         sum = abs(temp_1)+abs(temp_2)
    
20.         if sum <= 2:
    
21.             # 随机计算方向并移动到新的位置（x, y）
    
22.             new_x = self.x + temp_1
    
23.             # 导入 random 模块后，可调用choice()方法,即：返回一个列表、元组或字符串的随机项
    
24.             new_y = self.y + temp_1
    
25.       
    
26.             # 检查移动后是否超出场景 x 轴边界
    
27.             if new_x < legal_x[0]:
    
28.                 self.x = legal_x[0] - (new_x - legal_x[0])
    
29.             elif new_x > legal_x[1]:
    
30.                 self.x = legal_x[1] - (new_x - legal_x[1])
    
31.             else:
    
32.                 self.x = new_x
    
33. 
    
34.             # 检查移动后是否超出场景 y 轴边界
    
35.             if new_y < legal_y[0]:
    
36.                 self.y = legal_y[0] - (new_y - legal_y[0])
    
37.             elif new_y > legal_y[1]:
    
38.                 self.y = legal_y[1] - (new_y - legal_y[1])
    
39.             else:
    
40.                 self.y = new_y
    
41. 
    
42.         else:
    
43.             self.move()
    
44.             # 即，当出现 x轴 和 y轴的绝对值之和，大于 2 时，重新取值，直到符合要求为止。但此处，我写的不对吧？为什么？
    
45. 
    
46.         # 体力消耗
    
47.         self.power -= 1
    
48.             
    
49.         # 返回移动后的新位置
    
50.         return (self.x, self.y)            
    
51. 
    
52.     def eat(self):
    
53.         self.power += 20
    
54.         if self.power > 100:
    
55.             self.power = 100
    
56. 
    
57. class Fish():
    
58.     def __init__(self):
    
59.         self.x = r.randint(legal_x[0], legal_x[1])
    
60.         self.y = r.randint(legal_y[0], legal_y[1])
    
61. 
    
62.     def move(self):
    
63.         new_x = self.x + r.choice([-1, 1])
    
64.         new_y = self.y + r.choice([-1, 1])
    
65. 
    
66.         if new_x < legal_x[0]:
    
67.             self.x = -new_x
    
68.         elif new_x > legal_x[1]:
    
69.             self.x = legal_x[1] - (new_x - legal_x[1])
    
70.         else:
    
71.             self.x = new_x
    
72. 
    
73.         if new_y < legal_y[0]:
    
74.             self.y = -new_y
    
75.         elif self.y > legal_y[1]:
    
76.             self.y = legal_y[1] - (new_y - legal_y[1])
    
77.         else:
    
78.             self.y = new_y
    
79.         print("这个鱼的位置在(" + str(self.x) + ',' + str(self.y) + ')')
    
80.         return (self.x, self.y)
    
81. 
    
82. turtle = Turtle()
    
83. fish = []
    
84. for i in range(10):
    
85.     new_fish = Fish()
    
86.     fish.append(new_fish)
    
87. 
    
88. while True:
    
89.     if not len(fish):
    
90.         print("鱼儿都吃完了，游戏结束！")
    
91.         break
    
92.     if turtle.power <= 0:
    
93.         print("乌龟体力耗尽，挂掉了！")
    
94.         break
    
95. 
    
96.     pos = turtle.move()
    
97.     # 在迭代器中删除列表元素是非常危险的，经常会出现意想不到的问题，因为迭代器是直接引用列表的数据进行引用
    
98.     # 这里我们把列表拷贝给迭代器，然后对原列表进行删除操作就不会有问题了^_^
    
99.     for each_fish in fish:
    
100.         #print(str(each_fish.move()) + "   " + str(pos))
     
101.         if each_fish.move() == pos:
     
102.             # 鱼儿被吃掉了
     
103.             turtle.eat()
     
104.             fish.remove(each_fish)
     
105.             print("有一条鱼儿被吃掉了...")
     
106.             
     

复制代码

Peteryo01223

小甲鱼的铁粉 发表于 2021-2-8 18:07
看不懂你这个递归，你递归之后对self.power的判断出错误了，应该不再是power == 0, 而是power

回过头再看，感觉你的答案也不对啊。没有显示任何预鱼被吃。运行结果如下：

1. ================== RESTART: C:/Users/user/Desktop/20210209b.py =================
   
2. 这个鱼的位置在(8,0)
   
3. 这个鱼的位置在(7,7)
   
4. 这个鱼的位置在(7,11)
   
5. 这个鱼的位置在(5,1)
   
6. 这个鱼的位置在(4,5)
   
7. 这个鱼的位置在(7,10)
   
8. 这个鱼的位置在(3,10)
   
9. 这个鱼的位置在(1,2)
   
10. 这个鱼的位置在(2,6)
    
11. 这个鱼的位置在(7,4)
    
12. 这个鱼的位置在(9,1)
    
13. 这个鱼的位置在(6,6)
    
14. 这个鱼的位置在(8,8)
    
15. 这个鱼的位置在(4,0)
    
16. 这个鱼的位置在(5,6)
    
17. 这个鱼的位置在(6,9)
    
18. 这个鱼的位置在(4,9)
    
19. 这个鱼的位置在(2,3)
    
20. 这个鱼的位置在(3,5)
    
21. 这个鱼的位置在(8,5)
    
22. 这个鱼的位置在(8,2)
    
23. 这个鱼的位置在(7,5)
    
24. 这个鱼的位置在(9,7)
    
25. 这个鱼的位置在(5,1)
    
26. 这个鱼的位置在(4,7)
    
27. 这个鱼的位置在(7,10)
    
28. 这个鱼的位置在(5,8)
    
29. 这个鱼的位置在(1,2)
    
30. 这个鱼的位置在(4,4)
    
31. 这个鱼的位置在(9,6)
    
32. 这个鱼的位置在(9,3)
    
33. 这个鱼的位置在(6,6)
    
34. 这个鱼的位置在(10,8)
    
35. 这个鱼的位置在(4,0)
    
36. 这个鱼的位置在(3,6)
    
37. 这个鱼的位置在(6,11)
    
38. 这个鱼的位置在(4,7)
    
39. 这个鱼的位置在(2,1)
    
40. 这个鱼的位置在(5,3)
    
41. 这个鱼的位置在(8,7)
    
42. 这个鱼的位置在(8,2)
    
43. 这个鱼的位置在(7,5)
    
44. 这个鱼的位置在(9,9)
    
45. 这个鱼的位置在(3,1)
    
46. 这个鱼的位置在(2,7)
    
47. 这个鱼的位置在(5,10)
    
48. 这个鱼的位置在(5,8)
    
49. 这个鱼的位置在(1,2)
    
50. 这个鱼的位置在(6,2)
    
51. 这个鱼的位置在(7,6)
    
52. 这个鱼的位置在(9,1)
    
53. 这个鱼的位置在(8,6)
    
54. 这个鱼的位置在(10,10)
    
55. 这个鱼的位置在(4,2)
    
56. 这个鱼的位置在(3,8)
    
57. 这个鱼的位置在(4,11)
    
58. 这个鱼的位置在(4,9)
    
59. 这个鱼的位置在(0,3)
    
60. 这个鱼的位置在(7,1)
    
61. 这个鱼的位置在(6,5)
    
62. 这个鱼的位置在(8,0)
    
63. 这个鱼的位置在(9,7)
    
64. 这个鱼的位置在(9,11)
    
65. 这个鱼的位置在(3,3)
    
66. 这个鱼的位置在(2,9)
    
67. 这个鱼的位置在(5,8)
    
68. 这个鱼的位置在(5,8)
    
69. 这个鱼的位置在(1,2)
    
70. 这个鱼的位置在(6,2)
    
71. 这个鱼的位置在(7,4)
    
72. 这个鱼的位置在(9,1)
    
73. 这个鱼的位置在(10,6)
    
74. 这个鱼的位置在(10,8)
    
75. 这个鱼的位置在(4,2)
    
76. 这个鱼的位置在(1,10)
    
77. 这个鱼的位置在(4,9)
    
78. 这个鱼的位置在(6,7)
    
79. 这个鱼的位置在(0,1)
    
80. 这个鱼的位置在(7,3)
    
81. 这个鱼的位置在(6,3)
    
82. 这个鱼的位置在(10,2)
    
83. 这个鱼的位置在(9,7)
    
84. 这个鱼的位置在(9,9)
    
85. 这个鱼的位置在(5,1)
    
86. 这个鱼的位置在(0,11)
    
87. 这个鱼的位置在(5,10)
    
88. 这个鱼的位置在(5,8)
    
89. 这个鱼的位置在(1,0)
    
90. 这个鱼的位置在(8,2)
    
91. 这个鱼的位置在(7,2)
    
92. 这个鱼的位置在(9,1)
    
93. 这个鱼的位置在(8,6)
    
94. 这个鱼的位置在(10,10)
    
95. 这个鱼的位置在(4,2)
    
96. 这个鱼的位置在(1,10)
    
97. 这个鱼的位置在(6,9)
    
98. 这个鱼的位置在(6,7)
    
99. 这个鱼的位置在(0,1)
    
100. 这个鱼的位置在(7,1)
     
101. 这个鱼的位置在(6,1)
     
102. 这个鱼的位置在(10,2)
     
103. 这个鱼的位置在(7,7)
     
104. 这个鱼的位置在(9,9)
     
105. 这个鱼的位置在(5,3)
     
106. 这个鱼的位置在(2,11)
     
107. 这个鱼的位置在(7,8)
     
108. 这个鱼的位置在(5,8)
     
109. 这个鱼的位置在(1,2)
     
110. 这个鱼的位置在(6,2)
     
111. 这个鱼的位置在(5,0)
     
112. 这个鱼的位置在(9,3)
     
113. 这个鱼的位置在(6,8)
     
114. 这个鱼的位置在(10,10)
     
115. 这个鱼的位置在(4,2)
     
116. 这个鱼的位置在(1,8)
     
117. 这个鱼的位置在(8,7)
     
118. 这个鱼的位置在(4,9)
     
119. 这个鱼的位置在(0,1)
     
120. 这个鱼的位置在(7,1)
     
121. 这个鱼的位置在(6,1)
     
122. 这个鱼的位置在(10,2)
     
123. 这个鱼的位置在(7,7)
     
124. 这个鱼的位置在(9,9)
     
125. 这个鱼的位置在(5,3)
     
126. 这个鱼的位置在(2,9)
     
127. 这个鱼的位置在(7,8)
     
128. 这个鱼的位置在(5,10)
     
129. 这个鱼的位置在(1,2)
     
130. 这个鱼的位置在(8,2)
     
131. 这个鱼的位置在(5,0)
     
132. 这个鱼的位置在(9,1)
     
133. 这个鱼的位置在(6,6)
     
134. 这个鱼的位置在(10,8)
     
135. 这个鱼的位置在(6,2)
     
136. 这个鱼的位置在(1,8)
     
137. 这个鱼的位置在(8,7)
     
138. 这个鱼的位置在(6,9)
     
139. 这个鱼的位置在(0,1)
     
140. 这个鱼的位置在(7,1)
     
141. 这个鱼的位置在(4,1)
     
142. 这个鱼的位置在(8,0)
     
143. 这个鱼的位置在(5,5)
     
144. 这个鱼的位置在(9,7)
     
145. 这个鱼的位置在(5,3)
     
146. 这个鱼的位置在(2,7)
     
147. 这个鱼的位置在(7,6)
     
148. 这个鱼的位置在(7,10)
     
149. 这个鱼的位置在(1,2)
     
150. 这个鱼的位置在(8,2)
     
151. 这个鱼的位置在(3,0)
     
152. 这个鱼的位置在(7,1)
     
153. 这个鱼的位置在(4,6)
     
154. 这个鱼的位置在(8,8)
     
155. 这个鱼的位置在(6,2)
     
156. 这个鱼的位置在(1,8)
     
157. 这个鱼的位置在(6,5)
     
158. 这个鱼的位置在(6,9)
     
159. 这个鱼的位置在(2,3)
     
160. 这个鱼的位置在(7,1)
     
161. 这个鱼的位置在(4,1)
     
162. 这个鱼的位置在(8,2)
     
163. 这个鱼的位置在(3,5)
     
164. 这个鱼的位置在(9,9)
     
165. 这个鱼的位置在(5,3)
     
166. 这个鱼的位置在(2,7)
     
167. 这个鱼的位置在(5,4)
     
168. 这个鱼的位置在(5,8)
     
169. 这个鱼的位置在(1,4)
     
170. 这个鱼的位置在(8,2)
     
171. 这个鱼的位置在(3,0)
     
172. 这个鱼的位置在(7,1)
     
173. 这个鱼的位置在(2,4)
     
174. 这个鱼的位置在(8,10)
     
175. 这个鱼的位置在(6,2)
     
176. 这个鱼的位置在(1,8)
     
177. 这个鱼的位置在(4,5)
     
178. 这个鱼的位置在(4,7)
     
179. 这个鱼的位置在(2,3)
     
180. 这个鱼的位置在(7,3)
     
181. 这个鱼的位置在(4,1)
     
182. 这个鱼的位置在(8,0)
     
183. 这个鱼的位置在(1,5)
     
184. 这个鱼的位置在(9,11)
     
185. 这个鱼的位置在(5,1)
     
186. 这个鱼的位置在(2,7)
     
187. 这个鱼的位置在(5,4)
     
188. 这个鱼的位置在(5,6)
     
189. 这个鱼的位置在(1,4)
     
190. 这个鱼的位置在(6,2)
     
191. 这个鱼的位置在(3,0)
     
192. 这个鱼的位置在(7,1)
     
193. 这个鱼的位置在(2,4)
     
194. 这个鱼的位置在(10,10)
     
195. 这个鱼的位置在(6,0)
     
196. 这个鱼的位置在(1,8)
     
197. 这个鱼的位置在(6,3)
     
198. 这个鱼的位置在(6,5)
     
199. 这个鱼的位置在(0,5)
     
200. 这个鱼的位置在(7,3)
     
201. 这个鱼的位置在(4,1)
     
202. 这个鱼的位置在(6,0)
     
203. 这个鱼的位置在(3,5)
     
204. 这个鱼的位置在(9,11)
     
205. 这个鱼的位置在(7,1)
     
206. 这个鱼的位置在(2,7)
     
207. 这个鱼的位置在(7,2)
     
208. 这个鱼的位置在(7,4)
     
209. 这个鱼的位置在(1,6)
     
210. 这个鱼的位置在(8,4)
     
211. 这个鱼的位置在(5,2)
     
212. 这个鱼的位置在(5,1)
     
213. 这个鱼的位置在(2,6)
     
214. 这个鱼的位置在(8,8)
     
215. 这个鱼的位置在(6,2)
     
216. 这个鱼的位置在(3,8)
     
217. 这个鱼的位置在(8,1)
     
218. 这个鱼的位置在(6,3)
     
219. 这个鱼的位置在(0,5)
     
220. 这个鱼的位置在(9,5)
     
221. 这个鱼的位置在(6,1)
     
222. 乌龟体力耗尽，挂掉了！
     
223. >>>

复制代码

小甲鱼的铁粉

Peteryo01223 发表于 2021-2-9 14:19
回过头再看，感觉你的答案也不对啊。没有显示任何预鱼被吃。运行结果如下：

怎么不正常，那是因为你设置的污龟sum = abs(temp_1)+abs(temp_2)<=2
重新移动的次数太多了，污龟累死了

1. 污龟重新移动
   
2. 污龟重新移动
   
3. 污龟重新移动
   
4. 污龟重新移动
   
5. 污龟重新移动
   
6. 污龟重新移动
   
7. 这个鱼的位置在(2,6)
   
8. 这个鱼的位置在(7,9)
   
9. 有一条鱼儿被吃掉了...
   
10. 这个鱼的位置在(8,5)
    
11. 这个鱼的位置在(6,10)
    
12. 这个鱼的位置在(6,2)
    
13. 这个鱼的位置在(9,6)
    
14. 这个鱼的位置在(5,6)
    
15. 这个鱼的位置在(7,2)
    
16. 这个鱼的位置在(1,1)
    
17. 这个鱼的位置在(1,7)
    
18. 这个鱼的位置在(1,1)
    
19. 这个鱼的位置在(7,4)
    
20. 这个鱼的位置在(7,11)
    
21. 这个鱼的位置在(7,1)
    
22. 这个鱼的位置在(10,5)
    
23. 这个鱼的位置在(6,7)
    
24. 这个鱼的位置在(6,3)
    
25. 这个鱼的位置在(2,0)
    
26. 这个鱼的位置在(0,8)
    
27. 这个鱼的位置在(2,2)
    
28. 这个鱼的位置在(6,5)
    
29. 这个鱼的位置在(6,10)
    
30. 这个鱼的位置在(8,0)
    
31. 这个鱼的位置在(9,4)
    
32. 这个鱼的位置在(5,6)
    
33. 这个鱼的位置在(7,4)
    
34. 这个鱼的位置在(1,1)
    
35. 污龟重新移动
    
36. 这个鱼的位置在(1,9)
    
37. 这个鱼的位置在(1,3)
    
38. 这个鱼的位置在(7,4)
    
39. 这个鱼的位置在(7,11)
    
40. 这个鱼的位置在(7,1)
    
41. 这个鱼的位置在(10,3)
    
42. 这个鱼的位置在(6,7)
    
43. 这个鱼的位置在(6,5)
    
44. 这个鱼的位置在(0,2)
    
45. 污龟重新移动
    
46. 污龟重新移动
    
47. 污龟重新移动
    
48. 污龟重新移动
    
49. 这个鱼的位置在(2,8)
    
50. 这个鱼的位置在(0,4)
    
51. 这个鱼的位置在(6,5)
    
52. 这个鱼的位置在(6,8)
    
53. 这个鱼的位置在(8,2)
    
54. 这个鱼的位置在(9,2)
    
55. 这个鱼的位置在(7,6)
    
56. 这个鱼的位置在(5,6)
    
57. 这个鱼的位置在(1,3)
    
58. 污龟重新移动
    
59. 污龟重新移动
    
60. 这个鱼的位置在(3,7)
    
61. 这个鱼的位置在(1,5)
    
62. 这个鱼的位置在(7,6)
    
63. 这个鱼的位置在(7,9)
    
64. 这个鱼的位置在(7,1)
    
65. 这个鱼的位置在(8,1)
    
66. 这个鱼的位置在(6,5)
    
67. 这个鱼的位置在(6,5)
    
68. 这个鱼的位置在(0,4)
    
69. 污龟重新移动
    
70. 污龟重新移动
    
71. 污龟重新移动
    
72. 污龟重新移动
    
73. 污龟重新移动
    
74. 污龟重新移动
    
75. 污龟重新移动
    
76. 这个鱼的位置在(4,8)
    
77. 这个鱼的位置在(0,6)
    
78. 这个鱼的位置在(8,5)
    
79. 这个鱼的位置在(8,8)
    
80. 这个鱼的位置在(8,0)
    
81. 这个鱼的位置在(9,2)
    
82. 这个鱼的位置在(7,4)
    
83. 这个鱼的位置在(7,4)
    
84. 这个鱼的位置在(1,3)
    
85. 污龟重新移动
    
86. 这个鱼的位置在(5,7)
    
87. 这个鱼的位置在(1,5)
    
88. 这个鱼的位置在(9,6)
    
89. 这个鱼的位置在(7,9)
    
90. 这个鱼的位置在(9,1)
    
91. 这个鱼的位置在(10,1)
    
92. 这个鱼的位置在(8,5)
    
93. 这个鱼的位置在(8,3)
    
94. 这个鱼的位置在(0,4)
    
95. 污龟重新移动
    
96. 污龟重新移动
    
97. 这个鱼的位置在(4,8)
    
98. 这个鱼的位置在(2,4)
    
99. 这个鱼的位置在(8,5)
    
100. 这个鱼的位置在(6,8)
     
101. 这个鱼的位置在(10,0)
     
102. 这个鱼的位置在(9,0)
     
103. 这个鱼的位置在(7,4)
     
104. 这个鱼的位置在(7,2)
     
105. 这个鱼的位置在(1,5)
     
106. 这个鱼的位置在(3,7)
     
107. 这个鱼的位置在(1,5)
     
108. 这个鱼的位置在(9,6)
     
109. 这个鱼的位置在(7,7)
     
110. 这个鱼的位置在(9,1)
     
111. 这个鱼的位置在(10,1)
     
112. 这个鱼的位置在(6,3)
     
113. 这个鱼的位置在(8,1)
     
114. 这个鱼的位置在(0,4)
     
115. 污龟重新移动
     
116. 这个鱼的位置在(2,8)
     
117. 这个鱼的位置在(2,6)
     
118. 这个鱼的位置在(10,5)
     
119. 这个鱼的位置在(6,8)
     
120. 这个鱼的位置在(10,2)
     
121. 这个鱼的位置在(9,2)
     
122. 这个鱼的位置在(5,2)
     
123. 这个鱼的位置在(7,2)
     
124. 这个鱼的位置在(1,3)
     
125. 污龟重新移动
     
126. 污龟重新移动
     
127. 污龟重新移动
     
128. 污龟重新移动
     
129. 污龟重新移动
     
130. 污龟重新移动
     
131. 污龟重新移动
     
132. 污龟重新移动
     
133. 污龟重新移动
     
134. 这个鱼的位置在(1,9)
     
135. 这个鱼的位置在(3,7)
     
136. 这个鱼的位置在(9,4)
     
137. 这个鱼的位置在(5,9)
     
138. 这个鱼的位置在(9,3)
     
139. 这个鱼的位置在(8,1)
     
140. 这个鱼的位置在(4,1)
     
141. 这个鱼的位置在(8,1)
     
142. 这个鱼的位置在(0,4)
     
143. 这个鱼的位置在(2,8)
     
144. 这个鱼的位置在(4,8)
     
145. 这个鱼的位置在(8,5)
     
146. 这个鱼的位置在(6,8)
     
147. 这个鱼的位置在(10,4)
     
148. 这个鱼的位置在(7,2)
     
149. 这个鱼的位置在(3,0)
     
150. 这个鱼的位置在(9,0)
     
151. 这个鱼的位置在(1,5)
     
152. 这个鱼的位置在(3,9)
     
153. 这个鱼的位置在(5,7)
     
154. 这个鱼的位置在(7,4)
     
155. 这个鱼的位置在(7,7)
     
156. 这个鱼的位置在(9,3)
     
157. 这个鱼的位置在(6,1)
     
158. 这个鱼的位置在(2,1)
     
159. 这个鱼的位置在(10,1)
     
160. 这个鱼的位置在(0,6)
     
161. 污龟重新移动
     
162. 污龟重新移动
     
163. 污龟重新移动
     
164. 污龟重新移动
     
165. 污龟重新移动
     
166. 这个鱼的位置在(4,8)
     
167. 这个鱼的位置在(4,6)
     
168. 这个鱼的位置在(8,5)
     
169. 这个鱼的位置在(8,6)
     
170. 这个鱼的位置在(10,2)
     
171. 这个鱼的位置在(5,0)
     
172. 这个鱼的位置在(3,2)
     
173. 这个鱼的位置在(9,2)
     
174. 这个鱼的位置在(1,5)
     
175. 污龟重新移动
     
176. 污龟重新移动
     
177. 这个鱼的位置在(5,9)
     
178. 这个鱼的位置在(3,5)
     
179. 这个鱼的位置在(9,6)
     
180. 这个鱼的位置在(7,5)
     
181. 这个鱼的位置在(9,3)
     
182. 这个鱼的位置在(4,1)
     
183. 这个鱼的位置在(4,3)
     
184. 这个鱼的位置在(10,3)
     
185. 这个鱼的位置在(0,6)
     
186. 污龟重新移动
     
187. 污龟重新移动
     
188. 这个鱼的位置在(4,8)
     
189. 这个鱼的位置在(4,6)
     
190. 这个鱼的位置在(10,7)
     
191. 这个鱼的位置在(6,6)
     
192. 这个鱼的位置在(10,4)
     
193. 这个鱼的位置在(3,2)
     
194. 这个鱼的位置在(5,2)
     
195. 这个鱼的位置在(9,2)
     
196. 这个鱼的位置在(1,5)
     
197. 这个鱼的位置在(5,9)
     
198. 这个鱼的位置在(5,7)
     
199. 这个鱼的位置在(9,6)
     
200. 这个鱼的位置在(7,5)
     
201. 这个鱼的位置在(9,3)
     
202. 这个鱼的位置在(4,3)
     
203. 这个鱼的位置在(4,1)
     
204. 这个鱼的位置在(8,1)
     
205. 这个鱼的位置在(0,4)
     
206. 污龟重新移动
     
207. 污龟重新移动
     
208. 污龟重新移动
     
209. 污龟重新移动
     
210. 污龟重新移动
     
211. 污龟重新移动
     
212. 污龟重新移动
     
213. 污龟重新移动
     
214. 污龟重新移动
     
215. 这个鱼的位置在(6,8)
     
216. 这个鱼的位置在(4,6)
     
217. 这个鱼的位置在(8,5)
     
218. 这个鱼的位置在(8,4)
     
219. 这个鱼的位置在(10,2)
     
220. 这个鱼的位置在(5,4)
     
221. 这个鱼的位置在(5,0)
     
222. 这个鱼的位置在(9,2)
     
223. 这个鱼的位置在(1,5)
     
224. 污龟重新移动
     
225. 污龟重新移动
     
226. 这个鱼的位置在(5,7)
     
227. 这个鱼的位置在(5,5)
     
228. 这个鱼的位置在(7,4)
     
229. 这个鱼的位置在(9,3)
     
230. 这个鱼的位置在(9,1)
     
231. 这个鱼的位置在(4,5)
     
232. 这个鱼的位置在(6,1)
     
233. 这个鱼的位置在(10,1)
     
234. 这个鱼的位置在(2,6)
     
235. 污龟重新移动
     
236. 污龟重新移动
     
237. 污龟重新移动
     
238. 这个鱼的位置在(4,6)
     
239. 这个鱼的位置在(4,6)
     
240. 这个鱼的位置在(8,3)
     
241. 这个鱼的位置在(10,4)
     
242. 这个鱼的位置在(10,2)
     
243. 这个鱼的位置在(5,6)
     
244. 这个鱼的位置在(5,0)
     
245. 这个鱼的位置在(9,0)
     
246. 这个鱼的位置在(3,7)
     
247. 这个鱼的位置在(5,7)
     
248. 这个鱼的位置在(5,5)
     
249. 这个鱼的位置在(7,4)
     
250. 这个鱼的位置在(9,5)
     
251. 这个鱼的位置在(9,3)
     
252. 这个鱼的位置在(6,5)
     
253. 这个鱼的位置在(6,1)
     
254. 这个鱼的位置在(8,1)
     
255. 这个鱼的位置在(2,6)
     
256. 污龟重新移动
     
257. 污龟重新移动
     
258. 污龟重新移动
     
259. 污龟重新移动
     
260. 污龟重新移动
     
261. 污龟重新移动
     
262. 这个鱼的位置在(6,6)
     
263. 这个鱼的位置在(6,6)
     
264. 这个鱼的位置在(8,5)
     
265. 这个鱼的位置在(10,4)
     
266. 这个鱼的位置在(10,2)
     
267. 这个鱼的位置在(7,6)
     
268. 这个鱼的位置在(7,2)
     
269. 这个鱼的位置在(7,0)
     
270. 这个鱼的位置在(1,7)
     
271. 污龟重新移动
     
272. 污龟重新移动
     
273. 这个鱼的位置在(7,5)
     
274. 这个鱼的位置在(5,7)
     
275. 这个鱼的位置在(9,4)
     
276. 这个鱼的位置在(9,3)
     
277. 这个鱼的位置在(9,1)
     
278. 这个鱼的位置在(6,7)
     
279. 这个鱼的位置在(6,1)
     
280. 这个鱼的位置在(6,1)
     
281. 这个鱼的位置在(0,6)
     
282. 污龟重新移动
     
283. 这个鱼的位置在(6,4)
     
284. 这个鱼的位置在(6,6)
     
285. 这个鱼的位置在(10,3)
     
286. 这个鱼的位置在(8,4)
     
287. 这个鱼的位置在(8,0)
     
288. 这个鱼的位置在(7,8)
     
289. 这个鱼的位置在(7,0)
     
290. 这个鱼的位置在(5,2)
     
291. 这个鱼的位置在(1,7)
     
292. 污龟重新移动
     
293. 污龟重新移动
     
294. 污龟重新移动
     
295. 这个鱼的位置在(5,5)
     
296. 这个鱼的位置在(5,5)
     
297. 这个鱼的位置在(9,2)
     
298. 这个鱼的位置在(7,5)
     
299. 这个鱼的位置在(7,1)
     
300. 这个鱼的位置在(8,9)
     
301. 这个鱼的位置在(8,1)
     
302. 这个鱼的位置在(4,1)
     
303. 这个鱼的位置在(2,8)
     
304. 污龟重新移动
     
305. 污龟重新移动
     
306. 这个鱼的位置在(6,4)
     
307. 这个鱼的位置在(6,4)
     
308. 这个鱼的位置在(10,3)
     
309. 这个鱼的位置在(6,6)
     
310. 这个鱼的位置在(6,2)
     
311. 这个鱼的位置在(7,10)
     
312. 这个鱼的位置在(9,2)
     
313. 这个鱼的位置在(3,2)
     
314. 这个鱼的位置在(1,9)
     
315. 污龟重新移动
     
316. 污龟重新移动
     
317. 污龟重新移动
     
318. 污龟重新移动
     
319. 污龟重新移动
     
320. 污龟重新移动
     
321. 污龟重新移动
     
322. 污龟重新移动
     
323. 这个鱼的位置在(7,5)
     
324. 这个鱼的位置在(7,3)
     
325. 这个鱼的位置在(9,4)
     
326. 这个鱼的位置在(7,7)
     
327. 这个鱼的位置在(5,1)
     
328. 这个鱼的位置在(8,9)
     
329. 这个鱼的位置在(10,3)
     
330. 这个鱼的位置在(2,1)
     
331. 这个鱼的位置在(2,8)
     
332. 这个鱼的位置在(8,4)
     
333. 这个鱼的位置在(8,4)
     
334. 这个鱼的位置在(8,3)
     
335. 这个鱼的位置在(8,6)
     
336. 这个鱼的位置在(4,2)
     
337. 这个鱼的位置在(9,10)
     
338. 这个鱼的位置在(9,2)
     
339. 这个鱼的位置在(3,2)
     
340. 这个鱼的位置在(3,7)
     
341. 乌龟体力耗尽，挂掉了！

复制代码

Peteryo01223

小甲鱼的铁粉 发表于 2021-2-9 14:31
怎么不正常，那是因为你设置的污龟sum = abs(temp_1)+abs(temp_2)

运行你的code后，没有打印出任何鱼被吃的字样。。。