如何剔除相同文本

山猫啊

圆圈 发表于 2025-8-16 10:52
[e=0].版本 2
.支持库 spec

你这个替换完  中间应该是会出现两个空格在一块

APPLEUFO

  

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

变量名	类 型	静态	数组	备 注
text1	文本型
text2	文本型
text1arr	文本型		0
xxxxxxxx	文本型		0

text1 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”
text2 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”
text1 ＝ text1 ＋ “ ” ＋ text2
text1arr ＝ 分割文本 (text1, “ ”, )
数组模块_去重复_删除重复的数据 (text1arr, xxxxxxxx)
调试输出 (xxxxxxxx)
结束 ()

子程序名	返回值类型	公开	备 注
数组模块_去重复_删除重复的数据			去掉重复的数据  ，流下不重复的//重复全部删除，流下不重复的 （1122334）（4）
参数名	类 型	参考	可空	数组	备 注
参数_文本们	文本型
参数_重复数组	文本型

变量名	类 型	静态	数组	备 注
局变_标记	整数型		0
n1	整数型
局变_对比a	文本型
m1	整数型

清除数组 (参数_重复数组)
重定义数组 (局变_标记, 假, 取数组成员数 (参数_文本们))
计次循环首 (取数组成员数 (参数_文本们) － 1, n1)
局变_对比a ＝ 参数_文本们 [n1]
变量循环首 (n1 ＋ 1, 取数组成员数 (参数_文本们), 1, m1)
如果 (局变_对比a ＝ 参数_文本们 [m1])
连续赋值 (1, 局变_标记 [n1], 局变_标记 [m1])


' 无动作

变量循环尾 ()
计次循环尾 ()
' 调试输出 (局变_标记)
计次循环首 (取数组成员数 (局变_标记), n1)
如果 (局变_标记 [n1] ＝ 0)  ' 未被标记的
加入成员 (参数_重复数组, 参数_文本们 [n1])



计次循环尾 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 text1, 文本型<br /> .局部变量 text2, 文本型<br /> .局部变量 text1arr, 文本型, , "0"<br /> .局部变量 xxxxxxxx, 文本型, , "0"<br /> <br /> text1 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”<br /> text2 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”<br /> text1 ＝ text1 ＋ “ ” ＋ text2<br /> <br /> text1arr ＝ 分割文本 (text1, “ ”, )<br /> 数组模块_去重复_删除重复的数据 (text1arr, xxxxxxxx)<br /> 调试输出 (xxxxxxxx)<br /> <br /> <br /> 结束 ()<br /> <br /> .版本 2<br /> <br /> .子程序 数组模块_去重复_删除重复的数据, , 公开, 去掉重复的数据  ，流下不重复的//重复全部删除，流下不重复的 （1122334）（4）<br /> .参数 参数_文本们, 文本型, 数组<br /> .参数 参数_重复数组, 文本型, 数组<br /> .局部变量 局变_标记, 整数型, , "0"<br /> .局部变量 n1, 整数型<br /> .局部变量 局变_对比a, 文本型<br /> .局部变量 m1, 整数型<br /> <br /> 清除数组 (参数_重复数组)<br /> <br /> 重定义数组 (局变_标记, 假, 取数组成员数 (参数_文本们))<br /> <br /> .计次循环首 (取数组成员数 (参数_文本们) － 1, n1)<br /> <br />     局变_对比a ＝ 参数_文本们 [n1]<br /> <br />     .变量循环首 (n1 ＋ 1, 取数组成员数 (参数_文本们), 1, m1)<br /> <br />         .如果 (局变_对比a ＝ 参数_文本们 [m1])<br /> <br />             连续赋值 (1, 局变_标记 [n1], 局变_标记 [m1])<br />         .否则<br /> <br />             ' 无动作<br />         .如果结束<br /> <br />     .变量循环尾 ()<br /> .计次循环尾 ()<br /> <br /> ' 调试输出 (局变_标记)<br /> <br /> <br /> .计次循环首 (取数组成员数 (局变_标记), n1)<br />     .如果 (局变_标记 [n1] ＝ 0)  ' 未被标记的<br />         加入成员 (参数_重复数组, 参数_文本们 [n1])<br />     .否则<br /> <br />     .如果结束<br /> <br /> .计次循环尾 ()

* 数组:14{“0059”,“0580”,“0004”,“7162”,“0803”,“6010”,“0673”,“1208”,“6019”,“5183”,“6037”,“6092”,“0724”,“3380”}
被调试易程序运行完毕


数组模块_去重复_删除重复的数据  这个还是未优化的，要再快点的  就是排序后对比了
https://bbs.ijingyi.com/forum.ph ... 14712534&extra=



下面这个会删除多余重复，保留下一个重复

  

子程序名	返回值类型	公开	备 注
数组模块_去重复7_排序后对比			排序过的   （1122334）（1234），也是非常快的，不输给去重复6。
参数名	类 型	参考	可空	数组	备 注
参数_文本	文本型
参数_重复数组	文本型

变量名	类 型	静态	数组	备 注
局变_原始文本开始的下标	整数型			跳转到下回开始对比的下标
n1	整数型			循环用
m1	整数型			重复数组的下标
局变_数组个数	整数型

' 局变_数组个数 ＝ 取数组成员数 (参数_文本)
如果真 (取数组成员数 (参数_文本) ＜ 2)
参数_重复数组 ＝ 参数_文本
返回 ()

' 数组模块_快速排序_文本 (参数_文本, 真)
排序模块_归并排序_迭代版_文本 (参数_文本, 真)
重定义数组 (参数_重复数组, 假, 取数组成员数 (参数_文本))
局变_原始文本开始的下标 ＝ 1
循环判断首 ()
变量循环首 (局变_原始文本开始的下标, 取数组成员数 (参数_文本) － 1, 1, n1)  ' 假定他现在前面几个都是重复的，开局就用变量循环
如果 (参数_文本 [n1] ＝ 参数_文本 [n1 ＋ 1])
' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “===”)
' 相等  无动作


' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “=!==!”)
m1 ＝ m1 ＋ 1
参数_重复数组 [m1] ＝ 参数_文本 [n1]  ' 不相等的上一个加入去重复
局变_原始文本开始的下标 ＝ n1 ＋ 1  ' 不相等的下一个 跳转进去。把变量循环的开始值设置成它
' 调试输出 (m1, 局变_原始文本开始的下标, 参数_文本 [n1], “-------------------”)
跳出循环 ()

变量循环尾 ()
' 调试输出 (n1, “=============================”)
如果真 (n1 ＝ 取数组成员数 (参数_文本))  ' 下标等于最后一个，它没办法和下一个比较了。就添加到去重复数组了
' 调试输出 (n1, 局变_原始文本开始的下标, , , 666)
m1 ＝ m1 ＋ 1
参数_重复数组 [m1] ＝ 参数_文本 [局变_原始文本开始的下标]  ' 局变_原始文本开始的下标  最后两种情况，相邻的两个相等或者不相等
跳出循环 ()

循环判断尾 (真)
重定义数组 (参数_重复数组, 真, m1)
' 不明白的是明明比6更紧凑，用的变量也少。还是不能大幅跑赢6///2025.6.19

.版本 2<br /> <br /> .子程序 数组模块_去重复7_排序后对比, , 公开, 排序过的   （1122334）（1234），也是非常快的，不输给去重复6。<br /> .参数 参数_文本, 文本型, 数组<br /> .参数 参数_重复数组, 文本型, 数组<br /> .局部变量 局变_原始文本开始的下标, 整数型, , , 跳转到下回开始对比的下标<br /> .局部变量 n1, 整数型, , , 循环用<br /> .局部变量 m1, 整数型, , , 重复数组的下标<br /> .局部变量 局变_数组个数, 整数型<br /> <br /> ' 局变_数组个数 ＝ 取数组成员数 (参数_文本)<br /> .如果真 (取数组成员数 (参数_文本) ＜ 2)<br />     参数_重复数组 ＝ 参数_文本<br />     返回 ()<br /> .如果真结束<br /> <br /> ' 数组模块_快速排序_文本 (参数_文本, 真)<br /> 排序模块_归并排序_迭代版_文本 (参数_文本, 真)<br /> <br /> 重定义数组 (参数_重复数组, 假, 取数组成员数 (参数_文本))<br /> <br /> 局变_原始文本开始的下标 ＝ 1<br /> .循环判断首 ()<br /> <br />     .变量循环首 (局变_原始文本开始的下标, 取数组成员数 (参数_文本) － 1, 1, n1)  ' 假定他现在前面几个都是重复的，开局就用变量循环<br /> <br />         .如果 (参数_文本 [n1] ＝ 参数_文本 [n1 ＋ 1])<br />             ' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “===”)<br />             ' 相等  无动作<br />         .否则<br /> <br />             ' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “=!==!”)<br />             m1 ＝ m1 ＋ 1<br />             参数_重复数组 [m1] ＝ 参数_文本 [n1]  ' 不相等的上一个加入去重复<br /> <br />             局变_原始文本开始的下标 ＝ n1 ＋ 1  ' 不相等的下一个 跳转进去。把变量循环的开始值设置成它<br />             ' 调试输出 (m1, 局变_原始文本开始的下标, 参数_文本 [n1], “-------------------”)<br />             跳出循环 ()<br />         .如果结束<br /> <br />     .变量循环尾 ()<br />     ' 调试输出 (n1, “=============================”)<br /> <br />     .如果真 (n1 ＝ 取数组成员数 (参数_文本))  ' 下标等于最后一个，它没办法和下一个比较了。就添加到去重复数组了<br />         ' 调试输出 (n1, 局变_原始文本开始的下标, , , 666)<br />         m1 ＝ m1 ＋ 1<br />         参数_重复数组 [m1] ＝ 参数_文本 [局变_原始文本开始的下标]  ' 局变_原始文本开始的下标  最后两种情况，相邻的两个相等或者不相等<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .循环判断尾 (真)<br /> 重定义数组 (参数_重复数组, 真, m1)<br /> ' 不明白的是明明比6更紧凑，用的变量也少。还是不能大幅跑赢6///2025.6.19

彼岸光年

山猫啊 发表于 2025-8-16 11:00
[e=2].版本 2
.支持库 spec

大神有没有更好的办法
我怕数据量一大，运行会比较慢

山猫啊

如果不在乎结果文本在一个里面可以用下面这种

  

变量名	类 型	静态	数组	备 注
文本1	文本型
文本2	文本型
分割1	文本型		0

文本1 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”
文本2 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”
分割1 ＝ 分割文本 (文本1 ＋ “ ” ＋ 文本2, “ ”, )
数组_去重复 (分割1, )
调试输出 (数组_合并 (分割1, “ ”))

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

.版本 2<br /> .支持库 spec<br /> <br /> .局部变量 文本1, 文本型<br /> .局部变量 文本2, 文本型<br /> .局部变量 分割1, 文本型, , "0"<br /> <br /> 文本1 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”<br /> 文本2 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”<br /> 分割1 ＝ 分割文本 (文本1 ＋ “ ” ＋ 文本2, “ ”, )<br /> 数组_去重复 (分割1, )<br /> 调试输出 (数组_合并 (分割1, “ ”))

补充内容 (2025-8-16 13:59):
这个有问题   重复的会去除一个丢下一个   这个不能用

黑咖啡

  

变量名	类 型	静态	数组	备 注
表	表
jd	节点
文本一	文本型
文本二	文本型
源文本	字节集		0
i	整数型
结果	文本型

文本一 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”
文本二 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”
源文本 ＝ 分割字节集 (到字节集 (删首尾空 (文本一) ＋ “ ” ＋ 删首尾空 (文本二)), 到字节集 (“ ”), )
计次循环首 (取数组成员数 (源文本), i)
表.加入键值对 (源文本 [i], jd)
计次循环尾 ()
重定义数组 (源文本, 假, 0)
源文本 ＝ 表.取所有键 ()
计次循环首 (取数组成员数 (源文本), i)
结果 ＝ 结果 ＋ 到文本 (源文本 [i]) ＋ “ ”
计次循环尾 ()
调试输出 (删首尾空 (结果))

i支持库列表	支持库注释
EDataStructure	数据结构支持库
spec	特殊功能支持库

.版本 2<br /> .支持库 EDataStructure<br /> .支持库 spec<br /> <br /> .局部变量 表, 表<br /> .局部变量 jd, 节点<br /> .局部变量 文本一, 文本型<br /> .局部变量 文本二, 文本型<br /> .局部变量 源文本, 字节集, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 结果, 文本型<br /> <br /> 文本一 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”<br /> 文本二 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”<br /> 源文本 ＝ 分割字节集 (到字节集 (删首尾空 (文本一) ＋ “ ” ＋ 删首尾空 (文本二)), 到字节集 (“ ”), )<br /> .计次循环首 (取数组成员数 (源文本), i)<br />     表.加入键值对 (源文本 <i>, jd)<br /> .计次循环尾 ()<br /> 重定义数组 (源文本, 假, 0)<br /> 源文本 ＝ 表.取所有键 ()<br /> .计次循环首 (取数组成员数 (源文本), i)<br />     结果 ＝ 结果 ＋ 到文本 (源文本 <i>) ＋ “ ”<br /> .计次循环尾 ()<br /> 调试输出 (删首尾空 (结果))

企鹅号525150138

  

变量名	类 型	静态	数组	备 注
文本一	文本型
文本二	文本型
文本三	文本型
z	正则表达式类

文本一 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”
文本二 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”
z.创建 (子文本替换 (文本一, “ ”, “\s?|”, , , 真) ＋ “\s?”, 文本二)
文本三 ＝ z.替换 ()
z.创建 (子文本替换 (文本二, “ ”, “\s?|”, , , 真) ＋ “\s?”, 文本一)
调试输出 (z.替换 () ＋ 文本三)

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

.版本 2<br /> .支持库 spec<br /> <br /> .局部变量 文本一, 文本型<br /> .局部变量 文本二, 文本型<br /> .局部变量 文本三, 文本型<br /> .局部变量 z, 正则表达式类<br /> <br /> 文本一 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”<br /> 文本二 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”<br /> z.创建 (子文本替换 (文本一, “ ”, “\s?|”, , , 真) ＋ “\s?”, 文本二)<br /> 文本三 ＝ z.替换 ()<br /> z.创建 (子文本替换 (文本二, “ ”, “\s?|”, , , 真) ＋ “\s?”, 文本一)<br /> 调试输出 (z.替换 () ＋ 文本三)

zainex

易语言文本操作并不快, 但是如果你给换成字节集操作:

  

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

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

变量名	类 型	静态	数组	备 注
文本1	文本型
文本2	文本型
数组	整数型		10000
数据	字节集
数	整数型
值	整数型
量	整数型
结果	文本型
次数	整数型
下标	整数型
起点	整数型
时间	整数型

' 调试输出 (取代码 (“0”, ), 取代码 (“9”, ), 取代码 (“ ”, ))
计次循环首 (10000, 数)  ' 生成所有组合
文本1 ＝ 文本1 ＋ 取文本右边 (“0000” ＋ 到文本 (数 － 1), 4) ＋ “ ”
计次循环尾 ()
' 文本1 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”
文本2 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”
时间 ＝ 取启动时间 ()
计次循环首 (2, 次数)
数据 ＝ 到字节集 (选择 (次数 ＝ 1, 文本1, 文本2)) ＋ { 0 }
量 ＝ 0
计次循环首 (取字节集长度 (数据), 数)
值 ＝ 数据 [数]
如果 (值 ≥ 48 且 值 ≤ 57)
量 ＝ 量 × 10 ＋ 值 － 48
值 ＝ 量 ＋ 1
数组 [值] ＝ 数组 [值] ＋ 1
量 ＝ 0

计次循环尾 ()
计次循环尾 ()
数据 ＝ 取空白字节集 (5 × 10000 ＋ 1)
起点 ＝ 1
计次循环首 (10000, 数)
如果真 (数组 [数] ＝ 1)
值 ＝ 数 － 1
下标 ＝ 3
循环判断首 ()
数据 [起点 ＋ 下标] ＝ 值 ％ 10 ＋ 48
下标 ＝ 下标 － 1
值 ＝ 值 ÷ 10
循环判断尾 (值 ≠ 0)
判断循环首 (下标 ≥ 0)
数据 [起点 ＋ 下标] ＝ 48
下标 ＝ 下标 － 1
判断循环尾 ()
数据 [起点 ＋ 4] ＝ 32
起点 ＝ 起点 ＋ 5

计次循环尾 ()
结果 ＝ 到文本 (数据)
调试输出 (格式化文本 (“出现一次的数量: %.0f, 耗时: %d 毫秒”, 取文本长度 (结果) ÷ 5, 取启动时间 () － 时间))

i支持库列表	支持库注释
spec	特殊功能支持库
eAPI	应用接口支持库

.版本 2<br /> .支持库 spec<br /> .支持库 eAPI<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 文本1, 文本型<br /> .局部变量 文本2, 文本型<br /> .局部变量 数组, 整数型, , "10000"<br /> .局部变量 数据, 字节集<br /> .局部变量 数, 整数型<br /> .局部变量 值, 整数型<br /> .局部变量 量, 整数型<br /> .局部变量 结果, 文本型<br /> .局部变量 次数, 整数型<br /> .局部变量 下标, 整数型<br /> .局部变量 起点, 整数型<br /> .局部变量 时间, 整数型<br /> <br /> ' 调试输出 (取代码 (“0”, ), 取代码 (“9”, ), 取代码 (“ ”, ))<br /> .计次循环首 (10000, 数)  ' 生成所有组合<br />     文本1 ＝ 文本1 ＋ 取文本右边 (“0000” ＋ 到文本 (数 － 1), 4) ＋ “ ”<br /> .计次循环尾 ()<br /> ' 文本1 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”<br /> 文本2 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”<br /> 时间 ＝ 取启动时间 ()<br /> .计次循环首 (2, 次数)<br />     数据 ＝ 到字节集 (选择 (次数 ＝ 1, 文本1, 文本2)) ＋ { 0 }<br />     量 ＝ 0<br />     .计次循环首 (取字节集长度 (数据), 数)<br />         值 ＝ 数据 [数]<br />         .如果 (值 ≥ 48 且 值 ≤ 57)<br />             量 ＝ 量 × 10 ＋ 值 － 48<br />         .否则<br />             值 ＝ 量 ＋ 1<br />             数组 [值] ＝ 数组 [值] ＋ 1<br />             量 ＝ 0<br />         .如果结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> 数据 ＝ 取空白字节集 (5 × 10000 ＋ 1)<br /> 起点 ＝ 1<br /> .计次循环首 (10000, 数)<br />     .如果真 (数组 [数] ＝ 1)<br />         值 ＝ 数 － 1<br />         下标 ＝ 3<br />         .循环判断首 ()<br />             数据 [起点 ＋ 下标] ＝ 值 ％ 10 ＋ 48<br />             下标 ＝ 下标 － 1<br />             值 ＝ 值 ÷ 10<br />         .循环判断尾 (值 ≠ 0)<br />         .判断循环首 (下标 ≥ 0)<br />             数据 [起点 ＋ 下标] ＝ 48<br />             下标 ＝ 下标 － 1<br />         .判断循环尾 ()<br />         数据 [起点 ＋ 4] ＝ 32<br />         起点 ＝ 起点 ＋ 5<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 结果 ＝ 到文本 (数据)<br /> 调试输出 (格式化文本 (“出现一次的数量: %.0f, 耗时: %d 毫秒”, 取文本长度 (结果) ÷ 5, 取启动时间 () － 时间))

性能提升会非常明显, 适合频繁调用, 毕竟每次运行只需0毫秒(低于1毫秒):

彼岸光年

黑咖啡 发表于 2025-8-16 11:48
[e=1].版本 2
.支持库 EDataStructure
.支持库 spec

这就是去重啊
我要的是去同存异。。。
相同的6006,0029去掉，留下不同的啊

花间一壶酒

山猫啊 发表于 2025-8-16 11:00
[e=2].版本 2
.支持库 spec

要不你仔细看看  两串文本是不同的  他需要的是 两串文本中 完全没有重复的内容

补充内容 (2025-8-16 13:40):
你不省题的么。。。

补充内容 (2025-8-16 13:42):
人家要的是把重复值完全删除  而不是保留一个。。。。而且 结果要把其他没有重复的内容整合到一起

蘇中二少

.版本 2
.支持库 spec

.子程序 _按钮1_被单击
.局部变量 文本一, 文本型
.局部变量 文本二, 文本型
.局部变量 数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 结果, 文本型

文本一 ＝ “0059 0580 0004 6006 7162 0803 6010 0029”
文本二 ＝ “0673 1208 6019 6006 5183 6037 6092 0029 0724 3380”
数组 ＝ 分割文本 (文本一 ＋ “ ” ＋ 文本二, “ ”, )
.计次循环首 (取数组成员数 (数组), i)
    .如果真 (数组_取次数 (数组, 数组 [i]) ＝ 1)
        结果 ＝ 结果 ＋ 数组 [i] ＋ “ ”
    .如果真结束

.计次循环尾 ()
调试输出 (结果)