不重复组合

likainan888

数组{"A","B","C","D"}   4个数组
数组{"A","B","C","D","E"}   5个数组


比如有4个文本数组  生成  不重复组合有  24个组合  

比如有5个文本数组  生成  不重复组合有  120 个组合  




在论坛找了个例子   但是  数组多的话就蹦了  或者卡死  就不行了   

有没有  好的方法  稳定  快速  

qcby

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
结果数组	文本型	0

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

启动线程 (&子程序22, , )

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

变量名	类 型	静态	数组	备 注
输入数组	文本型		0
数组大小	整数型
i	整数型

输入数组 ＝ { “A”, “B”, “C”, “D”, “E”, “F”, “G”, “H” }
数组大小 ＝ 取数组下标 (输入数组, )
排列组合 (输入数组, 0, 数组大小 － 1)
调试输出 (取数组成员数 (结果数组))

子程序名	返回值类型	公开	备 注
排列组合			生成所有不重复的排列组合
参数名	类 型	参考	可空	数组	备 注
数组	文本型
开始位置	整数型
结束位置	整数型

变量名	类 型	静态	数组	备 注
i	整数型
临时	文本型

如果真 (开始位置 ＝ 结束位置)
加入成员 (结果数组, 数组到文本 (数组, “”))

计次循环首 (结束位置 － 开始位置 ＋ 1, i)
交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)
排列组合 (数组, 开始位置 ＋ 1, 结束位置)
交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
交换元素			交换数组中的两个元素
参数名	类 型	参考	可空	数组	备 注
数组	文本型
i	整数型
j	整数型

变量名	类 型	静态	数组	备 注
临时	文本型

临时 ＝ 数组 [i ＋ 1]
数组 [i ＋ 1] ＝ 数组 [j ＋ 1]
数组 [j ＋ 1] ＝ 临时

子程序名	返回值类型	公开	备 注
数组到文本	文本型		将数组转换为字符串
参数名	类 型	参考	可空	数组	备 注
数组	文本型
分隔符	文本型

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

计次循环首 (取数组下标 (数组, ), i)
结果 ＝ 结果 ＋ 数组 [i] ＋ 分隔符
计次循环尾 ()
返回 (取文本左边 (结果, 取文本长度 (结果) － 取文本长度 (分隔符)))

i支持库列表	支持库注释
EThread	多线程支持库
spec	特殊功能支持库

.版本 2<br /> .支持库 EThread<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 结果数组, 文本型, , "0"<br /> <br /> .子程序 _按钮1_被单击<br /> <br /> 启动线程 (&子程序22, , )<br /> <br /> .子程序 子程序22, , , 本子程序在程序启动后最先执行<br /> .局部变量 输入数组, 文本型, , "0"<br /> .局部变量 数组大小, 整数型<br /> .局部变量 i, 整数型<br /> <br /> 输入数组 ＝ { “A”, “B”, “C”, “D”, “E”, “F”, “G”, “H” }<br /> 数组大小 ＝ 取数组下标 (输入数组, )<br /> 排列组合 (输入数组, 0, 数组大小 － 1)<br /> 调试输出 (取数组成员数 (结果数组))<br /> <br /> <br /> .子程序 排列组合, , , 生成所有不重复的排列组合<br /> .参数 数组, 文本型, 数组<br /> .参数 开始位置, 整数型<br /> .参数 结束位置, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 临时, 文本型<br /> <br /> .如果真 (开始位置 ＝ 结束位置)<br />     加入成员 (结果数组, 数组到文本 (数组, “”))<br /> .如果真结束<br /> <br /> .计次循环首 (结束位置 － 开始位置 ＋ 1, i)<br /> <br />     交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)<br /> <br />     排列组合 (数组, 开始位置 ＋ 1, 结束位置)<br /> <br />     交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)<br /> <br /> .计次循环尾 ()<br /> <br /> <br /> .子程序 交换元素, , , 交换数组中的两个元素<br /> .参数 数组, 文本型, 数组<br /> .参数 i, 整数型<br /> .参数 j, 整数型<br /> .局部变量 临时, 文本型<br /> <br /> 临时 ＝ 数组 [i ＋ 1]<br /> <br /> 数组 [i ＋ 1] ＝ 数组 [j ＋ 1]<br /> <br /> 数组 [j ＋ 1] ＝ 临时<br /> <br /> <br /> .子程序 数组到文本, 文本型, , 将数组转换为字符串<br /> .参数 数组, 文本型, 数组<br /> .参数 分隔符, 文本型<br /> .局部变量 结果, 文本型<br /> .局部变量 i, 整数型<br /> <br /> .计次循环首 (取数组下标 (数组, ), i)<br />     结果 ＝ 结果 ＋ 数组 <i> ＋ 分隔符<br /> .计次循环尾 ()<br /> 返回 (取文本左边 (结果, 取文本长度 (结果) － 取文本长度 (分隔符)))

likainan888

  

子程序名	返回值类型	公开	备 注
生成不重复数据
参数名	类 型	参考	可空	数组	备 注
P_前缀	文本型
P_数组	文本型
P_结果	文本型

变量名	类 型	静态	数组	备 注
L_前缀	文本型
临时数组	文本型		0
n	整数型

如果真 (取数组成员数 (P_数组) ＝ 1)
L_前缀 ＝ P_前缀 ＋ P_数组 [1]
加入成员 (P_结果, L_前缀)
返回 ()

计次循环首 (取数组成员数 (P_数组), n)
临时数组 ＝ P_数组
L_前缀 ＝ P_前缀 ＋ 临时数组 [n]
删除成员 (临时数组, n, 1)
生成不重复数据 (L_前缀, 临时数组, P_结果)
计次循环尾 ()
返回 ()

.版本 2<br /> <br /> .子程序 生成不重复数据<br /> .参数 P_前缀, 文本型<br /> .参数 P_数组, 文本型, 数组<br /> .参数 P_结果, 文本型, 参考 数组<br /> .局部变量 L_前缀, 文本型<br /> .局部变量 临时数组, 文本型, , "0"<br /> .局部变量 n, 整数型<br /> <br /> .如果真 (取数组成员数 (P_数组) ＝ 1)<br />     L_前缀 ＝ P_前缀 ＋ P_数组 [1]<br />     加入成员 (P_结果, L_前缀)<br />     返回 ()<br /> .如果真结束<br /> <br /> .计次循环首 (取数组成员数 (P_数组), n)<br />     临时数组 ＝ P_数组<br />     L_前缀 ＝ P_前缀 ＋ 临时数组 [n]<br />     删除成员 (临时数组, n, 1)<br />     生成不重复数据 (L_前缀, 临时数组, P_结果)<br /> .计次循环尾 ()<br /> 返回 ()

这个是我在论坛找了一个   生成的结果符合我  但是  数组多了就不行了

ll2001

.版本 2  .子程序 _按钮1_被单击, , , ‘最终版的 .局部变量 USL, 双精度小数型 .局部变量 LSL, 双精度小数型 .局部变量 中心值, 双精度小数型 .局部变量 标准差, 双精度小数型 .局部变量 i, 整数型 .局部变量 u1, 双精度小数型 .局部变量 u2, 双精度小数型 .局部变量 z, 双精度小数型 .局部变量 临时数值, 双精度小数型 .局部变量 结果文本, 文本型 .局部变量 小数位数, 整数型 .局部变量 目标Cpk, 双精度小数型 .局部变量 行, 整数型 .局部变量 列, 整数型 .局部变量 索引, 整数型 .局部变量 数值文本, 文本型 .局部变量 结果文本5, 文本型  ' 【1. 获取输入并验证】 USL ＝ 到数值 (编辑框1.内容) LSL ＝ 到数值 (编辑框2.内容) 小数位数 ＝ 到整数 (编辑框4.内容) .如果真 (USL ≤ LSL)     信息框 (“最大值必须大于最小值！”, 0, “错误”, )     返回 () .如果真结束  .如果真 (小数位数 ＜ 0 或 小数位数 ＞ 10)     小数位数 ＝ 2  ' 设置默认值 .如果真结束  ' 【2. 计算目标均值和标准差】 中心值 ＝ (USL ＋ LSL) ÷ 2 目标Cpk ＝ 1.85  ' 设置在1.8-1.9之间 标准差 ＝ (USL － LSL) ÷ (6 × 目标Cpk)  ' 【3. 生成随机数并存储到数组】 置随机数种子 ()  ' 初始化随机数生成器 .计次循环首 (125, i)     u1 ＝ 取随机数 (1, 10000) ÷ 10000     u2 ＝ 取随机数 (1, 10000) ÷ 10000     ' 使用Box-Muller变换生成标准正态分布随机数     z ＝ 求平方根 (-2 × 求自然对数 (u1)) × 求余弦 (2 × 3.141592653589 × u2)     临时数值 ＝ 中心值 ＋ 标准差 × z     生成数值数组 [i] ＝ 临时数值  ' 存储到程序集数组 .计次循环尾 ()  ' 【4. 为编辑框3构建竖向文本（每行一个数字）】 结果文本 ＝ “” .计次循环首 (125, i)     .如果真 (小数位数 ＝ 0)         结果文本 ＝ 结果文本 ＋ 到文本 (到整数 (生成数值数组 [i])) ＋ #换行符     .如果真结束     .如果真 (小数位数 ＞ 0)         结果文本 ＝ 结果文本 ＋ 数值到格式文本 (生成数值数组 [i], 小数位数, 假) ＋ #换行符     .如果真结束  .计次循环尾 () 编辑框3.内容 ＝ 结果文本

ll2001

.版本 2

.子程序 _按钮1_被单击, , , ‘最终版的
.局部变量 USL, 双精度小数型
.局部变量 LSL, 双精度小数型
.局部变量 中心值, 双精度小数型
.局部变量 标准差, 双精度小数型
.局部变量 i, 整数型
.局部变量 u1, 双精度小数型
.局部变量 u2, 双精度小数型
.局部变量 z, 双精度小数型
.局部变量 临时数值, 双精度小数型
.局部变量 结果文本, 文本型
.局部变量 小数位数, 整数型
.局部变量 目标Cpk, 双精度小数型
.局部变量 行, 整数型
.局部变量 列, 整数型
.局部变量 索引, 整数型
.局部变量 数值文本, 文本型
.局部变量 结果文本5, 文本型

' 【1. 获取输入并验证】
USL ＝ 到数值 (编辑框1.内容)
LSL ＝ 到数值 (编辑框2.内容)
小数位数 ＝ 到整数 (编辑框4.内容)
.如果真 (USL ≤ LSL)
    信息框 (“最大值必须大于最小值！”, 0, “错误”, )
    返回 ()
.如果真结束

.如果真 (小数位数 ＜ 0 或 小数位数 ＞ 10)
    小数位数 ＝ 2  ' 设置默认值
.如果真结束

' 【2. 计算目标均值和标准差】
中心值 ＝ (USL ＋ LSL) ÷ 2
目标Cpk ＝ 1.85  ' 设置在1.8-1.9之间
标准差 ＝ (USL － LSL) ÷ (6 × 目标Cpk)

' 【3. 生成随机数并存储到数组】
置随机数种子 ()  ' 初始化随机数生成器
.计次循环首 (125, i)
    u1 ＝ 取随机数 (1, 10000) ÷ 10000
    u2 ＝ 取随机数 (1, 10000) ÷ 10000
    ' 使用Box-Muller变换生成标准正态分布随机数
    z ＝ 求平方根 (-2 × 求自然对数 (u1)) × 求余弦 (2 × 3.141592653589 × u2)
    临时数值 ＝ 中心值 ＋ 标准差 × z
    生成数值数组 [i] ＝ 临时数值  ' 存储到程序集数组
.计次循环尾 ()

' 【4. 为编辑框3构建竖向文本（每行一个数字）】
结果文本 ＝ “”
.计次循环首 (125, i)
    .如果真 (小数位数 ＝ 0)
        结果文本 ＝ 结果文本 ＋ 到文本 (到整数 (生成数值数组 [i])) ＋ #换行符
    .如果真结束
    .如果真 (小数位数 ＞ 0)
        结果文本 ＝ 结果文本 ＋ 数值到格式文本 (生成数值数组 [i], 小数位数, 假) ＋ #换行符
    .如果真结束

.计次循环尾 ()
编辑框3.内容 ＝ 结果文本  可以参考一下

qcby

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_窗口1
变量名	类 型	数组	备 注
计数	整数型

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

启动线程 (&生成排列组合, , )

子程序名	返回值类型	公开	备 注
生成排列组合

变量名	类 型	静态	数组	备 注
输入数组	文本型		0
数组大小	整数型
开始时间	长整数型
结束时间	长整数型

开始时间 ＝ 系统_取启动时间 ()
输入数组 ＝ { “A”, “B”, “C”, “D”, “E”, “F”, “G”, “H”, “I”, “J”, “K” }
数组大小 ＝ 取数组下标 (输入数组, )
排列组合 (输入数组, 0, 数组大小 － 1)
结束时间 ＝ 系统_取启动时间 () － 开始时间
调试输出 (“总排列数:”, 计数, “用时：”, 结束时间 ÷ 1000)

子程序名	返回值类型	公开	备 注
排列组合
参数名	类 型	参考	可空	数组	备 注
数组	文本型
开始位置	整数型
结束位置	整数型

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

如果真 (开始位置 ＝ 结束位置)
计数 ＝ 计数 ＋ 1
返回 ()

计次循环首 (结束位置 － 开始位置 ＋ 1, i)
交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)
排列组合 (数组, 开始位置 ＋ 1, 结束位置)
交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
交换元素
参数名	类 型	参考	可空	数组	备 注
数组	文本型
i	整数型
j	整数型

变量名	类 型	静态	数组	备 注
临时	文本型

临时 ＝ 数组 [i ＋ 1]
数组 [i ＋ 1] ＝ 数组 [j ＋ 1]
数组 [j ＋ 1] ＝ 临时

i支持库列表	支持库注释
EThread	多线程支持库
spec	特殊功能支持库

.版本 2<br /> .支持库 EThread<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_窗口1<br /> .程序集变量 计数, 整数型<br /> <br /> .子程序 _窗口1_创建完毕<br /> <br /> 启动线程 (&生成排列组合, , )<br /> <br /> .子程序 生成排列组合<br /> .局部变量 输入数组, 文本型, , "0"<br /> .局部变量 数组大小, 整数型<br /> .局部变量 开始时间, 长整数型<br /> .局部变量 结束时间, 长整数型<br /> <br /> 开始时间 ＝ 系统_取启动时间 ()<br /> <br /> 输入数组 ＝ { “A”, “B”, “C”, “D”, “E”, “F”, “G”, “H”, “I”, “J”, “K” }<br /> <br /> 数组大小 ＝ 取数组下标 (输入数组, )<br /> <br /> 排列组合 (输入数组, 0, 数组大小 － 1)<br /> 结束时间 ＝ 系统_取启动时间 () － 开始时间<br /> <br /> 调试输出 (“总排列数:”, 计数, “用时：”, 结束时间 ÷ 1000)<br /> <br /> <br /> .子程序 排列组合<br /> .参数 数组, 文本型, 数组<br /> .参数 开始位置, 整数型<br /> .参数 结束位置, 整数型<br /> .局部变量 i, 整数型<br /> <br /> .如果真 (开始位置 ＝ 结束位置)<br /> <br />     计数 ＝ 计数 ＋ 1<br /> <br />     返回 ()<br /> .如果真结束<br /> <br /> .计次循环首 (结束位置 － 开始位置 ＋ 1, i)<br /> <br />     交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)<br /> <br />     排列组合 (数组, 开始位置 ＋ 1, 结束位置)<br /> <br />     交换元素 (数组, 开始位置, 开始位置 ＋ i － 1)<br /> <br /> .计次循环尾 ()<br /> <br /> .子程序 交换元素<br /> .参数 数组, 文本型, 数组<br /> .参数 i, 整数型<br /> .参数 j, 整数型<br /> .局部变量 临时, 文本型<br /> <br /> 临时 ＝ 数组 [i ＋ 1]<br /> <br /> 数组 [i ＋ 1] ＝ 数组 [j ＋ 1]<br /> <br /> 数组 [j ＋ 1] ＝ 临时

[14:37:56] * 开始运行被调试程序
[14:39:55] * “总排列数:” | 39916800 | “用时：” | 118.295000

数组越多时间越长，递归算法的瓶颈在于算法复杂度(O(n!))而非语言执行效率
如果需要处理大量数据，建议：
a) 使用C++等高性能语言重写
b) 采用并行计算(多线程/GPU)
c) 使用专门的组合数学库

你美得老子心碎

直接调用js吧

呵呵仙

https://bbs.ijingyi.com/thread-14865949-1-1.html
试下这个编译为64位软件,看下会蹦不?