//1.

Count Distinct Elements In Every Window Of Size K

public static ArrayList<Integer> solution(int[] arr, int k) {

ArrayList<Integer>list = new ArrayList<>();
HashMap<Integer,Integer> map = new HashMap<>();
for(int i=0; i<k-1; i++)
{
map.put(arr[i], map.getOrDefault(arr[i],0)+1);
}
for(int j=0, i=k-1; i<arr.length;)
{
map.put(arr[i], map.getOrDefault(arr[i],0)+1);
list.add(map.size());

int freq = map.get(arr[j]);

if(freq==1){
map.remove(arr[j]);
}else{
map.put(arr[j],freq-1);
}
i++;
j++;
}

return list;
}

7
1 2 1 3 4 2 3
4

ans: 3 4 4 3
---------------------------------------------------------------------
//Largest Subarray With Zero Sum

public static int solution(int[] arr) {

// write your code here
HashMap<Integer, Integer> map = new HashMap<>();
int i=-1;
int sum =0;
int mlen = 0;
while(i<arr.length-1)
{
i++;
sum +=arr[i];

if(map.containsKey(sum))
{
mlen = Math.max(mlen, i-map.get(sum));
}
else
map.put(sum,i);
}

return mlen;
}

8
15 -2 2 -8 1 7 10 23
ans: 5
-----------------------------------------------------------------------
//Count Of All Subarrays With Zero Sum
Note: only those will make sum subarray whoes freq repeated;
sum repeated means after becoming zero again.

HashMap<Integer, Integer>map = new HashMap<>();

int i = -1;
int sum = 0;
int count = 0;
map.put(0,1);
while(i<arr.length-1)
{
i++;
sum += arr[i];

if(map.containsKey(sum)){
count += map.get(sum); //stored freq of sum
map.put(sum, map.get(sum)+1);
}else{
map.put(sum,1);
}
}
return count;

8
15 -2 2 -8 1 7 10 23
ans: 3
---------------------------------------------------------------------
//Largest Subarray With Contiguous Elements
note: (maxele - minele = i - j); then sequence must be contiguous.
if repeat ele found skip or break;

public static int solution(int[] arr) {

int n = arr.length;
int ans = 0, len = 0;
for(int i=0; i<n; i++)
{ int max = arr[i];
int min = arr[i];
HashSet<Integer> map = new HashSet<>();
map.add(arr[i]);
for(int j=i+1; j<n; j++)
{
if(map.contains(arr[j]))
break;
map.add(arr[j]);

max = Math.max(max, arr[j]);

min = Math.min(min, arr[j]);

if(max-min==j-i)
{
len = j-i+1;
ans = Math.max(len,ans);
}
}
return ans;
3
10 12 11
ans: 3

----------------------------------------------------------------------------------
//Smallest Substring Of A String Containing All Characters Of Another String

public static String solution(String s1, String s2){

String ans = "";

HashMap<Character, Integer>map2 = new HashMap<>();

for(int i=0; i<s2.length(); i++)
{
char ch = s2.charAt(i);
map2.put(ch, map2.getOrDefault(ch,0)+1);
}

int mct = 0;
int dmct = s2.length(); //s2 len substring we want

HashMap<Character, Integer> map1 = new HashMap<>();

int i= -1;
int j = -1;

while(true)
{
boolean f1 = false;
boolean f2 = false;

//aquire from s1

while(i<s1.length()-1 && mct < dmct)

{
i++;
char ch = s1.charAt(i);
map1.put(ch, map1.getOrDefault(ch,0)+1);

//we are putting char freq in front of char.

if(map1.getOrDefault(ch,0) <= map2.getOrDefault(ch,0))
mct++;

f1 = true;
}

//collect answers and release

while(j<i && mct==dmct)

{
String pans = s1.substring(j+1, i+1);
if(ans.length() == 0 || pans.length() < ans.length())
ans = pans; //we want small substring

j++;
char ch = s1.charAt(j);
if(map1.get(ch)==1){
map1.remove(ch);
}
else{
map1.put(ch, map1.get(ch)-1);
}
 if(map1.getOrDefault(ch,0) < map2.getOrDefault(ch,0))
mct--;

f2 = true;
}
if(f1==false && f2==false)
break;
}
return ans;
}

timetopractice
toc
ans: toprac

-------------------------------------------------------------------------------
Note: Hashset takes unique elements. (creates map of unique elements)
//Smallest Substring Of A String Containing All Unique Characters Of Itself

public static int solution(String str){

int ans = str.length();
int n = str.length();
HashSet<Character>set = new HashSet<>();
for(int i=0; i<n; i++)
{
char ch = str.charAt(i);
set.add(ch);
}

int i = -1;
int j = -1;
HashMap<Character, Integer>map = new HashMap<>();

while(true)
{ boolean f1 = false;
boolean f2 = false;

//aquire till map.size() < set.size()

while(i<str.length()-1 && map.size() < set.size())

{
i++;
char ch = str.charAt(i);
map.put(ch, map.getOrDefault(ch,0)+1);

f1 = true;
}

//collect and release

while(j<i && map.size() == set.size())
{
int plen = i-j;
if(plen<ans) ans = plen;

j++;
char ch = str.charAt(j);
if(map.get(ch)==1){
map.remove(ch);
 }else{
map.put(ch, map.get(ch)-1);
}
f2 = true;
}
if(f1==false && f2==false)
break;
}
return ans;
}

i/p : aabcbcdbca
o/t : 4

---------------------------------------------------------------------
//Longest Substring With Non Repeating Characters

public static int solution(String str) {

int ans = 0;
int i = -1;
int j = -1;
HashMap<Character, Integer> map = new HashMap<>();

while(true)
{
boolean f1 = false;
boolean f2 = false;

//aquire
while(i<str.length()-1)
{ f1 = true;

i++;
char ch = str.charAt(i);
map.put(ch, map.getOrDefault(ch,0)+1);

if(map.get(ch)==2)
{
break;
}
else{
int len = i-j;
if(len>ans)
ans = len;
}
}

//release
while(j<i)
{ f2 = true;

j++;
char ch = str.charAt(j);
map.put(ch, map.get(ch)-1);

if(map.get(ch)==1)
break;

}
 if(f1==false && f2==false)
break;
}

return ans;

i/p : aabcbcdbca
o/p : 4