易语言实现将单维数组成员随机打乱(洗牌)模块源码V1.0 - 兼容所有基本数据类型

QAQ

1. 
   
2. 
   
3. .版本 2
   
4. .支持库 spec
   
5. 
   
6. .程序集 数组洗牌, , , 将数组成员随机打乱
   
7. 
   
8. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
9. 
   
10. 置随机数种子 ()
    
11. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
    
12. 返回 (0)  ' 可以根据您的需要返回任意数值
    
13. 
    
14. .子程序 _临时子程序
    
15. .局部变量 A, 整数型, , "0"
    
16. 
    
17. ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
    
18. 
    
19. A ＝ { 0.1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
    
20. 调试输出 (A)
    
21. 整数型_数组洗牌 (A)
    
22. 调试输出 (A)
    
23. 
    
24. .子程序 字节型_数组洗牌, , 公开
    
25. .参数 数组, 字节型, 参考 数组
    
26. .局部变量 下标, 整数型
    
27. .局部变量 数组2, 字节型, , "0"
    
28. 
    
29. .判断循环首 (取数组成员数 (数组) ≠ 0)
    
30.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
    
31.     加入成员 (数组2, 数组 [下标])
    
32.     删除成员 (数组, 下标, 1)
    
33. .判断循环尾 ()
    
34. 数组 ＝ 数组2
    
35. 
    
36. .子程序 整数型_数组洗牌, , 公开
    
37. .参数 数组, 整数型, 参考 数组
    
38. .局部变量 下标, 整数型
    
39. .局部变量 数组2, 整数型, , "0"
    
40. 
    
41. .判断循环首 (取数组成员数 (数组) ≠ 0)
    
42.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
    
43.     加入成员 (数组2, 数组 [下标])
    
44.     删除成员 (数组, 下标, 1)
    
45. .判断循环尾 ()
    
46. 数组 ＝ 数组2
    
47. 
    
48. .子程序 小数型_数组洗牌, , 公开
    
49. .参数 数组, 小数型, 参考 数组
    
50. .局部变量 下标, 整数型
    
51. .局部变量 数组2, 小数型, , "0"
    
52. 
    
53. .判断循环首 (取数组成员数 (数组) ≠ 0)
    
54.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
    
55.     加入成员 (数组2, 数组 [下标])
    
56.     删除成员 (数组, 下标, 1)
    
57. .判断循环尾 ()
    
58. 数组 ＝ 数组2
    
59. 
    
60. .子程序 逻辑型_数组洗牌, , 公开
    
61. .参数 数组, 逻辑型, 参考 数组
    
62. .局部变量 下标, 整数型
    
63. .局部变量 数组2, 逻辑型, , "0"
    
64. 
    
65. .判断循环首 (取数组成员数 (数组) ≠ 0)
    
66.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
    
67.     加入成员 (数组2, 数组 [下标])
    
68.     删除成员 (数组, 下标, 1)
    
69. .判断循环尾 ()
    
70. 数组 ＝ 数组2
    
71. 
    
72. .子程序 文本型_数组洗牌, , 公开
    
73. .参数 数组, 文本型, 参考 数组
    
74. .局部变量 下标, 整数型
    
75. .局部变量 数组2, 文本型, , "0"
    
76. 
    
77. .判断循环首 (取数组成员数 (数组) ≠ 0)
    
78.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
    
79.     加入成员 (数组2, 数组 [下标])
    
80.     删除成员 (数组, 下标, 1)
    
81. .判断循环尾 ()
    
82. 数组 ＝ 数组2
    
83. 
    
84. .子程序 字节集_数组洗牌, , 公开
    
85. .参数 数组, 字节集, 参考 数组
    
86. .局部变量 下标, 整数型
    
87. .局部变量 数组2, 字节集, , "0"
    
88. 
    
89. .判断循环首 (取数组成员数 (数组) ≠ 0)
    
90.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
    
91.     加入成员 (数组2, 数组 [下标])
    
92.     删除成员 (数组, 下标, 1)
    
93. .判断循环尾 ()
    
94. 数组 ＝ 数组2
    
95. 
    
96. .子程序 短整数型_数组洗牌, , 公开
    
97. .参数 数组, 短整数型, 参考 数组
    
98. .局部变量 下标, 整数型
    
99. .局部变量 数组2, 短整数型, , "0"
    
100. 
     
101. .判断循环首 (取数组成员数 (数组) ≠ 0)
     
102.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
     
103.     加入成员 (数组2, 数组 [下标])
     
104.     删除成员 (数组, 下标, 1)
     
105. .判断循环尾 ()
     
106. 数组 ＝ 数组2
     
107. 
     
108. .子程序 长整数型_数组洗牌, , 公开
     
109. .参数 数组, 长整数型, 参考 数组
     
110. .局部变量 下标, 整数型
     
111. .局部变量 数组2, 长整数型, , "0"
     
112. 
     
113. .判断循环首 (取数组成员数 (数组) ≠ 0)
     
114.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
     
115.     加入成员 (数组2, 数组 [下标])
     
116.     删除成员 (数组, 下标, 1)
     
117. .判断循环尾 ()
     
118. 数组 ＝ 数组2
     
119. 
     
120. .子程序 日期时间型_数组洗牌, , 公开
     
121. .参数 数组, 日期时间型, 参考 数组
     
122. .局部变量 下标, 整数型
     
123. .局部变量 数组2, 日期时间型, , "0"
     
124. 
     
125. .判断循环首 (取数组成员数 (数组) ≠ 0)
     
126.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
     
127.     加入成员 (数组2, 数组 [下标])
     
128.     删除成员 (数组, 下标, 1)
     
129. .判断循环尾 ()
     
130. 数组 ＝ 数组2
     
131. 
     
132. .子程序 子程序指针_数组洗牌, , 公开
     
133. .参数 数组, 子程序指针, 参考 数组
     
134. .局部变量 下标, 整数型
     
135. .局部变量 数组2, 子程序指针, , "0"
     
136. 
     
137. .判断循环首 (取数组成员数 (数组) ≠ 0)
     
138.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
     
139.     加入成员 (数组2, 数组 [下标])
     
140.     删除成员 (数组, 下标, 1)
     
141. .判断循环尾 ()
     
142. 数组 ＝ 数组2
     
143. 
     
144. .子程序 双精度小数型_数组洗牌, , 公开
     
145. .参数 数组, 双精度小数型, 参考 数组
     
146. .局部变量 下标, 整数型
     
147. .局部变量 数组2, 双精度小数型, , "0"
     
148. 
     
149. .判断循环首 (取数组成员数 (数组) ≠ 0)
     
150.     下标 ＝ 取随机整数 (1, 取数组成员数 (数组))
     
151.     加入成员 (数组2, 数组 [下标])
     
152.     删除成员 (数组, 下标, 1)
     
153. .判断循环尾 ()
     
154. 数组 ＝ 数组2
     
155. 
     
156. .子程序 限制整数范围, 整数型
     
157. .参数 数值, 整数型
     
158. .参数 最大值, 整数型
     
159. .参数 最小值, 整数型
     
160. .局部变量 无符号数值, 长整数型
     
161. .局部变量 无符号最大值, 长整数型
     
162. .局部变量 无符号最小值, 长整数型
     
163. .局部变量 无符号答案, 长整数型
     
164. 
     
165. .如果真 (最大值 ＜ 最小值)
     
166.     交换变量 (最大值, 最小值)
     
167. .如果真结束
     
168. 无符号数值 ＝ 数值 ＋ 2147483648
     
169. 无符号最大值 ＝ 最大值 ＋ 2147483648
     
170. 无符号最小值 ＝ 最小值 ＋ 2147483648
     
171. 无符号答案 ＝ 无符号数值 ％ (无符号最大值 － 无符号最小值 ＋ 1) ＋ 无符号最小值
     
172. 返回 (无符号答案 － 2147483648)
     
173. 
     
174. .子程序 取随机整数, 整数型, , 取随机整数 范围 -2147483648~2147483647
     
175. .参数 最大值, 整数型, , 支持负数
     
176. .参数 最小值, 整数型
     
177. .局部变量 字节集, 字节集
     
178. .局部变量 计数, 整数型
     
179. .局部变量 整数, 整数型
     
180. 
     
181. 字节集 ＝ 取空白字节集 (4)
     
182. .计次循环首 (4, 计数)
     
183.     字节集 [计数] ＝ 取随机数 (, )
     
184. .计次循环尾 ()
     
185. 返回 (限制整数范围 (取字节集数据 (字节集, #整数型, 1), 最大值, 最小值))
     
186. 
     
187. 
     

复制代码

1心1亿

谢谢分享

小莉今年7岁

1心1亿 发表于 2019-6-16 20:09
谢谢分享

你这到底是人还是机器

1心1亿

啧啧啧 发表于 2019-6-17 11:16
你这到底是人还是机器

你猜