├── 060_edit distance.cpp
├── 065_kmp algo.cpp
├── 064_rabin karp algo.cpp
├── 071_boyre mooore algo.cpp
├── 078_valid ip adress.cpp
├── 055_longest recurring subsequence.cpp
├── 068_Count Palindromic Subsequences.cpp
├── 077_longest common subsequence.cpp
├── strings
    ├── 052_valid string.cpp
    ├── 050_why strings are immutable in java.cpp
    ├── 067_count reversals.cpp
    ├── 073_longest common prefix.cpp
    ├── 048_string palindrome.cpp
    ├── 049_find duplicate characters.cpp
    ├── 047_reverse a string.cpp
    ├── 056_print all subsequence of a string.cpp
    ├── 072_roman no to integer.cpp
    ├── 053_count and say.cpp
    ├── 051_check string rotation.cpp
    ├── 084_remove consequtive characters.cpp
    ├── 061_next permutation.cpp
    ├── 086_customers cant get acomputer.cpp
    ├── 058_split binary string.cpp
    ├── 080_rearrange characters.cpp
    ├── 076_min swaps for bracket balancing.cpp
    ├── 062_balanced paranthesis.cpp
    ├── 074_min no of flips.cpp
    ├── 057_permutations of a string.cpp
    ├── 083_smallest window.cpp
    ├── 066_mobile numeric.cpp
    ├── 088_isomorphic strings.cpp
    ├── 075_second most repeted.cpp
    ├── 063_word break.cpp
    ├── 082_print anagrams together.cpp
    ├── 087_min operations-transform.cpp
    ├── 069_count a no of given strings.cpp
    └── 081_min char to make palindrome.cpp
├── arrays
    ├── 032_3 way partitioning.cpp
    ├── 035_median of the array.cpp
    ├── 025_given an array of size n, number k.cpp
    ├── 008_Kadanes algo.cpp
    ├── 003_ARRAYS_kth max & min.cpp
    ├── 007_cyclically rotate an arr by 1.cpp
    ├── 011_Find duplicates in an array.cpp
    ├── 016_best time to buy and sell stock.cpp
    ├── 012_merge 2 sorted arrays without extra space.cpp
    ├── 002_ARRAY_(find min & max eleement).cpp
    ├── 034_palindrome.cpp
    ├── 027_array subset of another.cpp
    ├── 026_maximum profit.cpp
    ├── 001_REVERSE AN ARRAY.cpp
    ├── 023_maximum product subarray.cpp
    ├── 028_triplet sum in array.cpp
    ├── 021_subarray with 0 sum.cpp
    ├── 006_union of 2 arrays.cpp
    ├── 029_trapping rain water.cpp
    ├── 031_smallest subarray with sum greater.cpp
    ├── 019_common elements.cpp
    ├── 004_ARRAYS_SORT without using algo.cpp
    ├── 014_next permutation.cpp
    ├── 018_cout pairs with sums.cpp
    ├── 033_min swaps.cpp
    ├── 009_minimize d max diff btw heights.cpp
    ├── 010_Minimum no. of jumps.cpp
    ├── 013_merge overlaping intervals.cpp
    ├── 005_ARRAYS_move all negitive to one side.cpp
    ├── 024_longest consecutive subsequence.cpp
    ├── 030_chocolate distribution.cpp
    └── 020_rearrage array.cpp
├── matrix
    ├── 038_search a 2d matrix.cpp
    ├── 041_sorted matrix.cpp
    ├── 044_rotate a matrix by 90.cpp
    ├── 039_median in a row wise sorted matrix.cpp
    ├── 040_row with max 1s.cpp
    ├── 037_siprally traversing a matrix.cpp
    ├── 045_kth element in matrix.cpp
    └── 043_find a specific pair in a matrix.cpp
├── 070_search a word in 2d grid.cpp
├── 046_common elements in all rows.cpp
├── LICENSE
├── 054_longest palindrome.cpp
├── 033_min swaps.cpp
├── 022_factorials of large number.cpp
├── README.md
└── 015_count inversion.cpp


/060_edit distance.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //dp problem/.... i shall do it later
 3 | 
 4 | #include<bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 | 
11 |      return 0;
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/065_kmp algo.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 
17 |      return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/064_rabin karp algo.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 
17 |      return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/071_boyre mooore algo.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 
17 |      return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/078_valid ip adress.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | idk but its a backtracking techiniqure
 6 | 
 7 | 
 8 | */
 9 | 
10 | 
11 | #include<bits/stdc++.h>
12 | 
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 
18 |      return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/055_longest recurring subsequence.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //longest recurring subsequence
 4 | 
 5 | //ill do this prob when i will start dp problems
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 | 
14 |      return 0;
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/068_Count Palindromic Subsequences.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | supoose a b a :
 5 | ps will be a b a aba:
 6 | dp problem
 7 | 
 8 | */
 9 | 
10 | 
11 | #include<bits/stdc++.h>
12 | 
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 
18 |      return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/077_longest common subsequence.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | check the last charecters for bothe string if they are equal the recursively call.
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 
17 |      return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/strings/052_valid string.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //no proper link no question only ajeeb problem
 3 | 
 4 | 
 5 | //https://www.programiz.com/java-programming/examples/check-valid-shuffle-of-strings
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 | 
14 |      return 0;
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/strings/050_why strings are immutable in java.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //why strings are immutable in java
 3 | 
 4 | //https://javarevisited.blogspot.com/2010/10/why-string-is-immutable-or-final-in-java.html#axzz6uRRrAuhP
 5 | 
 6 | //check out the link 
 7 | 
 8 | #include<bits/stdc++.h>
 9 | 
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 | 
15 |      return 0;
16 | }
17 | 
18 | 


--------------------------------------------------------------------------------
/strings/067_count reversals.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given a string S consisting of only opening and closing curly brackets '{' and '}', find out the minimum number of reversals required to convert the string into a balanced expression.
 4 | //A reversal means changing '{' to '}' or vice-versa.
 5 | 
 6 | 
 7 | //already done this prob in parenthesis
 8 | //same thing.
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 
17 |      return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/arrays/032_3 way partitioning.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //#include<bits/stdc++.h>
 4 | //
 5 | //using namespace std;
 6 | //
 7 | //int main()
 8 | //{
 9 | //
10 | //     return 0;
11 | //}
12 | 
13 | //using quicksort
14 | 
15 | vector<int> threeWayPartition(vector<int> v, int a, int b)
16 | {
17 | 	int start=0,end=v.size-1;
18 | 	int i=0;
19 | 	
20 | 	while(i<=end)
21 | 	{
22 | 		if(v[i]<a)
23 | 		swap(v[i++],v[start++]);
24 | 		
25 | 		else if(v[i]>b)
26 | 		swap(v[i],v[end--]);
27 | 		
28 | 		else
29 | 		i++;
30 | 	}
31 | 	return v;
32 | }
33 | 


--------------------------------------------------------------------------------
/matrix/038_search a 2d matrix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | 
 4 | //search a 2d matrix
 5 | //as it is sorted we can actually6 apply binary search
 6 | 
 7 | //#include<bits/stdc++.h>
 8 | //
 9 | //using namespace std;
10 | //
11 | //int main()
12 | //{
13 | //
14 | //     return 0;
15 | //}
16 | 
17 | class Solution{
18 | 	public:
19 | 		bool searchMatrix(vector <vector<int>>&v, int t){
20 | 			for(int i=0;i<(int)v.size();i++)
21 | 			{
22 | 				if(binary_search(v[i].begin(),v[i].end(),t))
23 | 				return 1;
24 | 			}
25 | 			return 0;
26 | 		}
27 | };
28 | 


--------------------------------------------------------------------------------
/strings/073_longest common prefix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | vertical approach
 6 | 
 7 | */
 8 | 
 9 | 
10 | class Solution {
11 | public:
12 |     string longestCommonPrefix(vector<string> &s) {
13 |         string res("");
14 |         if(s.size() == 0) return res;
15 |         int i = 0;
16 |         while(1) {
17 |             for(int j = 0; j < s.size(); ++j) {
18 |                 if(i == s[j].size() || (j > 0 && s[j][i] != s[j-1][i]))
19 |                     return res;
20 |             }
21 |             res += s[0][i];
22 |             ++i;
23 |         }
24 |     }
25 | };
26 | 
27 | 


--------------------------------------------------------------------------------
/arrays/035_median of the array.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array arr[] of N integers, calculate the median
 4 | 
 5 | //#include<bits/stdc++.h>
 6 | //
 7 | //using namespace std;
 8 | 
 9 | class Solution
10 | {
11 | 	public:
12 | 		public:
13 | 			
14 | 		int find_median(vector<int> v)
15 | 		{
16 | 			sort(v.begin(),v.end());			 			//just sort the array
17 | 			if(v.size()%2==0)								//if array size is even
18 | 				return (v[v.size()/2]+v[v.size()/2-1])/2;	//avg of middle values
19 | 			else
20 | 				return v[v.size()/2];						//otherwise median will be the middle value
21 | 		}
22 | };
23 | 
24 | 
25 | 
26 | 	
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/arrays/025_given an array of size n, number k.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | //author :shreyamalogi
 4 | 
 5 | //Given an array of size n and a number k, find all elements that appear more than n/k times
 6 | 
 7 | //https://www.geeksforgeeks.org/given-an-array-of-of-size-n-finds-all-the-elements-that-appear-more-than-nk-times/
 8 | 
 9 | //ntg to practice here as this will give o(k) 
10 | //we can even use structure
11 | 
12 | //in leetcode we see majority element n/2 and n/3 times cuz
13 | //cuz those problems can be solved in o(1) space
14 | 
15 | #include<bits/stdc++.h>
16 | 
17 | using namespace std;
18 | 
19 | int main()
20 | {
21 | 
22 |      return 0;
23 | }
24 | 
25 | 


--------------------------------------------------------------------------------
/arrays/008_Kadanes algo.cpp:
--------------------------------------------------------------------------------
 1 | //author:shreyamalogi
 2 | #include<bits/stdc++.h>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 | int tt;
 9 | cin>>tt;
10 | while(tt--)
11 | {
12 | int n;
13 | cin>>n;
14 | 
15 | int a[n],i;
16 | for(i=0;i<n;i++)
17 | cin>>a[i];
18 | 
19 | int cs=a[0], ms=a[0]; //we need just 2 variables current sum and maximum sum
20 | 
21 | for(i=1; i<n; i++)
22 | {
23 | cs=max(cs+a[i],a[i]); //current sum will be maximum of ce or ce +cs
24 | ms=max(ms,cs); //maximum element will be max of max sum or current sum
25 | }
26 | cout<<ms<<endl; //print max sum
27 | }
28 | return 0;
29 | }
30 | 
31 | // 1
32 | // 5
33 | // 1 2 3 -2 5
34 | 
35 | //9
36 | 


--------------------------------------------------------------------------------
/arrays/003_ARRAYS_kth max & min.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |   int n,k;
10 |   cin>>n>>k;        
11 |   
12 |   int a[n],i;
13 |   for(i=0; i<n; i++)
14 |      cin>>a[i];         //array input is done
15 |      
16 |    sort(a,a+n);     //in-built sort function ,STL
17 |    cout<<a[k-1]<<" "<<a[n-k];  //kth min will be a[k-1]; kth max will be a[n-k]
18 |    
19 |    //suppose n=5, k=1 then a[0]
20 |     
21 |      
22 |   return 0;
23 |   }
24 |   
25 | //5 1
26 | //4 5 3 1 2
27 | //1 5       (1st min and 1st max as k=1)
28 | 
29 | //5 2
30 | //4 5 3 1 2
31 | //2 4  (2nd min and 2nd max)
32 | 
33 | 


--------------------------------------------------------------------------------
/strings/048_string palindrome.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //string palindrome
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | 
10 | int main()
11 | {
12 | 	int t;
13 | 	cin>>t;
14 | 	while(t--){
15 | 		string s;
16 | 		cin>>s;
17 | 		int n = s.length();
18 | 		
19 | 		bool palindrome = true;
20 | 		for(int i=0;i<n/2;i++)
21 | 			{
22 | 				if(s[i]!=s[n-i-1]){
23 | 					palindrome = false;
24 | 					break;
25 | 				}
26 | 
27 | 			}
28 | 			
29 | 		if(!palindrome) cout<< "not ";
30 | 		cout<<"palindrome"<<endl;	
31 | 		}
32 | 				
33 | 
34 |      return 0;
35 | }
36 | 
37 | 
38 | //2
39 | //abba
40 | //palindrome
41 | //hi
42 | //not palindrome
43 | 


--------------------------------------------------------------------------------
/strings/049_find duplicate characters.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //remove duplicates (im using mapping)
 3 | 
 4 | #include <bits/stdc++.h>
 5 | using namespace std;
 6 | void printDups(string s)
 7 | {
 8 |     map<char, int> count;
 9 |     for (int i = 0; i < s.length(); i++) {
10 |         count[s[i]]++;
11 |     }
12 |  
13 |     for (auto it : count) {
14 |         if (it.second > 1)
15 |             cout << it.first << ", count = " << it.second
16 |                  << "\n";
17 |     }
18 | }
19 | 
20 | int main()
21 | {
22 |     string s= "test string";
23 |     printDups(s);
24 |     return 0;
25 |     
26 |     
27 | }
28 | 
29 | 
30 | 
31 | //s, count = 2
32 | //t, count = 3
33 | 
34 | 


--------------------------------------------------------------------------------
/strings/047_reverse a string.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //  to reverse a string
 4 | 
 5 | #include <bits/stdc++.h>
 6 | using namespace std;
 7 |  
 8 | void reverseString(string& s)
 9 | {
10 |     int n = s.length();
11 |  
12 |     // Swap character starting from two
13 |     // corners using 2 pointer approach
14 |     for (int i=0, j=n-1; i<j; i++,j--)
15 |         swap(s[i], s[j]); 
16 | }
17 | 
18 | int main()
19 | {
20 |     //string s = "hello";
21 | 	string s;
22 | 	cin>>s;
23 |     reverseString(s);
24 |     cout << s;
25 |     return 0;
26 | }
27 | 
28 | //olleh
29 | 
30 | 
31 | //stl
32 | //reverse(s.begin(),s.end());
33 | //for(int i=0;i<s.size();i++)
34 | //	cout<<s[i]<<" ";
35 | 


--------------------------------------------------------------------------------
/070_search a word in 2d grid.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Find the string in grid
 4 | //search a word in a 2d grid of charecters
 5 | 
 6 | /*
 7 | 
 8 | Given a 2D grid of n*m of characters and a word, 
 9 | find all occurrences of given word in grid.
10 |  A word can be matched in all 8 directions 
11 |  at any point. Word is said be found in a 
12 |  direction if all characters match in this 
13 |  direction (not in zig-zag form).
14 |   The 8 directions are, horizontally left, 
15 |   horizontally right, vertically up,
16 |   vertically down and 4 diagonal directions.
17 | 
18 | 
19 | */
20 | 
21 | 
22 | #include<bits/stdc++.h>
23 | 
24 | using namespace std;
25 | 
26 | int main()
27 | {
28 | 
29 |      return 0;
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/arrays/007_cyclically rotate an arr by 1.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //cycling rotate an array by one
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int tt;
12 | 	cin>>tt;
13 | 	while(tt--){
14 |      int n;
15 |      cin>>n;
16 |      
17 |      int a[n], i;
18 |      for(i=0; i<n; ++i)
19 |      cin>>a[i];
20 |      
21 |      int last =a[n-1];
22 |      
23 |      for(i=n-2; i>=0; --i)  //prev val to next val
24 |      {
25 |      	a[i+1]=a[i];
26 | 	 }
27 | 	 
28 | 	 a[0]=last; //because a of last should come to first place
29 | 	 
30 | 	 //print
31 | 	 for(i=0; i<n; i++)
32 | 	  cout<<a[i]<<" ";
33 | 	}
34 | 	  cout<<endl;
35 |      return 0;
36 |      
37 | }
38 | 
39 | //2 5
40 | //1 2 3 4 5
41 | //5 1 2 3 4
42 | 
43 | 


--------------------------------------------------------------------------------
/strings/056_print all subsequence of a string.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //subsequences is 2 power n
 3 | //i need a variable total for 2 power n
 4 | //need 2 for loops: 
 5 | //i&(1<<j) if this value is non zero to print character
 6 | 
 7 | //we can also use recursion though
 8 | 
 9 | #include<bits/stdc++.h>
10 | 
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 | 	string s;
16 | 	cin>>s;
17 | 	
18 | 	int n=s.length();
19 | 	int total = 1<<n; 			// 2 power n
20 | 	for(int i=1;i<total;i++){
21 | 		for(int j=0;j<n;j++){		//2nd for loop scan through the string
22 | 			if(i&(1<<j))
23 | 				cout<<s[j];		//s[j] is the characeter
24 | 		}
25 | 		cout<<endl;
26 | 	}
27 |      return 0;
28 | }
29 | 
30 | 
31 | //abc
32 | 
33 | //a
34 | //b
35 | //ab
36 | //c
37 | //ac
38 | //bc
39 | //abc
40 | 


--------------------------------------------------------------------------------
/strings/072_roman no to integer.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //roman no to integer
 3 | 
 4 | 
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int convert(string s)
11 | {
12 | 	unordered_map<char,int> m;
13 | 	m['I']=1;
14 | 	m['V']=5;
15 | 	m['X']=10;
16 | 	m['L']=50;
17 | 	m['C']=100;
18 | 	m['D']=500;
19 | 	m['M']=1000;
20 | 	
21 | 	if(s.length()==1)
22 | 		return m[s[0]];
23 | 		
24 | 		int i;sum=0;
25 | 		
26 | 		for(i=0;i<s.length()-1;i++)
27 | 		{
28 | 			if(m[s[i]]<m[s[i+1]])
29 | 				sum+= m[s[i+1]-m[s[i]]];
30 | 				i++;
31 | 			else{
32 | 				sum+= m[s[i]];
33 | 			}
34 | 				
35 | 		}
36 | 		if(m[s[i]]<=m[s[i-1]]) //last char- second last
37 | 			sum+=m[s[i]];
38 | 			
39 | 			return sum;
40 | 	
41 | }
42 | 
43 | int main()
44 | {
45 | 	
46 | 	return 0;
47 | }
48 | 
49 | 


--------------------------------------------------------------------------------
/matrix/041_sorted matrix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an NxN matrix Mat. Sort all elements of the matrix.
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int tt;
12 | 	cin>>tt;
13 | 	while(tt--)
14 | 	{
15 | 		int n;
16 | 		cin>>n;
17 | 		int i,j;
18 | 		int a[n*n],k=0;
19 | 		
20 | 		for(i=0;i<n;i++){
21 | 			for(j=0;j<n;j++)
22 | 			{
23 | 				cin>>a[k++];
24 | 			}
25 | 		}
26 | 		
27 | 		sort(a, a+n*n);
28 | 		for(i=0;i<n*n;i++)
29 | 		cout<<a[i]<<" ";
30 | 	}
31 | 	
32 |     return 0;
33 | }
34 | 
35 | 
36 | 
37 | 
38 | //2
39 | //4
40 | //10 20 30 40
41 | //15 25 35 45
42 | //27 29 37 48
43 | //32 33 39 50
44 | //10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50
45 | //3
46 | //1 5 3
47 | //2 8 7
48 | //4 6 9
49 | //1 2 3 4 5 6 7 8 9
50 | 
51 | 


--------------------------------------------------------------------------------
/strings/053_count and say.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //count and say
 4 | 
 5 | //first counter kitna hai, fir value
 6 | 
 7 | //eg: 3 3   2 2 2  5    1
 8 | //so  2 3   3 2    1 5  1 1
 9 | 
10 | class Solution {
11 | public:
12 |     string countAndSay(int n) {
13 |       if(n==1) return "1";		//base case
14 | 	  if(n==2) return "11";
15 | 	  string s="11";
16 | 	  for(int i=3;i<=n;i++){
17 | 	  string t="";					//next ith value ka iteration aayega
18 | 	  s=s+'&';
19 | 	  int c=1;						//countr
20 | 	  for(int j=1;j<s.length();j++){
21 | 	  	if(s[j]!= s[j-1]){		
22 | 	  		t=t+to_string(c);		//because c is int type we need to convert to string
23 | 	  		t=t+s[j-1];
24 | 	  		c=1; 					 //reset c
25 | 		  }
26 | 		  else c++;						//agr same hai 
27 | 	  }
28 | 	  s=t;  						//update
29 |     }
30 |     return s;
31 |   }
32 | };
33 | 
34 | 


--------------------------------------------------------------------------------
/arrays/011_Find duplicates in an array.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //q11, find the duplicates of N+1 array
 4 | 
 5 | //time complexity o(n)
 6 | //space complexity o(1)
 7 | 
 8 | #include<bits/stdc++.h>
 9 | 
10 | using namespace std;
11 | 
12 | void solve()
13 | {
14 | 	int n;
15 | 	cin>>n;
16 | 	int a[n];
17 | 	for(int i=0;i<n;i++) cin>>a[i];
18 | 	
19 | 	for(int i=0;i<n;i++){
20 | 		a[a[i]%n] = a[a[i]%n]+ n;	                    //cuz when we go to index 2 it will give 8 (n+1inedx = 5+2=8) therefore: 8%6=2,15%6=3,21%6=3,
21 | 		                    
22 | 	}
23 | 	for(int i=0;i<n;i++){
24 | 		if(a[i]/n>1)  cout<<i<<endl; //which is our duplicated element
25 | 		
26 | 	}
27 | }
28 | int main()
29 | {
30 | 	solve();
31 |      return 0;
32 | }
33 | 
34 | 
35 | //6
36 | //1 2 3 3 2 3
37 | 
38 | //output, the duplicates are
39 | //2
40 | //3
41 | 
42 | 


--------------------------------------------------------------------------------
/strings/051_check string rotation.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //a program to check if strings are rotations of each other or not
 4 | 
 5 | //given 2 strings we need to say if s2 is rotation of s1
 6 | 
 7 | //tc: o(n) time complexity
 8 | 
 9 | #include<bits/stdc++.h>
10 | 
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 | 	string s1,s2;
16 | 	cin>>s1>>s2;
17 | 	
18 | 	int l1  = s1.length();		//s1 ka length and s2 ka length should be equal to get rotations
19 | 	int l2 = s2.length();
20 | 	
21 | 	if(l1!=l2) cout<<"no";
22 | 	else{
23 | 	string t= s1+s2;					//concatinate both strings to CHECK THE SUBSTRING s2
24 | 	if(t.find(s2)!=std::string::npos)	//find function 	//check if s2 is presesent or not
25 | 		cout<<"yes";
26 | 	else
27 | 		cout<<"no";
28 | 	}
29 |      return 0;
30 | }
31 | 
32 | //
33 | //AACD
34 | //ACDA
35 | //yes
36 | //adda
37 | //addsaaa
38 | //no
39 | 


--------------------------------------------------------------------------------
/arrays/016_best time to buy and sell stock.cpp:
--------------------------------------------------------------------------------
 1 | //author:shreyamalogi
 2 | 
 3 | 
 4 | //FIRST WE NEED TO RECORD THE MINIMUM VALUE WHILE TRAVERSING THROUGH THE ARRAY
 5 | 
 6 | // WE have to get maximum profit so we will compsare our max profit which is initially 0 with maximum available profit that is on that particular day if you sell a stock what will happen.
 7 |     
 8 | // so on that particular day if you brought a stock at some price so what u buy and what u sell, 
 9 | 
10 | // that differece u have to compare with the answer and that answer is the maximum value
11 | 
12 | 
13 | class Solution {
14 | public:
15 |     int maxProfit(vector<int>& v) {
16 |         
17 |         int i=0,m=0,m1=INT_MAX;
18 |         int ans=0;
19 |         for(i=0;i<v.size();i++)
20 |         {
21 |             m1=min(m1, v[i]);
22 |             ans=max(v[i]-m1,ans);
23 |          }
24 |         return ans;
25 |         
26 |     }
27 | };
28 | 


--------------------------------------------------------------------------------
/arrays/012_merge 2 sorted arrays without extra space.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 	 int n,m; //taking lengths of the array
10 | 	 cin>>n>>m;
11 | 	 
12 | 	 int a1[n], a2[m];
13 | 	 for(int i=0;i<n;i++) cin>>a1[n];
14 | 	 for(int i=0;i<m;i++) cin>>a2[m];
15 | 	 
16 | 	 //take another variable j (i will be last,j will be start)
17 | 	 int j;
18 | 	 int i=n-1;
19 | 	 j=0;
20 | 	 
21 | 	 while(i>=0 && j<m)
22 | 	 {
23 | 	 	if(a1[i]>a2[j])
24 | 	 		swap(a1[i],a2[j]);   //swap a1[i] with a2[j]
25 | 	 	else
26 | 		 break;                 //if thios condition is not true then we will break out
27 | 		 
28 | 		 i--;
29 | 		 i++;	
30 | 	 }
31 | 	 
32 | 	 //sorting both the arrays (a,a+n)
33 | 	 sort(a1, a1+n);
34 | 	 sort(a2, a2+n);
35 | 	 
36 | 	 //we dont have to output anything so its is done
37 |      return 0;
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/matrix/044_rotate a matrix by 90.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | 
 4 | //transpose and reverse coloumns
 5 | //it automatically rotates by 90 degress in clowckwise direction
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 | 	int n,m;
13 | 	cin>>n>>m;
14 | 	
15 | 	int a[n][m],i,j,k; //take k also
16 | 	for(int i=0;i<n;i++){
17 | 		for(int j=0;j<m;j++){
18 | 			cin>>a[i][j];
19 | 		}
20 | 	}
21 | 	
22 | 	//transpose in place
23 | 	for(i=0;i<n;i++)
24 | 	{
25 | 		for(j=i;j<n;j++) 				//j=i
26 | 		swap(a[i][j],a[j][i]);		   //swap
27 | 	}
28 | 	
29 | 	
30 | 	//reversing in place (in place means without taking extra space
31 | 	
32 | 	for(i=0;i<n;i++)
33 | 	{
34 | 		j=0;
35 | 		k=n-1; 					//k=c-1; r=c=n (where c rep coloums)
36 | 		while(j<k)
37 | 		{
38 | 			swap(a[j][i],a[k][i]);
39 | 			j++; 
40 | 			k--;
41 | 		}
42 | 		
43 | 	}
44 |      return 0;
45 | }
46 | 
47 | 


--------------------------------------------------------------------------------
/arrays/002_ARRAY_(find min & max eleement).cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //maximum and minimum element
 3 | //author :shreyamalogi
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |    int n;
12 |    cin>>n;
13 |    
14 |    int a[n],i;
15 |    for(int i=0; i<n; i++)
16 |    	cin>>a[i];
17 |    	
18 |    	int mn = INT_MAX, mx=INT_MIN; //SET min to INT_MAX and max to INT_MIN
19 |    	
20 |    	//minimum
21 |    	for(i=0; i<n; i++)
22 |    	{
23 |    		if(mn>a[i]) //if minimum is greater than a[i]
24 |    		   mn=a[i]; //then minimum is equal to a[i]
25 | 	   }
26 | 	 //maximum  
27 | 	for(i=0; i<n; i++)
28 |    	{
29 |    		if(mx<a[i])
30 |    		   mx=a[i];
31 | 	   }   
32 | 	 
33 | 	 //finally print minimum and maximum  
34 | 	 cout<<mn<<" "<<mx<<endl;
35 |    	
36 |    
37 |   return 0;
38 |   }
39 |   
40 |   
41 |    //input
42 | //5
43 | //3 4 5 1 2
44 | 
45 |    //output
46 | //1 5
47 | 
48 | 


--------------------------------------------------------------------------------
/arrays/034_palindrome.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //min no of opertations req to make an array palindrome
 3 | 
 4 | #include<bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 | 	int tt;
11 | 	cin>>tt;
12 | 	while(tt--)
13 | 	{
14 | 		int n;
15 | 		cin>>n;
16 | 		int a[n],i;
17 | 		for(i=0;i<n;i++) cin>>a[i];
18 | 		
19 | 		int j=n-1,ans=0;
20 | 		i=0;
21 | 		while(i<=j) //2 pointer prob
22 | 		{
23 | 			if(a[i]==a[j]) //the corner elements are equal move both the pointers
24 | 			{
25 | 				i++;
26 | 				j--;
27 | 			}
28 | 			else if(a[i]>a[j])
29 | 			{
30 | 				j--;
31 | 				a[j]+=a[j+1]; //merge
32 | 				ans++;
33 | 				
34 | 			}
35 | 			else
36 | 			{
37 | 				i++;
38 | 				a[i]+=a[i-1];
39 | 				ans++;
40 | 			}
41 | 		}
42 | 		cout<<ans<<endl;
43 | 	}
44 |      return 0;
45 | }
46 | 
47 | 
48 | //2
49 | //5
50 | //3 2 3 3 5
51 | 
52 | //1
53 | 
54 | //4
55 | //5 3 3 4
56 | 
57 | //3
58 | 
59 | 


--------------------------------------------------------------------------------
/strings/084_remove consequtive characters.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | recursively remove all the duplicates or
 6 | Remove Consecutive Characters 
 7 | 
 8 | im using 2 pointer approach 
 9 | 
10 | */
11 | 
12 | 
13 | #include<bits/stdc++.h>
14 | using namespace std;
15 | 
16 | void removeduplicate(string s)
17 | {
18 |     if(s.length()<2)
19 |         cout<<s<<endl;
20 |         
21 |     else
22 |     {
23 |         int i,j=0;
24 |         for(i=1;i<s.length();++i)
25 |         {
26 |             if(s[j]!=s[i])
27 |             {
28 |                 j++;
29 |                 s[j]=s[i];
30 |             }
31 |         }
32 |         
33 |         cout<<s.substr(0,j+1)<<endl;
34 |     }
35 | }
36 | 
37 | int main() {
38 | 	
39 | 	int t;
40 | 	cin>>t;
41 | 	while(t--)
42 | 	{
43 | 	    string s;
44 | 	    cin>>s;
45 | 	    removeduplicate(s);
46 | 	}
47 | 	return 0;
48 | }
49 | 
50 | 
51 | //1
52 | //aabb
53 | //ab
54 | 


--------------------------------------------------------------------------------
/arrays/027_array subset of another.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //author :shreyamalogi
 3 | 
 4 | //we actually have 4 methods of approach
 5 | //but im using hashing unordered map approach cuz its optimized way but this maping i think we acnt use in interviews
 6 | 
 7 | //tc: o(n)
 8 | //sc: o(n)
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	int tt;
17 | 	cin>>tt;
18 | 	while(tt--){
19 | 	int m,n;
20 | 	cin>>m>>n;
21 | 	int a[m],b[n];
22 | 	for(int i=0;i<m;i++) cin>>a[i];
23 | 	for(int i=0;i<n;i++) cin>>b[i];
24 | 	
25 | 	unordered_map<int,int>m1;
26 | 	
27 | 	for(int i=0;i<m;i++) m1[a[i]]++;
28 | 	
29 | 	int c=0;
30 | 	for(int i=0;i<n;i++){
31 | 		if(m1[b[i]]){
32 | 			c++;
33 | 		}
34 | 	}
35 | 	if(c!=n)cout<<"no"<<endl;
36 | 	else cout<<"yes"<<endl;
37 |     }
38 |      return 0;
39 | }
40 | 
41 | //2
42 | //6 4
43 | //11 1 13 2 3 7
44 | //11 3 7 1
45 | //yes
46 | //53
47 | //10 5 2 23 19
48 | //19 5 6
49 | //no
50 | 
51 | 


--------------------------------------------------------------------------------
/arrays/026_maximum profit.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Maximum profit by buying and selling a share at most twice.
 4 | 
 5 | 
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | //this is the general code for any buying and selling problem with atmost k times
12 | int maxprofit(int a[], int n,int k)
13 | {
14 | 	if(k>=n/2)
15 | 	{
16 | 		int maxp=0,i;
17 | 		for(i=0;i<n;i++)
18 | 		{
19 | 			if(a[i]>a[i-1])
20 | 			maxp+=a[i]-a[i-1];
21 | 		}
22 | 		return maxp;
23 | 	}
24 | }
25 | int mx[k+1]={0}
26 | int lp[k+1];
27 | 
28 | for(int i=0;i<k;i++)
29 | {
30 | 	lp[i]=3200;
31 | }
32 | //......................
33 | 
34 | //in this particular question that we are solving
35 | 
36 | 
37 | 
38 | int main()
39 | {
40 | 	int n;
41 | 	cin>>n;
42 | 	int a[n],i;
43 | 	int k=2; //k will be 2 cuz they are teling twice (in question)
44 | 	for(i=0;i<n;i++) cout<<a[i];
45 | 	
46 | 	cout<<maxprofit(a,n,k)<<endl;
47 |      return 0;
48 | }
49 | 
50 | //need help with this
51 | 


--------------------------------------------------------------------------------
/arrays/001_REVERSE AN ARRAY.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //reverse an array without using STL.
 3 | //author :shreyamalogi
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |  int n;  //till how many u wanna print
12 |  cin>>n;
13 |  
14 |    	int a[n],i;   
15 |    	for(i=0; i<n; ++i)
16 |    	cin>>a[i];
17 |    	
18 |    	 i=0;
19 | 	 int j=n-1; //swapING METHODS WILL TAKE TWO METHODS......first pointer will be at index 0 and second pointer will be pointing towards the last index
20 |    	 while(i<j)  //i is pointing to first element, j is pointing to last
21 |    	{
22 |    		swap(a[i], a[j]);  //swaping first element last element, 2nd element second last etc
23 |    		i++; //move first pointer forward
24 |    		j--; //move last pointer backward
25 | 	}
26 | 	   
27 | 	   //finally print the array
28 | 	   for(i=0; i<n; ++i)
29 | 	   cout<<a[i]<<" "; 
30 | 	   
31 |   	return 0;
32 |   }
33 |   
34 |   //input
35 | //5
36 | //2 3 4 6 7
37 | 
38 |  //output
39 | //7 6 4 3 2
40 | 
41 | 


--------------------------------------------------------------------------------
/arrays/023_maximum product subarray.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array Arr that contains N integers (may be positive, negative or zero). Find the product of the maximum product subarray.
 4 | //Note: Use 64-bit integer data type to avoid overflow.
 5 | 
 6 | 
 7 | // Auxiliary Space: O(1)
 8 | //Time Complexity: O(N)
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	 long long int n;
17 | 	 cin>>n;
18 | 	 long long int a[n],i;
19 | 	 for(i=0; i<n; i++) cin>>a[i];
20 | 	 
21 | 	 long long int x,y,z, mx=a[0],mn=a[0],res=a[0]; //let us take variables 
22 | 	 
23 | 	 for(i=1; i<n; i++)
24 | 	 {
25 | 	 	x=a[i];
26 | 	 	y=mx*x;
27 | 	 	z=mn*x;
28 | 	 	mx=max(x, max(y,z));
29 | 	 	mn=min(x, min(y,z));
30 | 	 	res=max(res, max(mx,mn));
31 | 	 }
32 | 	 cout<<res;
33 |      return 0;
34 | }
35 | 
36 | //5
37 | //6 -3 -10 0 2
38 | //
39 | //Explanation: Subarray with maximum product
40 | //is  6, -3, -10 which gives product as 180.
41 | 
42 | //180
43 | 
44 | 


--------------------------------------------------------------------------------
/arrays/028_triplet sum in array.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 	long long int n,sum;
10 | 	cin>>n>>sum;
11 | 	long long int a[n],i;
12 | 	for(i=0;i<n;i++)
13 | 	cin>>a[i];
14 | 	
15 | 	sort(a,a+n);
16 | 	long long int j,k,f=0;
17 | 	
18 | 	for(i=0;i<n;i++)
19 | 	{
20 | 		
21 | 		//when using 2 pointer approach 1 of them will always be fixed
22 | 		j=i+1;
23 | 		k=n-1;
24 | 		
25 | 	}
26 | 	
27 | 	while(j<k)
28 | 	{
29 | 		if (a[i]+a[j]+a[k]==sum)
30 | 		{
31 | 			f=1;
32 | 			break;
33 | 		}
34 | 		else if(a[i]+a[j]+a[k]<sum)
35 | 		j++;
36 | 		
37 | 		else
38 | 		k--;
39 | 		
40 | 		if(f)
41 | 	 break;
42 | 	 
43 | 	}
44 | 	
45 | 	if(f)
46 | 	cout<<1<<endl;
47 | 	
48 | 	else
49 | 	cout<<0<<endl;
50 | 	
51 | 	
52 | 	 
53 |      return 0;
54 | }
55 | 
56 | //n = 6, X = 13
57 | //arr[] = [1 4 45 6 10 8]
58 | //Output:
59 | //1
60 | //Explanation:
61 | //The triplet {1, 4, 8} in 
62 | //the array sums up to 13.
63 | 
64 | 


--------------------------------------------------------------------------------
/strings/061_next permutation.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | 
 4 | //Implement the next permutation, which rearranges the list of numbers into Lexicographically next greater permutation of list of numbers. If such arrangement is not possible, it must be rearranged to the lowest possible order i.e. sorted in an ascending order. You are given an list of numbers arr[ ] of size N.
 5 | 
 6 | //eg: 3 2 1 : it is lexicograp[hically largesyt so in this case the output should be all the digits in ascending order i.e 1 2 3
 7 | 
 8 | 
 9 | #include<bits/stdc++.h>
10 | 
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 | 	int t;
16 | 	cin>>t;
17 | 	while(t--)
18 | 	{
19 | 		int n;
20 | 		cin>>n;
21 | 		int a[n];
22 | 		for(int i=0;i<n;i++)
23 | 		cin>>a[i];
24 | 		
25 | 		next_permutation(a,a+n);  //just use next permutation wala function of stl
26 | 		
27 | 		for(int i=0;i<n;i++) cout<<a[i]<<" ";
28 | 		
29 | 		cout<<endl;
30 | 	}
31 |      return 0;
32 | }
33 | 
34 | //
35 | //1
36 | //6
37 | //1 2 3 6 5 4
38 | //1 2 4 3 5 6
39 | 


--------------------------------------------------------------------------------
/strings/086_customers cant get acomputer.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | Function to find Number of customers who could not get a computer
 6 | o(n) sol
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	int n;
17 | 	cin>>n;
18 | 	string s;
19 | 	cin>>s;
20 | 	
21 | 	
22 | 	int occupied=0;
23 | 	int visited[26]={0}; //extra space
24 | 	int didnotget=0; //which will be answer
25 | 	
26 | 	for(int i=0;i<s.length();i++)
27 | 	{
28 | 		if(visited[s[i]-'a']==0 && occupied <n) //this is the case when the customer visited for the first time and there is a computer whixh is unoccupied
29 | 		{
30 | 			visited[s[i]-'a']=1;
31 | 			occupied++;
32 | 		}
33 | 		else if(visited[s[i]-'a']==1 && occupied <=n) //this means the person is leaving now
34 | 		{
35 | 			occupied--;
36 | 			visited[s[i]-'a']=0; //cuz he left
37 | 		}
38 | 		else
39 | 			didnotget++;
40 | 	}
41 | 	
42 | 	cout<<didnotget/2<<endl; //by 2 is imp we cant count duplicates
43 |     return 0;
44 | }
45 | 
46 | 


--------------------------------------------------------------------------------
/046_common elements in all rows.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //common elements in all rows
 3 | 
 4 | //im using map
 5 | 
 6 | //map will help us to know how many times a particular elemet has appered
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 | 	unordered_map<int,int> map;
14 | 	
15 | 
16 | 	int n,m; //rows and coloums
17 | 	cin>>n>>m;
18 | 	int a[n][m];
19 | 	
20 | 	int i,j;
21 | 	for(i=0;i<n;i++){
22 | 		for(j=0;j<m;j++){
23 | 			cin>>a[n][m];
24 | 		}
25 | 	}
26 | 	
27 | 	
28 | 	for(j=0;j<m;j++)		//scan thru the 1st row
29 | 		map[a[0][j]]=1;		//map of
30 | 		
31 | 	for(i=1;i<n;i++)		//scan thru the 2nd row
32 | 	{
33 | 		for(j=0;j<m;j++){
34 | 			if(map[a[i][j]]=i)
35 | 			{
36 | 				map[a[i][j]]=i+1;  //increase the frequency of this element
37 | 				
38 | 				if(i==m-1)      //that is the last low(appeared in all rows)
39 | 					cout<<a[i][j]<<" ";
40 | 			}
41 | 		}
42 | 	}
43 | 	
44 |      return 0;
45 | }
46 | 
47 | //4 5
48 | //1 2 1 4 8
49 | //3 7 8 5 1
50 | //8 7 7 3 1
51 | //8 1 2 7 9
52 | 
53 | //8 1
54 | 
55 | 


--------------------------------------------------------------------------------
/arrays/021_subarray with 0 sum.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array of positive and negative numbers. Find if there is a subarray (of size at-least one) with 0 sum.
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int tt;
12 | 	cin>>tt;
13 | 	while(tt--)
14 | 	{
15 | 		int n;
16 | 		cin>>n;
17 | 		int a[n],sum=0,i;
18 | 		for(int i=0; i<n; i++)
19 | 		{
20 | 			cin>>a[i];
21 | 		}
22 | 		
23 | 		unordered_map<int,int> m;
24 | 		
25 | 		for(int i=0; i<n;i++)
26 | 		{
27 | 			sum+=a[i];     //we will take the cumulative sum which is the prefix sum
28 | 			if(sum==0)     //if the sum is 0 we will directly breakout
29 | 			break;
30 | 			
31 | 			if(m.find(sum)!=m.end())  //otherwise if the sum is found in the map we will break out
32 | 			break;
33 | 			
34 | 			m[sum]++;  //else we will say 
35 | 		}
36 | 		
37 | 		if(i==n)
38 | 		cout<<"no"<<endl;
39 | 		else
40 | 		cout<<"yes"<<endl;
41 | 		
42 | 	}
43 |      return 0;
44 |      
45 |      
46 |      
47 | }
48 | 
49 | 
50 | //5
51 | //4 2 -3 1 6
52 | 
53 | //yes
54 | 
55 | 


--------------------------------------------------------------------------------
/strings/058_split binary string.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Split the binary string into substrings with equal number of 0s and 1s
 4 | 
 5 | 
 6 | //if count of zero is equal to count of 1 thenm answerwer will be 1
 7 | 
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | int maxSubStr(string s, int n)
13 | {						
14 |     int zeroes = 0, ones = 0;	// To store the count of 0s and 1s
15 |   
16 |     // To store the count of maximum
17 |     // substrings str can be divided into
18 |     int cnt = 0;
19 |     for (int i = 0; i < n; i++) {
20 |         if (s[i] == '0') {
21 |             zeroes++;
22 |         }
23 |         else {
24 |             ones++;
25 |         }
26 |         if (zeroes == ones) {
27 |             cnt++;
28 |         }
29 |     }
30 |   
31 |     if (zeroes != ones) {
32 |         return -1;
33 |     }
34 |   
35 |     return cnt;
36 | }
37 |   
38 | 
39 | int main()
40 | {
41 |     string s;
42 |     cin>>s;
43 |     int n = s.length();
44 |     cout << maxSubStr(s, n);
45 |     return 0;
46 | }
47 | 
48 | //0100110101
49 | 
50 | //4
51 | 


--------------------------------------------------------------------------------
/arrays/006_union of 2 arrays.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | we actually need to considerv a data structure which dont allow duplicates so we take a set
 5 | ordered set will increse the time complexity so we are taking unordered set
 6 | we can use merge function: tc: o(m+n)
 7 | 
 8 | 
 9 | */
10 | 
11 | 
12 | //find the union and  of 2 sorted arrays
13 | 
14 | #include<bits/stdc++.h>
15 | 
16 | using namespace std;
17 | 
18 | int main()
19 | {
20 | 	 int tt;
21 | 	 cin>>tt;
22 | 	 while(tt--)
23 | 	 {
24 | 	 	int n,m;
25 | 	 	cin>>n>>m;
26 | 	 	int a[n],b[n],i;
27 | 	 	
28 | 	 	unordered_map<int,int>map; //cuz map contains distinct values which is our ultimate goal for this problem
29 | 	 	
30 | 	 	for(i=0; i<n; i++)
31 | 	 	{
32 | 	 		cin>>a[i];
33 | 	 		map[a[i]]++;
34 | 		 }
35 | 		 
36 | 		for(i=0;i<m;i++)
37 | 		{
38 | 			cin>>b[i];
39 | 			map[b[i]]++;
40 | 		 } 
41 | 		 cout<<map.size()<<endl;  //we can simply print the size which is the answer of the question
42 | 	 }
43 |      return 0;
44 | }
45 | 
46 | //2
47 | //5 3
48 | //1 2 3 4 5
49 | //1 2 3
50 | 
51 | //5
52 | 
53 | 
54 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 CodeMacrocosm
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/arrays/029_trapping rain water.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | //actually this prob has many sol but the best will o(n) tc, o(1) sc
 8 | 
 9 | 
10 | int main()
11 | {
12 | 	int tt;
13 | 	cin>>tt;
14 | 	while(tt--)
15 | 	{
16 | 		long long int n;
17 | 		cin>>n;
18 | 		
19 | 		long long int a[n],i;
20 | 		for(i=0;i<n;i++)  cin>>a[i];
21 | 		
22 | 		//we need variables her
23 | 		long long int sum=0, l, r, lmx=0, rmx=0;//let us take sum which will be the answer
24 | 		l=0;
25 | 		r=n-1;
26 | 		
27 | 		//so it is a 2 pointer approach untill l is less than r
28 | 		while(l<r)
29 | 		{
30 | 			if (lmx<rmx)
31 | 			{
32 | 				if(lmx<a[l])
33 | 					lmx=a[l];
34 | 			
35 | 				else
36 | 				{
37 | 					sum+=lmx-a[l];
38 | 					l++;
39 | 				}
40 | 			}
41 | 			
42 | 	     	else
43 | 			{
44 | 				if(rmx<a[r])
45 | 				rmx=a[r];
46 | 			
47 | 				else
48 | 				{
49 | 				sum+=rmx-a[r];
50 | 				r--;
51 | 				}
52 | 			}
53 | 		}
54 | 		cout<<sum<<endl;
55 | 	}
56 | 
57 |      return 0;
58 | }
59 | 
60 | //1
61 | //6
62 | //3 0 0 2 0 4
63 | //10
64 | 
65 | 


--------------------------------------------------------------------------------
/arrays/031_smallest subarray with sum greater.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array of integers (A[])  and a number x, find the smallest subarray with sum greater than the given value.
 4 | 
 5 | //sliding window technique
 6 | //we need to keep taking the sum and while sum is greater than x, we will continuosly record the minimum we will keep shrinking the left window
 7 | //i is right side, l is left side
 8 | 
 9 | //Expected Time Complexity: O(N)
10 | //Expected Auxiliary Space: O(1)
11 | 
12 | #include<bits/stdc++.h>
13 | 
14 | using namespace std;
15 | 
16 | int main()
17 | {
18 | 	int n,x;
19 | 	cin>>n>>x;
20 | 	
21 | 	int a[n],i,l=0,sum=0;
22 | 	for(i=0;i<n;i++) cin>>a[i];
23 | 	
24 | 	int mn=32000;
25 | 	
26 | 	for(i=0;i<n;i++)
27 | 	{
28 | 		sum+=a[i];
29 | 		while(sum>x)
30 | 		{
31 | 			mn=min(mn,i-l+1);
32 | 			sum-=a[l];
33 | 			l++;
34 | 		}
35 | 		cout<<mn<<endl;
36 | 	}
37 |      return 0;
38 | }
39 | 
40 | //6 51
41 | //1 4 45 6 0 19
42 | //32000
43 | //32000
44 | //32000
45 | //3
46 | //3
47 | //3
48 | 
49 | //5 9
50 | //1 10 5 2 7
51 | //32000
52 | //1
53 | //1
54 | //1
55 | //1
56 | 
57 | 


--------------------------------------------------------------------------------
/strings/080_rearrange characters.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | rearrange charecters in a string such that no two charects are the same
 6 | step1: calculate freq of all chareters in a hash array
 7 | srep2: keep and store the variable get the max frequency
 8 | if(2*maxfreq<=s.length()+1) 
 9 | */
10 | 
11 | 
12 | #include<bits/stdc++.h>
13 | 
14 | using namespace std;
15 | 
16 | int main()
17 | {
18 | 		
19 | 	int t;
20 | 	cin>>t;
21 | 	while(t--)
22 | 	{
23 | 	    string s;
24 | 	    cin>>s;
25 | 	    
26 | 	    int i,maxfreq=0;
27 | 	    int freq[26]; //hash array 26 alphabets
28 | 	    memset(freq,0,sizeof(freq));
29 | 	    
30 | 	    for(i=0;i<s.length();++i)
31 | 	    {
32 | 	        freq[s[i]-'a']++;
33 | 	        maxfreq=max(maxfreq,freq[s[i]-'a']);
34 | 	    }
35 | 	    
36 | 	    if(2*maxfreq<=s.length()+1) //if this condition satisfies we can always rearrange it
37 | 	        cout<<1<<endl;
38 | 	        
39 | 	    else
40 | 	      cout<<0<<endl;
41 | 	    
42 | 	}
43 | 
44 |      return 0;
45 | }
46 | //
47 | //3
48 | //geeksforgeeks
49 | //1
50 | //bbbabaaacd
51 | //1
52 | //bbbb
53 | //0
54 | 
55 | 


--------------------------------------------------------------------------------
/arrays/019_common elements.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given three arrays sorted in increasing order. Find the elements that are common in all three arrays.
 4 | //Note: can you take care of the duplicates without using any additional Data Structure?
 5 | 
 6 | 
 7 | //take 3 pointer approach
 8 | #include<bits/stdc++.h>
 9 | 
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 | 	int n1,n2,n3;
15 | 	cin>>n1>>n2>>n3;
16 | 	
17 | 	int a[n1],b[n2],c[n3];
18 | 	for(int i=0;i<n1;i++) cin>>a[i];
19 | 	for(int i=0;i<n2;i++) cin>>b[i];
20 | 	for(int i=0;i<n3;i++) cin>>c[i];
21 | 	
22 | 	unordered_map<int,int> m1,m2,m3;
23 | 	
24 | 	for(int i=0;i<n1;i++) m1[a[i]]++;
25 | 	for(int i=0;i<n2;i++) m2[b[i]]++;
26 | 	for(int i=0;i<n3;i++) m3[c[i]]++;
27 | 	
28 | 	vector<int> v;
29 | 	for(int i=0;i<n1;i++)
30 | 	{
31 | 		if(m1[a[i]] and m2[a[i]] and m3[a[i]]){
32 | 			v.push_back(a[i]);
33 | 			m1[a[i]]=0;
34 | 		}
35 | 	}
36 | 	
37 | 	for(int i=0; i<v.size(); i++) 
38 | 	cout<<v[i]<<" ";
39 | 	
40 | 	
41 |   return 0;
42 | }
43 | 
44 | //6 5 8
45 | //1 5 10 20 40 80
46 | //6 7 20 80 120
47 | //3 4 15 20 30 70 80 120
48 | //
49 | //20 80
50 | 
51 | 


--------------------------------------------------------------------------------
/strings/076_min swaps for bracket balancing.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	
17 | 	int t;
18 | 	cin>>t;
19 | 	while(t--)
20 | 	{
21 | 	    long int n;
22 | 	    cin>>n;
23 | 	    string s;
24 | 	    cin>>s;
25 | 
26 |         long int i,bracket=0; //take bracket variable
27 |         long int count=0;
28 | 
29 |         for(i=0;i<n;i++)
30 |         {
31 |              
32 |             if(s[i]==']') //whenever i got bracket i did --
33 |                  bracket--;
34 |                  
35 |             else if(bracket<0) //bracket no less than 0 that means that many no of swaps i have to do
36 |              {
37 |                 count+=abs(bracket); //add absolute value of this brackt value to the count variable and bracket ++
38 |                 bracket++;
39 |              }
40 |              
41 |             else
42 |                bracket++; //if it is an opening bracket
43 |            
44 |         }
45 |         
46 |        cout<<count<<endl;
47 | 	    
48 | 	}
49 |      return 0;
50 | }
51 | 
52 | //1
53 | //[[][]]
54 | //0
55 | 
56 | 


--------------------------------------------------------------------------------
/arrays/004_ARRAYS_SORT without using algo.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | // given an array which cosists of only 0,1 and 2, sort the array without using any sorting algo
 3 | 
 4 | //so we will keep 3 variables which counts occurence of 1 2 and 3
 5 | //time complexity O(n) because we will be counting how many ones how many twos ....will be there and then fill the array accordingly
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 |   int n;
14 |   cin>>n;
15 |   
16 |   int a[n],i;
17 |   for(i=0; i<n; i++)
18 |     cin>>a[i];
19 |     
20 |    // we need 3 variables for counting 0 1 and 2
21 |    int c0=0, c1=0, c2=0; 
22 |    
23 |    for(i=0; i<n; i++)
24 |    {
25 |    	
26 |    	if (a[i]==0)
27 |    	c0++;
28 |    	
29 |    	else if(a[i]==1)
30 |    	c1++;
31 |    	
32 |    	else
33 |    	c2++;
34 |    	
35 |    }
36 |    
37 |    //first we will fill c0 then c1 thn c2 so 3 for loops
38 |    for(i=0; i<c0; i++)
39 |    a[i]=0;
40 |    
41 |    for(i=0; i<c0+c1; i++)
42 |    a[1]=1;
43 |    
44 |    while(c2--)
45 |    {
46 |    	 a[i++]=2;
47 |    }
48 |    
49 |    //finally print the result
50 |    for(i=0; i<n; i++)
51 |    cout<<a[i]<<" ";
52 |   return 0;
53 |   }
54 | 
55 | 


--------------------------------------------------------------------------------
/arrays/014_next permutation.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     void nextPermutation(vector<int>& v) {
 4 |         
 5 |         next_permutation(v.begin(),v.end());
 6 |         
 7 |     }
 8 | };
 9 | 
10 | 
11 | 
12 | ////author :shreyamalogi
13 | //
14 | 
15 | ////without using STL
16 | //class solution{
17 | //	public: 
18 | //		void nextPermutation(vector<int> & nums){
19 | //		bool flag = false;  //initialize flag variable with false
20 | //		int i;
21 | //		for(i=nums.size()-1; i>0;i++)  //traverse to the vector from right to left
22 | //		
23 | //		{
24 | //			if(nums[i]>nums[i-1])    //if an element is greater than its right neighbour
25 | //			{
26 | //				flag=true;           //then i will say flag is true
27 | //				break;               //and i will break out
28 | //			}
29 | //		}
30 | //		
31 | //		if(flag){
32 | //			int j;
33 | //			for(j=nums.size()-1; j>=i; j--){
34 | //				{
35 | //					if(nums[j]>nums[i-1])
36 | //					{
37 | //						swap(nums[j], nums[i-1]);  //swap and break out
38 | //						break;
39 | //					}
40 | //				}
41 | //			}
42 | //			else
43 | //				i=0;     //if there is no such element in the if case then make i as 0
44 | //				
45 | //			sort(nums.begin()+i, nums.end())  //next greater will be a sorted array in ascending order
46 | //		}
47 | //    };
48 | 


--------------------------------------------------------------------------------
/matrix/039_median in a row wise sorted matrix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //median in a row wise sorted array
 4 | //fundamental thinking behind this algo is that
 5 | //the median in a sorted array then it would be
 6 | //greater than n/2 elements
 7 | 
 8 | class Solution{
 9 | 	public:
10 | 		int median(<vector<int>> &m, int r, int c){
11 | 			int mn= INT_MAX;
12 | 			int mx= INT_MIN;
13 | 			
14 | 			for(int i=0;i<r;i++)
15 | 			{
16 | 				//search space will be min to max
17 | 				mn=min(mn, m[i][0]);
18 | 				mx=max(mx, m[i][c-1]);
19 | 			}
20 | 			
21 | 			//what ans we would expect = needed
22 | 			int needed=(r*c+1)/2 //row x col+2 whole divide by 2
23 | 			while(mn<mx)
24 | 			{
25 | 				int mid=mn+(mx-mn)/2;
26 | 				int cnt=0;  //initialize count
27 | 				for(int i=0;i<r;i++)
28 | 				cnt+= upper_bound(m[i].begin(), m[i].end(), mid)-m[i].begin();
29 | 				
30 | 				if(cnt<needed)
31 | 					mn=mid+1;
32 | 				else
33 | 					mx=mid;	
34 | 			}
35 | 			return min;
36 | 		}
37 | };
38 | 
39 | 
40 | //Input:
41 | //R = 3, C = 3
42 | //M = [[1, 3, 5], 
43 | //     [2, 6, 9], 
44 | //     [3, 6, 9]]
45 | //
46 | //Output: 5
47 | //
48 | //Explanation:
49 | //Sorting matrix elements gives us 
50 | //{1,2,3,3,5,6,6,9,9}. Hence, 5 is median. 
51 | 


--------------------------------------------------------------------------------
/arrays/018_cout pairs with sums.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array of N integers, and an integer K, 
 4 | //find the number of pairs of elements in the array whose sum is equal to K.
 5 | 
 6 | //basic hashing question
 7 | 
 8 | #include<bits/stdc++.h>
 9 | 
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 | 	int n,k;
15 | 	cin>>n>>k;
16 | 	
17 | 	int a[n];
18 | 	for(int i=0;i<n;i++) cin>>a[i];
19 | 	
20 | 	int cnt=0;
21 |         unordered_map<int, int>m;  //take an unordered map and store all the arrays in that map
22 |         
23 |         for(int i=0;i<n;i++)  m[a[i]]++;
24 |         for(int i=0;i<n;i++){
25 |         	cnt+=m[k-a[i]];  //then count this value where k is the required sum
26 |         
27 |         	if(k-a[i]==a[i])
28 |         	cnt--;  // suppose k is 4 nad a[i]=2 then 2+2=4 but that values u should not count
29 |         	
30 | 		} 
31 | 		//cnt/2 because we have already counted duplicates 
32 |         cout<< cnt/2;  //ultimately we have to return count/2 because we have counted a pair twice like 1 and 4 is same as 4 and 1 
33 |         
34 |     return 0;
35 | }
36 | 
37 | //4 6
38 | //1 5 7 1
39 | 
40 | //2
41 | 
42 | //Explanation: 
43 | //arr[0] + arr[1] = 1 + 5 = 6 
44 | //and arr[1] + arr[3] = 5 + 1 = 6.
45 | 
46 | 


--------------------------------------------------------------------------------
/054_longest palindrome.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //longest palindrome in a string
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | string pal(string s, int l, int r)
10 | {
11 | 	if(s=="" || l>r)
12 | 		return "";
13 | 		
14 | 	while(l>=0 && r<s.length() && s[l]==s[r])
15 | 	{
16 | 		l--;
17 | 		r++;
18 | 	}
19 | 	return s.substr(l+1,r-1-1);
20 | }
21 | 
22 | int main()
23 | {
24 | 	int tt;
25 | 	cin>>tt;
26 | 	while(tt--)
27 | 	{
28 | 		string s;
29 | 		cin>>s;
30 | 		
31 | 		int n=s.length();
32 | 		
33 | 		//check for odd length and even length palindromes
34 | 		//and take the longest outta them
35 | 		//pal func will check for the palindrome around the center
36 | 		
37 | 		string longest = s.substr(0,1);
38 | 		for(int i=0;i<n-1;i++)
39 | 		{
40 | 			string p1 = pal(s,i,i);
41 | 			if(p1.length()>longest.length())
42 | 				longest = p1;
43 | 				
44 | 				string p2 = pal(s,i,i+1);
45 | 			if(p2.length()>longest.length())
46 | 				longest = p2;
47 | 		}
48 | 		cout<<longest<<endl;
49 | 	}
50 |      return 0;
51 | }
52 | 
53 | //2
54 | //aaaabbaa
55 | //aaaabbaa
56 | //abc
57 | //abc
58 | 
59 | 
60 | //Input:
61 | //S = "aaaabbaa"
62 | //Output: aabbaa
63 | //Explanation: The longest Palindromic
64 | //substring is "aabbaa".
65 | 
66 | 


--------------------------------------------------------------------------------
/strings/062_balanced paranthesis.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //balanced paranthesis checker
 4 | 
 5 | //by using stack method
 6 | 
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | bool cmp(char b,char c)
10 | {
11 | 
12 |     if(b=='{' && c=='}')
13 |         return true;
14 |     else if(b=='[' && c==']')
15 |         return true;
16 |     else if(b=='(' && c==')')
17 |         return true;
18 |      return false;
19 | }
20 | bool ispar(string x)
21 | {
22 |     stack<char> s;
23 |     for(int i=0;i<x.size();i++)
24 |     {
25 |         if(x[i]=='[' || x[i]=='{' || x[i]=='(')
26 |             s.push(x[i]);
27 |         else if(x[i]==']' || x[i]=='}' || x[i]==')')
28 |         {
29 |             if(s.empty() || !cmp(s.top(),x[i]))
30 |                 return false;
31 |             else
32 |                 s.pop();
33 |         }
34 |     }
35 |     if(s.empty())
36 |         return true;
37 |     else
38 |         return false;
39 | }
40 | int main()
41 | {
42 |    int t;
43 |    string a;
44 |    cin>>t;
45 |    while(t--)
46 |    {
47 |        cin>>a;
48 |        if(ispar(a))
49 |         cout<<"balanced"<<endl;
50 |        else
51 |         cout<<"not balanced"<<endl;
52 |    }
53 | }
54 | 
55 | //
56 | //2
57 | //{([])}
58 | //balanced
59 | //([]
60 | //not balanced
61 | 
62 | 


--------------------------------------------------------------------------------
/033_min swaps.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array of n positive integers and a number k. Find the minimum number of swaps required to bring all the numbers less than or equal to k together.
 4 | 
 5 | //2 pointer sliding window technique
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int ans(int a[], int n, int k){
12 | 		//less than or equal to k
13 | 		int cnt=0;
14 | 		for(int i=0;i<n;i++)
15 | 		if (a[i]<=k)
16 | 		++cnt;  //count how many elements are less than k
17 | 		
18 | 		//find unwanted elements in current window of size cnt
19 | 		int bad=0;
20 | 		for(int i=0;i<cnt;i++)
21 | 		if(a[i]>k)
22 | 		++bad;
23 | 		
24 | 		//initialize ans with bad value of current window
25 | 		int ans=bad;
26 | 		for(int i=0,j=cnt;j<n;i++,j++)   //i is left side of the window, j is right side
27 | 		
28 | 		//decrement cnt of prev window
29 | 		if(a[i]>k)
30 | 			--bad;
31 | 		
32 | 		//increment the cnt of the current window
33 | 		if(a[j]>k)
34 | 			++bad;
35 | 		
36 | 		//update ans if count of bad is less in ciurrent window
37 | 		ans=min(ans,bad);
38 | 	}
39 |      return ans;
40 | }
41 | 
42 | int main()
43 | {
44 | 	int t;
45 | 	cin>>t;
46 | 	while(t--)
47 | 	{
48 | 		int n;
49 | 		cin>>n;
50 | 		int i,a[n],k;
51 | 		for(i=0;i<n;i++) cin>>a[i];
52 | 		cout<<ans<<endl;
53 | 	}
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/arrays/033_min swaps.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array of n positive integers and a number k. Find the minimum number of swaps required to bring all the numbers less than or equal to k together.
 4 | 
 5 | //2 pointer sliding window technique
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int ans(int a[], int n, int k){
12 | 		//less than or equal to k
13 | 		int cnt=0;
14 | 		for(int i=0;i<n;i++)
15 | 		if (a[i]<=k)
16 | 		++cnt;  //count how many elements are less than k
17 | 		
18 | 		//find unwanted elements in current window of size cnt
19 | 		int bad=0;
20 | 		for(int i=0;i<cnt;i++)
21 | 		if(a[i]>k)
22 | 		++bad;
23 | 		
24 | 		//initialize ans with bad value of current window
25 | 		int ans=bad;
26 | 		for(int i=0,j=cnt;j<n;i++,j++)   //i is left side of the window, j is right side
27 | 		
28 | 		//decrement cnt of prev window
29 | 		if(a[i]>k)
30 | 			--bad;
31 | 		
32 | 		//increment the cnt of the current window
33 | 		if(a[j]>k)
34 | 			++bad;
35 | 		
36 | 		//update ans if count of bad is less in ciurrent window
37 | 		ans=min(ans,bad);
38 | 	}
39 |      return ans;
40 | }
41 | 
42 | int main()
43 | {
44 | 	int t;
45 | 	cin>>t;
46 | 	while(t--)
47 | 	{
48 | 		int n;
49 | 		cin>>n;
50 | 		int i,a[n],k;
51 | 		for(i=0;i<n;i++) cin>>a[i];
52 | 		cout<<ans<<endl;
53 | 	}
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/strings/074_min no of flips.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | implimentation : flip every 1 with 0 and 0 with 1
 6 | take the min 
 7 | 
 8 | */
 9 | 
10 | 
11 | #include <iostream>
12 | using namespace std;
13 | 
14 | int main() 
15 | {
16 | 	int t;
17 | 	cin>>t;
18 | 	while(t--)
19 | 	{
20 | 	    string s;
21 | 	    cin>>s;
22 | 	    int n=s.size();
23 | 	    
24 | 	    int count1=0; //toggle 1
25 | 	    for(int i=0;i<n;i++)
26 | 	    {
27 | 	        if(i%2==0)
28 | 	        {
29 | 	            if(s[i]!='1')
30 | 	            {
31 | 	                count1++;
32 | 	            }
33 | 	        }
34 | 	        else
35 | 	        {
36 | 	            if(s[i]!='0')
37 | 	            {
38 | 	                count1++;
39 | 	            }
40 | 	        }
41 | 	        
42 | 	    }
43 | 	    
44 | 	    int count2=0; //toggle 2
45 | 	    for(int i=0;i<n;i++)
46 | 	    {
47 | 	        if(i%2==0)
48 | 	        {
49 | 	            if(s[i]!='0')
50 | 	            {
51 | 	                count2++;
52 | 	            }
53 | 	        }
54 | 	        else
55 | 	        {
56 | 	            if(s[i]!='1')
57 | 	            {
58 | 	                count2++;
59 | 	            }
60 | 	        }
61 | 	        
62 | 	    }
63 | 	    cout<<min(count1,count2)<<endl;
64 | 	}
65 | 	return 0;
66 | }
67 | 
68 | 
69 | //2
70 | //001
71 | //1
72 | //0001010111
73 | //2
74 | 


--------------------------------------------------------------------------------
/arrays/009_minimize d max diff btw heights.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | { 
 9 |    // we need n, k and arr
10 | 	int n;
11 | 	cin>>n;
12 | 	int k;
13 | 	cin>>k;
14 | 	int a[n],i;
15 | 	for(i=0; i<n; i++)
16 | 	cin>>a[i];
17 | 	
18 | 	//lets sort to get min and max
19 | 	
20 | 	sort(a,a+n);
21 | 	
22 | 	int small=a[0]+k;
23 | 	int big=a[n-1]-k;
24 | 	
25 | 	//swap it
26 | 	if(small>big)
27 | 	swap(small,big);
28 | 	
29 | 	//run a loop from 1 to n-1
30 | 	for(i=1;i<n-1;i++)
31 | 	{
32 | 		int sub=a[i]-k;
33 | 		int add=a[i]+k;
34 | 		
35 | 		if(sub>=small || add<=big)
36 | 			continue; //then do ntg
37 | 		
38 | 		else if(big-sub<=add-small)	
39 | 			small=sub;
40 | 			
41 | 		else
42 | 			big=add;	
43 | 		
44 | 		}
45 | 		
46 | 		//print
47 | 		cout<<min(big-small, a[n-1]-a[0]); //if there is no operatipon then ultimately min-max
48 | 	
49 |      return 0;
50 | }
51 | 
52 | //4
53 | //2
54 | //1 5 8 10
55 | //
56 | //5
57 | 
58 | 
59 | // nav the rabbit
60 | 
61 | // int getMinDiff(int arr[], int n, int k) {
62 | // sort(arr, arr+n);
63 | // int mn{},mx{},ans=arr[n-1]-arr[0];
64 | // for(int i=1;i<n;i++){
65 | // if(arr[i]>=k){
66 | // mx=max(arr[i-1]+k,arr[n-1]-k);
67 | // mn=min(arr[0]+k,arr[i]-k);
68 | // ans=min(ans,mx-mn);
69 | // }
70 | // }
71 | // return ans;
72 | 
73 | 


--------------------------------------------------------------------------------
/arrays/010_Minimum no. of jumps.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //author :shreyamalogi
 3 | //mimimum no. of jumps
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	 int tt;
12 | 	 cin>>tt;
13 | 	 while(tt--)
14 | 	 {
15 | 	 	int n;
16 | 	 	cin>>n;
17 | 	 	int a[n],i;
18 | 	 	for(i=0; i<n; i++)
19 | 	 	cin>>a[i];
20 | 	 	
21 | 	 	int mx=a[0], step=a[0], jump=1; //initially 3 variables
22 | 	 	for(int i=1; i<n; i++)          //run a loop from 1 to n
23 | 	 	{
24 | 	 		if(i==n-1)               //if i becomes n-1, i have to
25 | 	 		{cout<<jump;              //print jump
26 | 	 		  break;                  //and break out
27 | 	 		}
28 | 	 		mx=max(mx,a[i]+i);        //otherwise my max will be updated to/with a[i]+i
29 | 	 	step--;                      //then i will decrease step count and check 	
30 | 	 	if(step==0)                  //if step becomes 0
31 | 	 	{
32 | 	 		jump++;                  //then increment jump
33 | 	 		if(i>=mx)
34 | 	 		{
35 | 	 			cout<<-1;
36 | 	 			break;
37 | 			}
38 | 			
39 | 			step=mx-i;
40 | 		}
41 | 	}
42 | 	    
43 |  
44 | 	 if(i!=n)                      //if i is not equal to n
45 | 	 	cout<<-1<<endl;            //then i will print -1
46 |  }
47 |      return 0;
48 | }
49 | 
50 | 
51 | //2
52 | //11
53 | //1 3 5 8 9 2 6 7 6 8 9
54 | //
55 | //6
56 | //1 4 3 2 6 7
57 | //
58 | 
59 | 
60 | 
61 | //3
62 | //2.
63 | 
64 | 


--------------------------------------------------------------------------------
/matrix/040_row with max 1s.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //it is sorted....whenever v get 0 go to next row
 4 | //if we are getting 1, then go to next coloumn
 5 | //using this approach we will get row with max no of ones
 6 | 
 7 | //author :shreyamalogi
 8 | 
 9 | #include<bits/stdc++.h>
10 | 
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 | 	int n,m;
16 | 	cin>>n>>m;
17 | 	int a[n][m];
18 | 	for(int i=0;i<n;i++){
19 | 		for(int j=0;j<m;j++){
20 | 			cin>>a[i][j];
21 | 		}
22 | 	}
23 | 	
24 | 		int mre =0; //max row element
25 | 		int j=m-1;
26 | 		int i=0;
27 | 		
28 | 		while(i<n && j>=0)
29 | 		{
30 | 			if(a[i][j]==1){
31 | 				mre = i;
32 | 				j--;
33 | 			}else
34 | 			i++;
35 | 		}
36 | 		cout<<mre<<endl;
37 | 		
38 | 		return 0;
39 | 	}
40 | 	
41 | 	
42 | //	4 4
43 | //0 1 1 1
44 | //0 0 1 1
45 | //1 1 1 1
46 | //0 0 0 0
47 | 
48 | //2
49 | 
50 | //Explanation: Row 2 contains 4 1's (0-based
51 | //indexing).
52 | 
53 | 
54 | 
55 | 
56 | 
57 | 
58 | 
59 | 
60 | //class Solution{
61 | //	public:
62 | //		int rowWithMax1s(vector<vector<int>> a, int n, int m,)
63 | //		
64 | //		int mre =0; //max row element
65 | //		int j=m-1;
66 | //		int i=0;
67 | //		
68 | //		while(i<n && j>=0)
69 | //		{
70 | //			if(a[i][j]==1){
71 | //				mre = i;
72 | //				j--;
73 | //			}else
74 | //			i++;
75 | //		}
76 | //		
77 | //		return mre;
78 | //	}
79 | //};
80 | 


--------------------------------------------------------------------------------
/strings/057_permutations of a string.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //permutations of a given string
 4 | //can be done with stl
 5 | //but if that is not allowed then
 6 | 
 7 | 
 8 | 
 9 | //#include<bits/stdc++.h>
10 | //
11 | //using namespace std;
12 | //
13 | //int main()
14 | //{
15 | //	int t;
16 | //	cin>>t;
17 | //	while(t--)
18 | //	{
19 | //		string s;
20 | //		cin>>s;
21 | //		int n= s.length();
22 | //		
23 | //		sort(s.begin(),s.end());
24 | //		do{
25 | //			cout<<s<<" ";
26 | //		}while (next_permutation(s.begin(), s.end()));
27 | //		
28 | //		cout<<endl;
29 | //	}
30 | //     return 0;
31 | //}
32 | 
33 | 
34 | //2
35 | //abc
36 | //abc acb bac bca cab cba
37 | //absg
38 | //abgs absg agbs agsb asbg asgb bags basg bgas bgsa bsag bsga gabs gasb gbas gbsa gsab gsba sabg sagb sbag sbga sgab sgba
39 | 
40 | 
41 | 
42 | #include<bits/stdc++.h>
43 | using namespace std;
44 | 
45 | void permutation(string s, int l, int r)
46 | {
47 | 	if(l==r)							//base case
48 | 		cout<<s<<" ";
49 | 	else{
50 | 		for(int i=l;i<=r;i++)
51 | 		{
52 | 			swap(s[l], s[i]);			//swap
53 | 			permutation(s,l+1,r);		//recursive call
54 | 			swap(s[l],s[i]);  			//backtracing step
55 | 		}
56 | 	}
57 | }
58 | 
59 | int main()
60 | {
61 | 	string s;
62 | 	cin>>s;
63 | 	permutation(s,0,s.length()-1);
64 | 	cout<<endl;
65 | 	return 0;
66 | }
67 | 
68 | //abc
69 | //abc acb bac bca cba cab
70 | 


--------------------------------------------------------------------------------
/arrays/013_merge overlaping intervals.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //time complexity--o(NlogN)
 4 | //SPACE Complexity--o(N)
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | 
11 | 
12 | int main()
13 | {
14 | 	int n;
15 | 	cin>>n;
16 | 	vector<pair<int,int>> a;  //vector of pair
17 | 	for(int i=0;i<n;i++){
18 | 		int x,y;             //2 inputs
19 | 		cin>>x>>y;
20 | 		a.push_back({x,y});   //array me push bk 
21 | 	}
22 | 	//then sort it
23 | 	
24 | 	sort(a.begin(),a.end());
25 | 	stack<pair<int, int>> s;   //taking a stack in pair wise
26 | 	s.push({a[0].first,a[0].second}); //1st parameter ko gusadenge
27 | 	for(int i=1;i<n;i++){             //1 to last tk run karenge
28 | 	   //taking 4 parameters
29 | 		int start1= s.top().first;
30 | 		int end1 = s.top().second;
31 | 		int start2= a[i].first;
32 | 		int end2 = a[i].second;
33 | 		
34 | 		if(end1 < start2){
35 | 			s.push({start2,end2});  //we acnt merge just push it to the stack
36 | 			
37 | 		}
38 | 		else{
39 | 			s.pop();                //first we need to delete the top elements then update it
40 | 			
41 | 			end1 = max(end1,end2);  //update
42 | 			s.push({start1,end1});  //push the updated into the stack
43 | 			
44 | 		}
45 | 	}
46 | 	while(!s.empty()){                 //while stack is not empty
47 | 		cout<<s.top().first<<" "<<s.top().second<<endl;
48 | 		s.pop();
49 | 	}
50 |      return 0;
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/matrix/037_siprally traversing a matrix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 	int n,m;
10 | 	cin>>n>>m;
11 | 	
12 | 	int a[n][m];
13 | 	for(int i=0;i<n;i++)
14 | 	{
15 | 		for(int j=0;j<m;j++)
16 | 		{
17 | 			cin>>a[i][j];
18 | 		}
19 | 	}
20 | 	
21 | 	//spiral order print
22 | 	int row_start=0, row_end=n-1, col_start=0, col_end=m-1;  //initializing
23 | 	
24 | 	while(row_start<=row_end && col_start<=col_end)
25 | 	{
26 | 		//for row start
27 | 		for(int col = col_start; col<=col_end; col++)
28 | 			cout<<a[row_start][col]<<" ";
29 | 			row_start++;
30 | 			
31 | 		//for column end
32 | 		for(int row=row_start;row<=row_end;row++)
33 |             cout<<a[row][col_end]<<"  ";
34 |         	col_end--;
35 |         	
36 |         	
37 |      	if(row_start<=row_end)
38 |     	{
39 |         for(int col=col_end;col>=col_start;col--)
40 |             cout<<a[row_end][col]<<"  ";
41 |     	}	
42 |         row_end--;
43 | 
44 |   		if(col_start<=col_end)
45 |     	{
46 | 
47 |         for(int row=row_end;row>=row_start;row--)
48 |         {
49 |             cout<<a[row][col_start]<<"  ";
50 |     	}
51 |         col_start++;  
52 |     	}
53 |     	
54 |     	
55 | 		return 0;
56 | 	}
57 | 	
58 | }
59 | 
60 | //4 4
61 | //1 2 3 4
62 | //5 6 7 8
63 | //9 10 11 12
64 | //13 14 15 16
65 | //1 2 3 4 8  12  16  15  14  13  9  5  6 7 11
66 | 


--------------------------------------------------------------------------------
/arrays/005_ARRAYS_move all negitive to one side.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | move all negitive to one side nad and all positive to other side
 5 | 
 6 | if we suse brute force: 
 7 | approach 1: sorting then tc will be more o(n logn) and space will be o(1) cuz we dont need extra space
 8 | approach 2: take 2 arrays one array for +ve and other for -ve but tc will be o(n+n) and sc: o(n) cuz we use extra space for N and p
 9 | approach 3 optimized: quick sort approach by using partition algo
10 | 						pivot element means 0
11 | 						i pointer will throw all eleemenst
12 | 						keep updating i ki value if there is positive element
13 | approach 4 optimized: two pointer approach						
14 | */
15 | 
16 | 
17 | //partition
18 | #include<bits/stdc++.h>
19 | 
20 | using namespace std;
21 | 
22 | int main()
23 | {
24 |   int n;
25 |   cin>>n;
26 |   
27 |   int a[n], i;
28 |   for(i=0; i<n; i++)
29 |      cin>>a[i];
30 |      
31 |     int j=0;              //take extra pointer j and initialize it with 0 (pivot)
32 | 	for(i=0; i<n; i++)   //scan/traverse through the array
33 | 	{
34 | 		if(a[i]<0)      //if we find a negitive element
35 | 		{
36 | 			swap(a[i],a[j]);  //we will swap it with a[j]
37 | 			j++;              //and will increment j
38 | 		}
39 | 	}
40 | 	
41 | 	//print the output
42 | 	for(i=0; i<n; i++)
43 | 	cout<<a[i]<<" ";
44 | 	
45 |   return 0;
46 |   }
47 |   
48 | //  5
49 | //2 -1 5 -4 -3
50 | //-1 -4 -3 2 5
51 | 
52 | 


--------------------------------------------------------------------------------
/arrays/024_longest consecutive subsequence.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given an array of positive integers. Find the length of the longest sub-sequence such that elements in the subsequence are consecutive integers, the consecutive numbers can be in any order.
 4 | 
 5 | //we dont care abt the order that is why we can use hash array
 6 | 
 7 | //Expected Time Complexity: O(N).
 8 | //Expected Auxiliary Space: O(N).
 9 | 
10 | 
11 | #include<bits/stdc++.h>
12 | 
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 	long long int n, m=0, cnt=0, m1=0;
18 | 	cin>>n;
19 | 	long long int a,i;
20 | 	long long int h[100005]={0};  //hash array and let all elements be 0
21 | 		for(i=0;i<n;i++)
22 | 		{
23 | 			cin>>a;
24 | 			h[a]=1;  //will be 1 if the particular element is present
25 | 			m1=max(a,m1);
26 | 		}
27 | 		
28 | 		for(i=0;i<=m1;i++)  //scan though the hash array
29 | 		{
30 | 			if(h[i]==1)  //that means element is present in the array
31 | 			cnt++;       
32 | 			
33 | 			else
34 | 			{
35 | 				m=max(m,cnt); //if h[i] is not 1 then record the maximum
36 | 				cnt=0;        //and reset count to 0
37 | 			}
38 | 		}
39 | 		m=max(m,cnt);
40 | 		cout<<m<<endl;   //finally print the maximum
41 |      return 0;
42 | }
43 | 
44 | //7
45 | //2 6 1 9 4 5 3
46 | 
47 | //6
48 | 
49 | //Explanation:
50 | //The consecutive numbers here
51 | //are 1, 2, 3, 4, 5, 6. These 6 
52 | //numbers form the longest consecutive
53 | //subsquence.
54 | 
55 | 
56 | 
57 | 
58 | 


--------------------------------------------------------------------------------
/strings/083_smallest window.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | Smallest window in a string containing all the 
 6 | characters of another string 
 7 | 
 8 | sliding window approach
 9 | 
10 | */
11 | 
12 | 
13 | #include<bits/stdc++.h>
14 | using namespace std;
15 | 
16 | int main() {
17 | 	
18 | 	int t;
19 | 	cin>>t;
20 | 	while(t--)
21 | 	{
22 | 	    string s,s1;
23 | 	    cin>>s>>s1;
24 | 	    long int i,beg=0,end=0,ansstart=0,len=INT_MAX;
25 | 	    
26 | 	    unordered_map<char,long int> m;
27 | 	    
28 | 	    for(i=0;i<s1.length();++i)
29 | 	       m[s1[i]]++;
30 | 	      
31 | 	     long int window=s1.length();  
32 | 	    while(end<s.length())
33 | 	    { 
34 | 	         if(m[s[end]]>0)
35 | 	            window--;
36 | 	            
37 | 	            m[s[end]]--;
38 | 	            
39 | 	            end++;
40 | 	            
41 | 	            while(window==0)
42 | 	             {
43 | 	                 if(len>end-beg)
44 | 	                  {
45 | 	                      len=end-beg;
46 | 	                      ansstart=beg;
47 | 	                  }
48 | 	                  
49 | 	                   m[s[beg]]++;
50 | 	                  if(m[s[beg]]>0)
51 | 	                     window++;
52 | 	                     
53 | 	                  
54 | 	                   beg++;
55 | 	             }
56 | 	        
57 | 	    }
58 | 	  if(len!=INT_MAX)  
59 | 	    cout<<s.substr(ansstart,len)<<endl;
60 | 	    
61 | 	  else
62 | 	    cout<<-1<<endl;
63 | 	    
64 | 	}
65 | 	return 0;
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/022_factorials of large number.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //find factorial of a large number
 4 | //i think we can find factorial upto 15 cuz after that we cant have large number right
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | void multiply(vector<int> &v, int x)
11 | {
12 | 	int carry=0,mul;   //in multiplication table we have carry
13 | 	for(int i=0; i<v.size();i++)
14 | 	{
15 | 		mul=v[i]*x + carry;  //let us say
16 | 		v[i]=mul%10;
17 | 		carry=mul/10;
18 | 	}
19 | 	
20 | 	while(carry)
21 | 	{
22 | 		v.push_back(carry%10);
23 | 		carry/=10;
24 | 	}
25 | }
26 | 
27 | void fact(int n)
28 | {
29 | 	vector<int> v; //take vector of integer type
30 | 	v.push_back();  //push 1 into the vector initially
31 | 	
32 | 	for(int i=1;i<=n;i++)
33 | 		multiply(v,i);    //multiply is a function which has 2 parameters vector and current integer
34 | 		
35 | 	reverse(v.begin(),v.end());  //we will reverse the vector
36 | 	
37 | 	int i=0;
38 | 	while(v[i]==0)
39 | 	i++;
40 | 	
41 | 	for(int j=i; j<v.size(); i++) cout<<v[j]; //basically we will be outputing all the digits but inorder to find digits, declare digits func as multiply
42 | 	
43 | }
44 | 
45 | int main()
46 | {
47 | 	int tt;
48 | 	cin>>tt;
49 | 	while(tt--)
50 | 	{
51 | 		int n;
52 | 		cin>>n;
53 | 	
54 | //		cout<<fact(n)<<endl; blunder error as we dont have to cout anything,
55 | 	fact(n);  //just call the function
56 | 	cout<<endl;
57 | }
58 |     return 0;
59 | }
60 | 
61 | //2
62 | //5
63 | //10
64 | 
65 | //120
66 | 
67 | 


--------------------------------------------------------------------------------
/strings/066_mobile numeric.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Convert a sentence into its equivalent mobile numeric keypad sequence
 4 | 
 5 | // make an array of size 26 and store all the patters eg: 2 , 22, 222, untill 9999
 6 | 
 7 | //arr[ch='A'] + '0'.
 8 | 
 9 | //basic hashing problem
10 | 
11 | 
12 | 
13 | #include <bits/stdc++.h>
14 | using namespace std;
15 |  
16 | // Function which computes the sequence
17 | string printSequence(string arr[],
18 |                        string input)
19 | {
20 |     string output = "";
21 |  
22 |     // length of input string
23 |     int n = input.length();
24 |     for (int i=0; i<n; i++)
25 |     {
26 |         // Checking for space
27 |         if (input[i] == ' ')
28 |             output = output + "0";
29 |  
30 |         else
31 |         {
32 |             // Calculating index for each character
33 |             int position = input[i]-'A';
34 |             output = output + arr[position];
35 |         }
36 |     }
37 |  
38 |     return output;
39 | }
40 | 
41 | int main()
42 | {
43 |     // storing the sequence in array
44 |     string str[] = {"2","22","222",
45 |                     "3","33","333",
46 |                     "4","44","444",
47 |                     "5","55","555",
48 |                     "6","66","666",
49 |                     "7","77","777","7777",
50 |                     "8","88","888",
51 |                     "9","99","999","9999"
52 |                    };
53 |  
54 |     string input = "STARGIRLSHREYA";
55 |     cout << printSequence(str, input);
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/strings/088_isomorphic strings.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | we need 2 arrays
 5 | 1 will be boolean
 6 | 1 will be map 
 7 | 
 8 | therefore we need 2 extra space
 9 | 
10 | 
11 | */
12 | 
13 | 
14 | #include<iostream>
15 | #include<string.h>
16 | 
17 | using namespace std;
18 | #define MAX_CHARS 256
19 | 
20 | bool areIsomorphic(string, string);
21 | 
22 | 
23 | // This function returns true if str1 and str2 are ismorphic
24 | // else returns false
25 | bool areIsomorphic(string s1, string s2)
26 | {
27 |     
28 |     if(s1.length()!=s2.length())
29 |         return 0;
30 |         
31 |     bool present[256]={false};
32 |     int map[256];
33 |     memset(map,-1,sizeof(map));
34 |     
35 |     for(int i=0;i<s1.length();++i)
36 |       {
37 |           if(map[s1[i]]==-1) //first occurence
38 |           {
39 |               if(present[s2[i]])
40 |                   return false;
41 |                   
42 |               present[s2[i]]=true;
43 |               map[s1[i]]=s2[i];
44 |           }
45 |           
46 |           else
47 |           {
48 |               if(map[s1[i]]!=s2[i])
49 |                  return false;
50 |           }
51 |       }
52 |       
53 |       return true;
54 | }
55 | 
56 | // Driver program
57 | int main()
58 | {
59 |     int t;
60 |     cin>>t;
61 |     string s1,s2;
62 |     while (t--) {
63 |         cin>>s1;
64 |         cin>>s2;
65 |         cout<<areIsomorphic(s1,s2)<<endl;
66 |     }
67 |     
68 |     return 0;
69 | }
70 | //
71 | //2
72 | //aab
73 | //xxy
74 | 
75 | //1
76 | 
77 | 
78 | //Explanation: There are two different
79 | //charactersin aab and xxy, i.e a and b
80 | //with frequency 2and 1 respectively.
81 | 
82 | 


--------------------------------------------------------------------------------
/arrays/030_chocolate distribution.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //sort the array find the min such that 1st pointer is at min and 2nd pointer is at m-1
 4 | //keep moving both the pointers untill u reach the end of the array
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 
12 | 		long long int n;
13 | 		cin>>n;
14 | 		long long int a[n],i,j=0,mn=INT_MAX;
15 | 		for(i=0;i<n;i++) cin>>a[i];
16 | 		
17 | 		sort(a,a+n);
18 | 		
19 | 		long long int m;
20 | 		cin>>m;
21 | 		
22 | 		for(i=m-1;i<n;i++) //for i=m-1 till n we will run the loop so initially j will be 0
23 | 		{
24 | 			mn=min(mn,a[i]-a[j]);   //we will continuosly be recording the min
25 | 			j++; //and will be moving j pointer as well as i pointer and this is workin cuz we have already sorted the array
26 | 			
27 | 		}
28 | 		cout<<mn<<endl;
29 | 	
30 |      return 0;
31 | }
32 | 
33 | //7
34 | //7 3 2 4 9 12 56
35 | //3
36 | 
37 | //2
38 | 
39 | //8
40 | //3 4 1 9 56 7 9 12
41 | //5
42 | 
43 | //6
44 | 
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 
51 | ////author :shreyamalogi
52 | //
53 | //#include<bits/stdc++.h>
54 | //
55 | //using namespace std;
56 | //
57 | //int main()
58 | //{
59 | //	int t;
60 | //	cin>>t;
61 | //	while(t--)
62 | //	{
63 | //		int n;
64 | //		cin>>n;
65 | //		int a[n];
66 | //		for(int i=0;i<n;i++) cin>>a[i];
67 | //		
68 | //		int m;
69 | //		cin>>m;
70 | //		
71 | //		sort(a,a+n);
72 | //		
73 | //		int mn=INT_MAX;
74 | //		
75 | //		for(int i=0;i+m-1<n;i++)
76 | //		{
77 | //			int d= a[i+m-1]-a[i]; //difference variable
78 | //			
79 | //			if(d<mn)
80 | //			mn=d;  //update min by d
81 | //		}
82 | //		cout<<mn<<endl;
83 | //	}
84 | //     return 0;
85 | //}
86 | 


--------------------------------------------------------------------------------
/matrix/045_kth element in matrix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Given a N x N matrix, where every row and column is sorted in non-decreasing order. Find the kth smallest element in the matrix.
 4 | 
 5 | //we can use priority queue, min heap
 6 | 
 7 | //but im doing by binary search
 8 | 
 9 | #include<bits/stdc++.h>
10 | #define MAX 1000
11 | 
12 | int mat[MAX][MAX];
13 | int kthSmallest(int a[MAX][MAX], int n, int k);
14 | 
15 | using namespace std;
16 | 
17 | 
18 | int kthSmallest(int a[MAX][MAX], int n, int k)
19 | {
20 | 	if(n==0)
21 | 		return 0;
22 | 		
23 | 		
24 | 	int s=a[0][0];  //search space
25 | 	int e=a[n-1][n-1];
26 | 	
27 | 	while(s<e){    //start and end
28 | 		int cnt =0,j;
29 | 		int mid = s+(e-s)/2;
30 | 		for(int r=0; r<n; r++ ){			//traverse thru the row
31 | 			j=n-1;							//upperbound
32 | 			while(j<=0 && a[r][j]>mid){
33 | 				j--;
34 | 			}
35 | 			
36 | 			cnt+=(j+1);						//store in cnt
37 | 		}
38 | 		if(cnt<k)
39 | 			s=mid+1;   //ans is towars right side
40 | 		else
41 | 			e=mid;
42 | 		}
43 | 		return s;	//cuz that will give us the kth smallest element
44 | 		
45 | }
46 | 
47 | int main()
48 | {
49 | 	int t;
50 | 	cin>>t;
51 | 	while(t--){
52 | 		int n;
53 | 		cin>>n;
54 | 		for(int i=0;i<n;i++)
55 | 			for(int j=0;j<n;i++)
56 | 				cin>>mat[i][j];
57 | 		
58 | 		int r;
59 | 		cin>>r;
60 | 		cout<<kthSmallest(mat,n,r)<<endl;
61 | 		
62 | 	}
63 |      return 0;
64 | }
65 | 
66 | //
67 | //N = 4
68 | //mat[][] =     {{16, 28, 60, 64},
69 | //                   {22, 41, 63, 91},
70 | //                   {27, 50, 87, 93},
71 | //                   {36, 78, 87, 94 }}
72 | //K = 3
73 | //Output: 27
74 | //Explanation: 27 is the 3rd smallest element.
75 | 
76 | 
77 | 
78 | 
79 | 
80 | 
81 | 


--------------------------------------------------------------------------------
/strings/075_second most repeted.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | A sequence of strings is a collection of strings which we have entered by the user. In this problem, we have to find the second most repeated word in a sequence.
 6 | 
 7 | We are going to use maps in this solution. Maps will save the values of the word and their occurrences. Word will be used as the key and occurrence will be used as value.
 8 | 
 9 | Algorithm to solve this problem is :
10 | 
11 | Create a map. Save words as keys and occurrences as values.
12 | Find the second most value.
13 | Again traverse the map and find the key with the second-most value and return it.
14 | 
15 | 
16 | */
17 | 
18 | 
19 | #include <bits/stdc++.h> 
20 | using namespace std; 
21 | string repeat(vector<string> s) 
22 | { 
23 |   
24 |     unordered_map<string, int> occ; 
25 |     for (int i = 0; i < s.size(); i++) 
26 |         occ[s[i]]++; 
27 |         
28 |     int first_max = INT_MIN;
29 | 	int sec_max = INT_MIN; 
30 |     for (auto it = occ.begin(); it != occ.end(); it++) { 
31 |         if (it->second > first_max) { 
32 |             sec_max = first_max; 
33 |             first_max = it->second; 
34 |         } 
35 |   
36 |         else if (it->second > sec_max &&  
37 |                  it->second != first_max) 
38 |             sec_max = it->second; 
39 |     } 
40 |     for (auto it = occ.begin(); it != occ.end(); it++) 
41 |         if (it->second == sec_max) 
42 |             return it->first; 
43 | } 
44 | int main() 
45 | {
46 |     string str;
47 |     int n;
48 |     vector<string> s ;
49 |     cout<<"Enter the number of string : ";
50 |     cin>>n;
51 |     cout<<"Enter the strings : ";
52 |     for(int i=0;i<n;i++){
53 |       cin>>str;
54 |       s.push_back(str);
55 |   }
56 |     cout <<"The second most used word is : "<< repeat(s); 
57 |     return 0; 
58 | }
59 | 
60 | 
61 | //Enter the number of string : 5
62 | //Enter the strings : shreya nav nav shreya shreya
63 | //The second most used word is : nav
64 | 


--------------------------------------------------------------------------------
/arrays/020_rearrage array.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //Rearrange array in alternating positive & negative items with O(1) extra space
 4 | 
 5 | 
 6 | //approach:take 2 pointers i(at first) and j(at last)
 7 | // +ve to first and negitive to last
 8 | 
 9 | // 2 3 -4 -1 6 -9        //i at 2, j at -9, it is barabar so dont do anything
10 | // 2 3 -4 -1 6 -9        //i at 3 (true), j at 6 is false
11 | // 2 3 -4 -1 6 -9	    //just move i forward but will be at 6 only
12 | // 2 3  6  -1 -4 -9       //swap then we can see both will point towards -1, as it is -ve j will go to 6 i++,j--
13 | //then we get condition i<=j then break outaa loop
14 | 
15 | //we see that i is pointing towards first -ve element and take k which will be pointing towards 1st positive eleement then swap i with k
16 | //i ko 1 se iterate and k to 2 se iterate
17 | 
18 |  #include<bits/stdc++.h>
19 | 
20 | using namespace std;
21 | 
22 | int main()
23 | {
24 | 	 int n;
25 | 	 cin>>n;
26 | 	 int a[n];
27 | 	 for(int i=0;i<n;i++) cin>>a[i];
28 | 	 
29 | 	 int i=0; int j=n-1;  //i ko starting me, j ko last me
30 | 	 while(i<=j)     //in this while loop we will get all positive to left and all negitive to right
31 | 	 {
32 | 	 	if(a[i]<0 and a[j]>0){ //check false condition
33 | 	 		swap(a[i],a[j]);  //swap it
34 | 	 		i++;
35 | 	 		j--;
36 | 		 }
37 | 		 else if(a[i]>0 and a[j]<0){ //check true condition and do ntg just incr/dec
38 | 		 i++;
39 | 		 j--;
40 | 		}
41 | 		else if(a[i]>0){  //1 is true just move forward
42 | 			i++;
43 | 		}
44 | 		else if(a[j]<0){  //other 1 is true move bkwards
45 | 			j--;
46 | 		}
47 | 	}
48 | 	
49 | 	//checking conditions
50 | 	if(i==0 or i==n){
51 | 		for(int m=0; m<n; m++) cout<<a[m]<<"";
52 | 		cout<<endl;
53 | 	}else{
54 | 		int k=0;
55 | 		while(k<n and i<n){
56 | 			swap(a[k],a[i]);
57 | 			k=k+2;
58 | 			i++;
59 | 		}
60 | 		for(int m=0; m<n; m++) cout<<a[m]<<" ";
61 | 		cout<<endl;
62 | 	}
63 | 	
64 |      return 0;
65 | }
66 | 
67 | //6
68 | //2 3 -4 -1 6 9
69 | 
70 | //-1 3 -4 6 2 9
71 | 
72 | 


--------------------------------------------------------------------------------
/strings/063_word break.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | // dp prob
 4 | 
 5 | 
 6 | //Given a string A and a dictionary of n words B, find out if A can be segmented into a space-separated sequence of dictionary words. 
 7 | 
 8 | // we are given a string......we need to break the strings anmd check whether the broken strings are found in the library
 9 | 
10 | //trying with recurssion but tcx is too high
11 | 
12 | //we can do dp : cuz optimization of recursion is dp
13 | 
14 | //so first put all those in unordered set to reduce the tc
15 | 
16 | //check from last....the if dp[0] = 1 it means we can make the entire string
17 | 
18 | #include<bits/stdc++.h>
19 | 
20 | using namespace std;
21 | 
22 | int main()
23 | {
24 | 	int t;
25 | 	cin>>t;
26 | 	while(t--)
27 | 	{
28 | 		int n;
29 | 		cin>>n;
30 | 		string dict[n];
31 | 		
32 | 		string s;
33 | 		
34 | 		
35 | 		unordered_set<string> st;
36 | 		for(int i=0;i<n;i++){
37 | 			cin>>dict[i];		//while accepeting the input , insert it into the set
38 | 			st.insert(dict[i]);
39 | 		}
40 | 		
41 | 		cin>>s;
42 | 		int n=s.length();
43 | 		
44 | 		//now take a dp array which is gonna be a boolean array only
45 | 		int dp[n+1];
46 | 		memset(dp,0,sizeof(dp)); 				//let us set all the values of a dp array to 0
47 | 		dp[n]=1; 								//set dp of n as 1 because empty sequence is also valid
48 | 												//let us take twi variables i and j
49 | 			for(int i=n-1;i>0;i--){
50 | 				string word;
51 | 				for(int j=i; j<n; j++)
52 | 				{
53 | 					word.push_back(s[j]);
54 | 					if(st.find(word)!=st.end())
55 | 					{
56 | 						if(dp[j+1])
57 | 						dp[i]=1;
58 | 					}
59 | 				}
60 | 			}
61 | //			if (dp[0])
62 | //				cout<<"yes"<<endl;
63 | //			else
64 | //				cout<<"no"<<endl;
65 | 
66 | 		cout<<dp[0]<<endl;
67 | 		
68 | 	}
69 |      return 0;
70 | }
71 | 
72 | //
73 | //Input:
74 | //n = 12
75 | //B = { "i", "like", "sam", "sung", "samsung", "mobile",
76 | //"ice","cream", "icecream", "man", "go", "mango" }
77 | //A = "ilike"
78 | //Output: 1
79 | //Explanation:The string can be segmented as "i like".
80 | 
81 | 


--------------------------------------------------------------------------------
/strings/082_print anagrams together.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | brute only ik i dint try with tries
 6 | 
 7 | */
 8 | 
 9 | 
10 | //Initial Template for C++
11 | #include <bits/stdc++.h>
12 | #include <unordered_map>
13 | using namespace std;
14 | vector<vector<string> > Anagrams(vector<string>& string_list) ;
15 | 
16 | vector<vector<string> > Anagrams(vector<string>& s) 
17 | {
18 |     map<map<char, int>, vector<string>> my_map;
19 |      
20 |    
21 |     for(string str : s)
22 |     {
23 |          
24 |         map<char, int> temp_map;
25 |         vector<string> temp_my_list;
26 |         for(int i = 0; i < str.length(); ++i) 
27 |         {
28 |             ++temp_map[str[i]];
29 |         }
30 |          
31 |        
32 |         auto it = my_map.find(temp_map);
33 |         if (it != my_map.end())
34 |         {
35 |             it->second.push_back(str);
36 |         }
37 |         else
38 |         {
39 |             temp_my_list.push_back(str);
40 |             my_map.insert({ temp_map, temp_my_list });
41 |         }
42 |     }
43 |      
44 |    
45 |     vector<vector<string>> result;
46 |  
47 |     for(auto it = my_map.begin();
48 |              it != my_map.end(); ++it)
49 |     {
50 |         result.push_back(it->second);
51 |     }
52 |  
53 |  return result;
54 | 	                 
55 | }
56 | 
57 | 
58 | int main()
59 | {
60 |     int t;
61 |     cin>>t;
62 |     while(t--)
63 |     {
64 |         int n;
65 |         cin>>n;
66 |         vector<string> string_list(n);
67 |         for (int i = 0; i < n; ++i)
68 |             cin>>string_list[i]; 
69 |         vector<vector<string> > result = Anagrams(string_list);
70 |         sort(result.begin(),result.end());
71 |         for (int i = 0; i < result.size(); i++)
72 |         {
73 |             for(int j=0; j < result[i].size(); j++)
74 |             {
75 |                 cout<<result[i][j]<<" ";
76 |             }
77 |             cout<<"\n";
78 |         }
79 |     }
80 | 
81 |     return 0;
82 | }
83 | 
84 | //1
85 | //5
86 | //act god cat dog tac
87 | //act cat tac
88 | //god dog
89 | 
90 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 30-Day DSA Training - Arrays, Strings, Matrices 💡
 2 | 
 3 | 
 4 | Welcome to the 30-Day Basic Data Structures and Algorithms (DSA) Training led by Shreya Malogi! 🌟
 5 | 
 6 | This repository contains a collection of 100 resources and problems designed to help you build a strong foundation in DSA. Whether you're a beginner or looking to refresh your knowledge, this training program is the perfect starting point.
 7 | 
 8 | ## Why This Training? 😊
 9 | 
10 | - Strengthen your DSA foundation: This training program is carefully structured to reinforce your understanding of arrays, strings, and matrices—the building blocks of many algorithms.
11 | 
12 | - Practical problem-solving: Each day, you'll dive into real-world coding challenges to apply what you've learned, gaining hands-on experience.
13 | 
14 | - Gradual progression: Problems are organized by difficulty, ensuring a smooth learning curve as you tackle increasingly complex challenges.
15 | 
16 | - Learn at your own pace: You have the flexibility to complete the training over 30 days, allowing you to balance learning with your schedule.
17 | 
18 | ## Training Structure 👩‍💻
19 | 
20 | - **Day 1-10: Arrays** - Focus on array-related problems, understanding array manipulation, and solving problems that require efficient array operations.
21 | 
22 | - **Day 11-20: Strings** - Deepen your knowledge of strings, covering topics like string manipulation, pattern matching, and more.
23 | 
24 | - **Day 21-30: Matrices** - Explore matrix-related problems, including matrix transformations, traversals, and optimizations.
25 | 
26 | ## How to Use This Repository
27 | 
28 | 1. Navigate to the respective folders for each category (Arrays, Strings, Matrices) to find the problem descriptions and solutions.
29 | 
30 | 2. Work on the problems in sequence, starting from Day 1 and progressing to Day 30.
31 | 
32 | 3. Each problem is accompanied by a solution, but we encourage you to attempt solving it on your own before referring to the provided solution.
33 | 
34 | 4. Feel free to adapt the code and experiment with your solutions.
35 | 
36 | ## Let's Learn Together!
37 | Join us on this learning journey and strengthen your DSA skills. If you find this repository helpful, don't forget to give it a star ⭐ to show your support and share it with others.
38 | 
39 | ## License
40 | This project is licensed under the MIT License - see the LICENSE file for details.
41 | 
42 | MIT License
43 | 
44 | Copyright (c) 2021 CodeMacrocosm
45 | 
46 | ## Happy coding! 🚀👩‍💻👨‍💻
47 | 


--------------------------------------------------------------------------------
/matrix/043_find a specific pair in a matrix.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //find a specific pair in the matrix
 4 | 
 5 | 
 6 | // An efficient method to find maximum value of mat[d]
 7 | // - ma[a][b] such that c > a and d > b
 8 | #include <bits/stdc++.h>
 9 | using namespace std;
10 | #define N 5
11 |  
12 | // The function returns maximum value A(c,d) - A(a,b)
13 | // over all choices of indexes such that both c > a
14 | // and d > b.
15 | int findMaxValue(int mat[][N])
16 | {
17 |     //stores maximum value
18 |     int maxValue = INT_MIN;
19 |  
20 |     // maxArr[i][j] stores max of elements in matrix
21 |     // from (i, j) to (N-1, N-1)
22 |     int maxArr[N][N];
23 |  
24 |     // last element of maxArr will be same's as of
25 |     // the input matrix
26 |     maxArr[N-1][N-1] = mat[N-1][N-1];
27 |  
28 |     // preprocess last row
29 |     int maxv = mat[N-1][N-1];  // Initialize max
30 |     for (int j = N - 2; j >= 0; j--)
31 |     {
32 |         if (mat[N-1][j] > maxv)
33 |             maxv = mat[N - 1][j];
34 |         maxArr[N-1][j] = maxv;
35 |     }
36 |  
37 |     // preprocess last column
38 |     maxv = mat[N - 1][N - 1];  // Initialize max
39 |     for (int i = N - 2; i >= 0; i--)
40 |     {
41 |         if (mat[i][N - 1] > maxv)
42 |             maxv = mat[i][N - 1];
43 |         maxArr[i][N - 1] = maxv;
44 |     }
45 |  
46 |     // preprocess rest of the matrix from bottom
47 |     for (int i = N-2; i >= 0; i--)
48 |     {
49 |         for (int j = N-2; j >= 0; j--)
50 |         {
51 |             // Update maxValue
52 |             if (maxArr[i+1][j+1] - mat[i][j] >
53 |                                             maxValue)
54 |                 maxValue = maxArr[i + 1][j + 1] - mat[i][j];
55 |  
56 |             // set maxArr (i, j)
57 |             maxArr[i][j] = max(mat[i][j],
58 |                                max(maxArr[i][j + 1],
59 |                                    maxArr[i + 1][j]) );
60 |         }
61 |     }
62 |  
63 |     return maxValue;
64 | }
65 |  
66 | 
67 | int main()
68 | {
69 |     int mat[N][N] = {
70 |                       { 1, 2, -1, -4, -20 },
71 |                       { -8, -3, 4, 2, 1 },
72 |                       { 3, 8, 6, 1, 3 },
73 |                       { -4, -1, 1, 7, -6 },
74 |                       { 0, -4, 10, -5, 1 }
75 |                     };
76 |     cout << "Maximum Value is "
77 |          << findMaxValue(mat);
78 |  
79 |     return 0;
80 | }
81 | 
82 | 
83 | //Maximum Value is 18.
84 | 


--------------------------------------------------------------------------------
/015_count inversion.cpp:
--------------------------------------------------------------------------------
  1 | //author :shreyamalogi
  2 | 
  3 | /*
  4 | 
  5 | basically batana hai ki hamara ye jo array hai kitna dur hai isko sort hone se
  6 | so i<j and ai<=aj
  7 | 
  8 | in an array of 5 4 1 2 3
  9 | the inversions are : (5,4) (5,1) (5,2) (5,3)
 10 | 					(4,1) (4,2) (4,3)
 11 | total inversions are 7
 12 | 
 13 | */
 14 | 
 15 | 
 16 | //brute force: ek element ko pakad aur last tk jaa
 17 | // int count=0;
 18 | // for(int i=0;i<n;i++){ 		//0 to n
 19 | // 	for(int j=i+1;j<n;j++){ 	//i+1 to n
 20 | // 		if(a[i]>a[j]) 			//strictly greater
 21 | // 			count++;
 22 | // 	}
 23 | // }
 24 | // cout<<count;  
 25 | //tc: o(n^2)
 26 | //sc: o(1)
 27 | 
 28 | 
 29 | 
 30 | //OPTIMIZED
 31 | //merge sort approach
 32 | //divide and conquer algo which takes n(logn) time
 33 | 
 34 | 
 35 | #include<bits/stdc++.h>
 36 | 
 37 | using namespace std;
 38 | 
 39 | long long int ans=0;    //answer will be our global variable
 40 | 
 41 | void merge(long long int a[], long long int l, long long int m, long long int r)//merge function take 4 parameters
 42 | {
 43 | 	int i,j,k;       //we need 3 variables
 44 | 	int n1= m-l+1;  //as we are splitting array into 2, n1 and n2
 45 | 	int n2= r-m;     //will be the sizes of the array
 46 | 	
 47 | 	long long int L[n1], R[n2];  //left subarray with n1 size and right subarray with n2 size
 48 | 	
 49 | 	//run 2 loops
 50 | 	
 51 | 	for(int i=0;i<n1;i++) L[i]=a[i+1];
 52 | 	for(int i=0;i<n2;i++) R[j]=a[i+m+1];
 53 | 	
 54 | 	//let us equate 
 55 | 	i=0; j=0; k=l;
 56 | 	while(i<n1 && j<n2)
 57 | 	{
 58 | 		if(L[i]<=R[j])
 59 | 		{
 60 | 			a[k++]=L[i++];
 61 | 		}
 62 | 		else
 63 | 		{
 64 | 			//imp step/ extra line (if left subarray is greater than the right subarray
 65 | 			// then there will be n-1 inversion or we have to store the count everytime
 66 | 			ans+=n1-i; 	
 67 | 			a[k++]=R[j++];
 68 | 		}
 69 | 	}
 70 | 	
 71 | 	while(i<n1)
 72 | 	a[k++]=L[i++];
 73 | 	
 74 | 	while(j<n2)
 75 | 	a[k++]=R[j++];
 76 | 	
 77 | }
 78 | 
 79 | void mergesort(long long int a[], long long int l, long long int r)	// merge sort function req 3 parameters - an array, lower bound ,upper bound
 80 | {
 81 | 	if(l<r)
 82 | 	{
 83 | 		long long int mid= l+(r-1)/2 ;  //mid, to avoid integer overflow
 84 | 		mergesort(a,l,mid);   
 85 | 		mergesort(a,mid+1,r);
 86 | 		merge(a,l,mid,r);   		 //final merge 
 87 | 	}
 88 | }
 89 | int main()
 90 | 
 91 | {
 92 | 	long long int n;
 93 | 	cin>>n;
 94 | 	long long int a[n],i;
 95 | 	for(int i=0;i<n;i++) cin>>a[i];
 96 | 		
 97 | 	mergesort(a,0,n-1);
 98 | 		
 99 | 	cout<<ans<<endl;
100 | 	
101 |     return 0;
102 | }
103 | 
104 | //
105 | //5
106 | //2 4 1 3 5
107 | 
108 | //output 3 
109 | 


--------------------------------------------------------------------------------
/strings/087_min operations-transform.cpp:
--------------------------------------------------------------------------------
  1 | //author :shreyamalogi
  2 | 
  3 | /*
  4 | 
  5 | 
  6 | find minimum number of
  7 |  operations required to transform 
  8 |  one string to other
  9 |  
 10 |  in the first string put a char in front
 11 | 
 12 | Time Complexity: O(n)
 13 | */
 14 | 
 15 | #include<bits/stdc++.h>
 16 | using namespace std;
 17 |  
 18 | // Function to find minimum number of operations required to transform
 19 | // A to B.
 20 | int minOps(string& A, string& B)
 21 | {
 22 |     int m = A.length(), n = B.length();
 23 |     if (n != m)
 24 |        return -1;
 25 |     int count[256];
 26 |     memset(count, 0, sizeof(count));
 27 |     for (int i=0; i<n; i++)   // count characters in A
 28 |        count[B[i]]++;
 29 |     for (int i=0; i<n; i++)   // subtract count for
 30 |        count[A[i]]--;         // every character in B
 31 |     for (int i=0; i<256; i++)   // Check if all counts become 0
 32 |       if (count[i])
 33 |          return -1;
 34 |  
 35 |     // This part calculates the number of operations required
 36 |     int res = 0;
 37 |     for (int i=n-1, j=n-1; i>=0; )
 38 |     {
 39 |         // If there is a mismatch, then keep incrementing
 40 |         // result 'res' until B[j] is not found in A[0..i]
 41 |         while (i>=0 && A[i] != B[j])
 42 |         {
 43 |             i--;
 44 |             res++;
 45 |         }
 46 |  
 47 |         // If A[i] and B[j] match
 48 |         if (i >= 0)
 49 |         {
 50 |             i--;
 51 |             j--;
 52 |         }
 53 |     }
 54 |     return res;
 55 | }
 56 |  
 57 | int main()
 58 | {
 59 |     string A = "EACBD";
 60 |     string B = "EABCD";
 61 |     cout << "Minimum number of operations "
 62 |             "required is " << minOps(A, B);
 63 |     return 0;
 64 | }
 65 | 
 66 | //Minimum number of operations required is 3
 67 | 
 68 | 
 69 | 
 70 | 
 71 | //#include<bits/stdc++.h>
 72 | //
 73 | //using namespace std;
 74 | //
 75 | //int main()
 76 | //{
 77 | //	string s1,s2;
 78 | //	cin>>s1>>s2;
 79 | //	int i=0,j=0;
 80 | //	
 81 | //	int map[256]={0};
 82 | //	
 83 | //	for(int i=0;i<s2.length();i++) //s2
 84 | //	{
 85 | //		map[s2[i]]++;
 86 | //	}
 87 | //
 88 | //	for(int i=0;i<s1.length();i++) //s1
 89 | //	{
 90 | //		map[s1[i]]--;
 91 | //	}
 92 | //	
 93 | //	for(int i=0;i<256;i++)//ascii
 94 | //	{
 95 | //		if(map[i]!=0)
 96 | //		break;
 97 | //	}
 98 | //	
 99 | //	if(i!=256)
100 | //	{
101 | //		cout<<"IMPOSSIBLE";
102 | //	}
103 | //	
104 | //	else{
105 | //	
106 | //	int ans=0;
107 | //	
108 | //	int i=s1.length()-1;
109 | //	int j=s2.length()-1;
110 | //	
111 | //	while(i>0 && j>0)
112 | //	{
113 | //		if(s1[i]==s2[j])
114 | //		{
115 | //			i--;
116 | //			j--;
117 | //		}
118 | //		else
119 | //		{
120 | //			while(i>0 && s1[i]!=s2[j])
121 | //			{
122 | //				i--;
123 | //				ans++;
124 | //			}
125 | //		}
126 | //	}
127 | //  }
128 | //	
129 | //     return 0;
130 | //}
131 | 


--------------------------------------------------------------------------------
/strings/069_count a no of given strings.cpp:
--------------------------------------------------------------------------------
  1 | //author :shreyamalogi
  2 | 
  3 | /*
  4 | 1- Traverse matrix character by character and take one character as string start 
  5 | 2- For each character find the string in all the four directions recursively 
  6 | 3- If a string found, we increase the count 
  7 | 4- When we are done with one character as start, we repeat the same process for the next character 
  8 | 5- Calculate the sum of count for each character 
  9 | 6- Final count will be the answer
 10 | 
 11 | 
 12 | just a heavy implemenetation problem
 13 | 
 14 | */
 15 | 
 16 | 
 17 | #include <bits/stdc++.h>
 18 | using namespace std;
 19 |  
 20 | #define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))
 21 |  
 22 | // utility function to search
 23 | // complete string from any
 24 | // given index of 2d char array
 25 | int internalSearch(string needle, int row,
 26 |                    int col, string hay[],
 27 |                    int row_max, int col_max, int xx)
 28 | {
 29 |     int found = 0;
 30 |  
 31 |     if (row >= 0 && row <= row_max && col >= 0 &&
 32 |         col <= col_max && needle[xx] == hay[row][col])
 33 |     {
 34 |         char match = needle[xx];
 35 |         xx += 1;
 36 |  
 37 |         hay[row][col] = 0;
 38 |  
 39 |         if (needle[xx] == 0)
 40 |         {
 41 |             found = 1;
 42 |         }
 43 |         else
 44 |         {
 45 |  
 46 |             // through Backtrack searching
 47 |             // in every directions
 48 |             found += internalSearch(needle, row,
 49 |                                     col + 1, hay,
 50 |                                     row_max, col_max,xx);
 51 |             found += internalSearch(needle, row, col - 1,
 52 |                                     hay, row_max, col_max,xx);
 53 |             found += internalSearch(needle, row + 1, col,
 54 |                                     hay, row_max, col_max,xx);
 55 |             found += internalSearch(needle, row - 1, col,
 56 |                                     hay, row_max, col_max,xx);
 57 |         }
 58 |         hay[row][col] = match;
 59 |     }
 60 |     return found;
 61 | }
 62 |  
 63 | // Function to search the string in 2d array
 64 | int searchString(string needle, int row, int col,
 65 |                   string str[], int row_count,
 66 |                                 int col_count)
 67 | {
 68 |     int found = 0;
 69 |     int r, c;
 70 |  
 71 |     for (r = 0; r < row_count; ++r)
 72 |     {
 73 |         for (c = 0; c < col_count; ++c)
 74 |         {
 75 |             found += internalSearch(needle, r, c, str,
 76 |                                     row_count - 1,
 77 |                                     col_count - 1, 0);
 78 |         }
 79 |     }
 80 |     return found;
 81 | }
 82 |  
 83 | // Driver code
 84 | int main()
 85 | {
 86 |     string needle = "MAGIC";
 87 |     string input[] = { "BBABBM",
 88 |                        "CBMBBA",
 89 |                        "IBABBG",
 90 |                        "GOZBBI",
 91 |                        "ABBBBC",
 92 |                        "MCIGAM" };
 93 |     string str[ARRAY_SIZE(input)];
 94 |     int i;
 95 |     for (i = 0; i < ARRAY_SIZE(input); ++i)
 96 |     {
 97 |         str[i] = input[i];
 98 |     }
 99 |  
100 |     cout << "count: " << searchString(needle, 0, 0, str,
101 |                                       ARRAY_SIZE(str),
102 |                                       str[0].size()) << endl;
103 |     return 0;
104 | }
105 | 
106 | //count: 3
107 | 
108 | 


--------------------------------------------------------------------------------
/strings/081_min char to make palindrome.cpp:
--------------------------------------------------------------------------------
  1 | //author :shreyamalogi
  2 | 
  3 | /*
  4 | Minimum characters to be added at front to make
  5 |  string palindrome
  6 |  
  7 |  brute force
  8 |  tart checking the string each 
  9 |  time if it is a palindrome and 
 10 |  if not, then delete the last 
 11 |  character and check again. 
 12 |  When the string gets reduced to 
 13 |  wither a palindrome or empty then the number of characters deleted from the end till now will be the answer as those characters could have been inserted at the beginning of the original string in the order which will will
 14 |   make the string a palindrome.
 15 | 
 16 | o(n2) tc
 17 | 
 18 | but for better approach we can use kmp algo
 19 | 
 20 | */
 21 | 
 22 | 
 23 | //#include<bits/stdc++.h>
 24 | //using namespace std;
 25 | // 
 26 | //// function for checking string is palindrome or not
 27 | //bool ispalindrome(string s)
 28 | //{
 29 | //    int l = s.length();
 30 | //    int j;
 31 | //     
 32 | //    for(int i = 0, j = l - 1; i <= j; i++, j--)
 33 | //    {
 34 | //        if(s[i] != s[j])
 35 | //            return false;
 36 | //    }
 37 | //    return true;
 38 | //}
 39 | // 
 40 | //
 41 | //int main()
 42 | //{
 43 | //    string s = "BABABAA";
 44 | //    int cnt = 0;
 45 | //    int flag = 0;
 46 | //     
 47 | //    while(s.length()>0)
 48 | //    {
 49 | //        // if string becomes palindrome then break
 50 | //        if(ispalindrome(s))
 51 | //        {
 52 | //            flag = 1;
 53 | //             break;
 54 | //        }
 55 | //        else
 56 | //        {
 57 | //        cnt++;
 58 | //         
 59 | //        // erase the last element of the string
 60 | //        s.erase(s.begin() + s.length() - 1);
 61 | //        }
 62 | //    }
 63 | //     
 64 | //    // print the number of insertion at front
 65 | //    if(flag)
 66 | //        cout << cnt;
 67 | //}
 68 | ////2
 69 | 
 70 | 
 71 | #include <bits/stdc++.h>
 72 | using namespace std;
 73 |  
 74 | // returns vector lps for given string str
 75 | vector<int> computeLPSArray(string str)
 76 | {
 77 |     int M = str.length();
 78 |     vector<int> lps(M);
 79 |  
 80 |     int len = 0;
 81 |     lps[0] = 0; // lps[0] is always 0
 82 |  
 83 |     // the loop calculates lps[i] for i = 1 to M-1
 84 |     int i = 1;
 85 |     while (i < M)
 86 |     {
 87 |         if (str[i] == str[len])
 88 |         {
 89 |             len++;
 90 |             lps[i] = len;
 91 |             i++;
 92 |         }
 93 |         else // (str[i] != str[len])
 94 |         {
 95 |             // This is tricky. Consider the example.
 96 |             // AAACAAAA and i = 7. The idea is similar
 97 |             // to search step.
 98 |             if (len != 0)
 99 |             {
100 |                 len = lps[len-1];
101 |  
102 |                 // Also, note that we do not increment
103 |                 // i here
104 |             }
105 |             else // if (len == 0)
106 |             {
107 |                 lps[i] = 0;
108 |                 i++;
109 |             }
110 |         }
111 |     }
112 |     return lps;
113 | }
114 |  
115 | // Method returns minimum character to be added at
116 | // front to make string palindrome
117 | int getMinCharToAddedToMakeStringPalin(string str)
118 | {
119 |     string revStr = str;
120 |     reverse(revStr.begin(), revStr.end());
121 |  
122 |     // Get concatenation of string, special character
123 |     // and reverse string
124 |     string concat = str + "$" + revStr;
125 |  
126 |     //  Get LPS array of this concatenated string
127 |     vector<int> lps = computeLPSArray(concat);
128 |  
129 |     // By subtracting last entry of lps vector from
130 |     // string length, we will get our result
131 |     return (str.length() - lps.back());
132 | }
133 |  
134 | 
135 | int main()
136 | {
137 |     string str = "AACECAAAA";
138 |     cout << getMinCharToAddedToMakeStringPalin(str);
139 |     return 0;
140 | }
141 | 
142 | 


--------------------------------------------------------------------------------