关于2个数组穿插内容

刘玮

数组1      数组2

1刘先生    100

2李女士    200

3王先生    300

4马小姐    400

5字小姐    500

6无小姐    600

7真小姐   

数组1保持不动，数组2的内容随机插入到数组1里，请问老师们如何做到？

想要的结果如下：

1刘先生  

200

2李女士   

100

3王先生   

300

4马小姐  

600

5字小姐   

500

6无小姐   

500

7真小姐   

补充内容 (2025-3-5 17:58):
计次循环时，如果数组2小于数组1怎么办？

b0y

  

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
数组1	文本型		0
数组2	文本型		0
num
a
b

数组1 ＝ { “a”, “b”, “c”, “d”, “e”, “f” }
数组2 ＝ { “1”, “2”, “3”, “4”, “5” }
置随机数种子 ()
计次循环首 (取数组成员数 (数组2), a)
b ＝ 取随机数 (1, 取数组成员数 (数组2))
插入成员 (数组1, a × 2, 数组2 [b])
删除成员 (数组2, b, )
计次循环尾 ()
调试输出 (数组1)
' * 数组:11{“a”,“5”,“b”,“1”,“c”,“3”,“d”,“2”,“e”,“4”,“f”}
' 被调试易程序运行完毕

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 数组1, 文本型, , "0"<br /> .局部变量 数组2, 文本型, , "0"<br /> .局部变量 num<br /> .局部变量 a<br /> .局部变量 b<br /> <br /> 数组1 ＝ { “a”, “b”, “c”, “d”, “e”, “f” }<br /> 数组2 ＝ { “1”, “2”, “3”, “4”, “5” }<br /> 置随机数种子 ()<br /> .计次循环首 (取数组成员数 (数组2), a)<br />     b ＝ 取随机数 (1, 取数组成员数 (数组2))<br />     插入成员 (数组1, a × 2, 数组2 <strong>)<br />     删除成员 (数组2, b, )<br /> .计次循环尾 ()<br /> 调试输出 (数组1)<br /> ' * 数组:11{“a”,“5”,“b”,“1”,“c”,“3”,“d”,“2”,“e”,“4”,“f”}<br /> ' 被调试易程序运行完毕

LWB666

  

子程序名	返回值类型	公开	备 注
_启动子程序	整数型		本子程序在程序启动后最先执行

变量名	类 型	静态	数组	备 注
数组1	文本型		0
数组2	整数型		0
i	整数型
index	整数型

数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }
数组2 ＝ { 100, 200, 300, 400, 500, 600 }
index ＝ 1
计次循环首 (取数组成员数 (数组2), i)
数组1 [index] ＝ 数组1 [index] ＋ 到文本 (数组2 [index])
index ＝ index ＋ 1
如果真 (index ＞ 取数组成员数 (数组1))
跳出循环 ()

计次循环尾 ()
调试输出 (数组1)
返回 (0)  ' 可以根据您的需要返回任意数值

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 数组1, 文本型, , "0"<br /> .局部变量 数组2, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 index, 整数型<br /> <br /> 数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }<br /> 数组2 ＝ { 100, 200, 300, 400, 500, 600 }<br /> <br /> index ＝ 1<br /> .计次循环首 (取数组成员数 (数组2), i)<br />     数组1 [index] ＝ 数组1 [index] ＋ 到文本 (数组2 [index])<br />     index ＝ index ＋ 1<br />     .如果真 (index ＞ 取数组成员数 (数组1))<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 调试输出 (数组1)<br /> 返回 (0)  ' 可以根据您的需要返回任意数值

补充内容 (2025-3-5 17:58):
有点脱了裤子放屁了, index可以换成i

算法艺术家

  

子程序名	返回值类型	公开	备 注
数组随机分配

变量名	类 型	静态	数组	备 注
数组1	文本型		0
数组2	文本型		0
i	整数型
lenth	整数型		2

数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }
数组2 ＝ { “100”, “ 200”, “300”, “ 400”, “500”, “600” }
lenth [1] ＝ 取数组成员数 (数组1)
lenth [2] ＝ 取数组成员数 (数组2)
数组打乱 (数组2)
判断 (lenth [1] ≥ lenth [2])
计次循环首 (lenth [2], i)
数组1 [i] ＝ 数组1 [i] ＋ #换行符 ＋ 数组2 [i]
计次循环尾 ()
计次循环首 (lenth [1], i)
数组1 [i] ＝ 数组1 [i] ＋ #换行符 ＋ 数组2 [i]
计次循环尾 ()

调试输出 (数组1)

子程序名	返回值类型	公开	备 注
数组打乱			数组类型换成实际类型即可通用  分割文本 (#新UA, #换行符, )////分割后文本 [1]为随机输出一个
参数名	类 型	参考	可空	数组	备 注
参数组	文本型

变量名	类 型	静态	数组	备 注
i	整数型
局_长度	整数型
局_随机数	整数型

置随机数种子 ()
局_长度 ＝ 取数组成员数 (参数组)
如果真 (局_长度 ＞ 2)
计次循环首 (局_长度, i)
循环判断首 ()
局_随机数 ＝ 取随机数 (1, 局_长度)
循环判断尾 (i ＝ 局_随机数)
交换变量 (参数组 [i], 参数组 [局_随机数])
计次循环尾 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 数组随机分配<br /> .局部变量 数组1, 文本型, , "0"<br /> .局部变量 数组2, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 lenth, 整数型, , "2"<br /> <br /> 数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }<br /> 数组2 ＝ { “100”, “ 200”, “300”, “ 400”, “500”, “600” }<br /> lenth [1] ＝ 取数组成员数 (数组1)<br /> lenth [2] ＝ 取数组成员数 (数组2)<br /> 数组打乱 (数组2)<br /> .判断开始 (lenth [1] ≥ lenth [2])<br />     .计次循环首 (lenth [2], i)<br />         数组1 <i> ＝ 数组1 <i> ＋ #换行符 ＋ 数组2 <i><br />     .计次循环尾 ()<br /> .默认<br />     .计次循环首 (lenth [1], i)<br />         数组1 <i> ＝ 数组1 <i> ＋ #换行符 ＋ 数组2 <i><br />     .计次循环尾 ()<br /> .判断结束<br /> <br /> 调试输出 (数组1)<br /> <br /> <br /> .子程序 数组打乱, , 公开, 数组类型换成实际类型即可通用  分割文本 (#新UA, #换行符, )////分割后文本 [1]为随机输出一个<br /> .参数 参数组, 文本型, 参考 数组<br /> .局部变量 i, 整数型<br /> .局部变量 局_长度, 整数型<br /> .局部变量 局_随机数, 整数型<br /> <br /> 置随机数种子 ()<br /> 局_长度 ＝ 取数组成员数 (参数组)<br /> .如果真 (局_长度 ＞ 2)<br />     .计次循环首 (局_长度, i)<br />         .循环判断首 ()<br />             局_随机数 ＝ 取随机数 (1, 局_长度)<br />         .循环判断尾 (i ＝ 局_随机数)<br />         交换变量 (参数组 <i>, 参数组 [局_随机数])<br />     .计次循环尾 ()<br /> .如果真结束

算法艺术家

  

刚才理解错了 这样

子程序名	返回值类型	公开	备 注
数组随机分配

变量名	类 型	静态	数组	备 注
数组1	文本型		0
数组2	文本型		0
i	整数型
lenth	整数型		2
结果数组	文本型		0

数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }
数组2 ＝ { “100”, “ 200”, “300”, “ 400”, “500”, “600” }
lenth [1] ＝ 取数组成员数 (数组1)
lenth [2] ＝ 取数组成员数 (数组2)
数组打乱 (数组2)
判断 (lenth [1] ≥ lenth [2])
计次循环首 (lenth [2], i)
加入成员 (结果数组, 数组1 [i])
加入成员 (结果数组, 数组2 [i])
计次循环尾 ()
计次循环首 (lenth [1], i)
加入成员 (结果数组, 数组1 [i])
加入成员 (结果数组, 数组2 [i])
计次循环尾 ()

调试输出 (结果数组)

i支持库列表	支持库注释
spec	特殊功能支持库

刚才理解错了 这样<br /> .版本 2<br /> .支持库 spec<br /> <br /> .子程序 数组随机分配<br /> .局部变量 数组1, 文本型, , "0"<br /> .局部变量 数组2, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 lenth, 整数型, , "2"<br /> .局部变量 结果数组, 文本型, , "0"<br /> <br /> 数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }<br /> 数组2 ＝ { “100”, “ 200”, “300”, “ 400”, “500”, “600” }<br /> lenth [1] ＝ 取数组成员数 (数组1)<br /> lenth [2] ＝ 取数组成员数 (数组2)<br /> 数组打乱 (数组2)<br /> .判断开始 (lenth [1] ≥ lenth [2])<br />     .计次循环首 (lenth [2], i)<br />         加入成员 (结果数组, 数组1 <i>)<br />         加入成员 (结果数组, 数组2 <i>)<br />     .计次循环尾 ()<br /> .默认<br />     .计次循环首 (lenth [1], i)<br />         加入成员 (结果数组, 数组1 <i>)<br />         加入成员 (结果数组, 数组2 <i>)<br />     .计次循环尾 ()<br /> .判断结束<br /> <br /> 调试输出 (结果数组)

菜鸟路过

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
add_1	文本型		0
add_2	整数型		0
i	整数型
int	整数型
a	整数型

add_1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }
add_2 ＝ { 100, 200, 300, 400, 500, 600 }
计次循环首 (取数组成员数 (add_1), i)
int ＝ 取数组成员数 (add_2)
如果 (int ＞ 0)
如果 (int ＝ 1)
add_1 [i] ＝ add_1 [i] ＋ 到文本 (add_2 [1])
跳出循环 ()


a ＝ 汇编_取随机数 (1, int)
add_1 [i] ＝ add_1 [i] ＋ 到文本 (add_2 [a])
删除成员 (add_2, a, 1)

跳出循环 ()

计次循环尾 ()
调试输出 (add_1)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 add_1, 文本型, , "0"<br /> .局部变量 add_2, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 int, 整数型<br /> .局部变量 a, 整数型<br /> <br /> add_1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }<br /> add_2 ＝ { 100, 200, 300, 400, 500, 600 }<br /> .计次循环首 (取数组成员数 (add_1), i)<br />     int ＝ 取数组成员数 (add_2)<br />     .如果 (int ＞ 0)<br />         .如果 (int ＝ 1)<br />             add_1 <i> ＝ add_1 <i> ＋ 到文本 (add_2 [1])<br />             跳出循环 ()<br />         .否则<br /> <br />             a ＝ 汇编_取随机数 (1, int)<br />             add_1 <i> ＝ add_1 <i> ＋ 到文本 (add_2 [a])<br />             删除成员 (add_2, a, 1)<br />         .如果结束<br /> <br />     .否则<br />         跳出循环 ()<br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> 调试输出 (add_1)

补充内容 (2025-3-5 19:16):
有那么难么？

aipca

好像好多种不同方法，我是用这种方法的

  

子程序名	返回值类型	公开	备 注
_按钮1_被单击

变量名	类 型	静态	数组	备 注
数组2	文本型		0
数组1	文本型		0
i	整数型
s	整数型
文本	文本型		0
随机数	整数型

数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }
数组2 ＝ { “100”, “ 200”, “300”, “ 400”, “500”, “600” }
置随机数种子 ()
变量循环首 (取数组成员数 (数组1), 1, -1, i)
随机数 ＝ 取随机数 (1, 取数组成员数 (数组2))
加入成员 (文本, 数组1 [i])
加入成员 (文本, 数组2 [随机数])
删除成员 (数组2, 随机数, )
变量循环尾 ()
计次循环首 (取数组成员数 (数组2), s)
加入成员 (文本, 数组2 [s])
计次循环尾 ()
调试输出 (文本)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _按钮1_被单击<br /> .局部变量 数组2, 文本型, , "0"<br /> .局部变量 数组1, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 s, 整数型<br /> .局部变量 文本, 文本型, , "0"<br /> .局部变量 随机数, 整数型<br /> <br /> 数组1 ＝ { “刘先生”, “李女士”, “王先生”, “马小姐” }<br /> 数组2 ＝ { “100”, “ 200”, “300”, “ 400”, “500”, “600” }<br /> <br /> 置随机数种子 ()<br /> <br /> .变量循环首 (取数组成员数 (数组1), 1, -1, i)<br />     随机数 ＝ 取随机数 (1, 取数组成员数 (数组2))<br />     加入成员 (文本, 数组1 <i>)<br />     加入成员 (文本, 数组2 [随机数])<br />     删除成员 (数组2, 随机数, )<br /> .变量循环尾 ()<br /> <br /> .计次循环首 (取数组成员数 (数组2), s)<br />     加入成员 (文本, 数组2 <strike>)<br /> .计次循环尾 ()<br /> 调试输出 (文本)

BruceJoysky1987

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
姓名	文本型		0
数字	整数型		0
新数组	文本型		0
i	整数型

姓名 ＝ { “1刘先生”, “2李女士”, “3王先生”, “4马小姐”, “5字小姐”, “6无小姐”, “7真小姐” }
数字 ＝ { 100, 200, 300, 400, 500, 600 }  
数组乱序 (数字)
计次循环首 (取数组成员数 (姓名), i)
加入成员 (新数组, 姓名 [i] ＋ 到文本 (数字 [取随机数 (1, 取数组成员数 (数字))]))
' 加入成员 (新数组, 姓名 [i] ＋ #换行符 ＋ 到文本 (数字 [取随机数 (1, 取数组成员数 (数字))]))
计次循环尾 ()
调试输出 (新数组)

子程序名	返回值类型	公开	备 注
数组乱序
参数名	类 型	参考	可空	数组	备 注
参_数组	整数型

变量名	类 型	静态	数组	备 注
局_临时数字	整数型
局_计次	整数型
局_索引	整数型

置随机数种子 ()
计次循环首 (取数组成员数 (参_数组), 局_计次)
局_索引 ＝ 取随机数 (局_计次, 取数组成员数 (参_数组))
局_临时数字 ＝ 参_数组 [局_计次]
参_数组 [局_计次] ＝ 参_数组 [局_索引]
参_数组 [局_索引] ＝ 局_临时数字
计次循环尾 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 姓名, 文本型, , "0"<br /> .局部变量 数字, 整数型, , "0"<br /> .局部变量 新数组, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> <br /> 姓名 ＝ { “1刘先生”, “2李女士”, “3王先生”, “4马小姐”, “5字小姐”, “6无小姐”, “7真小姐” }<br /> 数字 ＝ { 100, 200, 300, 400, 500, 600 }  <br /> 数组乱序 (数字)<br /> .计次循环首 (取数组成员数 (姓名), i)<br />     加入成员 (新数组, 姓名 <i> ＋ 到文本 (数字 [取随机数 (1, 取数组成员数 (数字))]))<br />     ' 加入成员 (新数组, 姓名 <i> ＋ #换行符 ＋ 到文本 (数字 [取随机数 (1, 取数组成员数 (数字))]))<br /> .计次循环尾 ()<br /> 调试输出 (新数组)<br /> <br /> .子程序 数组乱序, , 公开<br /> .参数 参_数组, 整数型, 数组<br /> .局部变量 局_临时数字, 整数型<br /> .局部变量 局_计次, 整数型<br /> .局部变量 局_索引, 整数型<br /> <br /> 置随机数种子 ()<br /> <br /> .计次循环首 (取数组成员数 (参_数组), 局_计次)<br /> <br />     局_索引 ＝ 取随机数 (局_计次, 取数组成员数 (参_数组))<br /> <br />     局_临时数字 ＝ 参_数组 [局_计次]<br /> <br />     参_数组 [局_计次] ＝ 参_数组 [局_索引]<br /> <br />     参_数组 [局_索引] ＝ 局_临时数字<br /> <br /> .计次循环尾 ()

sunfly

不是有插入成员吗？

frankiy

既然是随机，那么   1对1 ， 2对2  ， 3对3 ， 也是随机的一种可能。那为什么不直接按序列对齐呢？ 非要去伪随机？