Subarray with given sum 

😅

Thanks

then u use a hashmap to store the sums for each windows

yes!

Then to use this algorithm maybe add all the elements with the most negative number so every element will be positive

You'll have to use an array with running/prefix sum to solve if the arrays also contains negatives.

yes it will work only for positive numbers, if you want to handle negatives then you have to use hashmap

Thanks :)

If first element is greater then increment both right and left pointers.

If you find either right or left element is greater then just skip over that element.

@@techdose4u sir u should have mention this.

Thanks :)

@@techdose4u what if its starts with -ve array

Copy hai code from geeks for geek site and even variable is same..

Bro gfg me ouput wrong bta rha h

@@techzone0131 lol same, but we need to add another if block if given sum==0 thn return -1

@@padiakhil7620 yes after this condition solution is perfect 😄

why not in python?

we cannot return -1 because it is a vector@@padiakhil7620

7and 3 is not a subarray

I have already answered on your comment 6 months back. Please search it in comment section. You asked the same question.

​@@techdose4u ohh sry!!!! : )

No problem :)

Even I had the same doubt , did you find its solution?

I guess the loop ends when left and right == n ?? then there is chance of moving twice hence O(2*N).

Can you help me with python script for this

Yea

Well for short time, if you have GATE notes then revise DBMS and OS atleast, otherwise, just study important MCQ questions from geeks and search for top 50 and top100 MCQ questions for interviews. That should help :)

@@techdose4u thanks a lot sir

Welcome :)

Thanks :)

Thanks

Yeah, either we are looking for something else, or this is wrong.. if its 9 at index 4, it wont know the sum of index 0, 2, 3, and 4 = 33.

Thanks :)

Welcome :)

:)

:)

Thanks bro :)

the explanation is about finding subarray and not subsequence. 5 ,4 is not a subarray.

A subarray is a contiguous part of array. An array that is inside another array

​@@PankajSingh-mm3br thanks

Termination will be when right pointer goes out of bounds, that is, when right pointer goes beyond last value in array.

Thanks :)

what if we start arr[0] is -ve

Welcome :)

@@techdose4u plz give me solution of this Write a program to find lowest number of integers in the array that sums up the given number. In java,c,c++ only no python Write a program to find lowest number of integers in the array that sums up the given number. The program should ask user to input array of integers (“Input Array”) and the required sum (“Required Sum”). The output (“Output”) should list the lowest number of integers from the input array that sums up the “Required Sum”. Refer to examples given below. Input : Array of integers Required sum Output : Elements from array which makes sum equals to given value Example: Input Array : [10, 0, -1, 20, 25, 30] Required Sum: 45 Output: [20, 25] Required Sum: 59 Output: [10, -1, 20, 30] Required Sum: 60 Output: [10, 20, 30]

Can u provide a code plz

Can u provide a code plz

You are correct. But here we are solving subarray which is continuous and not subset. So it will be N^2 for subarray.

welcome

Yes you are correct. I did not cover for negative numbers. You can do so by using the modified kadane's algorithm which works for negative numbers as well. Whenever you are given a negative number as sum then negate the sum to make it positive and also negate all the elements of the array and so sum to be found will always be positive and so you can use kadane's algorithm.

I think that would not be the case when u are solving porgram in leetcode or gfg but yeah it is possible ..

Will try to.

Pls give code

Try 2 pointer technique.

Thanks :)

There are 2^n possible subsets of an array. So yeah, you are correct. I might have mistakenly told something, my bad.

all subsets of array is O(2^n) but consecutive subsets of an array is just O(n^2).

That's for non continuous Subarray, For continuous Subarray its O(n^2)

Should not give TLE bro :( Is there any algo to calculate below O(N) time?

@@techdose4u i think sliding window, thats what i am also looking for.

@@prabhatkashyap8333 yes correct.

@@techdose4u ide.geeksforgeeks.org/iN2jy9gvuo check this, and try to submit it on GFG, practice.geeksforgeeks.org/problems/subarray-with-given-sum/0 and tell me the mistake, why TLE?

Yea :)

Agreed

You are mistaken. It's O(N) only. How did you conclude O(N^2) ?

Subarray is continuous only. If something is not continuous then it is either subsequence or subset. This will work only for subarrays.

@@techdose4u Cool I think I was looking for the solution for subsets and target sums. Thanks for the clarification.

no subarray

static ArrayList subarraySum(int[] arr, int n, int s) { ArrayList list = new ArrayList(); int left = 0, right=0; int currentsum = arr[0]; try { for(int i=1; i s) { currentsum = currentsum - arr[left]; left +=1; } } else if(currentsum > s) { currentsum = currentsum - arr[left]; left += 1; } } } catch(ArrayIndexOutOfBoundsException e) { list.add(-1); } return list; }

Yea right :)

small modification for GFG Practice: return vector{l+1,r}; instead of return vector{l,r-1};

to understand tc , always find how many times the particular element is processed . In this case as @tech dose explained , in the worst case scenario , we shall need to process the element 2 times , so total complexity = O(2* n )

as per your doubt , it will not be O(n^2) in the efficient approach ? why ? | | -----> window bounded by left and right pointers. | 1| , | 1 , 2| , | 1 , 2 ,5| , | 1 , 2 ,5 , 10| , | 2 ,5 , 10| , | 5 , 10| , | 10| ------> different states of the window in the worst case , our window can take 2n states , i.e increase and then decrease , so at max TC = O(2n).

@@supratikpadhee4235 thanks :)

@@supratikpadhee4235 thanks :) i checked it after

Now I am explaining everything with code. Earlier I dint use to do that 😅

static ArrayList subarraySum(int[] arr, int n, int s) { ArrayList list = new ArrayList(); int left = 0, right=0; int currentsum = arr[0]; try { for(int i=1; i s) { currentsum = currentsum - arr[left]; left +=1; } } else if(currentsum > s) { currentsum = currentsum - arr[left]; left += 1; } } } catch(ArrayIndexOutOfBoundsException e) { list.add(-1); } return list; } Sir might have better code structure solution has this. but mine is also working as per sir approach

This is a subset sum problem which is different from a subarray sum problem