运行速度太慢，求提速

真冬

  

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

变量名	类 型	静态	数组	备 注
a	字节集
b	字节集
w1	整数型
w0	整数型
c	字节集
d	字节集
q	整数型

q ＝ 取启动时间 ()
a ＝ { 13, 10 } ＋ 到字节集 (编辑框_后区.内容)
b ＝ 到字节集 (编辑框_前区.内容) ＋ { 13, 10 }
连续赋值 (1, w0, w1)
判断循环首 (w1 ≠ -1)
w1 ＝ 寻找字节集 (b, { 13, 10 }, w1 ＋ 1)
判断 (w1 ≠ -1)
d ＝ 取字节集中间 (b, w0, w1 － w0)
w0 ＝ w1 ＋ 2
如果真 (d ≠ {  })
c ＝ c ＋ 子字节集替换 (a, { 10 }, { 10 } ＋ d ＋ { 32 }, , )

跳出循环 ()

判断循环尾 ()
编辑框_合并结果.内容 ＝ 到文本 (c)
调试输出 (取启动时间 () － q)

i支持库列表	支持库注释
iext2	扩展界面支持库二
spec	特殊功能支持库

.版本 2<br /> .支持库 iext2<br /> .支持库 spec<br /> <br /> .子程序 _按钮1生成2_被单击<br /> .局部变量 a, 字节集<br /> .局部变量 b, 字节集<br /> .局部变量 w1, 整数型<br /> .局部变量 w0, 整数型<br /> .局部变量 c, 字节集<br /> .局部变量 d, 字节集<br /> .局部变量 q, 整数型<br /> <br /> q ＝ 取启动时间 ()<br /> a ＝ { 13, 10 } ＋ 到字节集 (编辑框_后区.内容)<br /> b ＝ 到字节集 (编辑框_前区.内容) ＋ { 13, 10 }<br /> 连续赋值 (1, w0, w1)<br /> .判断循环首 (w1 ≠ -1)<br />     w1 ＝ 寻找字节集 (b, { 13, 10 }, w1 ＋ 1)<br />     .判断开始 (w1 ≠ -1)<br />         d ＝ 取字节集中间 (b, w0, w1 － w0)<br />         w0 ＝ w1 ＋ 2<br />         .如果真 (d ≠ {  })<br />             c ＝ c ＋ 子字节集替换 (a, { 10 }, { 10 } ＋ d ＋ { 32 }, , )<br />         .如果真结束<br /> <br />     .默认<br />         跳出循环 ()<br />     .判断结束<br /> <br /> .判断循环尾 ()<br /> 编辑框_合并结果.内容 ＝ 到文本 (c)<br /> 调试输出 (取启动时间 () － q)

求提速 1.e (12.73 KB, 下载次数: 1)

昨天 16:15 上传

点击文件名下载附件


补充内容 (2026-6-30 16:20):
用字节集就快很多了，34行前区乘以1000行的后区结果三万多行四五秒这样

补充内容 (2026-6-30 16:27):
我的思路是取前区的每一行，把后区的换行符替换成刚才前区的每一行。把替换好的组合成结果。

xiaokaidada

  

子程序名	返回值类型	公开	备 注
字节集_解析	整数型
参数名	类 型	参考	可空	数组	备 注
参_字节集	字节集
参_分隔符	字节集
参_行位置数组	整数型
参_行长度数组	整数型

变量名	类 型	静态	数组	备 注
局_源指针	整数型
局_源长度	整数型
局_分隔长度	整数型
局_总行数	整数型
局_当前位置	整数型
局_行位置	整数型

局_源指针 ＝ 取变量数据地址 (参_字节集)
局_源长度 ＝ 取字节集长度 (参_字节集)
局_分隔长度 ＝ 取字节集长度 (参_分隔符)
局_当前位置 ＝ 1
局_总行数 ＝ 0
重定义数组 (参_行位置数组, 假, 0)
重定义数组 (参_行长度数组, 假, 0)
判断循环首 (局_当前位置 ≤ 局_源长度)
局_行位置 ＝ 局_当前位置
' 查找换行符
判断循环首 (局_当前位置 ≤ 局_源长度 且 参_字节集 [局_当前位置] ≠ 13)
局_当前位置 ＝ 局_当前位置 ＋ 1
判断循环尾 ()
如果真 (局_当前位置 ＞ 局_源长度)
跳出循环 ()

局_总行数 ＝ 局_总行数 ＋ 1
加入成员 (参_行位置数组, 局_源指针 ＋ 局_行位置 － 1)
加入成员 (参_行长度数组, 局_当前位置 － 局_行位置)
如果真 (局_当前位置 ≤ 局_源长度 且 参_字节集 [局_当前位置] ＝ 13)
局_当前位置 ＝ 局_当前位置 ＋ 1
如果真 (局_当前位置 ≤ 局_源长度 且 参_字节集 [局_当前位置] ＝ 10)
局_当前位置 ＝ 局_当前位置 ＋ 1


判断循环尾 ()
返回 (局_总行数)

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

变量名	类 型	静态	数组	备 注
局_前区行位置	整数型		0
局_前区行长度	整数型		0
局_后区行位置	整数型		0
局_后区行长度	整数型		0
局_字符	字节集
局_总长度	整数型
局_前区总数	整数型
i	整数型
局_后区总数	整数型
n	整数型
局_字节集	字节集
局_写入指针	整数型
局_换行符	字节集
局_字符地址	整数型
局_换行符地址	整数型
局_前区字节集	字节集
局_后区字节集	字节集
启动时间	双精度小数型

启动时间 ＝ 取启动时间 ()
局_字符 ＝ { 32 }  ' 到字节集(“ ”)
局_换行符 ＝ { 13, 10 }  ' 到字节集(#换行符)
' 这里可以直接采用读入文件的方式，编辑框直接赋值过来也行
局_前区字节集 ＝ 到字节集 (集_文本1)
局_后区字节集 ＝ 到字节集 (集_文本2)
局_前区总数 ＝ 字节集_解析 (局_前区字节集, 局_换行符, 局_前区行位置, 局_前区行长度)
局_后区总数 ＝ 字节集_解析 (局_后区字节集, 局_换行符, 局_后区行位置, 局_后区行长度)
局_字符地址 ＝ 取变量数据地址 (局_字符)
局_换行符地址 ＝ 取变量数据地址 (局_换行符)
局_总长度 ＝ 0
计次循环首 (局_前区总数, i)
计次循环首 (局_后区总数, n)
局_总长度 ＝ 局_总长度 ＋ 局_前区行长度 [i] ＋ 1 ＋ 局_后区行长度 [n] ＋ 2
计次循环尾 ()
计次循环尾 ()
局_字节集 ＝ 取空白字节集 (局_总长度)
局_写入指针 ＝ 取变量数据地址 (局_字节集)
计次循环首 (局_前区总数, i)
计次循环首 (局_后区总数, n)
RtlMoveMemory (局_写入指针, 局_前区行位置 [i], 局_前区行长度 [i])
局_写入指针 ＝ 局_写入指针 ＋ 局_前区行长度 [i]
RtlMoveMemory (局_写入指针, 局_字符地址, 1)
局_写入指针 ＝ 局_写入指针 ＋ 1
RtlMoveMemory (局_写入指针, 局_后区行位置 [n], 局_后区行长度 [n])
局_写入指针 ＝ 局_写入指针 ＋ 局_后区行长度 [n]
RtlMoveMemory (局_写入指针, 局_换行符地址, 2)
局_写入指针 ＝ 局_写入指针 ＋ 2
计次循环尾 ()
计次循环尾 ()
'  写到文件 (“1.txt”, 局_字节集)
调试输出 (“字节集长度：” ＋ 到文本 (取字节集长度 (局_字节集)))
调试输出 (“耗时：” ＋ 到文本 (取启动时间 () － 启动时间) ＋ “ms”)
调试输出 (“组合数：” ＋ 到文本 (局_前区总数 × 局_后区总数))

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 字节集_解析, 整数型<br /> .参数 参_字节集, 字节集<br /> .参数 参_分隔符, 字节集<br /> .参数 参_行位置数组, 整数型, 参考 数组<br /> .参数 参_行长度数组, 整数型, 参考 数组<br /> .局部变量 局_源指针, 整数型<br /> .局部变量 局_源长度, 整数型<br /> .局部变量 局_分隔长度, 整数型<br /> .局部变量 局_总行数, 整数型<br /> .局部变量 局_当前位置, 整数型<br /> .局部变量 局_行位置, 整数型<br /> <br /> 局_源指针 ＝ 取变量数据地址 (参_字节集)<br /> 局_源长度 ＝ 取字节集长度 (参_字节集)<br /> 局_分隔长度 ＝ 取字节集长度 (参_分隔符)<br /> <br /> 局_当前位置 ＝ 1<br /> 局_总行数 ＝ 0<br /> <br /> 重定义数组 (参_行位置数组, 假, 0)<br /> 重定义数组 (参_行长度数组, 假, 0)<br /> <br /> .判断循环首 (局_当前位置 ≤ 局_源长度)<br />     局_行位置 ＝ 局_当前位置<br /> <br />     ' 查找换行符<br />     .判断循环首 (局_当前位置 ≤ 局_源长度 且 参_字节集 [局_当前位置] ≠ 13)<br />         局_当前位置 ＝ 局_当前位置 ＋ 1<br />     .判断循环尾 ()<br /> <br />     .如果真 (局_当前位置 ＞ 局_源长度)<br />         跳出循环 ()<br />     .如果真结束<br /> <br />     局_总行数 ＝ 局_总行数 ＋ 1<br />     加入成员 (参_行位置数组, 局_源指针 ＋ 局_行位置 － 1)<br />     加入成员 (参_行长度数组, 局_当前位置 － 局_行位置)<br /> <br />     .如果真 (局_当前位置 ≤ 局_源长度 且 参_字节集 [局_当前位置] ＝ 13)<br />         局_当前位置 ＝ 局_当前位置 ＋ 1<br />         .如果真 (局_当前位置 ≤ 局_源长度 且 参_字节集 [局_当前位置] ＝ 10)<br />             局_当前位置 ＝ 局_当前位置 ＋ 1<br />         .如果真结束<br /> <br />     .如果真结束<br /> <br /> .判断循环尾 ()<br /> <br /> 返回 (局_总行数)<br /> <br /> .子程序 _按钮2_被单击<br /> .局部变量 局_前区行位置, 整数型, , "0"<br /> .局部变量 局_前区行长度, 整数型, , "0"<br /> .局部变量 局_后区行位置, 整数型, , "0"<br /> .局部变量 局_后区行长度, 整数型, , "0"<br /> .局部变量 局_字符, 字节集<br /> .局部变量 局_总长度, 整数型<br /> .局部变量 局_前区总数, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 局_后区总数, 整数型<br /> .局部变量 n, 整数型<br /> .局部变量 局_字节集, 字节集<br /> .局部变量 局_写入指针, 整数型<br /> .局部变量 局_换行符, 字节集<br /> .局部变量 局_字符地址, 整数型<br /> .局部变量 局_换行符地址, 整数型<br /> .局部变量 局_前区字节集, 字节集<br /> .局部变量 局_后区字节集, 字节集<br /> .局部变量 启动时间, 双精度小数型<br /> <br /> 启动时间 ＝ 取启动时间 ()<br /> <br /> 局_字符 ＝ { 32 }  ' 到字节集(“ ”)<br /> 局_换行符 ＝ { 13, 10 }  ' 到字节集(#换行符)<br /> <br /> ' 这里可以直接采用读入文件的方式，编辑框直接赋值过来也行<br /> 局_前区字节集 ＝ 到字节集 (集_文本1)<br /> 局_后区字节集 ＝ 到字节集 (集_文本2)<br /> 局_前区总数 ＝ 字节集_解析 (局_前区字节集, 局_换行符, 局_前区行位置, 局_前区行长度)<br /> 局_后区总数 ＝ 字节集_解析 (局_后区字节集, 局_换行符, 局_后区行位置, 局_后区行长度)<br /> <br /> <br /> 局_字符地址 ＝ 取变量数据地址 (局_字符)<br /> 局_换行符地址 ＝ 取变量数据地址 (局_换行符)<br /> <br /> 局_总长度 ＝ 0<br /> .计次循环首 (局_前区总数, i)<br />     .计次循环首 (局_后区总数, n)<br />         局_总长度 ＝ 局_总长度 ＋ 局_前区行长度 <i> ＋ 1 ＋ 局_后区行长度 [n] ＋ 2<br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> 局_字节集 ＝ 取空白字节集 (局_总长度)<br /> 局_写入指针 ＝ 取变量数据地址 (局_字节集)<br /> .计次循环首 (局_前区总数, i)<br />     .计次循环首 (局_后区总数, n)<br /> <br />         RtlMoveMemory (局_写入指针, 局_前区行位置 <i>, 局_前区行长度 <i>)<br />         局_写入指针 ＝ 局_写入指针 ＋ 局_前区行长度 <i><br /> <br />         RtlMoveMemory (局_写入指针, 局_字符地址, 1)<br />         局_写入指针 ＝ 局_写入指针 ＋ 1<br /> <br />         RtlMoveMemory (局_写入指针, 局_后区行位置 [n], 局_后区行长度 [n])<br />         局_写入指针 ＝ 局_写入指针 ＋ 局_后区行长度 [n]<br /> <br />         RtlMoveMemory (局_写入指针, 局_换行符地址, 2)<br />         局_写入指针 ＝ 局_写入指针 ＋ 2<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> '  写到文件 (“1.txt”, 局_字节集)<br /> 调试输出 (“字节集长度：” ＋ 到文本 (取字节集长度 (局_字节集)))<br /> 调试输出 (“耗时：” ＋ 到文本 (取启动时间 () － 启动时间) ＋ “ms”)<br /> 调试输出 (“组合数：” ＋ 到文本 (局_前区总数 × 局_后区总数))

补充内容 (2026-6-30 18:19):
* “字节集长度：8786000”
* “耗时：156ms”
* “组合数：1000000”