计算文本组合_纯源码_求测试

jr21066

也不知道算快的还是慢的.标题也不加快速了.免的被啐了
主要是文本的不定长,没法用汇编加速.如果是整数还差不多.

  

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

变量名	类 型	静态	数组	备 注
文本数组	文本型		0
子集数组	文本型		0
计数器	整数型
文本1	文本型

计次循环首 (10, 计数器)
加入成员 (文本数组, 字符 (64 ＋ 计数器))
计次循环尾 ()
求数组组合 (文本数组, 6, 子集数组, )
调试输出 (子集数组)
计次循环首 (20, 计数器)
文本1 ＝ 文本1 ＋ 字符 (64 ＋ 计数器) ＋ “,”
计次循环尾 ()
调试输出 (求文本组合 (文本1, 6, , ))
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
求数组组合			求n-m组合
参数名	类 型	参考	可空	数组	备 注
参_数组	文本型				组合所有成员
参_组合位数	整数型				子集成员数
参_返回数组	文本型				用于存放返回的子集
参_子集分隔符	文本型

变量名	类 型	静态	数组	备 注
局_增量计数器	整数型			1到最大值的增量计数
局_位记数总量	长整数型			组合位数计算
局_成员总数	整数型			组合成员总数
局_位计数	整数型			当前增量值的1置位数
局_测试位	整数型			计算1个数用
局_位测试计数器	整数型			增量计数位计算计数
局_子集数值	文本型			子集成员临时值

如果真 (是否为空 (参_子集分隔符))
参_子集分隔符 ＝ “,”
局_成员总数 ＝ 取数组成员数 (参_数组)
局_测试位 ＝ 1
' 求出组合所有成员的使用位数的数值,
计次循环首 (局_成员总数, 局_增量计数器)
局_位记数总量 ＝ 左移 (局_位记数总量, 1)
局_位记数总量 ＝ 位或 (局_位记数总量, 1)
计次循环尾 ()
' 从1开始到最大值,循环求置1位数等于子集位数的数值成员
计次循环首 (局_位记数总量, 局_增量计数器)
局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)
' 符合子集数量的数
如果真 (局_位计数 ＝ 参_组合位数)
局_子集数值 ＝ “”
计次循环首 (局_成员总数, 局_位测试计数器)
' 计算1置位数量
如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))
局_子集数值 ＝ 局_子集数值 ＋ 参_数组 [局_位测试计数器] ＋ 参_子集分隔符

计次循环尾 ()
局_子集数值 ＝ 取文本左边 (局_子集数值, 取文本长度 (局_子集数值) － 取文本长度 (参_子集分隔符))
加入成员 (参_返回数组, 局_子集数值)

计次循环尾 ()

子程序名	返回值类型	公开	备 注
求1位数	整数型
参数名	类 型	参考	可空	数组	备 注
参_数值	整数型
参_计算位	整数型

置入代码 ({ 81, 82, 139, 69, 8, 139, 77, 12, 49, 210, 209, 216, 115, 1, 66, 226, 249, 137, 208, 90, 89, 201, 194, 8, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
求1是否置位	逻辑型
参数名	类 型	参考	可空	数组	备 注
参_数值	整数型
参_计算位	整数型

置入代码 ({ 81, 82, 139, 69, 8, 186, 1, 0, 0, 0, 139, 77, 12, 73, 211, 226, 133, 208, 117, 4, 49, 192, 235, 3, 49, 192, 64, 90, 89, 201, 194, 8, 0 })
返回 (假)

子程序名	返回值类型	公开	备 注
求文本组合	文本型		求n-m组合
参数名	类 型	参考	可空	数组	备 注
参_文本	文本型				组合所有成员
参_组合位数	整数型				子集成员数
参_文本分隔符	文本型				文本内容中分隔符号
参_子集分隔符	文本型				返回子集中分隔符

变量名	类 型	静态	数组	备 注
局_增量计数器	整数型			1到最大值的增量计数
局_位记数总量	长整数型			组合位数计算
局_成员总数	整数型			组合成员总数
局_位计数	整数型			当前增量值的1置位数
局_测试位	整数型			计算1个数用
局_位测试计数器	整数型			增量计数位计算计数
局_子集数值	文本型			子集成员临时值
局_返回文本	文本型			返回子集文本
局_文件句柄	整数型			内存文件句柄
局_文本数组	文本型		0

如果真 (是否为空 (参_文本分隔符))
参_文本分隔符 ＝ “,”
如果真 (是否为空 (参_子集分隔符))
参_子集分隔符 ＝ “,”
局_文本数组 ＝ 分割文本 (参_文本, 参_文本分隔符, )
局_成员总数 ＝ 取数组成员数 (局_文本数组)
局_测试位 ＝ 1
局_文件句柄 ＝ 打开内存文件 ()
' 求出组合所有成员的使用位数的数值,
调试输出 (参_文本, 取数组成员数 (局_文本数组))
计次循环首 (局_成员总数, 局_增量计数器)
局_位记数总量 ＝ 左移 (局_位记数总量, 1)
局_位记数总量 ＝ 位或 (局_位记数总量, 1)
计次循环尾 ()
' 从1开始到最大值,循环求置1位数等于子集位数的数值成员
计次循环首 (局_位记数总量, 局_增量计数器)
局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)
' 符合子集数量的数
如果真 (局_位计数 ＝ 参_组合位数)
局_子集数值 ＝ “”
计次循环首 (局_成员总数, 局_位测试计数器)
' 计算1置位数量
如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))
局_子集数值 ＝ 局_子集数值 ＋ 局_文本数组 [局_位测试计数器] ＋ 参_子集分隔符

计次循环尾 ()
写出文本 (局_文件句柄, 取文本左边 (局_子集数值, 取文本长度 (局_子集数值) － 取文本长度 (参_子集分隔符)) ＋ #换行符 )

计次循环尾 ()
移动读写位置 (局_文件句柄, #文件首, 0)
局_返回文本 ＝ 读入文本 (局_文件句柄, )
关闭文件 (局_文件句柄)
返回 (局_返回文本)

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 文本数组, 文本型, , "0"<br /> .局部变量 子集数组, 文本型, , "0"<br /> .局部变量 计数器, 整数型<br /> .局部变量 文本1, 文本型<br /> <br /> .计次循环首 (10, 计数器)<br />     加入成员 (文本数组, 字符 (64 ＋ 计数器))<br /> .计次循环尾 ()<br /> 求数组组合 (文本数组, 6, 子集数组, )<br /> 调试输出 (子集数组)<br /> .计次循环首 (20, 计数器)<br />     文本1 ＝ 文本1 ＋ 字符 (64 ＋ 计数器) ＋ “,”<br /> .计次循环尾 ()<br /> 调试输出 (求文本组合 (文本1, 6, , ))<br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 求数组组合, , 公开, 求n-m组合<br /> .参数 参_数组, 文本型, 数组, 组合所有成员<br /> .参数 参_组合位数, 整数型, , 子集成员数<br /> .参数 参_返回数组, 文本型, 数组, 用于存放返回的子集<br /> .参数 参_子集分隔符, 文本型, 可空<br /> .局部变量 局_增量计数器, 整数型, , , 1到最大值的增量计数<br /> .局部变量 局_位记数总量, 长整数型, , , 组合位数计算<br /> .局部变量 局_成员总数, 整数型, , , 组合成员总数<br /> .局部变量 局_位计数, 整数型, , , 当前增量值的1置位数<br /> .局部变量 局_测试位, 整数型, , , 计算1个数用<br /> .局部变量 局_位测试计数器, 整数型, , , 增量计数位计算计数<br /> .局部变量 局_子集数值, 文本型, , , 子集成员临时值<br /> <br /> .如果真 (是否为空 (参_子集分隔符))<br />     参_子集分隔符 ＝ “,”<br /> .如果真结束<br /> 局_成员总数 ＝ 取数组成员数 (参_数组)<br /> 局_测试位 ＝ 1<br /> ' 求出组合所有成员的使用位数的数值,<br /> <br /> .计次循环首 (局_成员总数, 局_增量计数器)<br />     局_位记数总量 ＝ 左移 (局_位记数总量, 1)<br />     局_位记数总量 ＝ 位或 (局_位记数总量, 1)<br /> .计次循环尾 ()<br /> <br /> ' 从1开始到最大值,循环求置1位数等于子集位数的数值成员<br /> .计次循环首 (局_位记数总量, 局_增量计数器)<br />     局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)<br />     ' 符合子集数量的数<br />     .如果真 (局_位计数 ＝ 参_组合位数)<br />         局_子集数值 ＝ “”<br />         .计次循环首 (局_成员总数, 局_位测试计数器)<br />             ' 计算1置位数量<br />             .如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))<br />                 局_子集数值 ＝ 局_子集数值 ＋ 参_数组 [局_位测试计数器] ＋ 参_子集分隔符<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />         局_子集数值 ＝ 取文本左边 (局_子集数值, 取文本长度 (局_子集数值) － 取文本长度 (参_子集分隔符))<br />         加入成员 (参_返回数组, 局_子集数值)<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> <br /> .子程序 求1位数, 整数型<br /> .参数 参_数值, 整数型<br /> .参数 参_计算位, 整数型<br /> <br /> 置入代码 ({ 81, 82, 139, 69, 8, 139, 77, 12, 49, 210, 209, 216, 115, 1, 66, 226, 249, 137, 208, 90, 89, 201, 194, 8, 0 })<br /> 返回 (0)<br /> <br /> <br /> .子程序 求1是否置位, 逻辑型<br /> .参数 参_数值, 整数型<br /> .参数 参_计算位, 整数型<br /> <br /> 置入代码 ({ 81, 82, 139, 69, 8, 186, 1, 0, 0, 0, 139, 77, 12, 73, 211, 226, 133, 208, 117, 4, 49, 192, 235, 3, 49, 192, 64, 90, 89, 201, 194, 8, 0 })<br /> 返回 (假)<br /> <br /> <br /> .子程序 求文本组合, 文本型, 公开, 求n-m组合<br /> .参数 参_文本, 文本型, , 组合所有成员<br /> .参数 参_组合位数, 整数型, , 子集成员数<br /> .参数 参_文本分隔符, 文本型, 可空, 文本内容中分隔符号<br /> .参数 参_子集分隔符, 文本型, 可空, 返回子集中分隔符<br /> .局部变量 局_增量计数器, 整数型, , , 1到最大值的增量计数<br /> .局部变量 局_位记数总量, 长整数型, , , 组合位数计算<br /> .局部变量 局_成员总数, 整数型, , , 组合成员总数<br /> .局部变量 局_位计数, 整数型, , , 当前增量值的1置位数<br /> .局部变量 局_测试位, 整数型, , , 计算1个数用<br /> .局部变量 局_位测试计数器, 整数型, , , 增量计数位计算计数<br /> .局部变量 局_子集数值, 文本型, , , 子集成员临时值<br /> .局部变量 局_返回文本, 文本型, , , 返回子集文本<br /> .局部变量 局_文件句柄, 整数型, , , 内存文件句柄<br /> .局部变量 局_文本数组, 文本型, , "0"<br /> <br /> .如果真 (是否为空 (参_文本分隔符))<br />     参_文本分隔符 ＝ “,”<br /> .如果真结束<br /> .如果真 (是否为空 (参_子集分隔符))<br />     参_子集分隔符 ＝ “,”<br /> .如果真结束<br /> 局_文本数组 ＝ 分割文本 (参_文本, 参_文本分隔符, )<br /> 局_成员总数 ＝ 取数组成员数 (局_文本数组)<br /> 局_测试位 ＝ 1<br /> 局_文件句柄 ＝ 打开内存文件 ()<br /> ' 求出组合所有成员的使用位数的数值,<br /> 调试输出 (参_文本, 取数组成员数 (局_文本数组))<br /> .计次循环首 (局_成员总数, 局_增量计数器)<br />     局_位记数总量 ＝ 左移 (局_位记数总量, 1)<br />     局_位记数总量 ＝ 位或 (局_位记数总量, 1)<br /> .计次循环尾 ()<br /> <br /> ' 从1开始到最大值,循环求置1位数等于子集位数的数值成员<br /> .计次循环首 (局_位记数总量, 局_增量计数器)<br />     局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)<br />     ' 符合子集数量的数<br />     .如果真 (局_位计数 ＝ 参_组合位数)<br />         局_子集数值 ＝ “”<br />         .计次循环首 (局_成员总数, 局_位测试计数器)<br />             ' 计算1置位数量<br />             .如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))<br />                 局_子集数值 ＝ 局_子集数值 ＋ 局_文本数组 [局_位测试计数器] ＋ 参_子集分隔符<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />         写出文本 (局_文件句柄, 取文本左边 (局_子集数值, 取文本长度 (局_子集数值) － 取文本长度 (参_子集分隔符)) ＋ #换行符)<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 移动读写位置 (局_文件句柄, #文件首, 0)<br /> 局_返回文本 ＝ 读入文本 (局_文件句柄, )<br /> 关闭文件 (局_文件句柄)<br /> 返回 (局_返回文本)

jr21066

优化第一版

  

窗口程序集名	保 留	保 留	备 注
程序集1

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

变量名	类 型	静态	数组	备 注
文本数组	文本型		0
子集数组	文本型		0
计数器	整数型
文本1	文本型
时间1	整数型

时间1 ＝ 取启动时间 ()
计次循环首 (10, 计数器)
加入成员 (文本数组, 字符 (64 ＋ 计数器))
计次循环尾 ()
求数组组合 (文本数组, 3, 子集数组, )
调试输出 (子集数组, 取启动时间 () － 时间1)
时间1 ＝ 取启动时间 ()
计次循环首 (10, 计数器)
文本1 ＝ 文本1 ＋ 字符 (64 ＋ 计数器) ＋ “,”
计次循环尾 ()
求文本组合 (文本1, 4, , )
调试输出 (取启动时间 () － 时间1)
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
求数组组合			求n-m组合
参数名	类 型	参考	可空	数组	备 注
参_数组	文本型				组合所有成员
参_组合位数	整数型				子集成员数
参_返回数组	文本型				用于存放返回的子集
参_子集分隔符	文本型

变量名	类 型	静态	数组	备 注
局_增量计数器	整数型			1到最大值的增量计数
局_位记数总量	长整数型			组合位数计算
局_成员总数	整数型			组合成员总数
局_位计数	整数型			当前增量值的1置位数
局_测试位	整数型			计算1个数用
局_位测试计数器	整数型			增量计数位计算计数
局_子集数值	文本型			子集成员临时值
局_文件句柄	整数型
局_写子集次数	整数型

如果真 (是否为空 (参_子集分隔符))
参_子集分隔符 ＝ “,”
局_成员总数 ＝ 取数组成员数 (参_数组)
局_测试位 ＝ 1
' 求出组合所有成员的使用位数的数值,
取变量地址 (局_位记数总量)
求置位数值 (局_成员总数)
调试输出 (“循环次数”, 局_位记数总量)
' 从1开始到最大值,循环求置1位数等于子集位数的数值成员
计次循环首 (局_位记数总量, 局_增量计数器)
局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)
' 符合子集数量的数
如果真 (局_位计数 ＝ 参_组合位数)
局_子集数值 ＝ “”
局_文件句柄 ＝ 打开内存文件 ()
计次循环首 (局_成员总数, 局_位测试计数器)
' 计算1置位数量
局_写子集次数 ＝ 0
如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))
局_写子集次数 ＝ 局_写子集次数 ＋ 1
如果 (局_写子集次数 ＜ 参_组合位数)
写出文本 (局_文件句柄, 参_数组 [局_位测试计数器] ＋ 参_子集分隔符)
写出文本 (局_文件句柄, 参_数组 [局_位测试计数器])


计次循环尾 ()
移动读写位置 (局_文件句柄, #文件首, 0)
加入成员 (参_返回数组, 读入文本 (局_文件句柄, ))
关闭文件 (局_文件句柄)

计次循环尾 ()

子程序名	返回值类型	公开	备 注
求1位数	整数型
参数名	类 型	参考	可空	数组	备 注
参_数值	整数型
参_计算位	整数型

置入代码 ({ 81, 82, 139, 69, 8, 139, 77, 12, 49, 210, 209, 216, 115, 1, 66, 226, 249, 137, 208, 90, 89, 201, 194, 8, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
求1是否置位	逻辑型
参数名	类 型	参考	可空	数组	备 注
参_数值	整数型
参_计算位	整数型

置入代码 ({ 81, 82, 139, 69, 8, 186, 1, 0, 0, 0, 139, 77, 12, 73, 211, 226, 133, 208, 117, 4, 49, 192, 235, 3, 49, 192, 64, 90, 89, 201, 194, 8, 0 })
返回 (假)

子程序名	返回值类型	公开	备 注
求文本组合	文本型		求n-m组合
参数名	类 型	参考	可空	数组	备 注
参_文本	文本型				组合所有成员
参_组合位数	整数型				子集成员数
参_文本分隔符	文本型				文本内容中分隔符号
参_子集分隔符	文本型				返回子集中分隔符

变量名	类 型	静态	数组	备 注
局_增量计数器	整数型			1到最大值的增量计数
局_位记数总量	长整数型			组合位数计算
局_成员总数	整数型			组合成员总数
局_位计数	整数型			当前增量值的1置位数
局_测试位	整数型			计算1个数用
局_位测试计数器	整数型			增量计数位计算计数
局_子集数值	文本型			子集成员临时值
局_返回文本	文本型			返回子集文本
局_文件句柄	整数型			内存文件句柄
局_文本数组	文本型		0	组合成员数组
局_写子集次数	整数型			临时计次变量

如果真 (是否为空 (参_文本分隔符))
参_文本分隔符 ＝ “,”
如果真 (是否为空 (参_子集分隔符))
参_子集分隔符 ＝ “,”
局_文本数组 ＝ 分割文本 (参_文本, 参_文本分隔符, )
局_成员总数 ＝ 取数组成员数 (局_文本数组)
局_测试位 ＝ 1
局_文件句柄 ＝ 打开内存文件 ()
' 求出组合所有成员的使用位数的数值,
取变量地址 (局_位记数总量)
求置位数值 (局_成员总数)
调试输出 (“循环次数”, 局_位记数总量)
' 从1开始到最大值,循环求置1位数等于子集位数的数值成员
计次循环首 (局_位记数总量, 局_增量计数器)
局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)
' 符合子集数量的数
如果真 (局_位计数 ＝ 参_组合位数)
局_子集数值 ＝ “”
局_写子集次数 ＝ 0
计次循环首 (局_成员总数, 局_位测试计数器)
' 计算1置位数量
如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))
局_写子集次数 ＝ 局_写子集次数 ＋ 1
如果 (局_写子集次数 ＜ 参_组合位数)
写出文本 (局_文件句柄, 局_文本数组 [局_位测试计数器] ＋ 参_子集分隔符)
写出文本 (局_文件句柄, 局_文本数组 [局_位测试计数器] ＋ #换行符 )


计次循环尾 ()

计次循环尾 ()
移动读写位置 (局_文件句柄, #文件首, 0)
局_返回文本 ＝ 读入文本 (局_文件句柄, )
关闭文件 (局_文件句柄)
返回 (局_返回文本)

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

置入代码 ({ 82, 81, 139, 77, 8, 49, 210, 66, 73, 249, 209, 210, 226, 251, 137, 16, 89, 90 })

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 程序集1<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 文本数组, 文本型, , "0"<br /> .局部变量 子集数组, 文本型, , "0"<br /> .局部变量 计数器, 整数型<br /> .局部变量 文本1, 文本型<br /> .局部变量 时间1, 整数型<br /> <br /> 时间1 ＝ 取启动时间 ()<br /> .计次循环首 (10, 计数器)<br />     加入成员 (文本数组, 字符 (64 ＋ 计数器))<br /> .计次循环尾 ()<br /> 求数组组合 (文本数组, 3, 子集数组, )<br /> 调试输出 (子集数组, 取启动时间 () － 时间1)<br /> 时间1 ＝ 取启动时间 ()<br /> .计次循环首 (10, 计数器)<br />     文本1 ＝ 文本1 ＋ 字符 (64 ＋ 计数器) ＋ “,”<br /> .计次循环尾 ()<br /> 求文本组合 (文本1, 4, , )<br /> 调试输出 (取启动时间 () － 时间1)<br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 求数组组合, , 公开, 求n-m组合<br /> .参数 参_数组, 文本型, 数组, 组合所有成员<br /> .参数 参_组合位数, 整数型, , 子集成员数<br /> .参数 参_返回数组, 文本型, 数组, 用于存放返回的子集<br /> .参数 参_子集分隔符, 文本型, 可空<br /> .局部变量 局_增量计数器, 整数型, , , 1到最大值的增量计数<br /> .局部变量 局_位记数总量, 长整数型, , , 组合位数计算<br /> .局部变量 局_成员总数, 整数型, , , 组合成员总数<br /> .局部变量 局_位计数, 整数型, , , 当前增量值的1置位数<br /> .局部变量 局_测试位, 整数型, , , 计算1个数用<br /> .局部变量 局_位测试计数器, 整数型, , , 增量计数位计算计数<br /> .局部变量 局_子集数值, 文本型, , , 子集成员临时值<br /> .局部变量 局_文件句柄, 整数型<br /> .局部变量 局_写子集次数, 整数型<br /> <br /> .如果真 (是否为空 (参_子集分隔符))<br />     参_子集分隔符 ＝ “,”<br /> .如果真结束<br /> 局_成员总数 ＝ 取数组成员数 (参_数组)<br /> 局_测试位 ＝ 1<br /> ' 求出组合所有成员的使用位数的数值,<br /> 取变量地址 (局_位记数总量)<br /> 求置位数值 (局_成员总数)<br /> 调试输出 (“循环次数”, 局_位记数总量)<br /> ' 从1开始到最大值,循环求置1位数等于子集位数的数值成员<br /> .计次循环首 (局_位记数总量, 局_增量计数器)<br />     局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)<br />     ' 符合子集数量的数<br />     .如果真 (局_位计数 ＝ 参_组合位数)<br />         局_子集数值 ＝ “”<br />         局_文件句柄 ＝ 打开内存文件 ()<br />         .计次循环首 (局_成员总数, 局_位测试计数器)<br />             ' 计算1置位数量<br />             局_写子集次数 ＝ 0<br />             .如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))<br />                 局_写子集次数 ＝ 局_写子集次数 ＋ 1<br />                 .如果 (局_写子集次数 ＜ 参_组合位数)<br />                     写出文本 (局_文件句柄, 参_数组 [局_位测试计数器] ＋ 参_子集分隔符)<br />                 .否则<br />                     写出文本 (局_文件句柄, 参_数组 [局_位测试计数器])<br />                 .如果结束<br /> <br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />         移动读写位置 (局_文件句柄, #文件首, 0)<br />         加入成员 (参_返回数组, 读入文本 (局_文件句柄, ))<br />         关闭文件 (局_文件句柄)<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> <br /> .子程序 求1位数, 整数型<br /> .参数 参_数值, 整数型<br /> .参数 参_计算位, 整数型<br /> <br /> 置入代码 ({ 81, 82, 139, 69, 8, 139, 77, 12, 49, 210, 209, 216, 115, 1, 66, 226, 249, 137, 208, 90, 89, 201, 194, 8, 0 })<br /> 返回 (0)<br /> <br /> <br /> .子程序 求1是否置位, 逻辑型<br /> .参数 参_数值, 整数型<br /> .参数 参_计算位, 整数型<br /> <br /> 置入代码 ({ 81, 82, 139, 69, 8, 186, 1, 0, 0, 0, 139, 77, 12, 73, 211, 226, 133, 208, 117, 4, 49, 192, 235, 3, 49, 192, 64, 90, 89, 201, 194, 8, 0 })<br /> 返回 (假)<br /> <br /> <br /> .子程序 求文本组合, 文本型, 公开, 求n-m组合<br /> .参数 参_文本, 文本型, , 组合所有成员<br /> .参数 参_组合位数, 整数型, , 子集成员数<br /> .参数 参_文本分隔符, 文本型, 可空, 文本内容中分隔符号<br /> .参数 参_子集分隔符, 文本型, 可空, 返回子集中分隔符<br /> .局部变量 局_增量计数器, 整数型, , , 1到最大值的增量计数<br /> .局部变量 局_位记数总量, 长整数型, , , 组合位数计算<br /> .局部变量 局_成员总数, 整数型, , , 组合成员总数<br /> .局部变量 局_位计数, 整数型, , , 当前增量值的1置位数<br /> .局部变量 局_测试位, 整数型, , , 计算1个数用<br /> .局部变量 局_位测试计数器, 整数型, , , 增量计数位计算计数<br /> .局部变量 局_子集数值, 文本型, , , 子集成员临时值<br /> .局部变量 局_返回文本, 文本型, , , 返回子集文本<br /> .局部变量 局_文件句柄, 整数型, , , 内存文件句柄<br /> .局部变量 局_文本数组, 文本型, , "0", 组合成员数组<br /> .局部变量 局_写子集次数, 整数型, , , 临时计次变量<br /> <br /> .如果真 (是否为空 (参_文本分隔符))<br />     参_文本分隔符 ＝ “,”<br /> .如果真结束<br /> .如果真 (是否为空 (参_子集分隔符))<br />     参_子集分隔符 ＝ “,”<br /> .如果真结束<br /> 局_文本数组 ＝ 分割文本 (参_文本, 参_文本分隔符, )<br /> 局_成员总数 ＝ 取数组成员数 (局_文本数组)<br /> 局_测试位 ＝ 1<br /> 局_文件句柄 ＝ 打开内存文件 ()<br /> ' 求出组合所有成员的使用位数的数值,<br /> 取变量地址 (局_位记数总量)<br /> 求置位数值 (局_成员总数)<br /> 调试输出 (“循环次数”, 局_位记数总量)<br /> ' 从1开始到最大值,循环求置1位数等于子集位数的数值成员<br /> .计次循环首 (局_位记数总量, 局_增量计数器)<br />     局_位计数 ＝ 求1位数 (局_增量计数器, 局_成员总数)<br />     ' 符合子集数量的数<br />     .如果真 (局_位计数 ＝ 参_组合位数)<br />         局_子集数值 ＝ “”<br />         局_写子集次数 ＝ 0<br />         .计次循环首 (局_成员总数, 局_位测试计数器)<br />             ' 计算1置位数量<br />             .如果真 (求1是否置位 (局_增量计数器, 局_位测试计数器))<br />                 局_写子集次数 ＝ 局_写子集次数 ＋ 1<br />                 .如果 (局_写子集次数 ＜ 参_组合位数)<br />                     写出文本 (局_文件句柄, 局_文本数组 [局_位测试计数器] ＋ 参_子集分隔符)<br />                 .否则<br />                     写出文本 (局_文件句柄, 局_文本数组 [局_位测试计数器] ＋ #换行符)<br />                 .如果结束<br /> <br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 移动读写位置 (局_文件句柄, #文件首, 0)<br /> 局_返回文本 ＝ 读入文本 (局_文件句柄, )<br /> 关闭文件 (局_文件句柄)<br /> 返回 (局_返回文本)<br /> <br /> .子程序 求置位数值<br /> .参数 参_置位次数, 整数型<br /> <br /> 置入代码 ({ 82, 81, 139, 77, 8, 49, 210, 66, 73, 249, 209, 210, 226, 251, 137, 16, 89, 90 })

jr21066

不出错的话.可能就是最终优化了.速度上差不多就是这样了.

  

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

变量名	类 型	静态	数组	备 注
文本数组	文本型		0
子集数组	文本型		0
计数器	整数型
文本1	文本型
时间1	整数型

时间1 ＝ 取启动时间 ()
计次循环首 (20, 计数器)
加入成员 (文本数组, 字符 (64 ＋ 计数器))
计次循环尾 ()
求数组组合 (文本数组, 6, 子集数组, )
调试输出 (取启动时间 () － 时间1)
时间1 ＝ 取启动时间 ()
计次循环首 (20, 计数器)
文本1 ＝ 文本1 ＋ 字符 (64 ＋ 计数器) ＋ “,”
计次循环尾 ()
求文本组合 (文本1, 6, , )
调试输出 (取启动时间 () － 时间1)
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
求数组组合			求n-m组合
参数名	类 型	参考	可空	数组	备 注
参_数组	文本型				组合所有成员
参_组合位数	整数型				子集成员数
参_返回数组	文本型				用于存放返回的子集
参_子集分隔符	文本型

变量名	类 型	静态	数组	备 注
局_成员总数	整数型			组合成员总数
局_文件句柄	整数型
局_写子集次数	整数型
局_符合数值	整数型
局_数组偏移位置	整数型

如果真 (是否为空 (参_子集分隔符))
参_子集分隔符 ＝ “,”
局_成员总数 ＝ 取数组成员数 (参_数组)
局_符合数值 ＝ 求下一符合数 (1, 参_组合位数, 局_成员总数)
判断循环首 (局_符合数值 ≠ 0)
局_符合数值 ＝ 求下一符合数 (局_符合数值, 参_组合位数, 局_成员总数)
如果真 (局_符合数值 ＝ 0)
跳出循环 ()
局_文件句柄 ＝ 打开内存文件 ()
计次循环首 (参_组合位数, 局_写子集次数)
局_数组偏移位置 ＝ 求下一置位 (局_符合数值, 局_写子集次数)
如果 (局_写子集次数 ＜ 参_组合位数)
写出文本 (局_文件句柄, 参_数组 [局_数组偏移位置] ＋ 参_子集分隔符)
写出文本 (局_文件句柄, 参_数组 [局_数组偏移位置])

计次循环尾 ()
移动读写位置 (局_文件句柄, #文件首, 0)
加入成员 (参_返回数组, 读入文本 (局_文件句柄, ))
关闭文件 (局_文件句柄)
判断循环尾 ()

子程序名	返回值类型	公开	备 注
求下一符合数	整数型
参数名	类 型	参考	可空	数组	备 注
参_起始数值	整数型
参_子集成员	整数型
参_组合成员	整数型

置入代码 ({ 86, 87, 82, 81, 83, 139, 77, 16, 49, 246, 249, 209, 214, 226, 251, 139, 125, 8, 71, 139, 85, 12, 49, 201, 137, 248, 15, 188, 216, 116, 6, 15, 187, 216, 65, 235, 245, 57, 209, 116, 13, 71, 57, 247, 127, 6, 49, 201, 137, 248, 235, 230, 49, 255, 137, 248, 91, 89, 90, 95, 94, 201, 194, 12, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
求下一置位	整数型
参数名	类 型	参考	可空	数组	备 注
参_当前值	整数型
参_位计数	整数型

置入代码 ({ 81, 83, 139, 69, 8, 139, 77, 12, 15, 188, 216, 15, 187, 216, 226, 248, 137, 216, 64, 91, 89, 201, 194, 8, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
求文本组合	文本型		求n-m组合
参数名	类 型	参考	可空	数组	备 注
参_文本	文本型				组合所有成员
参_组合位数	整数型				子集成员数
参_分隔符	文本型
参_子集分隔符	文本型

变量名	类 型	静态	数组	备 注
局_成员总数	整数型			组合成员总数
局_文件句柄	整数型
局_写子集次数	整数型
局_符合数值	整数型
局_数组偏移位置	整数型
局_文本数组	文本型		0
局_返回值	文本型

如果真 (是否为空 (参_子集分隔符))
参_子集分隔符 ＝ “,”
如果真 (是否为空 (参_分隔符))
参_分隔符 ＝ “,”

局_文本数组 ＝ 分割文本 (参_文本, 参_分隔符, )
局_成员总数 ＝ 取数组成员数 (局_文本数组)
局_符合数值 ＝ 求下一符合数 (1, 参_组合位数, 局_成员总数)
局_文件句柄 ＝ 打开内存文件 ()
判断循环首 (局_符合数值 ≠ 0)
局_符合数值 ＝ 求下一符合数 (局_符合数值, 参_组合位数, 局_成员总数)
如果真 (局_符合数值 ＝ 0)
跳出循环 ()

计次循环首 (参_组合位数, 局_写子集次数)
局_数组偏移位置 ＝ 求下一置位 (局_符合数值, 局_写子集次数)
如果 (局_写子集次数 ＜ 参_组合位数)
写出文本 (局_文件句柄, 局_文本数组 [局_数组偏移位置] ＋ 参_子集分隔符)
写出文本 (局_文件句柄, 局_文本数组 [局_数组偏移位置] ＋ #换行符 )

计次循环尾 ()
判断循环尾 ()
移动读写位置 (局_文件句柄, #文件首, 0)
局_返回值 ＝ 读入文本 (局_文件句柄, )
关闭文件 (局_文件句柄)
返回 (局_返回值)

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 文本数组, 文本型, , "0"<br /> .局部变量 子集数组, 文本型, , "0"<br /> .局部变量 计数器, 整数型<br /> .局部变量 文本1, 文本型<br /> .局部变量 时间1, 整数型<br /> <br /> 时间1 ＝ 取启动时间 ()<br /> .计次循环首 (20, 计数器)<br />     加入成员 (文本数组, 字符 (64 ＋ 计数器))<br /> .计次循环尾 ()<br /> 求数组组合 (文本数组, 6, 子集数组, )<br /> 调试输出 (取启动时间 () － 时间1)<br /> 时间1 ＝ 取启动时间 ()<br /> .计次循环首 (20, 计数器)<br />     文本1 ＝ 文本1 ＋ 字符 (64 ＋ 计数器) ＋ “,”<br /> .计次循环尾 ()<br /> 求文本组合 (文本1, 6, , )<br /> 调试输出 (取启动时间 () － 时间1)<br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 求数组组合, , 公开, 求n-m组合<br /> .参数 参_数组, 文本型, 数组, 组合所有成员<br /> .参数 参_组合位数, 整数型, , 子集成员数<br /> .参数 参_返回数组, 文本型, 数组, 用于存放返回的子集<br /> .参数 参_子集分隔符, 文本型, 可空<br /> .局部变量 局_成员总数, 整数型, , , 组合成员总数<br /> .局部变量 局_文件句柄, 整数型<br /> .局部变量 局_写子集次数, 整数型<br /> .局部变量 局_符合数值, 整数型<br /> .局部变量 局_数组偏移位置, 整数型<br /> <br /> .如果真 (是否为空 (参_子集分隔符))<br />     参_子集分隔符 ＝ “,”<br /> .如果真结束<br /> 局_成员总数 ＝ 取数组成员数 (参_数组)<br /> 局_符合数值 ＝ 求下一符合数 (1, 参_组合位数, 局_成员总数)<br /> .判断循环首 (局_符合数值 ≠ 0)<br />     局_符合数值 ＝ 求下一符合数 (局_符合数值, 参_组合位数, 局_成员总数)<br />     .如果真 (局_符合数值 ＝ 0)<br />         跳出循环 ()<br />     .如果真结束<br />     局_文件句柄 ＝ 打开内存文件 ()<br />     .计次循环首 (参_组合位数, 局_写子集次数)<br />         局_数组偏移位置 ＝ 求下一置位 (局_符合数值, 局_写子集次数)<br />         .如果 (局_写子集次数 ＜ 参_组合位数)<br />             写出文本 (局_文件句柄, 参_数组 [局_数组偏移位置] ＋ 参_子集分隔符)<br />         .否则<br />             写出文本 (局_文件句柄, 参_数组 [局_数组偏移位置])<br />         .如果结束<br /> <br />     .计次循环尾 ()<br />     移动读写位置 (局_文件句柄, #文件首, 0)<br />     加入成员 (参_返回数组, 读入文本 (局_文件句柄, ))<br />     关闭文件 (局_文件句柄)<br /> .判断循环尾 ()<br /> <br /> <br /> .子程序 求下一符合数, 整数型<br /> .参数 参_起始数值, 整数型<br /> .参数 参_子集成员, 整数型<br /> .参数 参_组合成员, 整数型<br /> <br /> 置入代码 ({ 86, 87, 82, 81, 83, 139, 77, 16, 49, 246, 249, 209, 214, 226, 251, 139, 125, 8, 71, 139, 85, 12, 49, 201, 137, 248, 15, 188, 216, 116, 6, 15, 187, 216, 65, 235, 245, 57, 209, 116, 13, 71, 57, 247, 127, 6, 49, 201, 137, 248, 235, 230, 49, 255, 137, 248, 91, 89, 90, 95, 94, 201, 194, 12, 0 })<br /> <br /> 返回 (0)<br /> <br /> .子程序 求下一置位, 整数型<br /> .参数 参_当前值, 整数型<br /> .参数 参_位计数, 整数型<br /> <br /> 置入代码 ({ 81, 83, 139, 69, 8, 139, 77, 12, 15, 188, 216, 15, 187, 216, 226, 248, 137, 216, 64, 91, 89, 201, 194, 8, 0 })<br /> <br /> 返回 (0)<br /> <br /> <br /> .子程序 求文本组合, 文本型, 公开, 求n-m组合<br /> .参数 参_文本, 文本型, , 组合所有成员<br /> .参数 参_组合位数, 整数型, , 子集成员数<br /> .参数 参_分隔符, 文本型, 可空<br /> .参数 参_子集分隔符, 文本型, 可空<br /> .局部变量 局_成员总数, 整数型, , , 组合成员总数<br /> .局部变量 局_文件句柄, 整数型<br /> .局部变量 局_写子集次数, 整数型<br /> .局部变量 局_符合数值, 整数型<br /> .局部变量 局_数组偏移位置, 整数型<br /> .局部变量 局_文本数组, 文本型, , "0"<br /> .局部变量 局_返回值, 文本型<br /> <br /> .如果真 (是否为空 (参_子集分隔符))<br />     参_子集分隔符 ＝ “,”<br /> .如果真结束<br /> .如果真 (是否为空 (参_分隔符))<br />     参_分隔符 ＝ “,”<br /> .如果真结束<br /> <br /> 局_文本数组 ＝ 分割文本 (参_文本, 参_分隔符, )<br /> 局_成员总数 ＝ 取数组成员数 (局_文本数组)<br /> 局_符合数值 ＝ 求下一符合数 (1, 参_组合位数, 局_成员总数)<br /> 局_文件句柄 ＝ 打开内存文件 ()<br /> .判断循环首 (局_符合数值 ≠ 0)<br />     局_符合数值 ＝ 求下一符合数 (局_符合数值, 参_组合位数, 局_成员总数)<br />     .如果真 (局_符合数值 ＝ 0)<br />         跳出循环 ()<br />     .如果真结束<br /> <br />     .计次循环首 (参_组合位数, 局_写子集次数)<br />         局_数组偏移位置 ＝ 求下一置位 (局_符合数值, 局_写子集次数)<br />         .如果 (局_写子集次数 ＜ 参_组合位数)<br />             写出文本 (局_文件句柄, 局_文本数组 [局_数组偏移位置] ＋ 参_子集分隔符)<br />         .否则<br />             写出文本 (局_文件句柄, 局_文本数组 [局_数组偏移位置] ＋ #换行符)<br />         .如果结束<br /> <br />     .计次循环尾 ()<br /> .判断循环尾 ()<br /> 移动读写位置 (局_文件句柄, #文件首, 0)<br /> 局_返回值 ＝ 读入文本 (局_文件句柄, )<br /> 关闭文件 (局_文件句柄)<br /> 返回 (局_返回值)

longerzqy

都是会的人啊，学习中

sdan1201

下载下来以后可能 用得上

E世繁华

强大，感谢分享

E世繁华

此帖仅作者可见

dangerace

jr21066 发表于 2018-12-18 20:00
不知啥时修正过.忘上传了.现在补上.

如图所示，我测试50个元素按3位进行组合，正确结果应该是有19600个组合。另外，如果继续加大元素数量以及位数，您的算法会直接返回0。例如100-5

刚才继续随意修改元素数量和位数进行测试，发现当元素数量在30以下时结果都是正确的，不过运算速度不稳定，例如您可以试一下30-2或者30-3，速度都很快，但30-4时耗时会突然飙升。

我用来对比速度的是一位网名叫birdmanxp的大牛编写的排列组合模块，他的模块的计算速度基本是线性的，比较稳定。

jr21066

不知啥时修正过.忘上传了.现在补上.

weewee

太太太强大了

kyo9766

感谢分享，虽然看懵了