整数向上查找

啊基德

有一个整数数组,[50,51,65,65,80,88,125]   如果输入52 就查找比它大的数,要保证输出65,65,这两个,求大佬给个思路

企鹅号525150138

  

变量名	类 型	静态	数组	备 注
a	整数型		0
j	整数型

a ＝ { 50, 51, 65, 65, 80, 88, 125 }
数组排序 (a, )
计次循环首 (取数组成员数 (a), j)
如果真 (a [j] ＞ 52)
调试输出 (a [j], a [j ＋ 1])
跳出循环 ()

计次循环尾 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .局部变量 a, 整数型, , "0"<br /> .局部变量 j, 整数型<br /> <br /> a ＝ { 50, 51, 65, 65, 80, 88, 125 }<br /> 数组排序 (a, )<br /> .计次循环首 (取数组成员数 (a), j)<br />     .如果真 (a [j] ＞ 52)<br />         调试输出 (a [j], a [j ＋ 1])<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .计次循环尾 ()

人杰啊

.版本 2
.支持库 spec

.程序集 程序集1

.子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行
.局部变量 原始数组, 整数型, , "0"
.局部变量 目标值, 整数型
.局部变量 结果数量, 整数型
.局部变量 结果数组, 整数型, , "0"

原始数组 ＝ { 50, 51, 65, 65, 80, 80, 88, 125 }
' 查找大于52的最小元素
目标值 ＝ 52

结果数量 ＝ 查找大于指定值的最小元素 (原始数组, 目标值, 结果数组)

调试输出 (“查找大于”, 目标值, “的最小元素结果:”)
调试输出 (结果数组)

返回 (0)  ' 可以根据您的需要返回任意数值

.子程序 查找大于指定值的最小元素, 整数型, 公开
.参数 数组, 整数型, 数组
.参数 目标值, 整数型
.参数 结果数组, 整数型, 参考 数组
.局部变量 左边界, 整数型
.局部变量 右边界, 整数型
.局部变量 中间, 整数型
.局部变量 结果位置, 整数型
.局部变量 最小值, 整数型
.局部变量 i, 整数型

' 首先对数组进行排序
数组排序 (数组, 真)  ' 使用精易模块的数组排序功能，按升序排序

' 初始化变量
左边界 ＝ 0
右边界 ＝ 取数组成员数 (数组) － 1
结果位置 ＝ -1

' 二分查找第一个大于目标值的元素
.判断循环首 (左边界 ≤ 右边界)
    中间 ＝ (左边界 ＋ 右边界) ÷ 2

    .如果 (数组 [中间] ＞ 目标值)
        结果位置 ＝ 中间
        右边界 ＝ 中间 － 1

    .否则
        左边界 ＝ 中间 ＋ 1

    .如果结束

.判断循环尾 ()


' 如果没有找到大于目标值的元素，返回空数组
.如果真 (结果位置 ＝ -1)
    重定义数组 (结果数组, 假, 0)
    返回 (0)

.如果真结束


' 获取最小值
最小值 ＝ 数组 [结果位置]

' 收集所有等于最小值的元素
i ＝ 结果位置
.判断循环首 (i ＜ 取数组成员数 (数组) 且 数组 [i] ＝ 最小值)
    加入成员 (结果数组, 数组 [i])
    i ＝ i ＋ 1

.判断循环尾 ()

返回 (取数组成员数 (结果数组))

人杰啊

  

窗口程序集名	保 留	保 留	备 注
程序集1

子程序名	返回值类型	公开	备 注
_启动子程序	整数型		本子程序在程序启动后最先执行

变量名	类 型	静态	数组	备 注
原始数组	整数型		0
目标值	整数型
结果数量	整数型
结果数组	整数型		0

原始数组 ＝ { 50, 51, 65, 65, 80, 80, 88, 125 }
' 查找大于52的最小元素
目标值 ＝ 52
结果数量 ＝ 查找大于指定值的最小元素 (原始数组, 目标值, 结果数组)
调试输出 (“查找大于”, 目标值, “的最小元素结果:”)
调试输出 (结果数组)
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
查找大于指定值的最小元素	整数型
参数名	类 型	参考	可空	数组	备 注
数组	整数型
目标值	整数型
结果数组	整数型

变量名	类 型	静态	数组	备 注
左边界	整数型
右边界	整数型
中间	整数型
结果位置	整数型
最小值	整数型
i	整数型

' 首先对数组进行排序
数组排序 (数组, 真)  ' 使用精易模块的数组排序功能，按升序排序
' 初始化变量
左边界 ＝ 0
右边界 ＝ 取数组成员数 (数组) － 1
结果位置 ＝ -1
' 二分查找第一个大于目标值的元素
判断循环首 (左边界 ≤ 右边界)
中间 ＝ (左边界 ＋ 右边界) ÷ 2
如果 (数组 [中间] ＞ 目标值)
结果位置 ＝ 中间
右边界 ＝ 中间 － 1

左边界 ＝ 中间 ＋ 1

判断循环尾 ()
' 如果没有找到大于目标值的元素，返回空数组
如果真 (结果位置 ＝ -1)
重定义数组 (结果数组, 假, 0)
返回 (0)

' 获取最小值
最小值 ＝ 数组 [结果位置]
' 收集所有等于最小值的元素
i ＝ 结果位置
判断循环首 (i ＜ 取数组成员数 (数组) 且 数组 [i] ＝ 最小值)
加入成员 (结果数组, 数组 [i])
i ＝ i ＋ 1
判断循环尾 ()
返回 (取数组成员数 (结果数组))

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 程序集1<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 原始数组, 整数型, , "0"<br /> .局部变量 目标值, 整数型<br /> .局部变量 结果数量, 整数型<br /> .局部变量 结果数组, 整数型, , "0"<br /> <br /> 原始数组 ＝ { 50, 51, 65, 65, 80, 80, 88, 125 }<br /> ' 查找大于52的最小元素<br /> 目标值 ＝ 52<br /> <br /> 结果数量 ＝ 查找大于指定值的最小元素 (原始数组, 目标值, 结果数组)<br /> <br /> 调试输出 (“查找大于”, 目标值, “的最小元素结果:”)<br /> 调试输出 (结果数组)<br /> <br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 查找大于指定值的最小元素, 整数型, 公开<br /> .参数 数组, 整数型, 数组<br /> .参数 目标值, 整数型<br /> .参数 结果数组, 整数型, 参考 数组<br /> .局部变量 左边界, 整数型<br /> .局部变量 右边界, 整数型<br /> .局部变量 中间, 整数型<br /> .局部变量 结果位置, 整数型<br /> .局部变量 最小值, 整数型<br /> .局部变量 i, 整数型<br /> <br /> ' 首先对数组进行排序<br /> 数组排序 (数组, 真)  ' 使用精易模块的数组排序功能，按升序排序<br /> <br /> ' 初始化变量<br /> 左边界 ＝ 0<br /> 右边界 ＝ 取数组成员数 (数组) － 1<br /> 结果位置 ＝ -1<br /> <br /> ' 二分查找第一个大于目标值的元素<br /> .判断循环首 (左边界 ≤ 右边界)<br />     中间 ＝ (左边界 ＋ 右边界) ÷ 2<br /> <br />     .如果 (数组 [中间] ＞ 目标值)<br />         结果位置 ＝ 中间<br />         右边界 ＝ 中间 － 1<br /> <br />     .否则<br />         左边界 ＝ 中间 ＋ 1<br /> <br />     .如果结束<br /> <br /> .判断循环尾 ()<br /> <br /> <br /> ' 如果没有找到大于目标值的元素，返回空数组<br /> .如果真 (结果位置 ＝ -1)<br />     重定义数组 (结果数组, 假, 0)<br />     返回 (0)<br /> <br /> .如果真结束<br /> <br /> <br /> ' 获取最小值<br /> 最小值 ＝ 数组 [结果位置]<br /> <br /> ' 收集所有等于最小值的元素<br /> i ＝ 结果位置<br /> .判断循环首 (i ＜ 取数组成员数 (数组) 且 数组 <i> ＝ 最小值)<br />     加入成员 (结果数组, 数组 <i>)<br />     i ＝ i ＋ 1<br /> <br /> .判断循环尾 ()<br /> <br /> 返回 (取数组成员数 (结果数组))

输出[21:59:47] * “查找大于” | 52 | “的最小元素结果:”
[21:59:47] * 数组:2{65,65}

zainex

不需要排序, 直接查找就行了:

  

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

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

变量名	类 型	静态	数组	备 注
数组	整数型		0
查找	整数型
数	整数型
目标	整数型

数组 ＝ { 50, 51, 65, 65, 80, 88, 125 }
查找 ＝ 52
计次循环首 (取数组成员数 (数组), 数)
如果真 (数组 [数] ＞ 查找)
目标 ＝ 数组 [数]
跳出循环 ()

计次循环尾 ()
计次循环首 (取数组成员数 (数组), 数)
如果真 (数组 [数] ＝ 目标)
调试输出 (数组 [数])

计次循环尾 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 数组, 整数型, , "0"<br /> .局部变量 查找, 整数型<br /> .局部变量 数, 整数型<br /> .局部变量 目标, 整数型<br /> <br /> 数组 ＝ { 50, 51, 65, 65, 80, 88, 125 }<br /> 查找 ＝ 52<br /> <br /> .计次循环首 (取数组成员数 (数组), 数)<br />     .如果真 (数组 [数] ＞ 查找)<br />         目标 ＝ 数组 [数]<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> .计次循环首 (取数组成员数 (数组), 数)<br />     .如果真 (数组 [数] ＝ 目标)<br />         调试输出 (数组 [数])<br />     .如果真结束<br /> <br /> .计次循环尾 ()

汉族

AI给的代码，调试输出  
开始运行被调试程序
* 结果: 65,65

  

窗口程序集名	保 留	保 留	备 注
程序集1

子程序名	返回值类型	公开	备 注
_启动子程序	整数型		本子程序在程序启动后最先执行

变量名	类 型	静态	数组	备 注
数组	整数型		0
输入值	整数型
位置	整数型
结果	文本型
i	整数型

' 初始化数组
数组 ＝ { 50, 51, 65, 65, 80, 88, 125 }
' 获取输入值（此处以52为例）
输入值 ＝ 52
' 查找第一个大于输入值的位置
位置 ＝ 二分查找 (数组, 输入值)
如果真 (位置 ＝ -1)
输出调试文本 (“未找到符合条件的数”)
返回 (0)

' 收集连续相同的值
结果 ＝ “”
i ＝ 位置
判断循环首 (i ≤ 取数组成员数 (数组) 且 数组[i] ＝ 数组[位置])
结果 ＝ 结果 ＋ 到文本 (数组[i]) ＋ “,”
i ＝ i ＋ 1
判断循环尾 ()
' 去掉末尾逗号并输出
结果 ＝ 取文本左边 (结果, 取文本长度 (结果) － 1)
输出调试文本 (“结果: ” ＋ 结果)
返回 (0)

子程序名	返回值类型	公开	备 注
二分查找	整数型
参数名	类 型	参考	可空	数组	备 注
数组	整数型
目标值	整数型

变量名	类 型	静态	数组	备 注
左	整数型
右	整数型
中间	整数型

左 ＝ 1
右 ＝ 取数组成员数 (数组)
循环判断首 ()
如果真 (左 ＞ 右)
返回 (-1)  ' 未找到

中间 ＝ (左 ＋ 右) ＼ 2
如果 (数组[中间] ＜ 目标值)
左 ＝ 中间 ＋ 1
右 ＝ 中间 － 1

循环判断尾 (左 ≤ 右)
' 返回第一个大于目标值的位置
返回 (左)

.版本 2<br /> .程序集 程序集1<br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> <br /> .局部变量 数组, 整数型, , "0"<br /> .局部变量 输入值, 整数型<br /> .局部变量 位置, 整数型<br /> .局部变量 结果, 文本型<br /> .局部变量 i, 整数型<br /> <br /> ' 初始化数组<br /> 数组 ＝ { 50, 51, 65, 65, 80, 88, 125 }<br /> <br /> ' 获取输入值（此处以52为例）<br /> 输入值 ＝ 52<br /> <br /> ' 查找第一个大于输入值的位置<br /> 位置 ＝ 二分查找(数组, 输入值)<br /> <br /> .如果真 (位置 ＝ -1)<br />     输出调试文本 (“未找到符合条件的数”)<br />     返回 (0)<br /> .如果真结束<br /> <br /> ' 收集连续相同的值<br /> 结果 ＝ “”<br /> i ＝ 位置<br /> .判断循环首 (i ≤ 取数组成员数(数组) 且 数组<i> ＝ 数组[位置])<br />     结果 ＝ 结果 ＋ 到文本(数组<i>) ＋ “,”<br />     i ＝ i ＋ 1<br /> .判断循环尾 ()<br /> <br /> ' 去掉末尾逗号并输出<br /> 结果 ＝ 取文本左边(结果, 取文本长度(结果) － 1)<br /> 输出调试文本 (“结果: ” ＋ 结果)<br /> <br /> 返回 (0)<br /> <br /> .子程序 二分查找, 整数型<br /> .参数 数组, 整数型, 数组<br /> .参数 目标值, 整数型<br /> <br /> .局部变量 左, 整数型<br /> .局部变量 右, 整数型<br /> .局部变量 中间, 整数型<br /> <br /> 左 ＝ 1<br /> 右 ＝ 取数组成员数(数组)<br /> .循环判断首 ()<br />     .如果真 (左 ＞ 右)<br />         返回 (-1)  ' 未找到<br />     .如果真结束<br />     <br />     中间 ＝ (左 ＋ 右) ＼ 2<br />     .如果 (数组[中间] ＜ 目标值)<br />         左 ＝ 中间 ＋ 1<br />     .否则<br />         右 ＝ 中间 － 1<br />     .如果结束<br /> .循环判断尾 (左 ≤ 右)<br /> <br /> ' 返回第一个大于目标值的位置<br /> 返回 (左)

萧楚楠

汉族 发表于 2025-8-18 22:13
AI给的代码，调试输出  
开始运行被调试程序
* 结果: 65,65

什么ai这么牛逼？

汉族

萧楚楠 发表于 2025-8-18 22:15
什么ai这么牛逼？

我给它：

有一个整数数组,[50,51,65,65,80,88,125]   如果输入52 就查找比它大的数,要保证输出65,65,这两个,求大佬给个思路,易语言代码，简洁明了的那种

高级工程师

  

子程序名	返回值类型	公开	备 注
_按钮1_被单击

变量名	类 型	静态	数组	备 注
整数数组	整数型		0
i	整数型
目标整数	整数型
输出次数	整数型
当前次数	整数型

整数数组 ＝ { 50, 51, 65, 65, 80, 88, 125 }
目标整数 ＝ 52
输出次数 ＝ 2
计次循环首 (取数组成员数 (整数数组), i)
如果真 (整数数组 [i] ＞ 目标整数)
当前次数 ＝ 当前次数 ＋ 1
调试输出 (整数数组 [i])
如果真 (当前次数 ≥ 输出次数)
跳出循环 ()

计次循环尾 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _按钮1_被单击<br /> .局部变量 整数数组, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 目标整数, 整数型<br /> .局部变量 输出次数, 整数型<br /> .局部变量 当前次数, 整数型<br /> <br /> 整数数组 ＝ { 50, 51, 65, 65, 80, 88, 125 }<br /> 目标整数 ＝ 52<br /> 输出次数 ＝ 2<br /> .计次循环首 (取数组成员数 (整数数组), i)<br />     .如果真 (整数数组 <i> ＞ 目标整数)<br />         当前次数 ＝ 当前次数 ＋ 1<br />         调试输出 (整数数组 <i>)<br />     .如果真结束<br />     .如果真 (当前次数 ≥ 输出次数)<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .计次循环尾 ()

zhtcCC

是要输入所有比他大的   还是就比他大最接近的他这个。如果是输出所有的就一个循环 取出来一个个的对比大的就出，如果是最接近的那个就排序一下 再对比输入。 两个一样的都要输出就找到了之后 再判断下一个。