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

____________

m选n ({ “A|AA|AAA”, “B”, “C”, “D” }, 3, 结果)  ' 这组应该有10种组合  33相组合      这种多对一好实现
数组:10{“A,B,C”,“AA,B,C”,“AAA,B,C”,“A,B,D”,“AA,B,D”,“AAA,B,D”,“A,C,D”,“AA,C,D”,“AAA,C,D”,“B,C,D”}


m选n ({ “A|AA|AAA”, “B|CC”, “C”, “D” }, 3, 结果)  ' 这组应该有17种组合 33相组合   这种多对多不好实现
数组:17{“A,B,C”,“AA,B,C”,“AAA,B,C”,“A,B,D”,“AA,B,D”,“AAA,B,D”,“A,C,D”,“AA,C,D”,“AAA,C,D”,“B,C,D”,“A,CC,C“,“A,CC,D“,“AA,CC,C“,“AA,CC,D“,“AAA,CC,C“,“AAA,CC,D“,“CC,C,D“}



本人想要用易语言实现，应该如和实现
不要python和js

lixiaoyao666

https://www.123pan.com/s/WEA9jv-50WNv.html?提取码:52pj
或者你自己下源码

shuisanyue

未实际验证……供参考……

[Erlang] 纯文本查看 复制代码

.版本 2

.程序集 程序集1

.子程序 m 选 n, 整数型
.参数 数据源, 文本型, , {"A|AA|AAA", "B|CC", "C", "D"}
.参数 选择数量, 整数型, 3
.参数 结果, 文本型, 引用

.局部变量 选项数组, 文本型, , "0"
.局部变量 组合数组, 文本型, , "0"
.局部变量 选项数, 整数型
.局部变量 组合数, 整数型
.局部变量 临时组合, 文本型
.局部变量 选项索引数组, 整数型, , 选择数量
.局部变量 生成的组合数量, 整数型

选项数 = 取数组成员数(数据源)
组合数 = 计算组合数(选项数, 选择数量)

.计次循环首(选项数, 索引)
    选项数组[索引] = 分割文本(数据源[索引], "|")
.计次循环尾()

初始化索引数组(选项索引数组, 0)

生成所有组合(选项数组, 选择数量, 组合数组, 选项索引数组, 生成的组合数量)

结果 = 到文本(组合数组)

输出调试文本("生成的组合数量: " + 到文本(生成的组合数量))
.如果 (生成的组合数量 = 17)
    输出调试文本("生成的组合数量正确，为 17 种")
.否则
    输出调试文本("生成的组合数量错误，预期 17 种，实际生成 " + 到文本(生成的组合数量) + " 种")
.如果结束

返回 (1)

.子程序 初始化索引数组, 无返回值, , 数组, 初始值
.局部变量 索引, 整数型
.对于 索引 = 0 到 取数组成员数(数组) - 1
    数组[索引] = 初始值
.结束对于

.子程序 生成所有组合, 无返回值, , 选项数组, 选择数量, 结果数组, 索引数组, 生成数量
.局部变量 索引, 整数型
.循环
    添加当前组合到结果(选项数组, 索引数组, 结果数组, 生成数量)
    .如果 (索引数组[选择数量 - 1] >= 取数组成员数(选项数组[选择数量 - 1]))
        .对于 索引 = 选择数量 - 1 到 0 步 -1
            索引数组[索引] = 索引数组[索引] + 1
            .如果 (索引数组[索引] < 取数组成员数(选项数组[索引]))
                退出内循环
            .如果结束
        .结束对于
    .否则
        索引数组[选择数量 - 1] = 索引数组[选择数量 - 1] + 1
    .如果结束
.循环尾()

.子程序 添加当前组合到结果, 无返回值, , 选项数组, 索引数组, 结果数组, 生成数量
.局部变量 临时组合, 文本型
.局部变量 索引, 整数型
.对于 索引 = 0 到 选择数量 - 1
    临时组合 = 临时组合 + 选项数组[索引][索引数组[索引]] + ","
.结束对于
临时组合 = 取文本左边(临时组合, 取文本长度(临时组合) - 1)
加入成员(结果数组, 临时组合)
生成数量 = 生成数量 + 1

.子程序 计算组合数, 整数型
.参数 n, 整数型
.参数 k, 整数型
.局部变量 结果, 整数型
.局部变量 i, 整数型

结果 = 1
.对于 i = 1 到 k
    结果 = 结果 * (n - i + 1) / i
.结束对于

返回 (结果)

shuisanyue

第二稿，未实际验证……供参考……

[Erlang] 纯文本查看 复制代码

.版本 2

.程序集 程序集1

.子程序 m 选 n, 整数型
.参数 数据源, 文本型,, {"A|AA|AAA", "B|CC", "C", "D"}
.参数 选择数量, 整数型, 3
.参数 结果, 文本型, 参考

.局部变量 选项数组, 文本型,, "0"
.局部变量 组合数组, 文本型,, "0"
.局部变量 选项数, 整数型
.局部变量 生成的组合数量, 整数型
.局部变量 多对多标志, 逻辑型  ' 用于标记是否为多对多组合
.局部变量 索引数组, 整数型,, 选择数量

选项数 = 取数组成员数(数据源)

.计次循环首(选项数, 索引)
    选项数组[索引] = 分割文本(数据源[索引], "|")
.计次循环尾()

生成的组合数量 = 0  ' 初始化组合数量
多对多标志 = 假  ' 初始化多对多标志

生成组合(选项数组, 选择数量, 索引数组, 组合数组, 生成的组合数量, 多对多标志)

结果 = "数组: " + 到文本(生成的组合数量) + "{"
.计次循环首(生成的组合数量, 计次)
    结果 = 结果 + 组合数组[计次] + ", "
.计次循环尾()
结果 = 取文本左边(result, 取文本长度(result) - 2) + "}"

结果 = 结果 + #换行符 + "编号: " + 到文本(生成的组合数量) + "{"
.计次循环首(生成的组合数量, 计次)
    结果 = 结果 + 组合数组[计次] + ", "
.计次循环尾()
结果 = 取文本左边(result, 取文本长度(result) - 2) + "}"

输出调试文本("生成的组合数量: " + 到文本(生成的组合数量))
.如果 (生成的组合数量 = 17)
    输出调试文本("生成的组合数量正确，为 17 种")
.否则
    输出调试文本("生成的组合数量错误，预期 17 种，实际生成 " + 到文本(生成的组合数量) + " 种")
.如果结束

.如果 (多对多标志)
    输出调试文本("这是多对多的组合")
.否则
    输出调试文本("这不是多对多的组合")
.如果结束

返回 (1)

.子程序 生成组合, 无返回值
.参数 选项数组, 文本型,, 每个元素是一个选项集合（用 "|" 分隔）
.参数 选择数量, 整数型
.参数 索引数组, 整数型,, 选择数量
.参数 组合数组, 文本型,, 引用 用于存储生成的组合
.参数 引用 生成的组合数量, 整数型
.参数 引用 多对多标志, 逻辑型

.局部变量 临时组合, 文本型
.局部变量 循环结束标志, 逻辑型

.循环
    临时组合 = ""
    循环结束标志 = 假
    创建组合(选项数组, 索引数组, 临时组合, 多对多标志)
 .如果 (临时组合 <> "")
        加入成员(组合数组, 临时组合)
        生成的组合数量 = 生成的组合数量 + 1
 .如果结束
    下一个索引(索引数组, 取数组成员数(选项数组), 循环结束标志)
  .如果 (循环结束标志)
        退出循环
  .如果结束
.循环尾()

.子程序 创建组合, 无返回值
.参数 选项数组, 文本型,, 每个元素是一个选项集合（用 "|" 分隔）
.参数 索引数组, 整数型,, 选择数量
.参数 引用 临时组合, 文本型
.参数 引用 多对多标志, 逻辑型

.局部变量 索引

.对于 索引 = 0 到 选择数量 - 1
    临时组合 = 临时组合 + 选项数组[索引][索引数组[索引]] + ", "
  .如果 (取数组成员数(选项数组[索引]) > 1)
        多对多标志 = 真
  .如果结束
.结束对于

临时组合 = 取文本左边(临时组合, 取文本长度(临时组合) - 2)

.子程序 下一个索引, 无返回值
.参数 索引数组, 整数型,, 索引数组
.参数 选项数量, 整数型
.参数 引用 循环结束标志, 逻辑型

.局部变量 索引

索引 = 选择数量 - 1
.循环
    索引数组[索引] = 索引数组[索引] + 1
  .如果 (索引数组[索引] < 取数组成员数(选项数组[索引]))
        循环结束标志 = 假
        退出循环
  .否则
        索引数组[索引] = 0
        索引 = 索引 - 1
       .如果 (索引 < 0)
            循环结束标志 = 真
            退出循环
       .如果结束
  .如果结束
.循环尾()

deng116118

未经验证，仅供参考，内容来源于GPT4o

[C] 纯文本查看 复制代码

.版本 2

.程序集 窗口程序集_主窗口

.子程序 __启动窗口_创建完毕
    .局部变量 参数1, 文本型
    .局部变量 参数2, 文本型
    .局部变量 参数3, 文本型
    .局部变量 参数4, 文本型
    .局部变量 参数5, 整数型

    参数1 ＝ “A|AA|AAA”
    参数2 ＝ “B|CC”
    参数3 ＝ “C”
    参数4 ＝ “D”
    参数5 ＝ 3

    调试输出 (组合 (参数1, 参数2, 参数3, 参数4, 参数5))

.子程序 组合, 文本型, , 文本型 参数1, 文本型 参数2, 文本型 参数3, 文本型 参数4, 整数型 参数5
.局部变量 结果数组, 文本型, , 0
.局部变量 组合数组1, 文本型, , 0
.局部变量 组合数组2, 文本型, , 0
.局部变量 是多对多, 逻辑型

    .如果 (找到文本 (参数2, "|", 1) ＞ 0)
        是多对多 ＝ 真
    .否则
        是多对多 ＝ 假
    .如果结束

    组合数组1 ＝ 全排列组合 (分割文本 (参数1, "|"))

    .如果 (是多对多)
        组合数组2 ＝ 全排列组合 (分割文本 (参数2, "|"))
        结果数组 ＝ 多对多组合生成 (组合数组1, 组合数组2, 参数3, 参数4)
    .否则
        结果数组 ＝ 多对一组合生成 (组合数组1, 参数2, 参数3, 参数4)
    .如果结束

    返回 (结果数组)

.子程序 多对一组合生成, 文本型, , 文本型 数组1, 文本型 参数2, 文本型 参数3, 文本型 参数4
.局部变量 结果数组, 文本型, , 10
.局部变量 索引, 整数型
.局部变量 计数, 整数型

    计数 ＝ 0
    .计次循环首 (取数组成员数 (数组1), 索引)
        结果数组 [计数] ＝ 数组1 [索引 - 1] ＋ “,” ＋ 参数2 ＋ “,” ＋ 参数3
        计数 ＋＝ 1
        结果数组 [计数] ＝ 数组1 [索引 - 1] ＋ “,” ＋ 参数2 ＋ “,” ＋ 参数4
        计数 ＋＝ 1
        结果数组 [计数] ＝ 数组1 [索引 - 1] ＋ “,” ＋ 参数3 ＋ “,” ＋ 参数4
        计数 ＋＝ 1
    .计次循环尾 ()

    返回 (结果数组)

.子程序 多对多组合生成, 文本型, , 文本型 数组1, 文本型 数组2, 文本型 参数3, 文本型 参数4
.局部变量 结果数组, 文本型, , 17
.局部变量 索引1, 整数型
.局部变量 索引2, 整数型
.局部变量 计数, 整数型

    计数 ＝ 0
    .计次循环首 (取数组成员数 (数组1), 索引1)
        .计次循环首 (取数组成员数 (数组2), 索引2)
            结果数组 [计数] ＝ 数组1 [索引1 - 1] ＋ “,” ＋ 数组2 [索引2 - 1] ＋ “,” ＋ 参数3
            计数 ＋＝ 1
            结果数组 [计数] ＝ 数组1 [索引1 - 1] ＋ “,” ＋ 数组2 [索引2 - 1] ＋ “,” ＋ 参数4
            计数 ＋＝ 1
        .计次循环尾 ()
    .计次循环尾 ()

    .计次循环首 (取数组成员数 (数组2), 索引2)
        结果数组 [计数] ＝ 数组2 [索引2 - 1] ＋ “,” ＋ 参数3 ＋ “,” ＋ 参数4
        计数 ＋＝ 1
    .计次循环尾 ()

    返回 (结果数组)

.子程序 全排列组合, 文本型, , 文本型 数组1
.局部变量 组合数组, 文本型, , 0
.局部变量 索引, 整数型

    .计次循环首 (取数组成员数 (数组1), 索引)
        调用 组合数组.添加 (数组1 [索引 - 1])
    .计次循环尾 ()

    返回 (组合数组)

[C] 纯文本查看 复制代码

.版本 2

.程序集 窗口程序集_主窗口

.子程序 __启动窗口_创建完毕
    .局部变量 参数1, 文本型
    .局部变量 参数2, 文本型
    .局部变量 参数3, 文本型
    .局部变量 参数4, 文本型
    .局部变量 参数5, 整数型

    参数1 ＝ “A|AA|AAA”
    参数2 ＝ “B|CC”
    参数3 ＝ “C”
    参数4 ＝ “D”
    参数5 ＝ 3

    调试输出 (组合 (参数1, 参数2, 参数3, 参数4, 参数5))

.子程序 组合, 文本型, , 文本型 参数1, 文本型 参数2, 文本型 参数3, 文本型 参数4, 整数型 参数5
.局部变量 所有参数数组, 文本型, , 0
.局部变量 结果数组, 文本型, , 0
.局部变量 临时数组, 文本型, , 0
.局部变量 是多对多, 逻辑型

    所有参数数组 ＝ 取所有参数数组 (参数1, 参数2, 参数3, 参数4)
    是多对多 ＝ 假
   
    .计次循环首 (取数组成员数 (所有参数数组), 索引)
        .如果 (找到文本 (所有参数数组 [索引 - 1], "|", 1) ＞ 0)
            是多对多 ＝ 真
            .退出循环 ()
        .如果结束
    .计次循环尾 ()
   
    .如果 (是多对多)
        结果数组 ＝ 生成多对多组合 (所有参数数组, 参数5)
    .否则
        结果数组 ＝ 生成多对一组合 (所有参数数组, 参数5)
    .如果结束

    返回 (结果数组)

.子程序 取所有参数数组, 文本型, , 文本型 参数1, 文本型 参数2, 文本型 参数3, 文本型 参数4
.局部变量 所有参数数组, 文本型, , 0

    调用 所有参数数组.添加 (参数1)
    调用 所有参数数组.添加 (参数2)
    调用 所有参数数组.添加 (参数3)
    调用 所有参数数组.添加 (参数4)

    返回 (所有参数数组)

.子程序 生成多对一组合, 文本型, , 文本型 所有参数数组, 整数型 参数5
.局部变量 结果数组, 文本型, , 0
.局部变量 临时数组, 文本型, , 0
.局部变量 索引, 整数型
.局部变量 组合结果, 文本型, , 0

    临时数组 ＝ 全排列组合 (所有参数数组, 参数5)
   
    .计次循环首 (取数组成员数 (临时数组), 索引)
        调用 结果数组.添加 (临时数组 [索引 - 1])
    .计次循环尾 ()

    返回 (结果数组)

.子程序 生成多对多组合, 文本型, , 文本型 所有参数数组, 整数型 参数5
.局部变量 结果数组, 文本型, , 0
.局部变量 临时数组, 文本型, , 0
.局部变量 临时数组2, 文本型, , 0
.局部变量 索引, 整数型
.局部变量 索引2, 整数型
.局部变量 组合结果, 文本型, , 0

    临时数组 ＝ 全排列组合 (所有参数数组, 参数5)
   
    .计次循环首 (取数组成员数 (临时数组), 索引)
        临时数组2 ＝ 分割文本 (临时数组 [索引 - 1], ",")
        .计次循环首 (取数组成员数 (临时数组2), 索引2)
            .如果 (找到文本 (临时数组2 [索引2 - 1], "|", 1) ＞ 0)
                临时数组2 ＝ 全排列组合 (分割文本 (临时数组2 [索引2 - 1], "|"))
                .计次循环首 (取数组成员数 (临时数组2), 索引2)
                    调用 结果数组.添加 (临时数组2 [索引2 - 1])
                .计次循环尾 ()
            .否则
                调用 结果数组.添加 (临时数组2 [索引2 - 1])
            .如果结束
        .计次循环尾 ()
    .计次循环尾 ()

    返回 (结果数组)

.子程序 全排列组合, 文本型, , 文本型 数组1, 整数型 数量
.局部变量 组合数组, 文本型, , 0
.局部变量 临时数组, 文本型, , 0
.局部变量 索引, 整数型

    .计次循环首 (取数组成员数 (数组1), 索引)
        .如果 (数量 ＝ 1)
            调用 组合数组.添加 (数组1 [索引 - 1])
        .否则
            临时数组 ＝ 全排列组合 (数组1, 数量 - 1)
            .计次循环首 (取数组成员数 (临时数组), 索引2)
                调用 组合数组.添加 (数组1 [索引 - 1] ＋ "," ＋ 临时数组 [索引2 - 1])
            .计次循环尾 ()
        .如果结束
    .计次循环尾 ()

    返回 (组合数组)

第二次生成的代码

lixiaoyao666

代码：

.版本 2
.支持库 spec

.子程序 __启动窗口_创建完毕
.局部变量 待选选项, 文本型, , "4"
.局部变量 选取数, 整数型
.局部变量 组合结果, 文本型, , "0"
.局部变量 计次, 整数型
.局部变量 组合数量, 整数型

待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }
选取数 ＝ 3

多对多M选N (待选选项, 3, 组合结果, 组合数量)
调试输出 (“组合数量”, 组合数量)
重定义数组 (组合结果, 真, 组合数量, 选取数)
.计次循环首 (组合数量, 计次)
调试输出 (“组合” ＋ 到文本 (计次) ＋ “：”, 组合结果 [计次] [1], 组合结果 [计次] [2], 组合结果 [计次] [3])
.计次循环尾 ()

.子程序 多对多M选N
.参数 待选选项, 文本型, 数组
.参数 选取数, 整数型
.参数 组合结果, 文本型, 参考 数组
.参数 组合数量, 整数型, 参考
.局部变量 结果_Cmn, 整数型, , "1,1"
.局部变量 数量_Cmn, 整数型
.局部变量 计次, 整数型
.局部变量 待选选项组, 文本数组, , "0"
.局部变量 选项组长度, 整数型, , "0"
.局部变量 待选长度, 整数型
.局部变量 计次2, 整数型
.局部变量 组合数, 整数型
.局部变量 索引, 整数型
.局部变量 临时, 整数型
.局部变量 计次3, 整数型
.局部变量 临时选项, 文本型, , "0"

清除数组 (组合结果)
待选长度 ＝ 取数组成员数 (待选选项)
数量_Cmn ＝ 计算数量_Cmn (待选长度, 选取数)
重定义数组 (结果_Cmn, 假, 数量_Cmn, 选取数)
Cmn (待选长度, 选取数, 结果_Cmn, )
重定义数组 (待选选项组, 假, 待选长度)
重定义数组 (选项组长度, 假, 待选长度)
重定义数组 (临时选项, 假, 选取数)
.计次循环首 (待选长度, 计次)
文本_分割文本 (待选选项 [计次], “|”, , 待选选项组 [计次].文本成员)
选项组长度 [计次] ＝ 取数组成员数 (待选选项组 [计次].文本成员)
.计次循环尾 ()
组合数量 ＝ 0
.计次循环首 (待选长度, 计次)
组合数 ＝ 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)

运行结果：

[09:27:14] * “组合数量” | 17
[09:27:14] * “组合1：” | “A” | “B” | “C”
[09:27:14] * “组合2：” | “AA” | “B” | “C”
[09:27:14] * “组合3：” | “AAA” | “B” | “C”
[09:27:14] * “组合4：” | “A” | “CC” | “C”
[09:27:14] * “组合5：” | “AA” | “CC” | “C”
[09:27:14] * “组合6：” | “AAA” | “CC” | “C”
[09:27:14] * “组合7：” | “A” | “B” | “D”
[09:27:14] * “组合8：” | “AA” | “B” | “D”
[09:27:14] * “组合9：” | “AAA” | “B” | “D”
[09:27:14] * “组合10：” | “A” | “CC” | “D”
[09:27:14] * “组合11：” | “AA” | “CC” | “D”
[09:27:14] * “组合12：” | “AAA” | “CC” | “D”
[09:27:14] * “组合13：” | “A” | “C” | “D”
[09:27:14] * “组合14：” | “AA” | “C” | “D”
[09:27:14] * “组合15：” | “AAA” | “C” | “D”
[09:27:14] * “组合16：” | “B” | “C” | “D”
[09:27:14] * “组合17：” | “CC” | “C” | “D”

lixiaoyao666

lixiaoyao666 发表于 2024-8-4 09:29
代码：

运行结果：

用Python实现贼简单，但用易语言挺烦的

lixiaoyao666

lixiaoyao666 发表于 2024-8-4 09:29
代码：

运行结果：

.版本 2

.数据类型 文本数组
    .成员 文本成员, 文本型, , "1"

需要补一个自定义数据类型才能正常运行

____________

lixiaoyao666 发表于 2024-8-4 10:22
需要补一个自定义数据类型才能正常运行

待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }选取数 ＝ 2  数组越界  实际应有24种组合
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }选取数 ＝3   调试输出24种组合 实际应有34种组合
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }选取数 ＝ 2  数组越界  实际应有17种组合
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D” }选取数 ＝ 4  数组越界  实际应有6种组合

lixiaoyao666

____________ 发表于 2024-8-4 13:55
待选选项 ＝ { “A|AA|AAA”, “B|CC”, “C”, “D”, “E” }选取数 ＝ 2  数组越界  实际应有24种组合 ...

我测试下看看