精易论坛
标题: 数组去重复，再比原来快一倍，数组排序用了归并算法 [打印本页]
作者: APPLEUFO 时间: 2025-6-22 22:31
标题: 数组去重复，再比原来快一倍，数组排序用了归并算法
本帖最后由 APPLEUFO 于 2025-6-23 09:50 编辑
https://125.confly.eu.org/forum.php?mod=viewthread&tid=14712534&extra=
前面那帖子，排序后去重复
原来是文本的快速排序后，再循环对比
现在弄出文本的归并排序后，再循环对比了
文本的归并排序比 快速排序，快了3-5倍吧，速度也就又提起来了
至于整数型的去重复，直接用桶排序，测试速度比精益现在内置的的更快了
|
| 数组模块_去重复桶排序_整数型 | | |
|
| 参数_原始数组 | 整数型 | | | |
参数_结果数组 | 整数型 | | | |
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| 局变_最大数 | 整数型 | | |
| 局变_桶子 | 整数型 | | 0 |
| n1 | 整数型 | | |
| m1 | 整数型 | | |
计次循环首 (取数组成员数 (参数_原始数组
), n1
) 
如果真 (局变_最大数 ＜ 参数_原始数组
[n1
])局变_最大数 ＝ 参数_原始数组
[n1
]
计次循环尾 () 重定义数组 (局变_桶子, 假, 局变_最大数
) 计次循环首 (取数组成员数 (参数_原始数组
), n1
) 局变_桶子
[参数_原始数组
[n1
]] ＝ 1
计次循环尾 ()重定义数组 (参数_结果数组, 假,
取数组成员数 (参数_原始数组
))
计次循环首 (取数组成员数 (局变_桶子
), n1
)如果 (局变_桶子
[n1
] ＝ 0
)
m1 ＝ m1 ＋ 1
参数_结果数组
[m1
] ＝ n1
计次循环尾 ()重定义数组 (参数_结果数组, 真, m1
)|
| 数组模块_验证是否有重复_整数 | 逻辑型 | |
|
| 参数_整数数组 | 整数型 | | | |
数组排序 (参数_整数数组,
真)计次循环首 (取数组成员数 (参数_整数数组
) － 1, n1
) 如果 (参数_整数数组
[n1
] ＝ 参数_整数数组
[n1 ＋ 1
])返回 (假) 计次循环尾 ()返回 (真)
-
-
10.8.e
306.99 KB, 下载次数: 64, 下载积分: 精币 -2 枚
作者: cf2006a 时间: 2025-6-22 22:57
不是有汇编版文本数组去重复的
作者: APPLEUFO 时间: 2025-6-22 23:29
有地址么？我看看快多少
作者: cf2006a 时间: 2025-6-22 23:37
https://share.weiyun.com/xyw1wBMg
作者: APPLEUFO 时间: 2025-6-22 23:53
本帖最后由 APPLEUFO 于 2025-6-22 23:59 编辑
https://125.confly.eu.org/forum.php?mod ... B%E9%87%8D%E5%A4%8D
我找到一个这个 ，只能用于整数类型的文本去重复？ 结果的答案还是错的~~、
到文本 (取随机数 (1, 1000)) 答案应该是数组成员在1000以下，差很小
不知道为啥答案等于923
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| g | 文本型 | | 100000 |
| t | 整数型 | | |
| i | 整数型 | | |
| 字符长度 | 整数型 | | |
| 找到位置 | 整数型 | | |
| 写入位置 | 整数型 | | |
| 结果 | 文本型 | | |
| 调试 | 文本型 | | |
| ss | 文本型 | | 0 |
计次循环首 (100000, i
)
g
[i
] ＝
到文本 (取随机数 (1, 1000
))
计次循环尾 ()t ＝
取启动时间 ()数组模块_去重复7_排序后对比 (g, ss
)调试输出 (取启动时间 () － t,
取数组成员数 (ss
))
调试输出 (数组模块_验证是否无重复数据 (ss
))
结束 ()
-
-
汇编去重复.e
66.26 KB, 下载次数: 0, 下载积分: 精币 -2 枚
-
-
夏夜自由模块10.1.rar
51.63 KB, 下载次数: 1, 下载积分: 精币 -2 枚
作者: APPLEUFO 时间: 2025-6-22 23:55
下载到了 倒是没看到 去重复的代码
-
11111111111111111111.png
(25.12 KB, 下载次数: 0)
作者: APPLEUFO 时间: 2025-6-23 00:10
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| g | 文本型 | | 100000 |
| t | 整数型 | | |
| i | 整数型 | | |
| 字符长度 | 整数型 | | |
| 找到位置 | 整数型 | | |
| 写入位置 | 整数型 | | |
| 结果 | 文本型 | | |
| 调试 | 文本型 | | |
| ss | 文本型 | | 0 |
| 新数组长度 | 整数型 | | |
| 新数组 | 文本型 | | 0 |
计次循环首 (100000, i
)
g
[i
] ＝
到文本 (取随机数 (1, 1000
))
计次循环尾 ()t ＝
取启动时间 () . .
数组模块_去重复7_排序后对比 (g, 新数组
)调试输出 (数组模块_验证是否无重复数据 (新数组
))
调试输出 (取启动时间 () － t,
取数组成员数 (新数组
),
)
https://125.confly.eu.org/forum.php?mod ... B%E9%87%8D%E5%A4%8D
https://125.confly.eu.org/forum.php?mod ... E5%A4%8D&page=1
你18年两个帖子 结果是错的 数组成员数应该是1000 不知道你的为啥总是923 924
我前面发了个 前面帖子附件太多审核去了
作者: 黑咖啡 时间: 2025-6-23 00:15
有这么慢吗？
-
QQ20250623-001417.png
(167.7 KB, 下载次数: 0)
作者: APPLEUFO 时间: 2025-6-23 00:25
本帖最后由 APPLEUFO 于 2025-6-23 00:38 编辑
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| 节点 | 节点 | | |
| count | 整数型 | | |
变量循环首 (1,
取数组成员数 (文本数组
), 1, count
)
节点.
加入属性 (文本数组
[count
],
“”)
变量循环尾 ()节点.
取全部属性名 (文本数组
)
模块里也 内置了一个节点法 ，数据大的时候，排序后去重7 速度 是 节点法的五倍的。 大数据才能体现出差别
.版本 2
.支持库 spec
调试模块_创建整数型数组_有重复 (zzz, 100000, 1, 100) ' 1000000
转换模块_整数型数组转文本型数组 (zzz, aaa)
计时器启动 ()
数组模块_去重复7_排序后对比 (aaa, aaa_结果)
' 数组模块_去重复4_节点法 (aaa)
计时器结束 ()
调试输出 (“===============”)
=====================================
我知道慢在哪了 上面 内置的04，输入和输出，用的都是同一个数组。时间都消耗在把原始大数组清空，换成结果小数组了
你代码用的是两个不同的数组。这就快了，整挺好 学习了
计次循环首 (取数组成员数 (aaa
), m
)
jd.
加入属性 (aaa
[m
], 0
)
计次循环尾 ()jd.
取全部属性名 (bbb
)
作者: APPLEUFO 时间: 2025-6-23 01:00
本帖最后由 APPLEUFO 于 2025-6-23 01:06 编辑
调试模块_创建文本型数组 (aaa, 10000 × 5
) 计时器启动 ()数组模块_去重复7_排序后对比 (aaa, aaa_结果
) 计时器结束 ()调试输出 (“===============”) 调试输出 (取数组成员数 (aaa_结果
))
鸣叫 ()鸣叫 ()结束 ()
这里创建了一个大量不重复的数据。
节点法的时间 都花在 加入属性 这上面了。如果数据是大量不重复的。就会消耗非常多在循环加入上
而排序去重 的时间消耗，还是很稳定的
|
| 数组模块_去重复4_节点法 | | |
|
| 参数_原始数组 | 文本型 | | | |
参数_结果数组 | 文本型 | | | |
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| 局变_节点 | 节点 | | |
| m1 | 整数型 | | |
计时器启动 ()
计次循环首 (取数组成员数 (参数_原始数组
), m1
)
局变_节点.
加入属性 (参数_原始数组
[m1
],
“”)
计次循环尾 ()计时器结束 ()计时器启动 ()局变_节点.
取全部属性名 (参数_结果数组
)计时器结束 ()
作者: APPLEUFO 时间: 2025-6-23 01:04
不是变量循环的问题 ，时间消耗在 清空10000的数组，然后重定义成100的数组上面了
作者: malin158 时间: 2025-6-23 01:32
感谢分享，很给力！~
作者: 你不丑 时间: 2025-6-23 01:45
精易模块不是有汇编版本的吗 你还要写一个有啥意义呢 你比他那个还快吗
作者: 黑咖啡 时间: 2025-6-23 03:49
那就多线程一起干，哪个快输出哪个
也可以用”表“试试
作者: ale99 时间: 2025-6-23 04:02
感谢分享！学习一下~
作者: 非善类 时间: 2025-6-23 06:45
不错下载看看
作者: 豆豆灰常开心 时间: 2025-6-23 07:16
感谢分享，很给力！~
作者: 查过 时间: 2025-6-23 07:21
已经顶贴，感谢您对论坛的支持！
作者: 杨明煜 时间: 2025-6-23 07:38
学习进步！......
作者: 佛学e语言 时间: 2025-6-23 08:07
谢谢分享
作者: 李泽勇2 时间: 2025-6-23 08:29
楼主模块功能挺多。
作者: youxigw 时间: 2025-6-23 08:35
感谢分享，很给力！~
作者: 1184798949 时间: 2025-6-23 08:45
感谢分享
作者: 不苦小和尚 时间: 2025-6-23 08:46
试试看看效果不错
作者: cf2006a 时间: 2025-6-23 08:51
数组去重_ASM，1000万数据，毫秒级去重复，支持通用型数组
https://125.confly.eu.org/forum.php?mod=viewthread&tid=14841955
(出处: 精易论坛)
作者: APPLEUFO 时间: 2025-6-23 09:02
本帖最后由 APPLEUFO 于 2025-6-23 09:24 编辑
那个只能整数型去重复，对于文本型的就不行了（混合字母的也不行） 顺便问一下精益模块里的哪一条命令，精益模块11里，我 就找到了不是汇编版本的，汇编版本的没看到
用桶排序去重复，测试了速度不输精易模块的， 只能排序大于0的正整数
|
| 数组模块_去重复桶排序_整数型 | | |
|
| 参数_原始数组 | 整数型 | | | |
参数_结果数组 | 整数型 | | | |
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| 局变_最大数 | 整数型 | | |
| 局变_桶子 | 整数型 | | 0 |
| n1 | 整数型 | | |
| m1 | 整数型 | | |
计次循环首 (取数组成员数 (参数_原始数组
), n1
) 如果真 (局变_最大数 ＜ 参数_原始数组
[n1
])局变_最大数 ＝ 参数_原始数组
[n1
]计次循环尾 () 重定义数组 (局变_桶子, 假, 局变_最大数
) 计次循环首 (取数组成员数 (参数_原始数组
), n1
) 局变_桶子
[参数_原始数组
[n1
]] ＝ 1
计次循环尾 ()重定义数组 (参数_结果数组, 假,
取数组成员数 (参数_原始数组
))
计次循环首 (取数组成员数 (局变_桶子
), n1
)如果 (局变_桶子
[n1
] ＝ 0
)m1 ＝ m1 ＋ 1
参数_结果数组
[m1
] ＝ n1
计次循环尾 ()重定义数组 (参数_结果数组, 真, m1
)|
| 数组模块_验证是否有重复_整数 | 逻辑型 | |
|
| 参数_整数数组 | 整数型 | | | |
数组排序 (参数_整数数组,
真)计次循环首 (取数组成员数 (参数_整数数组
) － 1, n1
) 如果 (参数_整数数组
[n1
] ＝ 参数_整数数组
[n1 ＋ 1
])返回 (假) 计次循环尾 ()返回 (真)
.版本 2
' 计时器启动 ()
' 数组_去重复_整数型 (aaa)
' 计时器结束 ()
计时器启动 ()
数组_去重复_整数型1 (bbb)
计时器结束 ()
计时器启动 ()
数组模块_去重复桶排序_整数型 (ddd, ddd_结果)
计时器结束 ()
* Windows 11
* “8 秒 734 毫秒 ”
* “453 毫秒 ”
* “218 毫秒 ” ----------------------------------这个
* 真 | 32768
* 真 | 32768
* 真 | 32768
-
-
测试和精益模块对比的.e
1019.84 KB, 下载次数: 2, 下载积分: 精币 -2 枚
作者: 一指温柔 时间: 2025-6-23 09:11
感谢分享，很给力！~
作者: APPLEUFO 时间: 2025-6-23 09:19
本帖最后由 APPLEUFO 于 2025-6-23 09:45 编辑
.版本 2
计时器启动 ()
数组去重 (ccc, #整数型)
计时器结束 ()
这个代码试了一下 没跑通 得不到正确结果啊 ，咋回事
结果素组成员 还是 原始的那么多
=================
.版本 2
计时器启动 ()
ls ＝ 数组去重 (ccc, #整数型)
重定义数组 (ccc, 真, ls)
' 调试输出 (ls)
计时器结束 ()
后面行了要这样
我这里测试 桶排序比汇编还是快的。
除非他用汇编版本桶排序，才会更快
-
-
测试和精益模块对比的 汇编没跑通 .e
1 MB, 下载次数: 2, 下载积分: 精币 -2 枚
作者: 杰西卡技术传媒 时间: 2025-6-23 09:20
感谢分享，很给力！~
作者: 我的yyy123 时间: 2025-6-23 09:25
学习学习
作者: cf2006a 时间: 2025-6-23 11:06
重定义 不是浪费时间 他 ls是不重复的数量重复的都放后面去了也就是ls 后面都是重复的数据
作者: APPLEUFO 时间: 2025-6-23 12:09
后面跑通了，这样才看到
重定义数组 (ccc, 真, ls)
' 调试输出 (ls)
计时器结束 ()
作者: 外星星人 时间: 2025-6-23 12:58
感谢分享 支持
作者: cf2006a 时间: 2025-6-23 13:11
没懂 数组去重 (ccc, #文本型) 你不是去文本数组吗 整数没意义 他排序是在原数组里完成
作者: cf2006a 时间: 2025-6-23 13:15
不用啊 置数组成员数 （ccc,ls）就可以了 你要是调用计次循环 .版本 2
.局部变量 ls, 整数型
.局部变量 i, 整数型
.计次循环首 (ls, i)
调试输出 (ccc)
.计次循环尾 ()
这样都是不重复的 没有必要 把后面的去掉 调用不影响
作者: APPLEUFO 时间: 2025-6-23 13:27
你说的没错 ， 就是重定义数组以后， 看的更加清爽一些
符合 输出= 计算（输入 ）的样式
作者: kyo9766 时间: 2025-6-23 14:38
学习一下原理，感谢分享
作者: ttggnn 时间: 2025-6-23 21:27
感谢分享
作者: 1347379245 时间: 2025-6-23 23:34
感谢分享
作者: static101 时间: 2025-6-24 00:18
本帖最后由 static101 于 2025-6-24 00:25 编辑
取数组成员数 () 这些多次调用，写成变量能更快一点点，而且你的文本数组排序 循环嵌套多次都不考虑取长度写成变量，速度当然会慢
作者: 笨来无一悟 时间: 2025-6-24 04:01
整数 要看范围 小范围 比如最大值不超一千万的 用位图最快
作者: 豆豆灰常开心 时间: 2025-6-24 07:11
感谢发布原创作品，精易因你更精彩！6666666666666
作者: 查过 时间: 2025-6-24 07:15
感谢分享，很给力！~
作者: year1970 时间: 2025-6-24 07:53
感谢分享，学习一下
作者: APPLEUFO 时间: 2025-6-24 08:40
所言极是 疏忽大意了，增加一个变量免得重复取
作者: 一指温柔 时间: 2025-6-24 08:51
感谢分享
作者: qqmqqg 时间: 2025-6-24 09:40
666666666666666666
作者: aosheng 时间: 2025-6-24 09:42
6666666666666666666
作者: APPLEUFO 时间: 2025-6-24 11:19
本帖最后由 APPLEUFO 于 2025-6-24 15:45 编辑
有道理 我看视频他说用二进制代替整数型int。节约内存
’-------------------------------
。也就是说原来一个整数型的4字节，最大是 21亿
整数型 可容纳 -2,147,483,648 到 2,147,483,647 之间的数值，尺寸为 4 个字节
2147483647 的二进制表示为 01111111111111111111111111111111 。在32位操作系统中，由于计算机是由二进制组成的，其一个元素所能最大存储的数据是 01111111111111111111111111111111（符号位+31个1）。
一个 整数位能代替 31个原来的整数型数组 。69,273,666.03225806 大约6千万个数组成员 就能代替一个从1-20亿的数组了
==============
后面看了不行 不是上面这样搞 8字节的长整数，才是上视频提到的long 类型。代表64个二进制
4. 长整数型。可容纳 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 之间的数值，尺寸为 8 个字节。
计算机存储原理： 1. 计算机使用二进制来存储数据，每个二进制位表示0或1。 2. 一个字节由8个二进制位组成，int数据类型作为有符号整数，占用4个字节，即32个二进制位。 2. 编程语言规范： 1. 在Java语言中，int数据类型明确规定为32位的有符号整数，表示范围是2^31~2^311。 2. 在C语言中，int数据类型的大小取决于编译器的实现，但通常是32位或者16位。
作者: 胖子葛格 时间: 2025-6-24 11:26
感谢大神分享~！
作者: 你不丑 时间: 2025-6-24 15:17
哦哦 那可能不是精易模块的吧 我记错了 不好意思
作者: 独孤求胜 时间: 2025-6-24 15:19
纯易代码，不嵌入汇编还是太慢
作者: 18074941457 时间: 2025-6-24 15:26
感谢分享，很给力！~
作者: wjswzj0 时间: 2025-6-24 19:26
感谢分享，很给力！~
作者: 该死dē蚊子 时间: 2025-6-24 20:00
这个好，要的就是一个字：快
作者: 豆豆灰常开心 时间: 2025-6-25 07:20
全都是大佬~
作者: 查过 时间: 2025-6-25 07:25
感谢楼主分享！
作者: APPLEUFO 时间: 2025-6-25 08:23
一楼整数去重，桶排序的那个代码，我测试已经比精益模块的代码更快了，你可以试试看 按自己需要测试下速度怎么样
作者: APPLEUFO 时间: 2025-6-25 08:49
我昨天试了一下
还没写出来。就遇到几个问题
怀疑就算写出来了未必比桶排序快。省内存是没问题的
问题是现在的电脑不缺内存，宝贵的是时间
我能想到这个位图算法费时间的点就是：他没办法以二进制存在数组长整数或字节里。所以是字节型数存储的.还是一个整数
那么我修改未排序的 320 5 888 20 70，这几个位图地址的时候，那么 例如 5 和 20
就得先读取第一格 1-64格的数组值。 然后修改第5格的二进制，然后保存
到了20 的时候，还得再读取第一个整数值，找到20格修改，再保存
就算5和20是相邻的。也没办法读取一次 修改一次，保存一次
1读取整数，2转换二进制，3修改二进制，4转换成十进制
每修改一格的0和1，就得来上面4步，这样一次
肯定得耗费大量时间
作者: 一指温柔 时间: 2025-6-25 08:54
感谢分享
作者: tonc 时间: 2025-6-25 10:01
大神，请收下我的膝盖，膜拜你，真的很厉害！
作者: 艾玛克138 时间: 2025-6-25 21:59
谢谢大佬，很好很实用的教程。
作者: lxn2wyf 时间: 2025-6-26 02:16
感谢分享，很给力！继续努力哦~
作者: lassgo 时间: 2025-6-26 05:48
在此留名，以后多多交流，期待与你互动！
作者: 豆豆灰常开心 时间: 2025-6-26 07:15
感谢您对论坛的支持！
作者: 查过 时间: 2025-6-26 07:20
全都是大佬~
作者: 小虎来了 时间: 2025-6-26 09:11
感谢分享，很给力！~
作者: 黑咖啡 时间: 2025-6-26 10:49
再给你发个
-
-
10.8.e
1.23 MB, 下载次数: 9, 下载积分: 精币 -2 枚
作者: please 时间: 2025-6-27 09:37
感谢分享，支持开源！！！
作者: APPLEUFO 时间: 2025-6-27 10:01
本帖最后由 APPLEUFO 于 2025-6-27 10:36 编辑
.版本 2
' * “7 秒 484 毫秒 ”
' * “子程序1===============” | 500000
' * “36 秒 234 毫秒 ”
' * “去重复7===============” | 500000
36秒太长，我有点怀疑 两次测试的顺序颠倒一下就这样了
你的测试不标准，数据污染或者数组未清空。导致后面第二组的测试时间很长
第二轮测试还是得拷贝个一模一样的新变量来测试
拷贝1个BBB的数组就好 ，全新变量，未被排序污染的原始数组数据
你写的算法 速度还是很快的，能比07方法快了一倍！
是啥原理说说看 去重的类 ， 是类似哈希值的算法么
上面测试是数组里大量不重复类型的。
下面图测试的是数组里 大量重复类型的。的确是很快啊。比我那个快了10倍 。服了
调试输出 (“======================================================”)调试模块_创建整数型数组_有重复 (zzz, 100000 × 10, 1, 1000
) 转换模块_整数型数组转文本型数组 (zzz, aaa
)bbb ＝ aaa
调试输出 (“开始 ---------- ”)计时器启动 ()数组模块_去重复7_排序后对比 (aaa, aaa_结果
)计时器结束 ()调试输出 (“===============”,
取数组成员数 (aaa_结果
))
计时器启动 ()子程序1 (bbb, bbb_结果
)计时器结束 ()调试输出 (“===============”,
取数组成员数 (bbb_结果
))
调试输出 (“======================================================”)鸣叫 ()鸣叫 ()结束 ()
另外的问题就是 为啥是65536？
备注里写 待完善，缺少清空。创建和销毁很慢因为数组65536太大
你是一下创建65536个类，如果要计算的数据太大，甚至65536个数组都不够用，计算出的校验值里出现冲突。 ，那么就会出现重复了吧？
下面这个是 ？
| 变量名 | 类 型 | 静态 | 数组 | 备 注 |
| 局_输入字节集 | 字节集 | | |
| CRC寄存器 | 整数型 | | |
| m | 整数型 | | |
局_输入字节集 ＝
到字节集 (输入值
)CRC寄存器 ＝ 65535
计次循环首 (取字节集长度 (局_输入字节集
), m
)CRC寄存器 ＝
位异或 (CRC寄存器, 局_输入字节集
[m
])计次循环首 (8,
)
判断 (位与 (CRC寄存器, 1
) ＝ 0
)
CRC寄存器 ＝
右移 (CRC寄存器, 1
)
CRC寄存器 ＝
右移 (CRC寄存器, 1
)
CRC寄存器 ＝
位异或 (CRC寄存器,
十六进制 (“A001”))
计次循环尾 ()计次循环尾 ()判断 (0 ＜ CRC寄存器
且 CRC寄存器 ＜ 65536
)返回 (CRC寄存器
)返回 (65536
)
作者: pipicool 时间: 2025-6-27 10:11
学习一下
作者: 黑咖啡 时间: 2025-6-27 10:48
那个校验类似生成哈希值，但是只会输出0-65535，易语言下标从1开始，所以0替换成65536。
如果校验的值一样，那他们就在同一个类里进行比较，用的循环比较，当然也可以用其他更快的方法。
你也可以另外研究其他校验换算方法，只要能把文本型尽量的换算成相对均匀的整数分配到桶里也行的。比如除法缩放法，越简洁效率越高。
相当于提前预制足够多的桶，这样就能更少的比较，类似二分法吧，先粗略的分类一次，第二次数据量少了在精准比较。
当然了能根据成员数量，成员长度等，动态分配桶数量那就更高效了，前提是生成的哈希值要足够均匀把桶利用起来，不然大量都分在一个桶里也是慢的。
作者: APPLEUFO 时间: 2025-6-27 11:50
哦 原来如此 。我觉得你那个65535的类数组 和校验函数 也可以考虑一下 封装进去重复类里面。更简洁完美一些。在类外面就不用暴露设定太多
作者: 今时以至遂渐开 时间: 2025-6-28 01:18
感谢分享，很给力！~
作者: 股老传奇 时间: 2025-7-2 21:40
非常不错！！！
| 欢迎光临 精易论坛 (https://125.confly.eu.org/) |
Powered by Discuz! X3.4 |
如果真 (取数组成员数 (参数_文本) ＜ 2) 参数_重复数组 ＝ 参数_文本
' 相等 无动作
