不定长度 另类排列

笨来无一悟

上一版本 ↓


不定长度 另类组合
https://125.confly.eu.org/forum.php?mod=viewthread&tid=14788837
(出处: 精易论坛)

问答区有人提出排列的需求于是补充一份排列的写法


不定长度 另类排列 ↓

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
数量长度不定	不定	0

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

' 自定义数据类型[数组套数组] 实现 → 不同长度数组 枚举排列
数据初始化 ()

子程序名	返回值类型	公开	备 注
数据初始化

变量名	类 型	静态	数组	备 注
N	整数型
结果	快速文本对象
缓存	文本型		0

重定义数组 (数量长度不定, 假, 5)
数量长度不定 [1].不定 ＝ 分割文本 (“1,2,3”, “,”, )
数量长度不定 [2].不定 ＝ { “2”, “4”, “6”, “8”, “10” }
数量长度不定 [3].不定 ＝ { “1”, “3”, “5”, “7”, “9”, “11”, “13”, “15”, “17”, “19”, “21” }
数量长度不定 [4].不定 ＝ { “2”, “4”, “6”, “8”, “10”, “12”, “14”, “16”, “18” }
数量长度不定 [5].不定 ＝ { “8”, “13”, “24”, “56”, “78” }
' 实际应用的时候 可以换行符分割文本 再逗号,分割 最后赋值到 [不定] 数组
重定义数组 (缓存, 假, 取数组成员数 (数量长度不定))
排列 (数量长度不定, 结果, 取数组成员数 (数量长度不定), 缓存, )
调试输出 (结果.取文本 (, ))

子程序名	返回值类型	公开	备 注
排列			支持不同长度
参数名	类 型	参考	可空	数组	备 注
原始	不定
返回	快速文本对象
总数	整数型
缓存	文本型				留空
层次	整数型				留空

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

如果真 (层次 ＜ 总数)
层次 ＝ 层次 ＋ 1
判断 (层次 ＝ 1)
计次循环首 (取数组成员数 (原始 [层次].不定), A)
缓存 [层次] ＝ 原始 [层次].不定 [A]
排列 (原始, 返回, 总数, 缓存, 层次)
计次循环尾 ()
判断 (层次 ＝ 总数)
计次循环首 (取数组成员数 (原始 [层次].不定), A)
缓存 [层次] ＝ 原始 [层次].不定 [A]
计次循环首 (总数, B)
返回.添加 (缓存 [B], “,”)
计次循环尾 ()
返回.删除字符 (返回.取长度 (), 1)
返回.添加 ( #换行符 )
' 最终的计算结果 根据实际情况 自行处理 咱就写个罗列成文本的例子
计次循环尾 ()
计次循环首 (取数组成员数 (原始 [层次].不定), A)
缓存 [层次] ＝ 原始 [层次].不定 [A]
排列 (原始, 返回, 总数, 缓存, 层次)
计次循环尾 ()

i支持库列表	支持库注释
commobj	通用对象支持库
spec	特殊功能支持库

.版本 2<br /> .支持库 commobj<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 数量长度不定, 不定, , "0"<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> ' 自定义数据类型[数组套数组] 实现 → 不同长度数组 枚举排列<br /> 数据初始化 ()<br /> <br /> .子程序 数据初始化<br /> .局部变量 N, 整数型<br /> .局部变量 结果, 快速文本对象<br /> .局部变量 缓存, 文本型, , "0"<br /> <br /> 重定义数组 (数量长度不定, 假, 5)<br /> 数量长度不定 [1].不定 ＝ 分割文本 (“1,2,3”, “,”, )<br /> 数量长度不定 [2].不定 ＝ { “2”, “4”, “6”, “8”, “10” }<br /> 数量长度不定 [3].不定 ＝ { “1”, “3”, “5”, “7”, “9”, “11”, “13”, “15”, “17”, “19”, “21” }<br /> 数量长度不定 [4].不定 ＝ { “2”, “4”, “6”, “8”, “10”, “12”, “14”, “16”, “18” }<br /> 数量长度不定 [5].不定 ＝ { “8”, “13”, “24”, “56”, “78” }<br /> <br /> ' 实际应用的时候 可以换行符分割文本 再逗号,分割 最后赋值到 [不定] 数组<br /> <br /> 重定义数组 (缓存, 假, 取数组成员数 (数量长度不定))<br /> 排列 (数量长度不定, 结果, 取数组成员数 (数量长度不定), 缓存, )<br /> 调试输出 (结果.取文本 (, ))<br /> <br /> .子程序 排列, , , 支持不同长度<br /> .参数 原始, 不定, 数组<br /> .参数 返回, 快速文本对象, 参考<br /> .参数 总数, 整数型<br /> .参数 缓存, 文本型, 可空 数组, 留空<br /> .参数 层次, 整数型, 可空, 留空<br /> .局部变量 A, 整数型<br /> .局部变量 B, 整数型<br /> <br /> .如果真 (层次 ＜ 总数)<br />     层次 ＝ 层次 ＋ 1<br /> .如果真结束<br /> .判断开始 (层次 ＝ 1)<br />     .计次循环首 (取数组成员数 (原始 [层次].不定), A)<br />         缓存 [层次] ＝ 原始 [层次].不定 [A]<br />         排列 (原始, 返回, 总数, 缓存, 层次)<br />     .计次循环尾 ()<br /> .判断 (层次 ＝ 总数)<br />     .计次循环首 (取数组成员数 (原始 [层次].不定), A)<br />         缓存 [层次] ＝ 原始 [层次].不定 [A]<br />         .计次循环首 (总数, B)<br />             返回.添加 (缓存 [B], “,”)<br />         .计次循环尾 ()<br />         返回.删除字符 (返回.取长度 (), 1)<br />         返回.添加 (#换行符)<br />         ' 最终的计算结果 根据实际情况 自行处理 咱就写个罗列成文本的例子<br />     .计次循环尾 ()<br /> .默认<br />     .计次循环首 (取数组成员数 (原始 [层次].不定), A)<br />         缓存 [层次] ＝ 原始 [层次].不定 [A]<br />         排列 (原始, 返回, 总数, 缓存, 层次)<br />     .计次循环尾 ()

  

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

.版本 2<br /> <br /> .数据类型 不定<br />     .成员 不定, 文本型, , "1", 必须数组

来自群组: 热心网友

KD飞飞

我又仔细看了一遍，坦率的讲，我没看懂，这个快速文本对象，不定，这两个类 我从来没用过是关键问题，
另外我要处理的 八个编辑框里都是中国字，而且非常多，单行单行的一个里面就有几百行，如果不用多线程的话，我感觉必死无疑哦

KD飞飞

好吧，我等下试试因为没用过这两个类，不知道我能不能研究明白

KD飞飞

卡死了

KD飞飞

哇靠我就随便测试了一下，结果被我发现，原来你才是算法上的大师啊 无可匹敌的力量~

孤胆飞鹰

牛逼啊，不愧是你啊

qqmqqg

666666666666666666

KD飞飞

这边看到py写的例子

pipicool

学习一下

wh1234567

感谢分享