数组重复成员改成不重复

cwb757136008

有1组数量{“55”,“55”,“67”,“77”,“77”,“55”,“57”,“88”,“56”,“63”,“78”}
这组数量有重复的，需要加1直到全部数量不相同为止，并记录加了多少
比如成员4、成员5相同，成员4加1就是78，记录加了1
应该怎么写比较好

zainex

这类算法题，可以直接问豆包这类大语言模型。
如果直接生成易语言代码问题太多的话，先让它生成Python或C等等的代码。
然后再让它转成易语言：

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备 注
带索引排序
参数名	类 型	参考	可空	数组	备 注
数值数组	整数型
索引数组	整数型
长度	整数型

变量名	类 型	静态	数组	备 注
数	整数型
值	整数型
临时数值	整数型
临时索引	整数型

计次循环首 (长度, 数)
计次循环首 (长度 － 数, 值)
如果真 (数值数组 [值] ＞ 数值数组 [值 ＋ 1])
' 同步交换数值和对应的原始索引
临时数值 ＝ 数值数组 [值]
数值数组 [值] ＝ 数值数组 [值 ＋ 1]
数值数组 [值 ＋ 1] ＝ 临时数值
临时索引 ＝ 索引数组 [值]
索引数组 [值] ＝ 索引数组 [值 ＋ 1]
索引数组 [值 ＋ 1] ＝ 临时索引

计次循环尾 ()
计次循环尾 ()

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

变量名	类 型	静态	数组	备 注
原始文本数组	文本型		0
数值数组	整数型		0
原始索引数组	整数型		0
增量数组	整数型		0
最终值数组	整数型		0
数组长度	整数型
i	整数型
目标值	整数型
增加量	整数型
总增加量	整数型

' ========== 1. 初始化原始数据，可直接在此修改你的数据 ==========
原始文本数组 ＝ { “55”, “55”, “67”, “77”, “77”, “55”, “57”, “88”, “56”, “63”, “78” }
' ========== 2. 初始化数组，绑定数值和原始位置 ==========
数组长度 ＝ 取数组成员数 (原始文本数组)
重定义数组 (数值数组, 假, 数组长度)
重定义数组 (原始索引数组, 假, 数组长度)
重定义数组 (增量数组, 假, 数组长度)
重定义数组 (最终值数组, 假, 数组长度)
' 转换文本为数值，记录每个数的原始位置，增量初始化为0
计次循环首 (数组长度, i)
数值数组 [i] ＝ 到数值 (原始文本数组 [i])
原始索引数组 [i] ＝ i
增量数组 [i] ＝ 0
计次循环尾 ()
' ========== 3. 排序：数值升序，同步交换原始索引（保证位置绑定） ==========
带索引排序 (数值数组, 原始索引数组, 数组长度)
' ========== 4. 核心贪心算法：去重+记录每个位置的增量 ==========
总增加量 ＝ 0
计次循环首 (数组长度 － 1, i)
i ＝ i ＋ 1  ' 从第2个元素开始，和前一个对比
如果真 (数值数组 [i] ≤ 数值数组 [i － 1])
目标值 ＝ 数值数组 [i － 1] ＋ 1  ' 保证不重复的最小目标值
增加量 ＝ 目标值 － 数值数组 [i]
' 关键：把增量存到该数值对应的原始位置
增量数组 [原始索引数组 [i]] ＝ 增加量
数值数组 [i] ＝ 目标值
总增加量 ＝ 总增加量 ＋ 增加量

计次循环尾 ()
' ========== 5. 按原始顺序回填最终数值 ==========
计次循环首 (数组长度, i)
最终值数组 [原始索引数组 [i]] ＝ 数值数组 [i]
计次循环尾 ()
' ========== 6. 纯调试输出结果 ==========
调试输出 (“===== 去重处理结果（按原始数据顺序） =====”)
调试输出 (“原始数据 | 最终数值 | 对应位置增加量”)
调试输出 (“-------------------------------------------”)
计次循环首 (数组长度, i)
调试输出 (原始文本数组 [i] ＋ “ | ” ＋ 到文本 (最终值数组 [i]) ＋ “ | ” ＋ 到文本 (增量数组 [i]))
计次循环尾 ()
调试输出 (“-------------------------------------------”)
调试输出 (“所有位置总增加量：”, 总增加量)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 带索引排序<br /> .参数 数值数组, 整数型, 数组<br /> .参数 索引数组, 整数型, 数组<br /> .参数 长度, 整数型<br /> .局部变量 数, 整数型<br /> .局部变量 值, 整数型<br /> .局部变量 临时数值, 整数型<br /> .局部变量 临时索引, 整数型<br /> <br /> .计次循环首 (长度, 数)<br />     .计次循环首 (长度 － 数, 值)<br />         .如果真 (数值数组 [值] ＞ 数值数组 [值 ＋ 1])<br />             ' 同步交换数值和对应的原始索引<br />             临时数值 ＝ 数值数组 [值]<br />             数值数组 [值] ＝ 数值数组 [值 ＋ 1]<br />             数值数组 [值 ＋ 1] ＝ 临时数值<br /> <br />             临时索引 ＝ 索引数组 [值]<br />             索引数组 [值] ＝ 索引数组 [值 ＋ 1]<br />             索引数组 [值 ＋ 1] ＝ 临时索引<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 原始文本数组, 文本型, , "0"<br /> .局部变量 数值数组, 整数型, , "0"<br /> .局部变量 原始索引数组, 整数型, , "0"<br /> .局部变量 增量数组, 整数型, , "0"<br /> .局部变量 最终值数组, 整数型, , "0"<br /> .局部变量 数组长度, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 目标值, 整数型<br /> .局部变量 增加量, 整数型<br /> .局部变量 总增加量, 整数型<br /> <br /> ' ========== 1. 初始化原始数据，可直接在此修改你的数据 ==========<br /> 原始文本数组 ＝ { “55”, “55”, “67”, “77”, “77”, “55”, “57”, “88”, “56”, “63”, “78” }<br /> <br /> ' ========== 2. 初始化数组，绑定数值和原始位置 ==========<br /> 数组长度 ＝ 取数组成员数 (原始文本数组)<br /> 重定义数组 (数值数组, 假, 数组长度)<br /> 重定义数组 (原始索引数组, 假, 数组长度)<br /> 重定义数组 (增量数组, 假, 数组长度)<br /> 重定义数组 (最终值数组, 假, 数组长度)<br /> <br /> ' 转换文本为数值，记录每个数的原始位置，增量初始化为0<br /> .计次循环首 (数组长度, i)<br />     数值数组 <i> ＝ 到数值 (原始文本数组 <i>)<br />     原始索引数组 <i> ＝ i<br />     增量数组 <i> ＝ 0<br /> .计次循环尾 ()<br /> <br /> ' ========== 3. 排序：数值升序，同步交换原始索引（保证位置绑定） ==========<br /> 带索引排序 (数值数组, 原始索引数组, 数组长度)<br /> <br /> ' ========== 4. 核心贪心算法：去重+记录每个位置的增量 ==========<br /> 总增加量 ＝ 0<br /> .计次循环首 (数组长度 － 1, i)<br />     i ＝ i ＋ 1  ' 从第2个元素开始，和前一个对比<br />     .如果真 (数值数组 <i> ≤ 数值数组 [i － 1])<br />         目标值 ＝ 数值数组 [i － 1] ＋ 1  ' 保证不重复的最小目标值<br />         增加量 ＝ 目标值 － 数值数组 <i><br /> <br />         ' 关键：把增量存到该数值对应的原始位置<br />         增量数组 [原始索引数组 <i>] ＝ 增加量<br /> <br />         数值数组 <i> ＝ 目标值<br />         总增加量 ＝ 总增加量 ＋ 增加量<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> ' ========== 5. 按原始顺序回填最终数值 ==========<br /> .计次循环首 (数组长度, i)<br />     最终值数组 [原始索引数组 <i>] ＝ 数值数组 <i><br /> .计次循环尾 ()<br /> <br /> ' ========== 6. 纯调试输出结果 ==========<br /> 调试输出 (“===== 去重处理结果（按原始数据顺序） =====”)<br /> 调试输出 (“原始数据 | 最终数值 | 对应位置增加量”)<br /> 调试输出 (“-------------------------------------------”)<br /> .计次循环首 (数组长度, i)<br />     调试输出 (原始文本数组 <i> ＋ “ | ” ＋ 到文本 (最终值数组 <i>) ＋ “ | ” ＋ 到文本 (增量数组 <i>))<br /> .计次循环尾 ()<br /> 调试输出 (“-------------------------------------------”)<br /> 调试输出 (“所有位置总增加量：”, 总增加量)

开始运行被调试程序
* “===== 去重处理结果（按原始数据顺序） =====”
* “原始数据 | 最终数值 | 对应位置增加量”
* “-------------------------------------------”
* “55 | 55 | 0”
* “55 | 56 | 1”
* “67 | 67 | 0”
* “77 | 77 | 0”
* “77 | 78 | 1”
* “55 | 57 | 2”
* “57 | 59 | 2”
* “88 | 88 | 0”
* “56 | 58 | 2”
* “63 | 63 | 0”
* “78 | 79 | 1”
* “-------------------------------------------”
* “所有位置总增加量：” | 9
被调试易程序运行完毕

瀚海

如果数据量不大就取数组成员数然后挨着判断是否相同，再弄个变量记录加1的次数

qq1056123185

判断循环+循环判断