First subarray with negative sum from the given Array

import java.util.ArrayList;
import java.util.List;

public class Main {
    // Function to return the index of the first negative subarray sum
    static List<Integer> findSubarray(int[] arr, int N) {
        // To store the answer
        List<Integer> ans = new ArrayList<>();

        // Find all subarrays
        for (int i = 0; i < N; i++) {
            // To store the sum of subarray
            int sum = 0;
            for (int j = i; j < N; j++) {
                // Take this element in finding the sum of subarray
                sum += arr[j];

                // If the subarray has a negative sum, then store
                // its starting and last index in the ans list
                if (sum < 0) {
                    ans.add(i);
                    ans.add(j);
                    return ans;
                }
            }
        }

        // If no subarray sum is negative
        ans.add(-1);
        return ans;
    }

    // Driver Code
    public static void main(String[] args) {
        // Given array arr[]
        int arr[] = { 1, 2, -1, 3, -4, 3, -5 };

        int n = arr.length;

        // Function Call
        List<Integer> res = findSubarray(arr, n);

        // If subarray does not exist
        if (res.get(0) == -1)
            System.out.println("-1");

        // If the subarray exists
        else {
            System.out.println(res.get(0) + " " + res.get(1));
        }
    }
}

/*package whatever //do not write package name here */
// Java program for the above approach
import java.io.*;
import java.util.*;

class GFG {

    // lower bound for a map's key
    public static int
    lowerBound(Map<Integer, List<Integer> > m, int pre_sum)
    {
        int ans = -1;
        for (Integer key : m.keySet()) {
            if (key >= pre_sum) {
                ans = key;
                break;
            }
        }
        return ans;
    }

    // lower bound for a list
    public static int lowerBoundList(List<Integer> li,
                                     int target)
    {
        int ans = -1;
        for (int i = 0; i < li.size(); i++) {
            if (li.get(i) >= target) {
                ans = i;
                break;
            }
        }
        return ans;
    }

    // Function to check if a sum less
    // than pre_sum is present
    public static int
    b_search(int pre_sum, Map<Integer, List<Integer> > m,
             int index)
    {
      
        // Returns an iterator either equal
        // to given key or next greater
        int it = lowerBound(m, pre_sum);

        if (it == 0)
            return -1;

        // Decrement the iterator
        it--;

        List<Integer> map_list = new ArrayList<Integer>();
        map_list = m.get(it);
      
        // Check if the sum found at
        // a greater index
        int it1 = lowerBoundList(map_list, index);

        if (map_list.get(it1) > index)
            return map_list.get(it1);

        return -1;
    }

    // Function to return the index
    // of first negative subarray sum
    public static List<Integer> findSubarray(int[] arr,
                                             int n)
    {
      
        // Stores the prefix sum- index
        // mappings
        Map<Integer, List<Integer> > m
            = new HashMap<Integer, List<Integer> >();

        for (int i = 0; i < n; i++) {
            List<Integer> a = new ArrayList<Integer>();
            a.add(0);
            m.put(i, a);
        }

        int sum = 0;

        // Stores the prefix sum of
        // the original array
        int[] prefix_sum = new int[n];

        for (int i = 0; i < n; i++) {
            sum += arr[i];

            // Check if we get sum negative
            // starting from first element
            if (sum < 0) {

                List<Integer> xyz
                    = new ArrayList<Integer>();
                xyz.add(0);
                xyz.add(i);
                return xyz;
                // return { 0, i };
            }
            List<Integer> xyz = new ArrayList<Integer>();
            xyz.add(i);
            prefix_sum[i] = sum;
            m.put(sum, xyz);
        }

        // Iterate through array find
        // the sum which is just less
        // then the previous prefix sum
        for (int i = 1; i < n; i++)
        {

            // Check if the starting element
            // is itself negative
            if (arr[i] < 0)
            {
              
                // arr[i] becomes the required
                // subarray
                List<Integer> ret
                    = new ArrayList<Integer>();
                ret.add(i);
                ret.add(i);
                return ret;
                // return { i, i };
            }
            else {
                int pre_sum = prefix_sum[i - 1];

                // Find the index which forms
                // negative sum subarray
                // from i-th index
                int index = b_search(pre_sum, m, i);

                // If a subarray is found
                // starting from i-th index
                if (index != -1) {

                    List<Integer> ret
                        = new ArrayList<Integer>();
                    ret.add(i);
                    ret.add(index);
                    return ret;
                    // return { i, index };
                }
            }
        }

        // Return -1 if no such
        // subarray is present
        List<Integer> re = new ArrayList<Integer>();
        re.add(-1);
        return re;
    }

    public static void main(String[] args)
    {
      
        // Given array arr[]
        int[] arr = { 1, 2, -1, 3, -4, 3, -5 };

        int n = arr.length;

        // Function Call
        List<Integer> res = new ArrayList<Integer>();
        res = findSubarray(arr, n);

        // If subarray does not exist
        if (res.get(0) == -1)
            System.out.println("-1");

        // If the subarray exists
        else {
            System.out.print(res.get(0));
            System.out.print(" ");
            System.out.println(res.get(1));
        }
    }
}

// This code is contributed by akashish__