找出数字元素的下标

#include<stdio.h>
#include<map>
using namespace std;
int main(){
    int n,i,sum,a[1005];
    map<int,int> book;
    for(scanf("%d%d",&n,&sum),i=0;i<n;i++)
        scanf("%d",&a[i]),book[a[i]]=i;
    for(i=0;i<n;i++)
        if(book.count(sum-a[i])) break;
    i==n?printf("false\n"):printf("%d %d\n",i,book[sum-a[i]]);
}

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int sum=in.nextInt();
        /*n=6, sum=6
        2 1 7 8 5 4    满足的有（2，4）（1，5）的下标
        这时不能输出（1，4），而应该输出（0，5）
        所以该情况下不能找到一个满足的就退出，应该加多个比较，
        因此还是要遍历整个数据集的，除非找到了第一个数下标是0；
        时间O(N)  空间O(N)
        */
        Map<Integer,Integer> map=new HashMap<>();
        int pre=Integer.MAX_VALUE;
        int next=-1;
        for(int i=0;i<n;i++){
            int temp=in.nextInt();
            if(map.containsKey(sum-temp)){
                int val=map.get(sum-temp);
                if(val<pre){
                    pre=val;
                    next=i;
                    if(pre==0)
                        break;
                }
            }else
                map.put(temp,i);
        }
        if(next==-1) System.out.print("false");
        else System.out.print(pre+" "+next);
    }
}

# -*- coding:utf-8 -*-
# 解题思路：  # 输入数组先排序  # 设置头尾两个指针，第一个元素和最后一个元素 # 元素相加，如果大于sum, 则尾指针向前移1个元素，继续判断两个数的和；
# 如果小于sum，则头指针向后移1个元素，继续判断两个数的和
def quick_sort(nums,left,right):
    if left>right:
       return False
    if left==right:
        return nums
    pivot=Partition(nums,left,right)
    quick_sort(nums,left,pivot-1)  # 继续处理基准左边的序列
    quick_sort(nums,pivot+1,right)    # 继续处理基准右边的序列
    return nums
def Partition(nums,left,right):    # 这个函数很重要，很多函数可以调用这个Partition函数！！！
    pivotkey = nums[left]
    i = left
    j = right
    while (i != j):
        # 先移动右边的哨兵j，遇到比基准小的元素则停止移动
        while (nums[j] >= pivotkey and i < j):
            j -= 1
        # 再移动左边的哨兵i
        while (nums[i] <= pivotkey and i < j):
            i += 1
        # 交换，让较小值位于较大值的左边
        if (i < j):
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp
    # 最终将基准数归位
    nums[left] = nums[i]
    nums[i] = pivotkey
    return i
class Solution:
    def IsSum(self,array,sum_num):
        length=len(array)
        #非法输入
        if not array&nbs***bsp;sum_num<1&nbs***bsp;sum_num>10**9&nbs***bsp;length<1&nbs***bsp;length>1000:
            return False
        left=0
        right=length-1
        result=[]
        while(left<right):
            if(array[left]+array[right]==sum_num):
                result.append(left)
                result.append(right)
                break
            elif (array[left]+array[right]>sum_num):
                right-=1
            else:
                left+=1
        if not result:
            return False
        else:
            return result
if __name__ == '__main__':
    Line1=list(map(int,input().split(' ')))
    array=list(map(int,input().split(' ')))
    # 非法输入
    # 输入数组排序
    length = len(array)
    left = 0
    right = length - 1
    sorted_array=quick_sort(array, left, right)
    sum_num=Line1[1]
    s=Solution()
    result=s.IsSum(sorted_array,sum_num)
    for i in result:
        print(i,end=' ')

请检查是否存在语法错误或者数组越界非法访问等情况，case通过率为50.00%，请问为什么

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int sum=sc.nextInt();
        int[] ai=new int[n];
        for(int i=0;i<n;i++){
            ai[i]=sc.nextInt();
        }
        qiuhe(ai,sum);
    }
    
    public static void qiuhe(int[] ai,int sum){
       Map<Integer,Integer> map=new HashMap<Integer,Integer>();
       int n=ai.length-1;
        for(int i=0;i<ai.length-1;i++){
            for(int j=i+1;j<ai.length;j++){
                if(ai[i]+ai[j]==sum){
                    n=Math.min(n,i);
                    map.put(i,j);
                }
            }
        }
        if(map.containsKey(n)){
           System.out.print(n+" "+map.get(n));
        }else{
              System.out.print(false);
        }
        
    }