How can I solve this problem, and what kind of algorithm is the appropriate on if any to solve it

There is an array which contains non negative integers. I need to find a subarray (if there's one) that contains numbers that have a sum which equals to a given number (target). I wrote this code that works but I try to write it in a more efficient way (O(n)).

public static void solvedNotSoEnhanced(int[] arr, int target) {
    for (int i = 0; i <= arr.length-1;i++) {
        int cur_sum = 0;
        for (int j = i ; j <= arr.length-1; j++) {
            cur_sum += arr[j];
            if (cur_sum > target) {
                break;
            } else if (cur_sum == target) {
                System.out.println("start: " + i + " end: " + j);
            }
        }
    }
}

The trick lies in the restriction:

> There is an array which contains non negative integers.

This means that when you're going through your input front-to-back, you presume that the 'start' of the subarray is at index 0, and then you start adding each number in sequence. There are only 3 options, because of that restriction:

1. Adding the new number results in a sum that is less than the desired number. In which case, keep going.
2. Adding the new number results in an exact match to the desired number. You've found the subsequence and the algorithm is done.
3. Adding the new number results in a sum that is more. In which case, the only answer can lie in moving the start up: Element 0 is not part of the solution.

Thus:

static void solvedNotSoEnhanced(int[] arr, int target) {
    if (target < 1) {
        // Always mind your corner cases!
        System.out.println("(0, 0)");
        return;
    }

    int start = 0;
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        sum += arr[i];

        while (sum > target) {
            // Target exceeded; move up our startpoint.
            sum -= arr[start];
            start++;
        }

        // If we get here, we found our subsequence!
        if (sum == target) {
            System.out.println("[" + start + ", " + i + "]");
            return;
        }
    }
    return "No subsequence";
}

Here I have used sliding window approach. Mainly I am storing the sum of elements of array as I traverse them. Then I just store 2 pointers i and j which store the position of current sub array under consideration.

public static void solvedNotSoEnhanced(int[] arr, int target) 
{
  for(int i = 1;i>arr.length;i++)
  {
    arr[i] += arr[i-1];
  }
  
  int i=0,j=1;
  while(i<arr.length &&j<arr.Length)
  {
    int sum = arr[j] - arr[i];
    if(sum == target) System.out.println("start: " + (i + 1) + " end: " + j);
    else if(sum > target) i++;
    else j++;
  }
}

It can be done in O(nlogn + m), where n is the array size, and m is the number of subarrays matching the restriction.

First, create an auxillary array sum, which is the summation of all elements up to the current:

sum[i] = arr[0] + arr[1] + ... + arr[i]
Or (equivalent definition)
sum[0] = arr[0]
sum[i] = sum[i-1] + arr[i]

Now, note that sum is sorted (increasing) array (since all elements are not negative).

So, after the array is generated, you can iterate sum, and for each i in sum, look for k-sum[i] using binary search, which will give you index j if the element exists, and (i,j) is such a subarray.

Using a hash table to store the sums instead can also be done to further reduce complexity to O(n) on average case.