M选N 排列组合 多对多组合

a7612501

  

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

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

变量名	类 型	静态	数组	备 注
ret	文本型		0
i	整数型
i1	整数型
int	整数型
sum	整数型
array	文本型		0
结果	文本型		0

' m选n ({ “A|AA|AAA”, “B”, “C”, “D” }, 3, 结果)   '多对1没问题
' m选n ({ “A|AA|AAA”, “B|CC”, “C”, “D” }, 3, 结果)  ' 多对多就计算不了，这组应该有17种组合
m选n ({ “A|AA|AAA”, “B”, “C|CC”, “D|DD” }, 3, 结果)  ' 多对多就计算不了，这组应该有28种组合
' 1 2 3 4  2*1
' 2*1 = 12 13 14 23 24 34
' 3*1 = 123 124 134 234
' 4*1= 1234
调试输出 (结果)

子程序名	返回值类型	公开	备 注
get	文本型		代码由发条JS调试工具生成
参数名	类 型	参考	可空	数组	备 注
文本	文本型
个数	整数型

变量名	类 型	静态	数组	备 注
script	对象
result	变体型

script.创建 (“scriptcontrol”, )
script.写属性 (“Language”, “JScript”)
script.数值方法 (“AddCode”, #常量1 )
result ＝ script.通用方法 (“Eval”, “com('” ＋ 文本 ＋ “','” ＋ 到文本 (个数) ＋ “')”)  ' 此处的表达式如果比较复杂建议使用常量
返回 (result.取文本 ())  ' 返回变体类型 如果是文本可以取文本，如果是数值可以取数值

子程序名	返回值类型	公开	备 注
m选n
参数名	类 型	参考	可空	数组	备 注
array	文本型
sum	整数型
结果	文本型

变量名	类 型	静态	数组	备 注
result	文本型		0
i	整数型
a	整数型
b	文本型
i1	整数型
多个_x	文本型		0
x	整数型
右边	文本型

计次循环首 (求次方 (2, 取数组成员数 (array)), i)
a ＝ 0
b ＝ “”
计次循环首 (取数组成员数 (array), i1)
如果真 (位与 (右移 (i － 1, i1 － 1), 1) ＝ 1)
a ＝ a ＋ 1
b ＝ b ＋ array [i1] ＋ “,”

计次循环尾 ()
如果真 (a ＝ sum)
如果真 (取文本右边 (b, 1) ＝ “,”)
b ＝ 取文本左边 (b, 取文本长度 (b) － 1)

如果 (寻找文本 (b, “|”, , 假) ≠ -1)
多个_x ＝ 分割文本 (文本_取左边 (b, “,”), “|”, )
右边 ＝ 取右边 (b, “,”)
计次循环首 (取数组成员数 (多个_x), x)
加入成员 (result, 多个_x [x] ＋ “,” ＋ 右边)
计次循环尾 ()
加入成员 (result, b)


计次循环尾 ()
结果 ＝ result

子程序名	返回值类型	公开	备 注
m选n_	文本型
参数名	类 型	参考	可空	数组	备 注
array	文本型
sum	整数型

变量名	类 型	静态	数组	备 注
result	文本型
i	整数型
a	整数型
b	文本型
i1	整数型

计次循环首 (求次方 (2, 取数组成员数 (array)), i)
i1 ＝ i － 1
a ＝ 0
判断循环首 (i1 ＞ 0)
i1 ＝ 位与 (i1, i1 － 1)
a ＝ a ＋ 1
判断循环尾 ()
如果真 (a ＝ sum)
b ＝ “”
计次循环首 (取数组成员数 (array), i1)
如果真 (位与 (右移 (i － 1, i1 － 1), 1) ＝ 1)
b ＝ b ＋ array [i1]

计次循环尾 ()
result ＝ result ＋ b ＋ “,”

计次循环尾 ()
返回 (result)

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

子程序名	返回值类型	公开	备 注
取右边	文本型
参数名	类 型	参考	可空	数组	备 注
文本	文本型
分割符	文本型

变量名	类 型	静态	数组	备 注
array	文本型		0
结果	文本型
n	整数型

array ＝ 分割文本 (文本, 分割符, )
如果 (取数组成员数 (array) ＞ 0)
计次循环首 (取数组成员数 (array), n)
如果真 (n ＋ 1 ≤ 取数组成员数 (array))
结果 ＝ 结果 ＋ array [n ＋ 1] ＋ 分割符

计次循环尾 ()
如果真 (取文本右边 (结果, 取文本长度 (分割符)) ＝ 分割符)
结果 ＝ 取文本左边 (结果, 取文本长度 (结果) － 取文本长度 (分割符))

结果 ＝ 文本

返回 (结果)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 _按钮1_被单击<br /> .局部变量 ret, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 i1, 整数型<br /> .局部变量 int, 整数型<br /> .局部变量 sum, 整数型<br /> .局部变量 array, 文本型, , "0"<br /> .局部变量 结果, 文本型, , "0"<br /> <br /> <br /> ' m选n ({ “A|AA|AAA”, “B”, “C”, “D” }, 3, 结果)   '多对1没问题<br /> ' m选n ({ “A|AA|AAA”, “B|CC”, “C”, “D” }, 3, 结果)  ' 多对多就计算不了，这组应该有17种组合<br /> m选n ({ “A|AA|AAA”, “B”, “C|CC”, “D|DD” }, 3, 结果)  ' 多对多就计算不了，这组应该有28种组合<br /> ' 1 2 3 4  2*1<br /> ' 2*1 = 12 13 14 23 24 34<br /> ' 3*1 = 123 124 134 234<br /> ' 4*1= 1234<br /> 调试输出 (结果)<br /> <br /> .子程序 get, 文本型, , 代码由发条JS调试工具生成<br /> .参数 文本, 文本型<br /> .参数 个数, 整数型<br /> .局部变量 script, 对象<br /> .局部变量 result, 变体型<br /> <br /> script.创建 (“scriptcontrol”, )<br /> script.写属性 (“Language”, “JScript”)<br /> script.数值方法 (“AddCode”, #常量1)<br /> result ＝ script.通用方法 (“Eval”, “com('” ＋ 文本 ＋ “','” ＋ 到文本 (个数) ＋ “')”)  ' 此处的表达式如果比较复杂建议使用常量<br /> 返回 (result.取文本 ())  ' 返回变体类型 如果是文本可以取文本，如果是数值可以取数值<br /> <br /> .子程序 m选n<br /> .参数 array, 文本型, 数组<br /> .参数 sum, 整数型<br /> .参数 结果, 文本型, 数组<br /> .局部变量 result, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 b, 文本型<br /> .局部变量 i1, 整数型<br /> .局部变量 多个_x, 文本型, , "0"<br /> .局部变量 x, 整数型<br /> .局部变量 右边, 文本型<br /> <br /> .计次循环首 (求次方 (2, 取数组成员数 (array)), i)<br />     a ＝ 0<br />     b ＝ “”<br />     .计次循环首 (取数组成员数 (array), i1)<br />         .如果真 (位与 (右移 (i － 1, i1 － 1), 1) ＝ 1)<br />             a ＝ a ＋ 1<br />             b ＝ b ＋ array [i1] ＋ “,”<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     .如果真 (a ＝ sum)<br />         .如果真 (取文本右边 (b, 1) ＝ “,”)<br />             b ＝ 取文本左边 (b, 取文本长度 (b) － 1)<br />         .如果真结束<br /> <br /> <br /> <br /> <br />         .如果 (寻找文本 (b, “|”, , 假) ≠ -1)<br />             多个_x ＝ 分割文本 (文本_取左边 (b, “,”), “|”, )<br />             右边 ＝ 取右边 (b, “,”)<br />             .计次循环首 (取数组成员数 (多个_x), x)<br />                 加入成员 (result, 多个_x [x] ＋ “,” ＋ 右边)<br />             .计次循环尾 ()<br />         .否则<br />             加入成员 (result, b)<br />         .如果结束<br /> <br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 结果 ＝ result<br /> <br /> .子程序 m选n_, 文本型<br /> .参数 array, 文本型, 数组<br /> .参数 sum, 整数型<br /> .局部变量 result, 文本型<br /> .局部变量 i, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 b, 文本型<br /> .局部变量 i1, 整数型<br /> <br /> .计次循环首 (求次方 (2, 取数组成员数 (array)), i)<br />     i1 ＝ i － 1<br />     a ＝ 0<br />     .判断循环首 (i1 ＞ 0)<br />         i1 ＝ 位与 (i1, i1 － 1)<br />         a ＝ a ＋ 1<br />     .判断循环尾 ()<br /> <br />     .如果真 (a ＝ sum)<br />         b ＝ “”<br />         .计次循环首 (取数组成员数 (array), i1)<br />             .如果真 (位与 (右移 (i － 1, i1 － 1), 1) ＝ 1)<br />                 b ＝ b ＋ array [i1]<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />         result ＝ result ＋ b ＋ “,”<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 返回 (result)<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> <br /> <br /> .子程序 取右边, 文本型<br /> .参数 文本, 文本型<br /> .参数 分割符, 文本型<br /> .局部变量 array, 文本型, , "0"<br /> .局部变量 结果, 文本型<br /> .局部变量 n, 整数型<br /> <br /> array ＝ 分割文本 (文本, 分割符, )<br /> .如果 (取数组成员数 (array) ＞ 0)<br />     .计次循环首 (取数组成员数 (array), n)<br />         .如果真 (n ＋ 1 ≤ 取数组成员数 (array))<br />             结果 ＝ 结果 ＋ array [n ＋ 1] ＋ 分割符<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     .如果真 (取文本右边 (结果, 取文本长度 (分割符)) ＝ 分割符)<br />         结果 ＝ 取文本左边 (结果, 取文本长度 (结果) － 取文本长度 (分割符))<br />     .如果真结束<br /> <br /> .否则<br />     结果 ＝ 文本<br /> .如果结束<br /> <br /> 返回 (结果)

anyuezhiji

  

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

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

变量名	类 型	静态	数组	备 注
待选选项	文本型		4
选取数	整数型
组合结果	文本型		0
计次	整数型
组合数量	整数型
组合	文本型
计次2	整数型

待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }
选取数 ＝ 2v ' “组合数量” | 24
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }
选取数 ＝ 3  ' “组合数量” | 34
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }
选取数 ＝ 2  ' “组合数量” | 17
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }
选取数 ＝ 4  ' “组合数量” | 6
多对多M选N (待选选项, 选取数, 组合结果)
组合数量 ＝ 取数组成员数 (组合结果) ＼ 选取数
调试输出 (“组合数量”, 组合数量)
重定义数组 (组合结果, 真, 组合数量, 选取数)
计次循环首 (组合数量, 计次)
组合 ＝ “”
计次循环首 (选取数, 计次2)
组合 ＝ 组合 ＋ 组合结果 [计次] [计次2]
如果真 (计次2 ＜ 选取数)
组合 ＝ 组合 ＋ “，”

计次循环尾 ()
调试输出 (“组合” ＋ 到文本 (计次) ＋ “：”, 组合)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
多对多M选N
参数名	类 型	参考	可空	数组	备 注
待选选项	文本型
选取数	整数型
组合结果	文本型

变量名	类 型	静态	数组	备 注
结果_Cmn	整数型		1,1
数量_Cmn	整数型
计次	整数型
待选选项组	文本数组		0
选项组长度	整数型		0
待选长度	整数型
计次2	整数型
组合数	整数型
索引	整数型
临时	整数型
计次3	整数型
临时选项	文本型		0

清除数组 (组合结果)
待选长度 ＝ 取数组成员数 (待选选项)
数量_Cmn ＝ 计算数量_Cmn (待选长度, 选取数)
重定义数组 (结果_Cmn, 假, 数量_Cmn, 选取数)
Cmn (待选长度, 选取数, 结果_Cmn, )
重定义数组 (待选选项组, 假, 待选长度)
重定义数组 (选项组长度, 假, 待选长度)
重定义数组 (临时选项, 假, 选取数)
计次循环首 (待选长度, 计次)
文本_分割文本 (待选选项 [计次], “|”, , 待选选项组 [计次].文本成员)
选项组长度 [计次] ＝ 取数组成员数 (待选选项组 [计次].文本成员)
计次循环尾 ()
计次循环首 (数量_Cmn, 计次)
组合数 ＝ 1
计次循环首 (选取数, 计次2)
组合数 ＝ 组合数 × 选项组长度 [结果_Cmn [计次] [计次2]]
计次循环尾 ()
计次循环首 (组合数, 计次2)
临时 ＝ 计次2
计次循环首 (选取数, 计次3)
索引 ＝ (临时 － 1) ％ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1
临时 ＝ (临时 － 1) ＼ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1
临时选项 [计次3] ＝ 待选选项组 [结果_Cmn [计次] [计次3]].文本成员 [索引]
计次循环尾 ()
加入成员 (组合结果, 临时选项)
计次循环尾 ()
计次循环尾 ()

子程序名	返回值类型	公开	备 注
Cmn			m选n。存于数组
参数名	类 型	参考	可空	数组	备 注
M	整数型
N	整数型				即n。确保digit≤m，即字符数组的长度。
返回结果	整数型				返回结果，调用前须确保数组为空
数组缓存	整数型				数组缓存，无需填写
层次缓存	整数型				层次缓存，无需填写
索引缓存	整数型				索引缓存，无需填写
结果索引缓存	整数型				结果索引缓存，无需填写

变量名	类 型	静态	数组	备 注
i	整数型
j	整数型

如果真 (是否为空 (数组缓存))
重定义数组 (数组缓存, 假, N)
' m选n
' 其中level表示现在所处的第n阶段，如果是5选3，level=2，那就说明现在已经选了2个了
层次缓存 ＝ 层次缓存 ＋ 1  ' level再+1，变成level=3，  此时level = n ,那就说明已选齐3个了，加入到返回结果里面
如果 (层次缓存 ＝ N)
变量循环首 (索引缓存 ＋ 1, M, 1, i)
计次循环首 (N － 1, j)
返回结果 [结果索引缓存 ＋ i － 索引缓存] [j] ＝ 数组缓存 [j]
计次循环尾 ()
返回结果 [结果索引缓存 ＋ i － 索引缓存] [N] ＝ i
' 加入到返回结果里面
变量循环尾 ()
结果索引缓存 ＝ 结果索引缓存 ＋ M － 索引缓存
变量循环首 (索引缓存 ＋ 1, M － N ＋ 层次缓存, 1, i)
数组缓存 [层次缓存] ＝ i
Cmn (M, N, 返回结果, 数组缓存, 层次缓存, i, 结果索引缓存)
变量循环尾 ()

子程序名	返回值类型	公开	备 注
计算数量_Cmn	整数型		适用于小量 不超过整数型上限2147483647
参数名	类 型	参考	可空	数组	备 注
M	整数型
N	整数型

变量名	类 型	静态	数组	备 注
计次	整数型
Cmn	整数型

Cmn ＝ 1
变量循环首 (M, M － N ＋ 1, -1, 计次)
Cmn ＝ Cmn × 计次
变量循环尾 ()
计次循环首 (N, 计次)
Cmn ＝ Cmn ÷ 计次
计次循环尾 ()
返回 (Cmn)

数据类型名	公开	备 注
文本数组
成员名	类 型	传址	数组	备 注
文本成员	文本型		1

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 待选选项, 文本型, , "4"<br /> .局部变量 选取数, 整数型<br /> .局部变量 组合结果, 文本型, , "0"<br /> .局部变量 计次, 整数型<br /> .局部变量 组合数量, 整数型<br /> .局部变量 组合, 文本型<br /> .局部变量 计次2, 整数型<br /> <br /> <br /> 待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }<br /> 选取数 ＝ 2v ' “组合数量” | 24<br /> <br /> 待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }<br /> 选取数 ＝ 3  ' “组合数量” | 34<br /> <br /> 待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }<br /> 选取数 ＝ 2  ' “组合数量” | 17<br /> <br /> 待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }<br /> 选取数 ＝ 4  ' “组合数量” | 6<br /> <br /> 多对多M选N (待选选项, 选取数, 组合结果)<br /> 组合数量 ＝ 取数组成员数 (组合结果) ＼ 选取数<br /> 调试输出 (“组合数量”, 组合数量)<br /> 重定义数组 (组合结果, 真, 组合数量, 选取数)<br /> .计次循环首 (组合数量, 计次)<br />     组合 ＝ “”<br />     .计次循环首 (选取数, 计次2)<br />         组合 ＝ 组合 ＋ 组合结果 [计次] [计次2]<br />         .如果真 (计次2 ＜ 选取数)<br />             组合 ＝ 组合 ＋ “，”<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     调试输出 (“组合” ＋ 到文本 (计次) ＋ “：”, 组合)<br /> .计次循环尾 ()<br /> <br /> .子程序 多对多M选N<br /> .参数 待选选项, 文本型, 数组<br /> .参数 选取数, 整数型<br /> .参数 组合结果, 文本型, 参考 数组<br /> .局部变量 结果_Cmn, 整数型, , "1,1"<br /> .局部变量 数量_Cmn, 整数型<br /> .局部变量 计次, 整数型<br /> .局部变量 待选选项组, 文本数组, , "0"<br /> .局部变量 选项组长度, 整数型, , "0"<br /> .局部变量 待选长度, 整数型<br /> .局部变量 计次2, 整数型<br /> .局部变量 组合数, 整数型<br /> .局部变量 索引, 整数型<br /> .局部变量 临时, 整数型<br /> .局部变量 计次3, 整数型<br /> .局部变量 临时选项, 文本型, , "0"<br /> <br /> 清除数组 (组合结果)<br /> 待选长度 ＝ 取数组成员数 (待选选项)<br /> 数量_Cmn ＝ 计算数量_Cmn (待选长度, 选取数)<br /> 重定义数组 (结果_Cmn, 假, 数量_Cmn, 选取数)<br /> Cmn (待选长度, 选取数, 结果_Cmn, )<br /> 重定义数组 (待选选项组, 假, 待选长度)<br /> 重定义数组 (选项组长度, 假, 待选长度)<br /> 重定义数组 (临时选项, 假, 选取数)<br /> .计次循环首 (待选长度, 计次)<br />     文本_分割文本 (待选选项 [计次], “|”, , 待选选项组 [计次].文本成员)<br />     选项组长度 [计次] ＝ 取数组成员数 (待选选项组 [计次].文本成员)<br /> .计次循环尾 ()<br /> .计次循环首 (数量_Cmn, 计次)<br />     组合数 ＝ 1<br />     .计次循环首 (选取数, 计次2)<br />         组合数 ＝ 组合数 × 选项组长度 [结果_Cmn [计次] [计次2]]<br />     .计次循环尾 ()<br />     .计次循环首 (组合数, 计次2)<br />         临时 ＝ 计次2<br />         .计次循环首 (选取数, 计次3)<br />             索引 ＝ (临时 － 1) ％ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1<br />             临时 ＝ (临时 － 1) ＼ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1<br />             临时选项 [计次3] ＝ 待选选项组 [结果_Cmn [计次] [计次3]].文本成员 [索引]<br />         .计次循环尾 ()<br />         加入成员 (组合结果, 临时选项)<br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> .子程序 Cmn, , , m选n。存于数组<br /> .参数 M, 整数型<br /> .参数 N, 整数型, , 即n。确保digit≤m，即字符数组的长度。<br /> .参数 返回结果, 整数型, 参考 数组, 返回结果，调用前须确保数组为空<br /> .参数 数组缓存, 整数型, 参考 可空 数组, 数组缓存，无需填写<br /> .参数 层次缓存, 整数型, 可空, 层次缓存，无需填写<br /> .参数 索引缓存, 整数型, 可空, 索引缓存，无需填写<br /> .参数 结果索引缓存, 整数型, 参考 可空, 结果索引缓存，无需填写<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> <br /> .如果真 (是否为空 (数组缓存))<br />     重定义数组 (数组缓存, 假, N)<br /> .如果真结束<br /> ' m选n<br /> ' 其中level表示现在所处的第n阶段，如果是5选3，level=2，那就说明现在已经选了2个了<br /> 层次缓存 ＝ 层次缓存 ＋ 1  ' level再+1，变成level=3，  此时level = n ,那就说明已选齐3个了，加入到返回结果里面<br /> .如果 (层次缓存 ＝ N)<br />     .变量循环首 (索引缓存 ＋ 1, M, 1, i)<br />         .计次循环首 (N － 1, j)<br />             返回结果 [结果索引缓存 ＋ i － 索引缓存] [j] ＝ 数组缓存 [j]<br />         .计次循环尾 ()<br />         返回结果 [结果索引缓存 ＋ i － 索引缓存] [N] ＝ i<br />         ' 加入到返回结果里面<br />     .变量循环尾 ()<br />     结果索引缓存 ＝ 结果索引缓存 ＋ M － 索引缓存<br /> .否则<br />     .变量循环首 (索引缓存 ＋ 1, M － N ＋ 层次缓存, 1, i)<br />         数组缓存 [层次缓存] ＝ i<br />         Cmn (M, N, 返回结果, 数组缓存, 层次缓存, i, 结果索引缓存)<br />     .变量循环尾 ()<br /> .如果结束<br /> <br /> <br /> .子程序 计算数量_Cmn, 整数型, , 适用于小量 不超过整数型上限2147483647<br /> .参数 M, 整数型<br /> .参数 N, 整数型<br /> .局部变量 计次, 整数型<br /> .局部变量 Cmn, 整数型<br /> <br /> Cmn ＝ 1<br /> .变量循环首 (M, M － N ＋ 1, -1, 计次)<br />     Cmn ＝ Cmn × 计次<br /> .变量循环尾 ()<br /> .计次循环首 (N, 计次)<br />     Cmn ＝ Cmn ÷ 计次<br /> .计次循环尾 ()<br /> 返回 (Cmn)<br /> <br /> .版本 2<br /> <br /> .数据类型 文本数组<br />     .成员 文本成员, 文本型, , "1"

修正

a7612501

M选N所有组合遍历js方式实现 .e (967.35 KB, 下载次数: 8)

2024-8-3 21:09 上传

点击文件名下载附件
这个是源代码
下载积分: 精币 -1 枚

a7612501

1楼是源代码，帮我看看

明天自然醒

https://125.confly.eu.org/thread-14830372-1-1.html

anyuezhiji

  

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

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

变量名	类 型	静态	数组	备 注
待选选项	文本型		4
选取数	整数型
组合结果	文本型		0
计次	整数型
组合数量	整数型
组合	文本型
计次2	整数型

待选选项 ＝ { “A|AA|AAA”, “B”, “C|CC”, “D|DD” }
选取数 ＝ 3
多对多M选N (待选选项, 3, 组合结果)
组合数量 ＝ 取数组成员数 (组合结果) ＼ 选取数
调试输出 (“组合数量”, 组合数量)
重定义数组 (组合结果, 真, 组合数量, 选取数)
计次循环首 (组合数量, 计次)
组合 ＝ “”
计次循环首 (选取数, 计次2)
组合 ＝ 组合 ＋ 组合结果 [计次] [计次2]
如果真 (计次2 ＜ 选取数)
组合 ＝ 组合 ＋ “，”

计次循环尾 ()
调试输出 (“组合” ＋ 到文本 (计次) ＋ “：”, 组合)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
多对多M选N
参数名	类 型	参考	可空	数组	备 注
待选选项	文本型
选取数	整数型
组合结果	文本型

变量名	类 型	静态	数组	备 注
结果_Cmn	整数型		1,1
数量_Cmn	整数型
计次	整数型
待选选项组	文本数组		0
选项组长度	整数型		0
待选长度	整数型
计次2	整数型
组合数	整数型
索引	整数型
临时	整数型
计次3	整数型
临时选项	文本型		0

清除数组 (组合结果)
待选长度 ＝ 取数组成员数 (待选选项)
数量_Cmn ＝ 计算数量_Cmn (待选长度, 选取数)
重定义数组 (结果_Cmn, 假, 数量_Cmn, 选取数)
Cmn (待选长度, 选取数, 结果_Cmn, )
重定义数组 (待选选项组, 假, 待选长度)
重定义数组 (选项组长度, 假, 待选长度)
重定义数组 (临时选项, 假, 选取数)
计次循环首 (待选长度, 计次)
文本_分割文本 (待选选项 [计次], “|”, , 待选选项组 [计次].文本成员)
选项组长度 [计次] ＝ 取数组成员数 (待选选项组 [计次].文本成员)
计次循环尾 ()
计次循环首 (待选长度, 计次)
组合数 ＝ 1
计次循环首 (选取数, 计次2)
组合数 ＝ 组合数 × 选项组长度 [结果_Cmn [计次] [计次2]]
计次循环尾 ()
计次循环首 (组合数, 计次2)
临时 ＝ 计次2
计次循环首 (选取数, 计次3)
索引 ＝ (临时 － 1) ％ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1
临时 ＝ (临时 － 1) ＼ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1
临时选项 [计次3] ＝ 待选选项组 [结果_Cmn [计次] [计次3]].文本成员 [索引]
计次循环尾 ()
加入成员 (组合结果, 临时选项)
计次循环尾 ()
计次循环尾 ()

子程序名	返回值类型	公开	备 注
Cmn			m选n。存于数组
参数名	类 型	参考	可空	数组	备 注
M	整数型
N	整数型				即n。确保digit≤m，即字符数组的长度。
返回结果	整数型				返回结果，调用前须确保数组为空
数组缓存	整数型				数组缓存，无需填写
层次缓存	整数型				层次缓存，无需填写
索引缓存	整数型				索引缓存，无需填写
结果索引缓存	整数型				结果索引缓存，无需填写

变量名	类 型	静态	数组	备 注
i	整数型
j	整数型

如果真 (是否为空 (数组缓存))
重定义数组 (数组缓存, 假, N)
' m选n
' 其中level表示现在所处的第n阶段，如果是5选3，level=2，那就说明现在已经选了2个了
层次缓存 ＝ 层次缓存 ＋ 1  ' level再+1，变成level=3，  此时level = n ,那就说明已选齐3个了，加入到返回结果里面
如果 (层次缓存 ＝ N)
变量循环首 (索引缓存 ＋ 1, M, 1, i)
计次循环首 (N － 1, j)
返回结果 [结果索引缓存 ＋ i － 索引缓存] [j] ＝ 数组缓存 [j]
计次循环尾 ()
返回结果 [结果索引缓存 ＋ i － 索引缓存] [N] ＝ i
' 加入到返回结果里面
变量循环尾 ()
结果索引缓存 ＝ 结果索引缓存 ＋ M － 索引缓存
变量循环首 (索引缓存 ＋ 1, M － N ＋ 层次缓存, 1, i)
数组缓存 [层次缓存] ＝ i
Cmn (M, N, 返回结果, 数组缓存, 层次缓存, i, 结果索引缓存)
变量循环尾 ()

子程序名	返回值类型	公开	备 注
计算数量_Cmn	整数型		适用于小量 不超过整数型上限2147483647
参数名	类 型	参考	可空	数组	备 注
M	整数型
N	整数型

变量名	类 型	静态	数组	备 注
计次	整数型
因子M	整数型
因子N	整数型

因子M ＝ 1
因子N ＝ 1
变量循环首 (M, M － N ＋ 1, -1, 计次)
因子M ＝ 因子M × 计次
变量循环尾 ()
计次循环首 (N, 计次)
因子N ＝ 因子N × 计次
计次循环尾 ()
返回 (因子M ÷ 因子N)

数据类型名	公开	备 注
文本数组
成员名	类 型	传址	数组	备 注
文本成员	文本型		1

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 待选选项, 文本型, , "4"<br /> .局部变量 选取数, 整数型<br /> .局部变量 组合结果, 文本型, , "0"<br /> .局部变量 计次, 整数型<br /> .局部变量 组合数量, 整数型<br /> .局部变量 组合, 文本型<br /> .局部变量 计次2, 整数型<br /> <br /> 待选选项 ＝ { “A|AA|AAA”, “B”, “C|CC”, “D|DD” }<br /> 选取数 ＝ 3<br /> <br /> 多对多M选N (待选选项, 3, 组合结果)<br /> 组合数量 ＝ 取数组成员数 (组合结果) ＼ 选取数<br /> 调试输出 (“组合数量”, 组合数量)<br /> 重定义数组 (组合结果, 真, 组合数量, 选取数)<br /> .计次循环首 (组合数量, 计次)<br />     组合 ＝ “”<br />     .计次循环首 (选取数, 计次2)<br />         组合 ＝ 组合 ＋ 组合结果 [计次] [计次2]<br />         .如果真 (计次2 ＜ 选取数)<br />             组合 ＝ 组合 ＋ “，”<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     调试输出 (“组合” ＋ 到文本 (计次) ＋ “：”, 组合)<br /> .计次循环尾 ()<br /> <br /> .子程序 多对多M选N<br /> .参数 待选选项, 文本型, 数组<br /> .参数 选取数, 整数型<br /> .参数 组合结果, 文本型, 参考 数组<br /> .局部变量 结果_Cmn, 整数型, , "1,1"<br /> .局部变量 数量_Cmn, 整数型<br /> .局部变量 计次, 整数型<br /> .局部变量 待选选项组, 文本数组, , "0"<br /> .局部变量 选项组长度, 整数型, , "0"<br /> .局部变量 待选长度, 整数型<br /> .局部变量 计次2, 整数型<br /> .局部变量 组合数, 整数型<br /> .局部变量 索引, 整数型<br /> .局部变量 临时, 整数型<br /> .局部变量 计次3, 整数型<br /> .局部变量 临时选项, 文本型, , "0"<br /> <br /> 清除数组 (组合结果)<br /> 待选长度 ＝ 取数组成员数 (待选选项)<br /> 数量_Cmn ＝ 计算数量_Cmn (待选长度, 选取数)<br /> 重定义数组 (结果_Cmn, 假, 数量_Cmn, 选取数)<br /> Cmn (待选长度, 选取数, 结果_Cmn, )<br /> 重定义数组 (待选选项组, 假, 待选长度)<br /> 重定义数组 (选项组长度, 假, 待选长度)<br /> 重定义数组 (临时选项, 假, 选取数)<br /> .计次循环首 (待选长度, 计次)<br />     文本_分割文本 (待选选项 [计次], “|”, , 待选选项组 [计次].文本成员)<br />     选项组长度 [计次] ＝ 取数组成员数 (待选选项组 [计次].文本成员)<br /> .计次循环尾 ()<br /> .计次循环首 (待选长度, 计次)<br />     组合数 ＝ 1<br />     .计次循环首 (选取数, 计次2)<br />         组合数 ＝ 组合数 × 选项组长度 [结果_Cmn [计次] [计次2]]<br />     .计次循环尾 ()<br />     .计次循环首 (组合数, 计次2)<br />         临时 ＝ 计次2<br />         .计次循环首 (选取数, 计次3)<br />             索引 ＝ (临时 － 1) ％ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1<br />             临时 ＝ (临时 － 1) ＼ 选项组长度 [结果_Cmn [计次] [计次3]] ＋ 1<br />             临时选项 [计次3] ＝ 待选选项组 [结果_Cmn [计次] [计次3]].文本成员 [索引]<br />         .计次循环尾 ()<br />         加入成员 (组合结果, 临时选项)<br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> .子程序 Cmn, , , m选n。存于数组<br /> .参数 M, 整数型<br /> .参数 N, 整数型, , 即n。确保digit≤m，即字符数组的长度。<br /> .参数 返回结果, 整数型, 参考 数组, 返回结果，调用前须确保数组为空<br /> .参数 数组缓存, 整数型, 参考 可空 数组, 数组缓存，无需填写<br /> .参数 层次缓存, 整数型, 可空, 层次缓存，无需填写<br /> .参数 索引缓存, 整数型, 可空, 索引缓存，无需填写<br /> .参数 结果索引缓存, 整数型, 参考 可空, 结果索引缓存，无需填写<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> <br /> .如果真 (是否为空 (数组缓存))<br />     重定义数组 (数组缓存, 假, N)<br /> .如果真结束<br /> ' m选n<br /> ' 其中level表示现在所处的第n阶段，如果是5选3，level=2，那就说明现在已经选了2个了<br /> 层次缓存 ＝ 层次缓存 ＋ 1  ' level再+1，变成level=3，  此时level = n ,那就说明已选齐3个了，加入到返回结果里面<br /> .如果 (层次缓存 ＝ N)<br />     .变量循环首 (索引缓存 ＋ 1, M, 1, i)<br />         .计次循环首 (N － 1, j)<br />             返回结果 [结果索引缓存 ＋ i － 索引缓存] [j] ＝ 数组缓存 [j]<br />         .计次循环尾 ()<br />         返回结果 [结果索引缓存 ＋ i － 索引缓存] [N] ＝ i<br />         ' 加入到返回结果里面<br />     .变量循环尾 ()<br />     结果索引缓存 ＝ 结果索引缓存 ＋ M － 索引缓存<br /> .否则<br />     .变量循环首 (索引缓存 ＋ 1, M － N ＋ 层次缓存, 1, i)<br />         数组缓存 [层次缓存] ＝ i<br />         Cmn (M, N, 返回结果, 数组缓存, 层次缓存, i, 结果索引缓存)<br />     .变量循环尾 ()<br /> .如果结束<br /> <br /> <br /> .子程序 计算数量_Cmn, 整数型, , 适用于小量 不超过整数型上限2147483647<br /> .参数 M, 整数型<br /> .参数 N, 整数型<br /> .局部变量 计次, 整数型<br /> .局部变量 因子M, 整数型<br /> .局部变量 因子N, 整数型<br /> <br /> 因子M ＝ 1<br /> 因子N ＝ 1<br /> .变量循环首 (M, M － N ＋ 1, -1, 计次)<br />     因子M ＝ 因子M × 计次<br /> .变量循环尾 ()<br /> .计次循环首 (N, 计次)<br />     因子N ＝ 因子N × 计次<br /> .计次循环尾 ()<br /> 返回 (因子M ÷ 因子N)<br /> <br /> .版本 2<br /> <br /> .数据类型 文本数组<br />     .成员 文本成员, 文本型, , "1"

[11:45:42] * “组合数量” | 28
[11:45:42] * “组合1：” | “A，B，C”
[11:45:42] * “组合2：” | “AA，B，C”
[11:45:42] * “组合3：” | “AAA，B，C”
[11:45:42] * “组合4：” | “A，B，CC”
[11:45:42] * “组合5：” | “AA，B，CC”
[11:45:42] * “组合6：” | “AAA，B，CC”
[11:45:42] * “组合7：” | “A，B，D”
[11:45:42] * “组合8：” | “AA，B，D”
[11:45:42] * “组合9：” | “AAA，B，D”
[11:45:42] * “组合10：” | “A，B，DD”
[11:45:42] * “组合11：” | “AA，B，DD”
[11:45:42] * “组合12：” | “AAA，B，DD”
[11:45:42] * “组合13：” | “A，C，D”
[11:45:42] * “组合14：” | “AA，C，D”
[11:45:42] * “组合15：” | “AAA，C，D”
[11:45:42] * “组合16：” | “A，CC，D”
[11:45:42] * “组合17：” | “AA，CC，D”
[11:45:42] * “组合18：” | “AAA，CC，D”
[11:45:42] * “组合19：” | “A，C，DD”
[11:45:42] * “组合20：” | “AA，C，DD”
[11:45:42] * “组合21：” | “AAA，C，DD”
[11:45:42] * “组合22：” | “A，CC，DD”
[11:45:42] * “组合23：” | “AA，CC，DD”
[11:45:42] * “组合24：” | “AAA，CC，DD”
[11:45:42] * “组合25：” | “B，C，D”
[11:45:42] * “组合26：” | “B，CC，D”
[11:45:42] * “组合27：” | “B，C，DD”
[11:45:42] * “组合28：” | “B，CC，DD”
[11:45:44] 被调试易程序运行完毕

anyuezhiji

anyuezhiji 发表于 2024-8-4 11:46

  

[/quote]
[e=0].版本 2

子程序名	返回值类型	公开	备 注
计算数量_Cmn	整数型		适用于小量 不超过整数型上限2147483647
参数名	类 型	参考	可空	数组	备 注
M	整数型
N	整数型

变量名	类 型	静态	数组	备 注
计次	整数型
Cmn	整数型

Cmn ＝ 1
变量循环首 (M, M － N ＋ 1, -1, 计次)
Cmn ＝ Cmn × 计次
变量循环尾 ()
计次循环首 (N, 计次)
Cmn ＝ Cmn ÷ 计次
计次循环尾 ()
返回 (Cmn)

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

.版本 2<br /> .支持库 spec</blockquote></div><br /> [e=0].版本 2<br /> <br /> <br /> <br /> .子程序 计算数量_Cmn, 整数型, , 适用于小量 不超过整数型上限2147483647<br /> .参数 M, 整数型<br /> .参数 N, 整数型<br /> .局部变量 计次, 整数型<br /> .局部变量 Cmn, 整数型<br /> <br /> Cmn ＝ 1<br /> .变量循环首 (M, M － N ＋ 1, -1, 计次)<br />     Cmn ＝ Cmn × 计次<br /> .变量循环尾 ()<br /> .计次循环首 (N, 计次)<br />     Cmn ＝ Cmn ÷ 计次<br /> .计次循环尾 ()<br /> 返回 (Cmn)

Cmn可以优化下
M选N多对多.e (971.54 KB, 下载次数: 2)

2024-8-4 12:29 上传

点击文件名下载附件
下载积分: 精币 -1 枚