10多KB的源码实现超简单数据无损压缩解压算法V1.0 - 纯核心库实现无需DLL

CNWTEPRG

1. 
   
2. .版本 2
   
3. 
   
4. .程序集 窗口程序集_启动窗口
   
5. 
   
6. .子程序 _启动子程序, 整数型
   
7. .局部变量 压缩前, 字节集
   
8. .局部变量 压缩后, 字节集
   
9. .局部变量 压缩前大小, 整数型
   
10. .局部变量 压缩后大小, 整数型
    
11. .局部变量 压缩率, 双精度小数型
    
12. 
    
13. 压缩前 ＝ 取重复字节集 (1000, 到字节集 (“Hello World!”))
    
14. 压缩前大小 ＝ 取字节集长度 (压缩前)
    
15. 输出调试文本 (“压缩前:” ＋ 到文本 (压缩前大小))
    
16. 压缩后 ＝ 数据压缩 (压缩前)
    
17. 压缩后大小 ＝ 取字节集长度 (压缩后)
    
18. 输出调试文本 (“压缩后:” ＋ 到文本 (压缩后大小))
    
19. 压缩率 ＝ 压缩后大小 ÷ 压缩前大小 × 100
    
20. 输出调试文本 (“压缩率:” ＋ 到文本 (压缩率) ＋ “%”)
    
21. 
    
22. .如果 (数据解压 (压缩后) ＝ 压缩前)
    
23.     输出调试文本 (“解压正确”)
    
24. .否则
    
25.     输出调试文本 (“解压错误”)
    
26. .如果结束
    
27. 
    
28. 
    
29. 返回 (0)
    
30. 
    
31. .子程序 取字节集出现的字符, 字节集
    
32. .参数 字节集数据, 字节集
    
33. .局部变量 已出现的字符, 逻辑型, , "256"
    
34. .局部变量 出现的字符字节型数组, 字节型, , "0"
    
35. .局部变量 计数, 整数型
    
36. .局部变量 出现字符数, 字节型
    
37. 
    
38. .计次循环首 (取字节集长度 (字节集数据), 计数)
    
39.     .如果真 (已出现的字符 [字节集数据 [计数] ＋ 1] ＝ 假)
    
40.         已出现的字符 [字节集数据 [计数] ＋ 1] ＝ 真
    
41.         出现字符数 ＝ 出现字符数 ＋ 1
    
42.         .如果真 (出现字符数 ＝ 0)
    
43.             跳出循环 ()
    
44.         .如果真结束
    
45. 
    
46.     .如果真结束
    
47. 
    
48. .计次循环尾 ()
    
49. 返回 (逻辑型数组到字节集 (已出现的字符))
    
50. 
    
51. .子程序 压缩前编码, 字节集
    
52. .参数 俗操作的数据, 字节集
    
53. .参数 索引表, 字节集, 参考
    
54. .局部变量 出现的字符, 逻辑型, , "0"
    
55. .局部变量 长度, 整数型
    
56. .局部变量 返回值, 字节集
    
57. .局部变量 计数, 整数型
    
58. .局部变量 出现的字符表, 字节型, , "0"
    
59. .局部变量 位置, 整数型
    
60. .局部变量 计数2, 整数型
    
61. 
    
62. 长度 ＝ 取字节集长度 (俗操作的数据)
    
63. 返回值 ＝ 取空白字节集 (长度)
    
64. 索引表 ＝ 取字节集出现的字符 (俗操作的数据)
    
65. 字节集到逻辑型数组 (索引表, 出现的字符)
    
66. 重定义数组 (出现的字符表, 假, 256)
    
67. .计次循环首 (256, 计数)
    
68.     .如果真 (出现的字符 [计数])
    
69.         出现的字符表 [计数] ＝ 计数2
    
70.         计数2 ＝ 计数2 ＋ 1
    
71.     .如果真结束
    
72. 
    
73. .计次循环尾 ()
    
74. .计次循环首 (长度, 计数)
    
75.     返回值 [计数] ＝ 出现的字符表 [俗操作的数据 [计数] ＋ 1]
    
76. .计次循环尾 ()
    
77. 返回 (返回值)
    
78. 
    
79. 
    
80. .子程序 解压后解码, 字节集
    
81. .参数 俗操作的数据, 字节集
    
82. .参数 索引表, 字节集, 参考
    
83. .局部变量 返回值, 字节集
    
84. .局部变量 长度, 整数型
    
85. .局部变量 出现的字符, 逻辑型, , "0"
    
86. .局部变量 计数, 整数型
    
87. .局部变量 出现的字符表, 字节型, , "0"
    
88. 
    
89. 长度 ＝ 取字节集长度 (俗操作的数据)
    
90. 返回值 ＝ 取空白字节集 (长度)
    
91. 字节集到逻辑型数组 (索引表, 出现的字符)
    
92. 重定义数组 (出现的字符表, 假, 0)
    
93. .计次循环首 (256, 计数)
    
94.     .如果真 (出现的字符 [计数])
    
95.         加入成员 (出现的字符表, 计数 － 1)
    
96.     .如果真结束
    
97. 
    
98. .计次循环尾 ()
    
99. .计次循环首 (长度, 计数)
    
100.     返回值 [计数] ＝ 出现的字符表 [俗操作的数据 [计数] ＋ 1]
     
101. .计次循环尾 ()
     
102. 返回 (返回值)
     
103. 
     
104. 
     
105. .子程序 内部压缩, 字节集
     
106. .参数 数据, 字节集
     
107. .局部变量 数据进制, 字节型
     
108. .局部变量 计数, 整数型
     
109. .局部变量 长度, 整数型
     
110. 
     
111. 长度 ＝ 取字节集长度 (数据)
     
112. .如果真 (长度 ＝ 0)
     
113.     返回 ({  })
     
114. .如果真结束
     
115. .计次循环首 (取字节集长度 (数据), 计数)
     
116.     .如果真 (数据 [计数] ＞ 数据进制)
     
117.         数据进制 ＝ 数据 [计数]
     
118.         .如果真 (数据进制 ＝ 255)
     
119.             跳出循环 ()
     
120.         .如果真结束
     
121. 
     
122.     .如果真结束
     
123. 
     
124. .计次循环尾 ()
     
125. .如果真 (数据进制 ＝ 0)
     
126.     数据进制 ＝ 1
     
127. .如果真结束
     
128. 返回 (到字节集 (数据进制) ＋ 任意进制转换 ({ 1 } ＋ 数据, 数据进制, 255))
     
129. 
     
130. 
     
131. 
     
132. .子程序 内部解压, 字节集
     
133. .参数 数据, 字节集
     
134. .局部变量 解压后数据, 字节集
     
135. 
     
136. 解压后数据 ＝ 任意进制转换 (取字节集右边 (数据, 取字节集长度 (数据) － 1), 255, 数据 [1])
     
137. 返回 (取字节集右边 (解压后数据, 取字节集长度 (解压后数据) － 1))
     
138. 
     
139. 
     
140. .子程序 数据压缩, 字节集, 公开
     
141. .参数 数据, 字节集
     
142. .局部变量 索引表, 字节集
     
143. .局部变量 编码后, 字节集
     
144. .局部变量 返回值, 字节集
     
145. 
     
146. 编码后 ＝ 压缩前编码 (数据, 索引表)
     
147. 返回 (索引表 ＋ 内部压缩 (编码后))
     
148. 
     
149. .子程序 数据解压, 字节集, 公开
     
150. .参数 数据, 字节集
     
151. .局部变量 索引表, 字节集
     
152. .局部变量 解压前数据, 字节集
     
153. 
     
154. 索引表 ＝ 取字节集左边 (数据, 32)
     
155. 解压前数据 ＝ 取字节集右边 (数据, 取字节集长度 (数据) － 32)
     
156. 返回 (解压后解码 (内部解压 (解压前数据), 索引表))
     
157. 
     
158. .子程序 字节集到逻辑型数组
     
159. .参数 字节集数据, 字节集
     
160. .参数 逻辑型数组, 逻辑型, 参考 数组
     
161. .局部变量 字节集长度, 整数型
     
162. .局部变量 字节集计数, 整数型
     
163. .局部变量 移位位数计数, 整数型
     
164. .局部变量 移位后的值, 字节型
     
165. .局部变量 逻辑数组计数, 整数型
     
166. 
     
167. 字节集长度 ＝ 取字节集长度 (字节集数据)
     
168. 重定义数组 (逻辑型数组, 假, 字节集长度 × 8)
     
169. .计次循环首 (字节集长度, 字节集计数)
     
170.     .变量循环首 (0, 7, 1, 移位位数计数)
     
171.         逻辑数组计数 ＝ 逻辑数组计数 ＋ 1
     
172.         移位后的值 ＝ 左移 (1, 移位位数计数)
     
173.         逻辑型数组 [逻辑数组计数] ＝ 位与 (字节集数据 [字节集计数], 移位后的值) ＝ 移位后的值
     
174. 
     
175.     .变量循环尾 ()
     
176. 
     
177. .计次循环尾 ()
     
178. 
     
179. 
     
180. .子程序 逻辑型数组到字节集, 字节集
     
181. .参数 逻辑型数组, 逻辑型, 数组
     
182. .局部变量 逻辑组长度, 整数型
     
183. .局部变量 字节集数据, 字节集
     
184. .局部变量 字节集长度, 整数型
     
185. .局部变量 计数, 整数型
     
186. .局部变量 移位计数, 整数型
     
187. .局部变量 逻辑计数, 整数型
     
188. 
     
189. 逻辑组长度 ＝ 取数组成员数 (逻辑型数组)
     
190. .如果真 (逻辑组长度 ％ 8 ≠ 0)
     
191.     输出调试文本 (“数组成员数必须是8的倍数才可以导出字节集数据。”)
     
192.     返回 ({  })
     
193. .如果真结束
     
194. 字节集数据 ＝ 取空白字节集 (逻辑组长度 ÷ 8)
     
195. 字节集长度 ＝ 取字节集长度 (字节集数据)
     
196. .计次循环首 (字节集长度, 计数)
     
197.     .变量循环首 (0, 7, 1, 移位计数)
     
198.         .如果真 (逻辑型数组 [逻辑计数 ＋ 1] ＝ 真)
     
199.             字节集数据 [计数] ＝ 位或 (左移 (1, 移位计数), 字节集数据 [计数])
     
200.         .如果真结束
     
201.         逻辑计数 ＝ 逻辑计数 ＋ 1
     
202.     .变量循环尾 ()
     
203. .计次循环尾 ()
     
204. 返回 (字节集数据)
     
205. 
     
206. 
     
207. .子程序 任意进制转换, 字节集
     
208. .参数 欲操作的数据, 字节集
     
209. .参数 原进制, 字节型, , 2进制为1、3进制为2、256进制为255
     
210. .参数 目标进制, 字节型
     
211. .局部变量 计数, 整数型
     
212. .局部变量 长度, 整数型
     
213. .局部变量 运算值, 整数型
     
214. .局部变量 返回值, 字节集
     
215. .局部变量 返回值_, 字节型, , "0"
     
216. .局部变量 数组, 字节型, , "0"
     
217. .局部变量 原进制2, 短整数型
     
218. .局部变量 目标进制2, 短整数型
     
219. 
     
220. .如果真 (原进制 ＝ 目标进制)
     
221.     返回 (欲操作的数据)
     
222. .如果真结束
     
223. 原进制2 ＝ 原进制 ＋ 1
     
224. 目标进制2 ＝ 目标进制 ＋ 1
     
225. 
     
226. 长度 ＝ 取字节集长度 (欲操作的数据)
     
227. 重定义数组 (数组, 假, 长度)
     
228. 重定义数组 (返回值_, 假, 0)
     
229. .计次循环首 (长度, 计数)
     
230.     数组 [计数] ＝ 欲操作的数据 [计数]
     
231.     .如果真 (欲操作的数据 [计数] ＞ 原进制)
     
232.         输出调试文本 (“数据错误”)
     
233.         返回 ({  })
     
234.     .如果真结束
     
235. 
     
236. .计次循环尾 ()
     
237. .判断循环首 (长度 ≥ 1)
     
238. 
     
239.     运算值 ＝ 0
     
240. 
     
241.     .计次循环首 (长度, 计数)
     
242. 
     
243.         运算值 ＝ 运算值 × 原进制2 ＋ 数组 [计数]
     
244.         数组 [计数] ＝ 运算值 ÷ 目标进制2
     
245.         运算值 ＝ 运算值 ％ 目标进制2
     
246.     .计次循环尾 ()
     
247. 
     
248.     加入成员 (返回值_, 运算值)
     
249.     运算值 ＝ 1
     
250.     .判断循环首 (运算值 ≤ 长度 且 数组 [运算值] ＝ 0)
     
251.         运算值 ＝ 运算值 ＋ 1
     
252.     .判断循环尾 ()
     
253.     删除成员 (数组, 1, 运算值 － 1)
     
254.     长度 ＝ 取数组成员数 (数组)
     
255. .判断循环尾 ()
     
256. 长度 ＝ 取数组成员数 (返回值_)
     
257. 返回值 ＝ 取空白字节集 (长度)
     
258. .计次循环首 (长度, 计数)
     
259.     返回值 [计数] ＝ 返回值_ [长度 － 计数 ＋ 1]
     
260. .计次循环尾 ()
     
261. 返回 (返回值)
     
262. 
     
263. 
     

复制代码

Cute

欣欣 发表于 2018-9-2 23:42
昨天那谁没回哪贴这贴可能不会有

什么意思???

1心1亿

Cute 发表于 2018-10-16 22:40
什么意思???

我也没搞清楚

4面8方

昨天那谁没回哪贴这贴可能不会有

电脑高手

一楼来看看

电脑高手

这效率也是....

朵朵

看看吧正好需要

222

zzzzzzz

醉菲i

看一看

吃货

我也来看看