不定长度 另类排列

笨来无一悟

上一版本 ↓


不定长度 另类组合
https://bbs.125.la/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", 必须数组

来自群组: 热心网友

lxn2wyf

这标题挺有意思啊，不定长度的另类排列，感觉像是编程里的新玩法呢，去看看详情哈。

麦八

支持开源~！感谢分享

please

感谢分享，支持开源！！！

夜曦丫

感谢楼主啊！

kyo9766

学习一下排序，感谢分享

year1970

感谢分享

查过

感谢楼主分享！

豆豆灰常开心

感谢发布原创作品，精易因你更精彩！6666666666666

wh1234567

感谢分享