我的Python字典没有正确更新。

huangapple
go评论108阅读模式
英文:

My python dictionary is not updating properly

问题

I'm here to provide translations, but it seems like you've included a large portion of code and explanations. Please specify which parts of the text you would like me to translate for you, and I'll be happy to assist.

英文:

I am working on a project where I want to capture some data from different types of sorting algorithms and I planned on doing this by saving all the data into a dictionary and then converting that dictionary into a pandas data frame and eventually exporting it as a csv file.

The problem now is that I am updating my dictionary inside 4 for loops but it seems that for some reason the updating is being overwritten somewhere in my code at first I thought it was the global keyword that I was using to keep track of data comparison and data swap count but I am not sure I tried my best to look for moments that interfere with my global variable but I can't find anything can you please help?

My code looks something like this:

  2. def merge_sort(array):
  3.     #apparently merge sort only has data assignment without no swaps and will create a new array so we can exclude data swap count
  4.     if len(array) <= 1:
  5.         return
  6.     mid = len(array) // 2
  7.     left = array[:mid].copy()
  8.     right = array[mid:].copy()
  9.     merge_sort(left)
  10.     merge_sort(right)
  12.     x,y=merge(array, left, right)
  13.     global comparison_counter,swap_counter
  14.     comparison_counter+=x
  15.     swap_counter+=y
  17.     return comparison_counter,swap_counter
  18. def merge(array, lefthalf, righthalf):
  19.     i=0
  20.     j=0
  21.     k=0
  22.     global data_comparison_count, data_swap_count
  23.     while i < len(lefthalf) and j < len(righthalf):
  24.         #underneath is comparison
  25.         if lefthalf[i] < righthalf[j]:#data comparison
  26.             array[k]=lefthalf[i]
  27.             i=i+1
  28.         else:
  29.             array[k]=righthalf[j]
  30.             j=j+1
  31.         data_comparison_count+=1
  32.         k=k+1
  33.     while i < len(lefthalf):
  35.         array[k]=lefthalf[i]
  36.         i=i+1
  37.         k=k+1
  38.     while j < len(righthalf):
  40.         array[k]=righthalf[j]
  41.         j=j+1
  42.         k=k+1
  43.     return data_comparison_count,data_swap_count
  47. def partition(array, start_index, end_index):
  48.     global data_comparison_count, data_swap_count
  49.     pivot_value = array[start_index]
  50.     left_mark = start_index + 1
  51.     right_mark = end_index
  52.     while True:
  53.         while left_mark <= right_mark and array[left_mark] <= pivot_value:#comparison
  54.             data_comparison_count+=1
  55.             left_mark = left_mark + 1
  56.         while array[right_mark] >= pivot_value and right_mark >= left_mark:#comparison
  57.             data_comparison_count+=1
  58.             right_mark = right_mark - 1
  59.         if right_mark < left_mark:
  60.             break
  61.         else:
  62.             #data_swap=1
  64.             temp = array[left_mark]
  65.             array[left_mark] = array[right_mark]
  66.             array[right_mark] = temp
  67.             data_swap_count += 1
  68.     #data_swap
  69.     data_swap_count+=1
  70.     array[start_index] = array[right_mark]
  71.     array[right_mark] = pivot_value
  72.     return right_mark,data_comparison_count,data_swap_count
  75. def quick_sort(array):
  76.     temp1,temp2=quick_sort_helper(array, 0, len(array) - 1)
  77.     return temp1,temp2
  79. def quick_sort_helper(array, start_index, end_index):
  80.     global comparison_counter, swap_counter
  81.     if start_index < end_index:
  82.         split_point,x,y = partition(array, start_index, end_index)
  83.         comparison_counter+=x
  84.         swap_counter+=y
  85.         quick_sort_helper(array, start_index, split_point - 1)
  86.         quick_sort_helper(array, split_point + 1, end_index)
  88.     return comparison_counter,swap_counter
  2. time_and_data_dictionary={"Time":12,"Data Comparisons":12,"Data Swaps":12}
  3. selection_sort_information={"selection sort":time_and_data_dictionary}
  4. bubble_sort_information={"bubble sort":time_and_data_dictionary}
  5. insertion_sort_information={"insertion sort":time_and_data_dictionary}
  6. shell_sort_information={"shell sort":time_and_data_dictionary}
  7. quick_sort_information={"quick sort":time_and_data_dictionary}
  8. merge_sort_information={"merge sort":time_and_data_dictionary}
  9. array_of_sorting_algorithms=[selection_sort_information,bubble_sort_information,insertion_sort_information,shell_sort_information,quick_sort_information,merge_sort_information]
  10. dictionary={"Ascending_Sorted_250":array_of_sorting_algorithms,"Ascending_Sorted_500":array_of_sorting_algorithms,"Ascending_Sorted_1000": array_of_sorting_algorithms,"Ascending_Sorted_10000":array_of_sorting_algorithms,"Descending_Sorted_250":array_of_sorting_algorithms,"Descending_Sorted_500":array_of_sorting_algorithms," Descending_Sorted_1000": array_of_sorting_algorithms,"Descending_Sorted_10000":array_of_sorting_algorithms,"Random_Sorted_250":array_of_sorting_algorithms,"Random_Sorted_500":array_of_sorting_algorithms," Random_Sorted_1000":array_of_sorting_algorithms,"Random_Sorted_10000":array_of_sorting_algorithms}
  11. t="Time"
  12. dc="Data Comparisons"
  13. ds="Data Swaps"
  14. start = time()
  15. tuple_selection_sort_ad250 = selection_sort_array(ascending_data_250)
  16. end = time()
  17. td_selection_sort_ad250 = end - start
  18. start = time()
  19. tuple_bubble_sort_ad250 = bubble_sort_array(ascending_data_250)
  20. end = time()
  21. td_bubble_sort_ad250 = end - start
  22. start = time()
  23. tuple_insertion_sort_ad250 = insertion_sort_array(ascending_data_250)
  24. end = time()
  25. td_insertion_sort_ad250 = end - start
  26. start = time()
  27. tuple_shell_sort_ad250 = shell_sort_array(ascending_data_250)
  28. end = time()
  29. td_shell_sort_ad250 = end - start
  30. data_comparison_count = 0
  31. data_swap_count = 0
  32. comparison_counter = 0
  33. swap_counter = 0
  34. start = time()
  35. tuple_merge_sort_ad250 = merge_sort(ascending_data_250)
  36. end = time()
  37. td_merge_sort_ad250 = end - start
  38. data_comparison_count = 0
  39. data_swap_count = 0
  40. comparison_counter = 0
  41. swap_counter = 0
  42. start = time()
  43. tuple_quick_sort_ad250 = quick_sort(ascending_data_250)
  44. end = time()
  45. td_quick_sort_ad250 = end - start
  46. start = time()
  47. tuple_selection_sort_ad500 = selection_sort_array(ascending_data_500)
  48. end = time()
  49. td_selection_sort_ad500 = end - start
  50. start = time()
  51. tuple_bubble_sort_ad500 = bubble_sort_array(ascending_data_500)
  52. end = time()
  53. td_bubble_sort_ad500 = end - start
  54. start = time()
  55. tuple_insertion_sort_ad500 = insertion_sort_array(ascending_data_500)
  56. end = time()
  57. td_insertion_sort_ad500 = end - start
  58. start = time()
  59. tuple_shell_sort_ad500 = shell_sort_array(ascending_data_500)
  60. end = time()
  61. td_shell_sort_ad500 = end - start
  62. data_comparison_count = 0
  63. data_swap_count = 0
  64. comparison_counter = 0
  65. swap_counter = 0
  66. start = time()
  67. tuple_merge_sort_ad500 = merge_sort(ascending_data_500)
  68. end = time()
  69. td_merge_sort_ad500 = end - start
  70. data_comparison_count = 0
  71. data_swap_count = 0
  72. comparison_counter = 0
  73. swap_counter = 0
  74. start = time()
  75. tuple_quick_sort_ad500 = quick_sort(ascending_data_500)
  76. end = time()
  77. td_quick_sort_ad500 = end - start
  78. start = time()
  79. tuple_selection_sort_dd250 = selection_sort_array(descending_data_250)
  80. end = time()
  81. td_selection_sort_dd250 = end - start
  82. start = time()
  83. tuple_bubble_sort_dd250 = bubble_sort_array(descending_data_250)
  84. end = time()
  85. td_bubble_sort_dd250 = end - start
  86. start = time()
  87. tuple_insertion_sort_dd250 = insertion_sort_array(descending_data_250)
  88. end = time()
  89. td_insertion_sort_dd250 = end - start
  90. start = time()
  91. tuple_shell_sort_dd250 = shell_sort_array(descending_data_250)
  92. end = time()
  93. td_shell_sort_dd250 = end - start
  94. for i,j in dictionary.items():
  95. for x,val in enumerate(j):
  96. for k,v in val.items():
  97. for y,z in v.items():
  98. if i=="Ascending_Sorted_250":
  99. if x==0:
  100. dictionary[i][x][k][t]=td_selection_sort_ad250
  101. print(td_selection_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  102. dictionary[i][x][k][dc]=tuple_selection_sort_ad250[0]
  103. print(tuple_selection_sort_ad250[0], "???????????????????????")
  104. dictionary[i][x][k][ds]=tuple_selection_sort_ad250[1]
  105. print(tuple_selection_sort_ad250[1], "////////////////////")
  106. if x==1:
  107. print("is",k,x)
  108. print(i, x, k, t, dc, ds, type(i), type(x), type(k), type(t), type(dc), type(ds))
  109. dictionary[i][x][k][t] = td_bubble_sort_ad250
  110. print(td_bubble_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  111. dictionary[i][x][k][dc] = tuple_bubble_sort_ad250[0]
  112. dictionary[i][x][k][ds] = tuple_bubble_sort_ad250[1]
  113. if x==2:
  114. print("going",k,x)
  115. print(i, x, k, t, dc, ds, type(i), type(x), type(k), type(t), type(dc), type(ds))
  116. dictionary[i][x][k][t] = td_insertion_sort_ad250
  117. dictionary[i][x][k][dc] = tuple_insertion_sort_ad250[0]
  118. dictionary[i][x][k][ds] = tuple_insertion_sort_ad250[1]
  119. if x==3:
  120. print("on",k,x)
  121. print(i, x, k, t, dc, ds, type(i), type(x), type(k), type(t), type(dc), type(ds))
  122. dictionary[i][x][k][t] = td_shell_sort_ad250
  123. dictionary[i][x][k][dc] = tuple_shell_sort_ad250[0]
  124. dictionary[i][x][k][ds] = tuple_shell_sort_ad250[1]
  125. if x==4:
  126. print("here",k,x)
  127. print(i, x, k, t, dc, ds, type(i), type(x), type(k), type(t), type(dc), type(ds))
  128. dictionary[i][x][k][t] = td_merge_sort_ad250
  129. dictionary[i][x][k][dc] = tuple_merge_sort_ad250[0]
  130. dictionary[i][x][k][ds] = tuple_merge_sort_ad250[1]
  131. if x==5:
  132. print("now",k,x)
  133. print(i, x, k, t, dc, ds, type(i), type(x), type(k), type(t), type(dc), type(ds))
  134. dictionary[i][x][k][t] = td_quick_sort_ad250
  135. dictionary[i][x][k][dc] = tuple_quick_sort_ad250[0]
  136. dictionary[i][x][k][ds] = tuple_quick_sort_ad250[1]
  137. if i=="Ascending_Sorted_500":
  138. if x == 0:
  139. dictionary[i][x][k][t] = td_selection_sort_ad500
  140. print(td_selection_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  141. dictionary[i][x][k][dc] = tuple_selection_sort_ad500[0]
  142. print(tuple_selection_sort_ad250[0], "???????????????????????")
  143. dictionary[i][x][k][ds] = tuple_selection_sort_ad500[1]
  144. print(tuple_selection_sort_ad250[1], "////////////////////")
  145. if x == 1:
  146. dictionary[i][x][k][t] = td_bubble_sort_ad500
  147. print(td_bubble_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  148. dictionary[i][x][k][dc] = tuple_bubble_sort_ad500[0]
  149. print(tuple_bubble_sort_ad250[0], "???????????????????????")
  150. dictionary[i][x][k][ds] = tuple_bubble_sort_ad500[1]
  151. print(tuple_bubble_sort_ad250[1], "////////////////////")
  152. if x == 2:
  153. dictionary[i][x][k][t] = td_insertion_sort_ad500
  154. print(td_insertion_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  155. dictionary[i][x][k][dc] = tuple_insertion_sort_ad500[0]
  156. print(tuple_insertion_sort_ad250[0], "???????????????????????")
  157. dictionary[i][x][k][ds] = tuple_insertion_sort_ad500[1]
  158. print(tuple_insertion_sort_ad250[1], "////////////////////")
  159. if x == 3:
  160. dictionary[i][x][k][t] = td_shell_sort_ad500
  161. print(td_shell_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  162. dictionary[i][x][k][dc] = tuple_shell_sort_ad500[0]
  163. print(tuple_shell_sort_ad250[0], "???????????????????????")
  164. dictionary[i][x][k][ds] = tuple_shell_sort_ad500[1]
  165. print(tuple_shell_sort_ad250[1], "////////////////////")
  166. if x == 4:
  167. dictionary[i][x][k][t] = td_merge_sort_ad500
  168. print(td_merge_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  169. dictionary[i][x][k][dc] = tuple_merge_sort_ad500[0]
  170. print(tuple_merge_sort_ad250[0], "???????????????????????")
  171. dictionary[i][x][k][ds] = tuple_merge_sort_ad500[1]
  172. print(tuple_merge_sort_ad250[1], "////////////////////")
  173. if x == 5:
  174. dictionary[i][x][k][t] = td_quick_sort_ad500
  175. print(td_quick_sort_ad250,"!!!!!!!!!!!!!!!!!!!!!!")
  176. dictionary[i][x][k][dc] = tuple_quick_sort_ad500[0]
  177. print(tuple_quick_sort_ad250[0], "???????????????????????")
  178. dictionary[i][x][k][ds] = tuple_quick_sort_ad500[1]
  179. print(tuple_quick_sort_ad250[1], "////////////////////")
  180. print(dictionary,"$$$$$$$$$$$$$$")

I tried initializing the variables every time I called the merge_sort and quick_sort functions, since I thought it was a problem with the globalization of my variables, I thought this would fix it, but this was far from the truth. I also tried to debug it using different statements but the output of my debug and the output for my dictionary was very different.
Here is a snippet of what my console(output) looks like:

我的Python字典没有正确更新。

我的Python字典没有正确更新。

答案1

得分: 1

以下是您提供的代码部分的翻译：

  1. 主要要关注的是将这些仪器化排序方法实现在一个封装内，以便跟踪每个递增的计数器。仍然存在这些计数器的一种全局版本，但它们被包含在内。
  2. 以下是一个排序方法的示例，带有一些数据集。我将留下适当的计数器增加给您，但我保留了您已经有的一些。
  3. ```python
  4. from time import time
  5. def build_merge_sorter():
  6. ## ---------------------
  7. ## 保持操作的整洁跟踪
  8. ## ---------------------
  9. data_comparison_count = 0
  10. data_swap_count = 0
  11. comparison_counter = 0
  12. swap_counter = 0
  13. ## ---------------------
  14. def helper(array, lefthalf, righthalf):
  15. ## ---------------------
  16. ## 让这个方法知道这些变量来自其他地方
  17. ## ---------------------
  18. nonlocal data_comparison_count
  19. nonlocal data_swap_count
  20. nonlocal comparison_counter
  21. nonlocal swap_counter
  22. ## ---------------------
  23. i = 0
  24. j = 0
  25. k = 0
  26. while i < len(lefthalf) and j < len(righthalf):
  27. ## ---------------------
  28. ## 这是+1还是+3？
  29. ## ---------------------
  30. data_comparison_count += 1
  31. ## ---------------------
  32. if lefthalf[i] < righthalf[j]:
  33. array[k] = lefthalf[i]
  34. i += 1
  35. else:
  36. array[k] = righthalf[j]
  37. j += 1
  38. k += 1
  39. while i < len(lefthalf):
  40. array[k] = lefthalf[i]
  41. i += 1
  42. k += 1
  43. while j < len(righthalf):
  44. array[k] = righthalf[j]
  45. j += 1
  46. k += 1
  47. def sorter(array):
  48. ## ---------------------
  49. ## 让这个方法知道这些变量来自其他地方
  50. ## ---------------------
  51. nonlocal data_comparison_count
  52. nonlocal data_swap_count
  53. nonlocal comparison_counter
  54. nonlocal swap_counter
  55. ## ---------------------
  56. ## ---------------------
  57. ## 初始化这次排序的计数器
  58. ## ---------------------
  59. data_comparison_count = 0
  60. data_swap_count = 0
  61. comparison_counter = 0
  62. swap_counter = 0
  63. ## ---------------------
  64. ## ---------------------
  65. ## 一个只有1个元素的数组已经排序好了
  66. ## ---------------------
  67. comparison_counter += 1
  68. if len(array) <= 1:
  69. return (
  70. array,
  71. comparison_counter,
  72. swap_counter,
  73. data_comparison_count,
  74. data_swap_count
  75. )
  76. ## ---------------------
  77. ## ---------------------
  78. ## 这些操作应该有成本吗？
  79. ## ---------------------
  80. mid = len(array) // 2
  81. left = array[:mid]
  82. right = array[mid:]
  83. ## ---------------------
  84. ## ---------------------
  85. ## 对每一半应用排序，以便我们可以丢弃结果
  86. ## ---------------------
  87. sorter(left)
  88. sorter(right)
  89. ## ---------------------
  90. ## ---------------------
  91. ## 应用辅助函数来重新排列数据点
  92. ## ---------------------
  93. helper(array, left, right)
  94. ## ---------------------
  95. return (
  96. array,
  97. comparison_counter,
  98. swap_counter,
  99. data_comparison_count,
  100. data_swap_count
  101. )
  102. return sorter
  103. SORTERS = {
  104. "Merge Sort": build_merge_sorter()
  105. }
  106. DATASETS = {
  107. "Ascending 250": list(range(250)),
  108. "Decending 250": list(reversed(range(250)))
  109. }
  110. ## ---------------------
  111. ## 运行测试
  112. ## ---------------------
  113. test_results = {}
  114. for method_name, method in SORTERS.items():
  115. for dataset_name, dataset in DATASETS.items():
  116. dataset = dataset[:]
  117. start = time()
  118. (
  119. sorted_dataset,
  120. comparison_counter,
  121. swap_counter,
  122. data_comparison_count,
  123. data_swap_count
  124. ) = method(dataset)
  125. end = time()
  126. test_results.setdefault(method_name, {})[dataset_name] = {
  127. "time": end - start,
  128. "comparisons": comparison_counter,
  129. "swaps": swap_counter,
  130. "data_comparisons": data_comparison_count,
  131. "data_swaps": data_swap_count,
  132. }
  133. ## ---------------------
  134. import json
  135. print(json.dumps(test_results, indent=4))

这将产生类似以下的输出：

  1. {
  2.     "Merge Sort": {
  3.         "Ascending 250": {
  4.             "time": 0.000995635986328125,
  5.             "comparisons": 1,
  6.             "swaps": 0,
  7.             "data_comparisons": 249,
  8.             "data_swaps": 0
  9.         },
  10.         "Decending 250": {
  11.             "time": 0.0,
  12.             "comparisons": 1,
  13.             "swaps": 0,
  14.             "data_comparisons": 251,
  15.             "data_swaps": 0
  16.         }
  17.     }
  18. }
  19. }
英文:

The main thing I would look at would be to implement these instrumented sorting methods inside an enclosure so that you can track each incremented counter. There is still a kind of global version of these counters, but they are contained.

Here is an example of one sort method with a couple of data sets. I will leave the proper counter incrementing to you but I kept the couple you had in already.

  1. from time import time
  3. def build_merge_sorter():
  4.     ## ---------------------
  5.     ## keeping tidy track of operations
  6.     ## ---------------------
  7.     data_comparison_count = 0
  8.     data_swap_count = 0
  9.     comparison_counter = 0
  10.     swap_counter = 0
  11.     ## ---------------------
  13.     def helper(array, lefthalf, righthalf):
  14.         ## ---------------------
  15.         ## Let this method know that these variables come from someplace else
  16.         ## ---------------------
  17.         nonlocal data_comparison_count
  18.         nonlocal data_swap_count
  19.         nonlocal comparison_counter
  20.         nonlocal swap_counter
  21.         ## ---------------------
  23.         i=0
  24.         j=0
  25.         k=0
  27.         while i &lt; len(lefthalf) and j &lt; len(righthalf):
  29.             ## ---------------------
  30.             ## Is this +1 or +3?
  31.             ## ---------------------
  32.             data_comparison_count += 1
  33.             ## ---------------------
  35.             if lefthalf[i] &lt; righthalf[j]:
  36.                 array[k]=lefthalf[i]
  37.                 i += 1
  38.             else:
  39.                 array[k]=righthalf[j]
  40.                 j += 1
  42.             k += 1
  44.         while i &lt; len(lefthalf):
  45.             array[k] = lefthalf[i]
  46.             i += 1
  47.             k += 1
  49.         while j &lt; len(righthalf):
  50.             array[k] = righthalf[j]
  51.             j += 1
  52.             k += 1
  54.     def sorter(array):
  55.         ## ---------------------
  56.         ## Let this method know that these variables come from someplace else
  57.         ## ---------------------
  58.         nonlocal data_comparison_count
  59.         nonlocal data_swap_count
  60.         nonlocal comparison_counter
  61.         nonlocal swap_counter
  62.         ## ---------------------
  64.         ## ---------------------
  65.         ## initialize the counters for this sort
  66.         ## ---------------------
  67.         data_comparison_count = 0
  68.         data_swap_count = 0
  69.         comparison_counter = 0
  70.         swap_counter = 0
  71.         ## ---------------------
  73.         ## ---------------------
  74.         ## an array of 1 element is already sorted
  75.         ## ---------------------
  76.         comparison_counter += 1
  77.         if len(array) &lt;= 1:
  78.             return (
  79.                 array,
  80.                 comparison_counter,
  81.                 swap_counter,
  82.                 data_comparison_count,
  83.                 data_swap_count
  84.             )
  85.         ## ---------------------
  87.         ## ---------------------
  88.         ## Should these opperations have costs?
  89.         ## ---------------------
  90.         mid = len(array) // 2
  91.         left = array[:mid]
  92.         right = array[mid:]
  93.         ## ---------------------
  95.         ## ---------------------
  96.         ## apply the sort to each half in-place so we can discard the result
  97.         ## ---------------------
  98.         sorter(left)
  99.         sorter(right)
  100.         ## ---------------------
  102.         ## ---------------------
  103.         ## Apply the help to shuffle data points about
  104.         ## ---------------------
  105.         helper(array, left, right)
  106.         ## ---------------------
  108.         return (
  109.             array,
  110.             comparison_counter,
  111.             swap_counter,
  112.             data_comparison_count,
  113.             data_swap_count
  114.         )
  116.     return sorter
  118. SORTERS = {
  119.     &quot;Merge Sort&quot;: build_merge_sorter()
  120. }
  122. DATASETS = {
  123.     &quot;Ascending 250&quot;: list(range(250)),
  124.     &quot;Decending 250&quot;: list(reversed(range(250)))
  125. }
  127. ## ---------------------
  128. ## Run tests
  129. ## ---------------------
  130. test_results = {}
  131. for method_name, method in SORTERS.items():
  132.     for dataset_name, dataset in DATASETS.items():
  133.         dataset = dataset[:]
  135.         start = time()
  136.         (
  137.             sorted_dataset,
  138.             comparison_counter,
  139.             swap_counter,
  140.             data_comparison_count,
  141.             data_swap_count
  142.         ) = method(dataset)
  143.         end = time()
  145.         test_results.setdefault(method_name, {})[dataset_name] = {
  146.             &quot;time&quot;: end - start,
  147.             &quot;comparisons&quot;: comparison_counter,
  148.             &quot;swaps&quot;: swap_counter,
  149.             &quot;data_comparisons&quot;: data_comparison_count,
  150.             &quot;data_swaps&quot;: data_swap_count,
  151.         }
  152. ## ---------------------
  154. import json
  155. print(json.dumps(test_results, indent=4))

That is going to result in something like:

  1. {
  2. &quot;Merge Sort&quot;: {
  3. &quot;Ascending 250&quot;: {
  4. &quot;time&quot;: 0.000995635986328125,
  5. &quot;comparisons&quot;: 1,
  6. &quot;swaps&quot;: 0,
  7. &quot;data_comparisons&quot;: 249,
  8. &quot;data_swaps&quot;: 0
  9. },
  10. &quot;Decending 250&quot;: {
  11. &quot;time&quot;: 0.0,
  12. &quot;comparisons&quot;: 1,
  13. &quot;swaps&quot;: 0,
  14. &quot;data_comparisons&quot;: 251,
  15. &quot;data_swaps&quot;: 0
  16. }
  17. }
  18. }

huangapple
  • 本文由 发表于 2023年3月7日 21:33:25
  • 转载请务必保留本文链接：https://go.coder-hub.com/75662649.html
  • for-loop
  • global-variables
  • nested-loops
  • python
  • sorting
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定