```1.) Maximum subarray size, such that all subarrays of that size have sum less than k:
-------------------------------------------------------------------------------------
Given an array of n positive integers and a positive integer k, the task is to find the maximum 	subarray size such that all subarrays of that size have the sum of elements less than k.

https://www.geeksforgeeks.org/maximum-subarray-size-subarrays-size-sum-less-k/

2.) Find the prime numbers which can written as sum of most consecutive primes:
-------------------------------------------------------------------------------
Given an array of limits. For every limit, find the prime number which can be written as the 	 sum of the most consecutive primes smaller than or equal to the limit.

https://www.geeksforgeeks.org/find-prime-number-can-written-sum-consecutive-primes/

3.) Longest Span with same Sum in two Binary arrays :
-----------------------------------------------------
Given two binary arrays, arr1[] and arr2[] of the same size n. Find the length of the longest       common span (i, j) where j >= i such that arr1[i] + arr1[i+1] + …. + arr1[j] = arr2[i] +           arr2[i+1] + …. + arr2[j].

https://www.geeksforgeeks.org/longest-span-sum-two-binary-arrays/

3.) Maximum subarray sum modulo m:
----------------------------------
Given an array of n elements and an integer m. The task is to find the maximum value of the sum 	of its subarray modulo m i.e find the sum of each subarray mod m and print the maximum value of 	this modulo operation.

https://www.geeksforgeeks.org/maximum-subarray-sum-modulo-m/

4.) Maximum subarray size, such that all subarrays of that size have sum less than k:
-------------------------------------------------------------------------------------
Given an array of n positive integers and a positive integer k, the task is to find the maximum 	subarray size such that all subarrays of that size have sum of elements less than k.

https://www.geeksforgeeks.org/maximum-subarray-size-subarrays-size-sum-less-k/

5.) Minimum cost for acquiring all coins with k extra coins allowed with every coin:
---------------------------------------------------------------------------------
You are given a list of N coins of different denominations. you can pay an amount equivalent to 	any 1 coin and can acquire that coin. In addition, once you have paid for a coin, we can choose 	at most K more coins and can acquire those for free. The task is to find the minimum amount 	required to acquire all the N coins for a given value of K.

https://www.geeksforgeeks.org/minimum-cost-for-acquiring-all-coins-with-k-extra-coins-allowed-with-every-coin/

6.) Random number generator in arbitrary probability distribution fashion:
----------------------------------------------------------------------
Given n numbers, each with some frequency of occurrence. Return a random number with a 			probability proportional to its frequency of occurrence.

https://www.geeksforgeeks.org/random-number-generator-in-arbitrary-probability-distribution-fashion/```
```// Efficient : (HASHING Using Prefix Sum) : Time Complexity: O(n), Auxiliary Space: O(n)

class LargestSubArray {

// This function Prints the starting and ending
// indexes of the largest subarray with equal
// number of 0s and 1s. Also returns the size
// of such subarray.

int findSubArray(int arr[], int n)
{
int sum = 0;
int maxsize = -1, startindex = 0;
int endindex = 0;

// Pick a starting point as i

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

// Consider all subarrays starting from i

for (int j = i + 1; j < n; j++) {
if (arr[j] == 0)
sum += -1;
else
sum += 1;

// If this is a 0 sum subarray, then
// compare it with maximum size subarray
// calculated so far

if (sum == 0 && maxsize < j - i + 1) {
maxsize = j - i + 1;
startindex = i;
}
}
}
endindex = startindex + maxsize - 1;
if (maxsize == -1)
System.out.println("No such subarray");
else
System.out.println(startindex + " to " + endindex);

return maxsize;
}

/* Driver program to test the above functions */

public static void main(String[] args)
{
LargestSubArray sub;
sub = new LargestSubArray();
int arr[] = { 1, 0, 0, 1, 0, 1, 1 };
int size = arr.length;

sub.findSubArray(arr, size);
}
}
```
```// A Java program to find
// if there is a zero sum subarray
import java.util.HashSet;
import java.util.Set;

class ZeroSumSubarray
{
// Returns true if arr[]
// has a subarray with sero sum
static Boolean subArrayExists(int arr[])
{
// Creates an empty hashset hs
Set<Integer> hs = new HashSet<Integer>();

// Initialize sum of elements
int sum = 0;

// Traverse through the given array
for (int i = 0; i < arr.length; i++)
{
// Add current element to sum
sum += arr[i];

// Return true in following cases
// a) Current element is 0
// b) sum of elements from 0 to i is 0
// c) sum is already present in hash map
if (arr[i] == 0
|| sum == 0
|| hs.contains(sum))
return true;

// Add sum to hash set
}

// We reach here only when there is
// no subarray with 0 sum
return false;
}

// Driver code
public static void main(String arg[])
{
int arr[] = { -3, 2, 3, 1, 6 };
if (subArrayExists(arr))
System.out.println(
"Found a subarray with 0 sum");
else
System.out.println("No Such Sub Array Exists!");
}
}
```
```// Java program to determine if array arr[]
// can be split into three equal sum sets.

// Time Complexity: O(n), Auxiliary Space: O(1)

import java.io.*;
import java.util.*;

public class GFG {

// Function to determine if array arr[]
// can be split into three equal sum sets.
static int findSplit(int []arr, int n)
{
int i;

// variable to store prefix sum
int preSum = 0;

// variables to store indices which
// have prefix sum divisible by S/3.
int ind1 = -1, ind2 = -1;

// variable to store sum of
// entire array.
int S;

// Find entire sum of the array.
S = arr[0];
for (i = 1; i < n; i++)
S += arr[i];

// Check if array can be split in
// three equal sum sets or not.
if(S % 3 != 0)
return 0;

// Variables to store sum S/3
// and 2*(S/3).
int S1 = S / 3;
int S2 = 2 * S1;

// Loop until second last index
// as S2 should not be at the last
for (i = 0; i < n-1; i++)
{
preSum += arr[i];

// If prefix sum is equal to S/3
// store current index.
if (preSum == S1 && ind1 == -1)
ind1 = i;

// If prefix sum is equal to 2*(S/3)
// store current index.
else if(preSum == S2 && ind1 != -1)
{
ind2 = i;

// Come out of the loop as both the
// required indices are found.
break;
}
}

// If both the indices are found
// then print them.
if (ind1 != -1 && ind2 != -1)
{
System.out.print("(" + ind1 + ", "
+ ind2 + ")");
return 1;
}

return 0;
}

// Driver code
public static void main(String args[])
{
int []arr = { 1, 3, 4, 0, 4 };
int n = arr.length;
if (findSplit(arr, n) == 0)
System.out.print("-1");
}
}

// Output: (1, 2)```
```import java.util.*;
import java.io.*;

class GFG
{
static int maxOcc(int L[], int R[], int n, int maxx)
{
int arr[] = new int[1000000];

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

arr[R[i] + 1]-=1; // arr[R[i] + 1]--;
}

int maxm = arr[0], res = 0;

for(int i = 1; i < maxx; i++) // maxx = 1000000
{
arr[i] += arr[i - 1];

if(maxm < arr[i])
{
maxm = arr[i];

res = i;
}
}

return res;
}
public static void main(String args[])
{
int L[] = {1, 2, 3}, R[] = {3, 5, 7}, n = 3;

System.out.println(maxOcc(L, R, n));
}
}```
```// Efficient Method : Time Complexity : O(n), Auxilliary space : O(1)

import java.util.*;
import java.io.*;

class GFG
{
static boolean checkEquilibrium(int arr[], int n)
{
int sum = 0;

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

int l_sum = 0;

for(int i = 0; i < n; i++)
{
if(l_sum == sum - arr[i])
return true;

l_sum += arr[i];

sum -= arr[i];
}

return false;
}

public static void main(String args[])
{
int arr[] = {3, 4, 8, -9, 20, 6}, n = 6;

System.out.println(checkEquilibrium(arr, n));
}
}

// Naive Method : Time Complexity : O(n^2)

static boolean checkEquilibrium(int arr[], int n)
{
for(int i  = 0; i < n; i++)
{
int l_sum = 0, r_sum = 0;

for(int j = 0; j < i; j++)
l_sum += arr[j];

for(int j = i + 1; j < n; j++)
r_sum += arr[j];

if(l_sum == r_sum)
return true;
}

return false;
}```
```import java.util.*;
import java.io.*;

class GFG
{
// For preprocessing : O(n)
static int[] preSum(int arr[], int n)
{
int prefix_sum[] = new int[n];

prefix_sum[0] = arr[0];

for(int i = 1; i < n; i++)
{
prefix_sum[i] = prefix_sum[i - 1] + arr[i];
}

return prefix_sum;
}

// For answer queries : O(1)
static int getSum(int prefix_sum[], int l, int r)
{
if(l != 0)
return prefix_sum[r] - prefix_sum[l - 1];
else
return prefix_sum[r];
}

public static void main(String args[])
{
int arr[] = {2, 8, 3, 9, 6, 5, 4}, n = 7;

int prefix_sum[] = preSum(arr, n);

System.out.println(getSum(prefix_sum, 1, 3));

System.out.println(getSum(prefix_sum, 0, 2));

}

}```
star

Mon Feb 07 2022 15:51:57 GMT+0000 (UTC) https://www.geeksforgeeks.org/largest-subarray-with-equal-number-of-0s-and-1s/

#java #gfg #geeksforgeeks #lecture #arrays #prefixsum #subarrays #hashing
star

Mon Feb 07 2022 15:44:47 GMT+0000 (UTC) https://www.geeksforgeeks.org/find-if-there-is-a-subarray-with-0-sum/

#java #gfg #geeksforgeeks #lecture #arrays #prefixsum #subarrays #splitarray
star

Mon Feb 07 2022 15:33:54 GMT+0000 (UTC) https://www.geeksforgeeks.org/split-array-three-equal-sum-subarrays/

#java #gfg #geeksforgeeks #lecture #arrays #prefixsum #subarrays #splitarray
star

Mon Feb 07 2022 15:07:44 GMT+0000 (UTC) https://www.geeksforgeeks.org/maximum-occurred-integer-n-ranges/

#java #gfg #geeksforgeeks #lecture #arrays #prefixsum #maximumoccuredinteger