|
- .版本 2
- .程序集 窗口程序集_启动窗口
- .子程序 _启动子程序, 整数型
- .局部变量 压缩前, 字节集
- .局部变量 压缩后, 字节集
- .局部变量 压缩前大小, 整数型
- .局部变量 压缩后大小, 整数型
- .局部变量 压缩率, 双精度小数型
- 压缩前 = 取重复字节集 (1000, 到字节集 (“Hello World!”))
- 压缩前大小 = 取字节集长度 (压缩前)
- 输出调试文本 (“压缩前:” + 到文本 (压缩前大小))
- 压缩后 = 数据压缩 (压缩前)
- 压缩后大小 = 取字节集长度 (压缩后)
- 输出调试文本 (“压缩后:” + 到文本 (压缩后大小))
- 压缩率 = 压缩后大小 ÷ 压缩前大小 × 100
- 输出调试文本 (“压缩率:” + 到文本 (压缩率) + “%”)
- .如果 (数据解压 (压缩后) = 压缩前)
- 输出调试文本 (“解压正确”)
- .否则
- 输出调试文本 (“解压错误”)
- .如果结束
- 返回 (0)
- .子程序 取字节集出现的字符, 字节集
- .参数 字节集数据, 字节集
- .局部变量 已出现的字符, 逻辑型, , "256"
- .局部变量 出现的字符字节型数组, 字节型, , "0"
- .局部变量 计数, 整数型
- .局部变量 出现字符数, 字节型
- .计次循环首 (取字节集长度 (字节集数据), 计数)
- .如果真 (已出现的字符 [字节集数据 [计数] + 1] = 假)
- 已出现的字符 [字节集数据 [计数] + 1] = 真
- 出现字符数 = 出现字符数 + 1
- .如果真 (出现字符数 = 0)
- 跳出循环 ()
- .如果真结束
- .如果真结束
- .计次循环尾 ()
- 返回 (逻辑型数组到字节集 (已出现的字符))
- .子程序 压缩前编码, 字节集
- .参数 俗操作的数据, 字节集
- .参数 索引表, 字节集, 参考
- .局部变量 出现的字符, 逻辑型, , "0"
- .局部变量 长度, 整数型
- .局部变量 返回值, 字节集
- .局部变量 计数, 整数型
- .局部变量 出现的字符表, 字节型, , "0"
- .局部变量 位置, 整数型
- .局部变量 计数2, 整数型
- 长度 = 取字节集长度 (俗操作的数据)
- 返回值 = 取空白字节集 (长度)
- 索引表 = 取字节集出现的字符 (俗操作的数据)
- 字节集到逻辑型数组 (索引表, 出现的字符)
- 重定义数组 (出现的字符表, 假, 256)
- .计次循环首 (256, 计数)
- .如果真 (出现的字符 [计数])
- 出现的字符表 [计数] = 计数2
- 计数2 = 计数2 + 1
- .如果真结束
- .计次循环尾 ()
- .计次循环首 (长度, 计数)
- 返回值 [计数] = 出现的字符表 [俗操作的数据 [计数] + 1]
- .计次循环尾 ()
- 返回 (返回值)
- .子程序 解压后解码, 字节集
- .参数 俗操作的数据, 字节集
- .参数 索引表, 字节集, 参考
- .局部变量 返回值, 字节集
- .局部变量 长度, 整数型
- .局部变量 出现的字符, 逻辑型, , "0"
- .局部变量 计数, 整数型
- .局部变量 出现的字符表, 字节型, , "0"
- 长度 = 取字节集长度 (俗操作的数据)
- 返回值 = 取空白字节集 (长度)
- 字节集到逻辑型数组 (索引表, 出现的字符)
- 重定义数组 (出现的字符表, 假, 0)
- .计次循环首 (256, 计数)
- .如果真 (出现的字符 [计数])
- 加入成员 (出现的字符表, 计数 - 1)
- .如果真结束
- .计次循环尾 ()
- .计次循环首 (长度, 计数)
- 返回值 [计数] = 出现的字符表 [俗操作的数据 [计数] + 1]
- .计次循环尾 ()
- 返回 (返回值)
- .子程序 内部压缩, 字节集
- .参数 数据, 字节集
- .局部变量 数据进制, 字节型
- .局部变量 计数, 整数型
- .局部变量 长度, 整数型
- 长度 = 取字节集长度 (数据)
- .如果真 (长度 = 0)
- 返回 ({ })
- .如果真结束
- .计次循环首 (取字节集长度 (数据), 计数)
- .如果真 (数据 [计数] > 数据进制)
- 数据进制 = 数据 [计数]
- .如果真 (数据进制 = 255)
- 跳出循环 ()
- .如果真结束
- .如果真结束
- .计次循环尾 ()
- .如果真 (数据进制 = 0)
- 数据进制 = 1
- .如果真结束
- 返回 (到字节集 (数据进制) + 任意进制转换 ({ 1 } + 数据, 数据进制, 255))
- .子程序 内部解压, 字节集
- .参数 数据, 字节集
- .局部变量 解压后数据, 字节集
- 解压后数据 = 任意进制转换 (取字节集右边 (数据, 取字节集长度 (数据) - 1), 255, 数据 [1])
- 返回 (取字节集右边 (解压后数据, 取字节集长度 (解压后数据) - 1))
- .子程序 数据压缩, 字节集, 公开
- .参数 数据, 字节集
- .局部变量 索引表, 字节集
- .局部变量 编码后, 字节集
- .局部变量 返回值, 字节集
- 编码后 = 压缩前编码 (数据, 索引表)
- 返回 (索引表 + 内部压缩 (编码后))
- .子程序 数据解压, 字节集, 公开
- .参数 数据, 字节集
- .局部变量 索引表, 字节集
- .局部变量 解压前数据, 字节集
- 索引表 = 取字节集左边 (数据, 32)
- 解压前数据 = 取字节集右边 (数据, 取字节集长度 (数据) - 32)
- 返回 (解压后解码 (内部解压 (解压前数据), 索引表))
- .子程序 字节集到逻辑型数组
- .参数 字节集数据, 字节集
- .参数 逻辑型数组, 逻辑型, 参考 数组
- .局部变量 字节集长度, 整数型
- .局部变量 字节集计数, 整数型
- .局部变量 移位位数计数, 整数型
- .局部变量 移位后的值, 字节型
- .局部变量 逻辑数组计数, 整数型
- 字节集长度 = 取字节集长度 (字节集数据)
- 重定义数组 (逻辑型数组, 假, 字节集长度 × 8)
- .计次循环首 (字节集长度, 字节集计数)
- .变量循环首 (0, 7, 1, 移位位数计数)
- 逻辑数组计数 = 逻辑数组计数 + 1
- 移位后的值 = 左移 (1, 移位位数计数)
- 逻辑型数组 [逻辑数组计数] = 位与 (字节集数据 [字节集计数], 移位后的值) = 移位后的值
- .变量循环尾 ()
- .计次循环尾 ()
- .子程序 逻辑型数组到字节集, 字节集
- .参数 逻辑型数组, 逻辑型, 数组
- .局部变量 逻辑组长度, 整数型
- .局部变量 字节集数据, 字节集
- .局部变量 字节集长度, 整数型
- .局部变量 计数, 整数型
- .局部变量 移位计数, 整数型
- .局部变量 逻辑计数, 整数型
- 逻辑组长度 = 取数组成员数 (逻辑型数组)
- .如果真 (逻辑组长度 % 8 ≠ 0)
- 输出调试文本 (“数组成员数必须是8的倍数才可以导出字节集数据。”)
- 返回 ({ })
- .如果真结束
- 字节集数据 = 取空白字节集 (逻辑组长度 ÷ 8)
- 字节集长度 = 取字节集长度 (字节集数据)
- .计次循环首 (字节集长度, 计数)
- .变量循环首 (0, 7, 1, 移位计数)
- .如果真 (逻辑型数组 [逻辑计数 + 1] = 真)
- 字节集数据 [计数] = 位或 (左移 (1, 移位计数), 字节集数据 [计数])
- .如果真结束
- 逻辑计数 = 逻辑计数 + 1
- .变量循环尾 ()
- .计次循环尾 ()
- 返回 (字节集数据)
- .子程序 任意进制转换, 字节集
- .参数 欲操作的数据, 字节集
- .参数 原进制, 字节型, , 2进制为1、3进制为2、256进制为255
- .参数 目标进制, 字节型
- .局部变量 计数, 整数型
- .局部变量 长度, 整数型
- .局部变量 运算值, 整数型
- .局部变量 返回值, 字节集
- .局部变量 返回值_, 字节型, , "0"
- .局部变量 数组, 字节型, , "0"
- .局部变量 原进制2, 短整数型
- .局部变量 目标进制2, 短整数型
- .如果真 (原进制 = 目标进制)
- 返回 (欲操作的数据)
- .如果真结束
- 原进制2 = 原进制 + 1
- 目标进制2 = 目标进制 + 1
- 长度 = 取字节集长度 (欲操作的数据)
- 重定义数组 (数组, 假, 长度)
- 重定义数组 (返回值_, 假, 0)
- .计次循环首 (长度, 计数)
- 数组 [计数] = 欲操作的数据 [计数]
- .如果真 (欲操作的数据 [计数] > 原进制)
- 输出调试文本 (“数据错误”)
- 返回 ({ })
- .如果真结束
- .计次循环尾 ()
- .判断循环首 (长度 ≥ 1)
- 运算值 = 0
- .计次循环首 (长度, 计数)
- 运算值 = 运算值 × 原进制2 + 数组 [计数]
- 数组 [计数] = 运算值 ÷ 目标进制2
- 运算值 = 运算值 % 目标进制2
- .计次循环尾 ()
- 加入成员 (返回值_, 运算值)
- 运算值 = 1
- .判断循环首 (运算值 ≤ 长度 且 数组 [运算值] = 0)
- 运算值 = 运算值 + 1
- .判断循环尾 ()
- 删除成员 (数组, 1, 运算值 - 1)
- 长度 = 取数组成员数 (数组)
- .判断循环尾 ()
- 长度 = 取数组成员数 (返回值_)
- 返回值 = 取空白字节集 (长度)
- .计次循环首 (长度, 计数)
- 返回值 [计数] = 返回值_ [长度 - 计数 + 1]
- .计次循环尾 ()
- 返回 (返回值)
复制代码
|
评分
-
2
查看全部评分
-
|