数据转排名

woyao2991314

  

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

变量名	类 型	静态	数组	备 注
源数据	整数型		0
复制	整数型		0
排名	整数型		0
i	整数型
j	整数型

' 原数据【33 22 44 11】
' 转换为【3  2  4  1 】‘就是把数 转换成排序数
源数据 ＝ { 33, 33, 33, 11 }
复制 ＝ { 33, 33, 33, 11 }
数组排序 (复制, )
计次循环首 (取数组成员数 (源数据), i)
计次循环首 (取数组成员数 (复制), j)
如果真 (源数据 [i] ＝ 复制 [j])
加入成员 (排名, j)

计次循环尾 ()
计次循环尾 ()
调试输出 (排名)
' 数据不重复时可以实现想要的效果，
' 源数据 ＝ { 33, 23, 44, 11 }没重复
' * 数组:4{3,2,4,1}这正确的理想效果
' 源数据 ＝ { 33, 33, 44, 11 }两个重复
' 输出得到* 数组:6{2,3,2,3,4,1}理想效果是 【2 2 3 1】
' 源数据 ＝ { 33, 33, 33, 11 }三个重复
' * 数组:10{2,3,4,2,3,4,2,3,4,1}理想效果是 【2 2 2 1】

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 源数据, 整数型, , "0"<br /> .局部变量 复制, 整数型, , "0"<br /> .局部变量 排名, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> <br /> <br /> ' 原数据【33 22 44 11】<br /> ' 转换为【3  2  4  1 】‘就是把数 转换成排序数<br /> <br /> <br /> <br /> 源数据 ＝ { 33, 33, 33, 11 }<br /> 复制 ＝ { 33, 33, 33, 11 }<br /> <br /> 数组排序 (复制, )<br /> .计次循环首 (取数组成员数 (源数据), i)<br />     .计次循环首 (取数组成员数 (复制), j)<br />         .如果真 (源数据 <i> ＝ 复制 [j])<br />             加入成员 (排名, j)<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> 调试输出 (排名)<br /> ' 数据不重复时可以实现想要的效果，<br /> ' 源数据 ＝ { 33, 23, 44, 11 }没重复<br /> ' * 数组:4{3,2,4,1}这正确的理想效果<br /> <br /> ' 源数据 ＝ { 33, 33, 44, 11 }两个重复<br /> ' 输出得到* 数组:6{2,3,2,3,4,1}理想效果是 【2 2 3 1】<br /> <br /> ' 源数据 ＝ { 33, 33, 33, 11 }三个重复<br /> ' * 数组:10{2,3,4,2,3,4,2,3,4,1}理想效果是 【2 2 2 1】

四叔

  

子程序名	返回值类型	公开	备 注
数组转换为排序数组
参数名	类 型	参考	可空	数组	备 注
原数组	整数型
排序数组	整数型

变量名	类 型	静态	数组	备 注
局_排序数组	整数型		0
局_结果数组	整数型		0
i	整数型
j	整数型
局_当前值	整数型
局_序号	整数型

' 复制原数组到排序数组
局_排序数组 ＝ 原数组
' 对排序数组进行排序
数组排序 (局_排序数组, 真)  ' 假表示升序排序
变量循环首 (取数组成员数 (局_排序数组), 2, -1, i)
如果真 (局_排序数组 [i] ＝ 局_排序数组 [i － 1])
删除成员 (局_排序数组, i, 1)

变量循环尾 ()
' 创建结果数组，大小与原数组相同
重定义数组 (局_结果数组, 假, 取数组成员数 (原数组))
' 遍历原数组中的每个元素
计次循环首 (取数组成员数 (原数组), i)
局_当前值 ＝ 原数组 [i]
局_序号 ＝ 0
' 在排序数组中查找当前值的序号
计次循环首 (取数组成员数 (局_排序数组), j)
如果真 (局_排序数组 [j] ＝ 局_当前值)
局_序号 ＝ j
跳出循环 ()

计次循环尾 ()
' 将序号存入结果数组
局_结果数组 [i] ＝ 局_序号
计次循环尾 ()
排序数组 ＝ 局_结果数组
调试输出 (排序数组)

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 数组转换为排序数组<br /> .参数 原数组, 整数型, 数组<br /> .参数 排序数组, 整数型, 参考 可空 数组<br /> .局部变量 局_排序数组, 整数型, , "0"<br /> .局部变量 局_结果数组, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> .局部变量 局_当前值, 整数型<br /> .局部变量 局_序号, 整数型<br /> <br /> ' 复制原数组到排序数组<br /> 局_排序数组 ＝ 原数组<br /> <br /> ' 对排序数组进行排序<br /> 数组排序 (局_排序数组, 真)  ' 假表示升序排序<br /> .变量循环首 (取数组成员数 (局_排序数组), 2, -1, i)<br />     .如果真 (局_排序数组 <i> ＝ 局_排序数组 [i － 1])<br />         删除成员 (局_排序数组, i, 1)<br />     .如果真结束<br /> <br /> .变量循环尾 ()<br /> <br /> ' 创建结果数组，大小与原数组相同<br /> 重定义数组 (局_结果数组, 假, 取数组成员数 (原数组))<br /> <br /> ' 遍历原数组中的每个元素<br /> .计次循环首 (取数组成员数 (原数组), i)<br />     局_当前值 ＝ 原数组 <i><br />     局_序号 ＝ 0<br /> <br />     ' 在排序数组中查找当前值的序号<br />     .计次循环首 (取数组成员数 (局_排序数组), j)<br />         .如果真 (局_排序数组 [j] ＝ 局_当前值)<br />             局_序号 ＝ j<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     ' 将序号存入结果数组<br />     局_结果数组 <i> ＝ 局_序号<br /> .计次循环尾 ()<br /> 排序数组 ＝ 局_结果数组<br /> 调试输出 (排序数组)

trynew002

四叔 发表于 2025-8-3 01:52
[e=1].版本 2
.支持库 spec

老哥 用的什么AI

陌迁尘

.版本 2
.支持库 spec

.子程序 子程序1
.参数 源数组, 整数型, 数组
.局部变量 局_排序去重数组, 整数型, , "0"
.局部变量 局_结果数组, 整数型, , "0"
.局部变量 局_结果文本, 文本型
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 成员数, 整数型
.局部变量 当前值, 整数型
.局部变量 找到位置, 整数型

成员数 ＝ 取数组成员数 (源数组)
.如果真 (成员数 ＝ 0)
    返回 ()
.如果真结束
局_排序去重数组 ＝ 源数组
数组排序 (局_排序去重数组, 真)
.变量循环首 (成员数, 2, -1, i)
    .如果真 (局_排序去重数组 [i] ＝ 局_排序去重数组 [i － 1])
        删除成员 (局_排序去重数组, i, 1)
    .如果真结束

.变量循环尾 ()
重定义数组 (局_结果数组, 假, 成员数)
.计次循环首 (成员数, i)
    当前值 ＝ 源数组 [i]
    找到位置 ＝ 0
    .计次循环首 (取数组成员数 (局_排序去重数组), j)
        .如果真 (局_排序去重数组 [j] ＝ 当前值)
            找到位置 ＝ j
            跳出循环 ()
        .如果真结束

    .计次循环尾 ()
    局_结果文本 ＝ 局_结果文本 ＋ 到文本 (找到位置) ＋ “ ”
    局_结果数组 [i] ＝ 找到位置
.计次循环尾 ()
调试输出 (局_结果文本)
调试输出 (局_结果数组)

陌迁尘

  

子程序名	返回值类型	公开	备 注
子程序1
参数名	类 型	参考	可空	数组	备 注
源数组	整数型

变量名	类 型	静态	数组	备 注
局_排序去重数组	整数型		0
局_结果数组	整数型		0
局_结果文本	文本型
i	整数型
j	整数型
成员数	整数型
当前值	整数型
找到位置	整数型

成员数 ＝ 取数组成员数 (源数组)
如果真 (成员数 ＝ 0)
返回 ()
局_排序去重数组 ＝ 源数组
数组排序 (局_排序去重数组, 真)
变量循环首 (成员数, 2, -1, i)
如果真 (局_排序去重数组 [i] ＝ 局_排序去重数组 [i － 1])
删除成员 (局_排序去重数组, i, 1)

变量循环尾 ()
重定义数组 (局_结果数组, 假, 成员数)
计次循环首 (成员数, i)
当前值 ＝ 源数组 [i]
找到位置 ＝ 0
计次循环首 (取数组成员数 (局_排序去重数组), j)
如果真 (局_排序去重数组 [j] ＝ 当前值)
找到位置 ＝ j
跳出循环 ()

计次循环尾 ()
局_结果文本 ＝ 局_结果文本 ＋ 到文本 (找到位置) ＋ “ ”
局_结果数组 [i] ＝ 找到位置
计次循环尾 ()
调试输出 (局_结果文本)
调试输出 (局_结果数组)

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 子程序1<br /> .参数 源数组, 整数型, 数组<br /> .局部变量 局_排序去重数组, 整数型, , "0"<br /> .局部变量 局_结果数组, 整数型, , "0"<br /> .局部变量 局_结果文本, 文本型<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> .局部变量 成员数, 整数型<br /> .局部变量 当前值, 整数型<br /> .局部变量 找到位置, 整数型<br /> <br /> 成员数 ＝ 取数组成员数 (源数组)<br /> .如果真 (成员数 ＝ 0)<br />     返回 ()<br /> .如果真结束<br /> 局_排序去重数组 ＝ 源数组<br /> 数组排序 (局_排序去重数组, 真)<br /> .变量循环首 (成员数, 2, -1, i)<br />     .如果真 (局_排序去重数组 <i> ＝ 局_排序去重数组 [i － 1])<br />         删除成员 (局_排序去重数组, i, 1)<br />     .如果真结束<br /> <br /> .变量循环尾 ()<br /> 重定义数组 (局_结果数组, 假, 成员数)<br /> .计次循环首 (成员数, i)<br />     当前值 ＝ 源数组 <i><br />     找到位置 ＝ 0<br />     .计次循环首 (取数组成员数 (局_排序去重数组), j)<br />         .如果真 (局_排序去重数组 [j] ＝ 当前值)<br />             找到位置 ＝ j<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     局_结果文本 ＝ 局_结果文本 ＋ 到文本 (找到位置) ＋ “ ”<br />     局_结果数组 <i> ＝ 找到位置<br /> .计次循环尾 ()<br /> 调试输出 (局_结果文本)<br /> 调试输出 (局_结果数组)

zhtcCC

数组排序 (复制, )  后面加一个   数组_去重复 (, 复制)  就好了。

zainex

排序的同时对下标也进行排序, 最后就能在这些下标中填写出排名:

  

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

子程序名	返回值类型	公开	备 注
计算排序数	逻辑型
参数名	类 型	参考	可空	数组	备 注
数组	整数型
排序数	整数型

变量名	类 型	静态	数组	备 注
数	整数型
下标	整数型		0
值	整数型
备份	整数型		0
当前	整数型
名次	整数型

重定义数组 (排序数, 假, 取数组成员数 (数组))
如果真 (取数组成员数 (数组) ＜ 1)
返回 (假)
重定义数组 (下标, 假, 取数组成员数 (数组))
计次循环首 (取数组成员数 (数组), 数)
下标 [数] ＝ 数
计次循环尾 ()
备份 ＝ 数组
计次循环首 (取数组成员数 (备份), 数)
计次循环首 (取数组成员数 (备份) － 数, 值)
如果真 (备份 [值] ＞ 备份 [值 ＋ 1])
交换变量 (备份 [值], 备份 [值 ＋ 1])
交换变量 (下标 [值], 下标 [值 ＋ 1])

计次循环尾 ()
计次循环尾 ()
当前 ＝ 备份 [1]
名次 ＝ 1
计次循环首 (取数组成员数 (备份), 数)
如果真 (备份 [数] ≠ 当前)
当前 ＝ 备份 [数]
名次 ＝ 名次 ＋ 1
排序数 [下标 [数]] ＝ 名次
计次循环尾 ()
返回 (真)

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

变量名	类 型	静态	数组	备 注
数组	整数型		0
排序数	整数型		0

数组 ＝ { 33, 23, 44, 11 }
计算排序数 (数组, 排序数)
调试输出 (数组, 排序数)
数组 ＝ { 33, 33, 44, 11 }
计算排序数 (数组, 排序数)
调试输出 (数组, 排序数)
数组 ＝ { 33, 33, 33, 11 }
计算排序数 (数组, 排序数)
调试输出 (数组, 排序数)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 计算排序数, 逻辑型<br /> .参数 数组, 整数型, 数组<br /> .参数 排序数, 整数型, 数组<br /> .局部变量 数, 整数型<br /> .局部变量 下标, 整数型, , "0"<br /> .局部变量 值, 整数型<br /> .局部变量 备份, 整数型, , "0"<br /> .局部变量 当前, 整数型<br /> .局部变量 名次, 整数型<br /> <br /> 重定义数组 (排序数, 假, 取数组成员数 (数组))<br /> .如果真 (取数组成员数 (数组) ＜ 1)<br />     返回 (假)<br /> .如果真结束<br /> 重定义数组 (下标, 假, 取数组成员数 (数组))<br /> .计次循环首 (取数组成员数 (数组), 数)<br />     下标 [数] ＝ 数<br /> .计次循环尾 ()<br /> 备份 ＝ 数组<br /> .计次循环首 (取数组成员数 (备份), 数)<br />     .计次循环首 (取数组成员数 (备份) － 数, 值)<br />         .如果真 (备份 [值] ＞ 备份 [值 ＋ 1])<br />             交换变量 (备份 [值], 备份 [值 ＋ 1])<br />             交换变量 (下标 [值], 下标 [值 ＋ 1])<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> 当前 ＝ 备份 [1]<br /> 名次 ＝ 1<br /> .计次循环首 (取数组成员数 (备份), 数)<br />     .如果真 (备份 [数] ≠ 当前)<br />         当前 ＝ 备份 [数]<br />         名次 ＝ 名次 ＋ 1<br />     .如果真结束<br />     排序数 [下标 [数]] ＝ 名次<br /> .计次循环尾 ()<br /> 返回 (真)<br /> <br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 数组, 整数型, , "0"<br /> .局部变量 排序数, 整数型, , "0"<br /> <br /> 数组 ＝ { 33, 23, 44, 11 }<br /> 计算排序数 (数组, 排序数)<br /> 调试输出 (数组, 排序数)<br /> 数组 ＝ { 33, 33, 44, 11 }<br /> 计算排序数 (数组, 排序数)<br /> 调试输出 (数组, 排序数)<br /> 数组 ＝ { 33, 33, 33, 11 }<br /> 计算排序数 (数组, 排序数)<br /> 调试输出 (数组, 排序数)