├── Class3
    ├── BitwiseOperators.cpp
    ├── Factorial.cpp
    ├── FahrenheitToCelsius.cpp
    ├── UniqueNumber.cpp
    ├── FibonacciSeries.cpp
    ├── TernaryOperator.cpp
    ├── Forloop.cpp
    ├── MinAndMax.cpp
    └── SwitchCase.cpp
├── Class2
    ├── whileloop.cpp
    ├── HelloWorld.cpp
    ├── SumOfDigits.cpp
    ├── PosNegZero.cpp
    ├── SumOfNaturalNo.cpp
    ├── Largestof3Numbers.cpp
    ├── OddEven.cpp
    ├── AddNumbers.cpp
    ├── FizzBuzz.cpp
    ├── Operators.cpp
    └── DataTypes.cpp
├── Class4
    ├── Continue.cpp
    ├── StarPattern.cpp
    ├── UpperLowerCase.cpp
    ├── NumberPattern.cpp
    ├── FunctionAdd.cpp
    ├── Break.cpp
    ├── PrimeNumber.cpp
    ├── Functions.cpp
    ├── PrimeNumUsingFun.cpp
    └── PatternOddEven.cpp
├── Class17
    ├── Power.cpp
    ├── Factorial.cpp
    ├── Fibonacci.cpp
    ├── LinearSearch.cpp
    ├── IncDecSequence.cpp
    └── IsArraySorted.cpp
├── Class16
    ├── SingleNumber(ii).cpp
    ├── DecimalToBinary.cpp
    ├── CountSetBits.cpp
    ├── BitBasics.cpp
    └── SingleNumber(iii).cpp
├── Class11
    ├── IsPalindrome.cpp
    ├── ReverseWordsInString.cpp
    ├── StringCompression.cpp
    ├── RobotReturnToOrigin.cpp
    ├── ValidAnagram.cpp
    └── BasicsString.cpp
├── Class19
    ├── TowerOfHanoi.cpp
    ├── Subsets.cpp
    ├── Permutations.cpp
    └── FloodFill.cpp
├── Class13
    ├── PassByRefrence.cpp
    ├── SplitInBalancedStrings.cpp
    ├── Pointers.cpp
    ├── LongestPalindromicSubstring.cpp
    └── MultiplyStrings.cpp
├── Class7
    ├── PlusOne.cpp
    ├── SortArrayByParity.cpp
    ├── Vector.cpp
    ├── TrappingRainWater.cpp
    └── MaxProductOf3Num.cpp
├── Class5
    ├── MissingNumber.cpp
    ├── MoveZeros.cpp
    ├── ArrayBasics.cpp
    ├── MaxAndMin.cpp
    ├── SecondLargest.cpp
    └── LinearSearch.cpp
├── Class14
    ├── SearchA2DMatrix(ii).cpp
    ├── Sqrt(x).cpp
    ├── BinarySearch.cpp
    ├── SearchA2dMatrix.cpp
    └── FirstAndLastPositionOfElement.cpp
├── Class10
    ├── BubbleSort.cpp
    ├── SelectionSort.cpp
    ├── SortColors.cpp
    ├── CountingSort.cpp
    └── MergeIntervals.cpp
├── Class6
    ├── KadanesAlgo.cpp
    ├── GeneratingSubarrays.cpp
    ├── PivotIndex.cpp
    └── CountPairsWithSum.cpp
├── Class8
    ├── MergeSortedArray.cpp
    ├── ProductOfArrayExceptSelf.cpp
    ├── TripletSumArray.cpp
    └── NextPermutation.cpp
├── Class9
    ├── RowWithMax1s.cpp
    ├── 2DArrayBasics.cpp
    ├── WavePrint.cpp
    ├── RotateImage.cpp
    └── SpiralMatrix.cpp
├── Class15
    ├── FindPeakElement.cpp
    ├── SearchInRotatedSortedArray.cpp
    ├── SingleElementInSortedArray.cpp
    └── MedianOfTwoSortedArrays.cpp
├── Class12
    ├── LongestCommonPrefix.cpp
    ├── AddBinary.cpp
    ├── ValidPalindrome(ii).cpp
    └── RomanToInteger.cpp
├── Class18
    ├── QuickSort.cpp
    ├── NumberOfIslands.cpp
    ├── MergeSort.cpp
    └── InversionCount.cpp
├── Class20
    ├── GenerateParenthesis.cpp
    ├── LetterCombinationsOfPhoneNumber.cpp
    ├── CombinationalSum.cpp
    └── WordSearch.cpp
└── Class21
    ├── PalindromePartitioning.cpp
    ├── RatInAMaze.cpp
    ├── SurroundedRegions.cpp
    └── SudokuSolver.cpp


/Class3/BitwiseOperators.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     cout<<(5&7)<<endl;
 7 |     cout<<(5&6)<<endl;
 8 |     cout<<(5|6)<<endl;
 9 |     cout<<(5^7)<<endl;
10 |     
11 |     return 0;
12 | }


--------------------------------------------------------------------------------
/Class2/whileloop.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int count = 1;
 7 | 
 8 |     while(count < 6)
 9 |     {
10 |         cout<<"Hello World! "<<count<<endl;
11 |         count++;
12 |     }
13 | 
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Class3/Factorial.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int num;
 7 |     cin>>num;
 8 | 
 9 |     int fact = 1;
10 |     for(int i=1; i<=num; i++)
11 |     {
12 |         // fact = fact * i;
13 |         fact *= i;
14 |     }
15 | 
16 |     cout<<fact;
17 | 
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Class3/FahrenheitToCelsius.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 | 
 7 |     int f;
 8 |     cin>>f;
 9 |     int c;
10 | 
11 |     while(f<=200)
12 |     {
13 |         c = (5*(f-32)) / 9;
14 |         cout<<f<<" "<<c<<endl;
15 |         f = f+20;
16 |     }
17 | 
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Class2/HelloWorld.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | // starting point of program
 5 | int main(){ 
 6 | 
 7 |     /*
 8 |     multi line comment
 9 |     */
10 |     cout<<"Hello World!"<<endl;
11 | 
12 |     cout<<"Learning Data Structures and Algorithms";
13 |     
14 |     // end of program
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Class3/UniqueNumber.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // 4, 5, 1, 5, 3, 1, 4
 7 |     int n;
 8 |     cin>>n;
 9 |     int no;
10 |     int ans = 0;
11 |     for(int i=0; i<n; i++)
12 |     {
13 |         cin>>no;
14 |         ans ^= no;
15 |     }
16 |     cout<<ans;
17 | 
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Class4/Continue.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     for(int i=1; i<=10; i++)
 7 |     {
 8 |         if(i%2==0)
 9 |         {
10 |             continue; // start of the loop line no 6
11 |         }
12 |         cout<<i<<endl;
13 |     }
14 | 
15 |     cout<<"Out of the loop";
16 | 
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Class2/SumOfDigits.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 |     
 6 |     int num;
 7 |     cin>>num;
 8 |     int sum = 0;
 9 | 
10 |     while(num > 0)
11 |     {
12 |         int lastDigit = num%10;
13 |         sum += lastDigit;
14 |         num /= 10;
15 |     }
16 | 
17 |     cout<<"Sum of digits :"<<sum;
18 | 
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Class17/Power.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int power(int a, int b)
 5 | {
 6 |     // base case
 7 |     if(b==0)
 8 |     {
 9 |         return 1;
10 |     }
11 |     else
12 |     {
13 |         return a*power(a, b-1);
14 |     }
15 | }
16 | 
17 | int main(){
18 |     int a,b;
19 |     cin>>a>>b;
20 |     cout<<power(a,b);
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class2/PosNegZero.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int num;
 7 |     cin>>num;
 8 | 
 9 |     if(num > 0)
10 |     {
11 |         cout<<"Positive";
12 |     }
13 |     else if(num == 0)
14 |     {
15 |         cout<<"Zero";
16 |     }
17 |     else
18 |     {
19 |         cout<<"Negative";
20 |     }
21 | 
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Class2/SumOfNaturalNo.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int n; //5
 7 |     cin>>n;
 8 |     int i=1;
 9 |     int sum = 0;
10 |     while(i<=n)
11 |     {
12 |         //sum = sum + i;  0 + 1 = 1 + 2 = 3 + 3 = 6 + 4 = 10 + 5 = 15
13 |         sum += i;
14 |         i++; // 6
15 |     }
16 |     cout<<sum;
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Class2/Largestof3Numbers.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int a=20, b=20, c=10;
 7 | 
 8 |     if(a>=b && a>=c)
 9 |     {
10 |         cout<<"a :"<<a;
11 |     }
12 |     else if(b>=a && b>=c)
13 |     {
14 |         cout<<"b :"<<b;
15 |     }
16 |     else
17 |     {
18 |         cout<<"c :"<<c;
19 |     }
20 | 
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class17/Factorial.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int fact(int n)
 5 | {
 6 |     // base case
 7 |     if(n==0)
 8 |     {
 9 |         return 1;
10 |     }
11 |     // recursive case
12 |     int smallAns = n * fact(n-1);
13 |     return smallAns;
14 | }
15 | 
16 | int main(){
17 |     int n;
18 |     cin>>n;
19 |     cout<<fact(n)<<endl;
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Class4/StarPattern.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void patternPrint(int n)
 5 | {
 6 |     for(int row=1; row<=n; row++)
 7 |     {
 8 |         for(int col=1; col<=row; col++)
 9 |         {
10 |             cout<<"* ";
11 |         }
12 |         cout<<endl; // changing the row
13 |     }
14 | }
15 | 
16 | int main(){
17 | 
18 |     patternPrint(5);
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Class2/OddEven.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int num = 11;
 7 |     // condition
 8 |     if(num%2==0)
 9 |     {
10 |         cout<<"Entering if block"<<endl;
11 |         cout<<"Even number";
12 |     }
13 |     else
14 |     {
15 |         cout<<"Entering else block"<<endl;
16 |         cout<<"Odd number";
17 |     }
18 | 
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Class3/FibonacciSeries.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int n;
 7 |     cin>>n;
 8 |     int n1 = 0;
 9 |     int n2 = 1;
10 |     cout<<n1<<" "<<n2<<" ";
11 |     int n3;
12 | 
13 |     for(int i=2; i<n; i++)
14 |     {
15 |         n3 = n1+n2;
16 |         cout<<n3<<" ";
17 |         n1 = n2;
18 |         n2 = n3;
19 |     }
20 | 
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class4/UpperLowerCase.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     char ch;
 7 |     cin>>ch;
 8 | 
 9 |     if(ch>='A' && ch<='Z')
10 |     {
11 |         cout<<"UPPERCASE";
12 |     }
13 |     else if(ch>='a' && ch<='z')
14 |     {
15 |         cout<<"Lowecase";
16 |     }
17 |     else
18 |     {
19 |         cout<<"Invalid";
20 |     }
21 | 
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Class17/Fibonacci.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int fib(int n)
 5 | {
 6 |     // base case
 7 |     if(n==0 || n==1)
 8 |     {
 9 |         return n;
10 |     }
11 |     // recursive case
12 |     int f1 = fib(n-1);
13 |     int f2 = fib(n-2); 
14 |     return f1+f2;
15 | }
16 | 
17 | int main(){
18 |     int n;
19 |     cin>>n;
20 |     cout<<fib(n)<<endl;
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class2/AddNumbers.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // int num1 = 3;
 7 |     // int num2 = 5;
 8 |     // int result = num1+num2;
 9 |     // cout<<result;
10 | 
11 |     // int num1, num2;
12 |     // cin>>num1>>num2;
13 | 
14 |     // int result = num1+num2;
15 |     // cout<<result;
16 | 
17 |     int a=2, b=1, c=4;
18 |     cout<<(a+b+c);
19 | 
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Class16/SingleNumber(ii).cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/single-number-ii/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int singleNumber(vector<int>& nums) {
 6 |         
 7 |         int ones = 0;
 8 |         int twos = 0;
 9 |         
10 |         for(int i:nums)
11 |         {
12 |             ones = (ones^i) & (~twos);
13 |             twos = (twos^i) & (~ones);
14 |         }
15 |         return ones;
16 |     }
17 | };


--------------------------------------------------------------------------------
/Class2/FizzBuzz.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int n = 28;
 7 | 
 8 |     if(n%3==0 && n%4==0)
 9 |     {
10 |         cout<<"FizzBuzz";
11 |     }
12 |     else if(n%3==0)
13 |     {
14 |         cout<<"Fizz";
15 |     }
16 |     else if(n%4==0)
17 |     {
18 |         cout<<"Buzz";
19 |     }
20 |     else
21 |     {
22 |         cout<<"Bye";
23 |     }
24 | 
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Class11/IsPalindrome.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | string isPalindrome(string str)
 5 | {
 6 |     int n = str.size();
 7 |     for(int i=0; i<n/2; i++)
 8 |     {
 9 |         if(str[i]!=str[n-i-1])
10 |         {
11 |             return "NO";
12 |         }
13 |     }
14 |     return "YES";
15 | }
16 | 
17 | int main(){
18 |     string str;
19 |     cin>>str;
20 |     cout<<isPalindrome(str);
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class16/DecimalToBinary.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int decimalToBinary(int n)
 5 | {
 6 |     int ans = 0;
 7 |     int p = 1;
 8 |     while(n>0)
 9 |     {
10 |         int lastBit = (n&1);
11 |         ans += p*lastBit;
12 |         p = p*10;
13 |         n = n>>1;
14 |     }
15 |     return ans;
16 | }
17 | 
18 | int main(){
19 |     int n;
20 |     cin>>n;
21 |     cout<<decimalToBinary(n)<<endl;
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Class4/NumberPattern.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void numberPat(int n)
 5 | {
 6 |     int value = 1;
 7 |     for(int row=1; row<=n; row++)
 8 |     {
 9 |         for(int col=1; col<=row; col++)
10 |         {
11 |             cout<<value++<<" ";
12 |             // value++;
13 |         }
14 |         cout<<endl; // changing the row
15 |     }
16 | }
17 | 
18 | int main(){
19 | 
20 |     numberPat(6);
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class4/FunctionAdd.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | // void addTwoNumbers(int num1, int num2)
 5 | // {
 6 | //     cout<<num1+num2<<endl;
 7 | // }
 8 | 
 9 | int addNumbers(int a, int b, int c)
10 | {
11 |     return a+b+c;
12 | }
13 | 
14 | int main(){
15 |     // int num1, num2;
16 |     // cin>>num1>>num2;
17 | 
18 |     // addTwoNumbers(5, 11);
19 |     
20 |     cout<<addNumbers(6, 10, 13)<<endl;
21 |     cout<<addNumbers(16, 10, 13);
22 | 
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Class19/TowerOfHanoi.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void TOH(int n, char src, char helper, char dest)
 5 | {
 6 |     // base case
 7 |     if(n==0)
 8 |     {
 9 |         return;
10 |     }
11 |     // recursive case
12 |     TOH(n-1, src, dest, helper);
13 |     cout<<"Move disk "<<n<<" from "<<src<<" to "<<dest<<endl;
14 |     TOH(n-1, helper, src, dest);
15 | }
16 | 
17 | int main(){
18 |     int n;
19 |     cin>>n;
20 |     TOH(n, 'A', 'B', 'C');
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Class11/ReverseWordsInString.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/reverse-words-in-a-string-iii/
 2 | 
 3 | class Solution {   
 4 | public:
 5 |     string reverseWords(string s) {
 6 |         
 7 |         int i=0;
 8 |         for(int j=0; j<s.size(); j++)
 9 |         {
10 |             if(s[j]==' ')
11 |             {
12 |                 reverse(s.begin()+i, s.begin()+j);
13 |                 i = j+1;
14 |             }
15 |         }
16 |         reverse(s.begin()+i, s.end());
17 |         return s;
18 |     }
19 | };


--------------------------------------------------------------------------------
/Class17/LinearSearch.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int linearSearch(int arr[], int i, int n, int key)
 5 | {
 6 |     // base case
 7 |     if(i==n)
 8 |     {
 9 |         return -1;
10 |     }
11 |     if(arr[i]==key)
12 |     {
13 |         return i;
14 |     }
15 |     return linearSearch(arr, i+1, n, key);
16 | }
17 | 
18 | int main(){
19 |     int arr[] = {2,4,5,1,3,7};
20 |     int n = 6;
21 |     int key = 13;
22 |     cout<<linearSearch(arr, 0, n, key);
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Class17/IncDecSequence.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void dec(int n)
 5 | {
 6 |     // base case
 7 |     if(n==0)
 8 |     {
 9 |         return;
10 |     }
11 |     cout<<n<<", ";
12 |     dec(n-1);
13 | }
14 | 
15 | void inc(int n)
16 | {
17 |     // base case
18 |     if(n==0)
19 |     {
20 |         return;
21 |     }
22 |     inc(n-1);
23 |     cout<<n<<", ";
24 | }
25 | 
26 | int main(){
27 |     int n;
28 |     cin>>n;
29 |     // dec(n);
30 |     inc(n);
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/Class11/StringCompression.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void compressString(string str)
 5 | {
 6 |     int n = str.size();
 7 |     for(int i=0; i<n; i++)
 8 |     {
 9 |         int count = 1;
10 |         while(i<n-1 && str[i]==str[i+1])
11 |         {
12 |             count++;
13 |             i++;
14 |         }
15 |         count==1 ? cout<<str[i] : cout<<str[i]<<count;
16 |     }
17 | }
18 | 
19 | int main(){
20 |     string str;
21 |     cin>>str;
22 |     compressString(str);
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Class3/TernaryOperator.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // int num = 8;
 7 |     // bool checkEven = num%2==0 ? true : false;
 8 |     // cout<<checkEven;
 9 | 
10 |     // int marks;
11 |     // cin>>marks;
12 |     // string result = (marks >= 50) ? "pass" : "fail";
13 |     // cout<<result;
14 | 
15 |     int num;
16 |     cin>>num;
17 | 
18 |     string res;
19 | 
20 |     res = (num==0) ? "zero" : ((num>0) ? "positive" : "negative");
21 | 
22 |     cout<<res;
23 | 
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/Class13/PassByRefrence.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | // void multiply(int x)
 5 | // {
 6 | //     x *=2;
 7 | //     cout<<"Inside function : "<<x<<endl;
 8 | // }
 9 | 
10 | // void multiply(int *xptr)
11 | // {
12 | //     *xptr *= 2;
13 | //     cout<<"Inside function : "<<*xptr<<endl;
14 | // }
15 | 
16 | void multiply(int &x)
17 | {
18 |     x *=2;
19 |     cout<<"Inside function : "<<x<<endl;
20 | }
21 | 
22 | int main(){
23 |     int x = 7;
24 |     multiply(x);
25 |     cout<<"Inside main : "<<x<<endl;
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/Class7/PlusOne.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/plus-one/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<int> plusOne(vector<int>& digits) {
 6 |         
 7 |         int n = digits.size();
 8 |         for(int i=n-1; i>=0; i--)
 9 |         {
10 |             if(digits[i] < 9)
11 |             {
12 |                 digits[i] += 1;
13 |                 return digits;
14 |             }
15 |             digits[i] = 0;
16 |         }
17 |         digits[0] = 1;
18 |         digits.push_back(0);
19 |         
20 |         return digits;
21 |     }
22 | };


--------------------------------------------------------------------------------
/Class4/Break.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // for(int i=1; i<=10; i++)
 7 |     // {
 8 |     //     if(i==7)
 9 |     //     {
10 |     //         break; // it will go to line no 13
11 |     //     }
12 |     //     cout<<i<<endl;
13 |     // }
14 |     int no;
15 | 
16 |     while(true)
17 |     {
18 |         cin>>no;
19 |         if(no%5==0)
20 |         {
21 |             break;
22 |         }
23 |         cout<<"Not multiple of 5"<<endl;
24 |     }
25 | 
26 |     cout<<"Out of the loop";
27 | 
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Class17/IsArraySorted.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool isSorted(int arr[], int n)
 5 | {
 6 |     // base case
 7 |     if(n==0 || n==1)
 8 |     {
 9 |         return true;
10 |     }
11 |     if(arr[0] <= arr[1] && isSorted(arr+1, n-1))
12 |     {
13 |         return true;
14 |     }
15 |     return false;
16 | }
17 | 
18 | int main(){
19 |     int arr[] = {12,4,6,7,9};
20 |     int n = 5;
21 |     if(isSorted(arr, n)){
22 |         cout<<"Sorted Array";
23 |     }
24 |     else{
25 |         cout<<"Not sorted";
26 |     }
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/Class7/SortArrayByParity.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/sort-array-by-parity/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<int> sortArrayByParity(vector<int>& A) {
 6 |     
 7 |         int n = A.size();
 8 |         int i=0;
 9 |         int j=n-1;
10 |         
11 |         while(i<j)
12 |         {
13 |             if(A[i]%2!=0)
14 |             {
15 |                 swap(A[i], A[j]);
16 |                 j--;
17 |             }
18 |             else
19 |             {
20 |                 i++;
21 |             }
22 |         }
23 |         return A;
24 |     }
25 | };


--------------------------------------------------------------------------------
/Class4/PrimeNumber.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<math.h>
 3 | // #include<bits/stdc++.h>
 4 | using namespace std;
 5 | 
 6 | int main(){
 7 | 
 8 |     int num;
 9 |     cin>>num;
10 |     bool isPrime = true;
11 | 
12 |     for(int i=2; i<=sqrt(num); i++)
13 |     {
14 |         if(num%i==0)
15 |         {
16 |             isPrime = false;
17 |             break;
18 |         }
19 |     }
20 | 
21 |     if(isPrime==true)
22 |     {
23 |         cout<<"Num is prime";
24 |     }
25 |     else
26 |     {   
27 |         cout<<"Num is not prime";
28 |     }
29 | 
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Class5/MissingNumber.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | // #include<bits/stdc++.h>
 4 | 
 5 | int missingNumber(int arr[], int n)
 6 | {
 7 |     int totalSum = n*(n+1)/2;
 8 |     int arraySum = 0;
 9 | 
10 |     for(int i=0; i<n; i++)
11 |     {
12 |         arraySum += arr[i];    
13 |     }
14 | 
15 |     return totalSum - arraySum;
16 | }
17 | 
18 | int main(){
19 | 
20 |     int n;
21 |     cin>>n;
22 |     int arr[n];
23 |     for(int i=0; i<n; i++)
24 |     {
25 |         cin>>arr[i];
26 |     }
27 | 
28 |     cout<<missingNumber(arr, n);
29 | 
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Class14/SearchA2DMatrix(ii).cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/search-a-2d-matrix-ii/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     bool searchMatrix(vector<vector<int>>& matrix, int target) {
 6 |         
 7 |         int row = matrix.size();
 8 |         int col = matrix[0].size();
 9 |         
10 |         int i=0;
11 |         int j=col-1;
12 |         
13 |         while(i<row && j>=0)
14 |         {
15 |             if(matrix[i][j]==target)
16 |             {
17 |                 return true;
18 |             }
19 |             target > matrix[i][j] ? i++ : j--;
20 |         }
21 |         return false;
22 |     }
23 | };


--------------------------------------------------------------------------------
/Class4/Functions.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | // void printHello()
 5 | // {
 6 | //     cout<<"Hello"<<endl;
 7 | // }
 8 | 
 9 | int factorial(int num)
10 | {
11 |     int fact = 1;
12 |     for(int i=1; i<=num; i++)
13 |     {
14 |         // fact = fact * i;
15 |         fact *= i;
16 |     }
17 |     return fact;
18 | }
19 | 
20 | int main(){
21 |     // cout<<"Before function"<<endl;
22 |     // printHello();
23 |     // cout<<"After function";
24 |     cout<<factorial(6)<<endl;
25 |     cout<<factorial(5)<<endl;
26 |     cout<<factorial(3)<<endl;
27 |     cout<<factorial(7);
28 | 
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/Class10/BubbleSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void bubbleSort(int arr[], int n)
 5 | {
 6 |     for(int i=0; i<n-1; i++)
 7 |     {
 8 |         for(int j=0; j<n-i-1; j++)
 9 |         {
10 |             if(arr[j] > arr[j+1])
11 |             {
12 |                 swap(arr[j], arr[j+1]);
13 |             }
14 |         }
15 |     }
16 | }
17 | 
18 | int main(){
19 |     int n;
20 |     cin>>n;
21 |     int arr[n];
22 |     for(int i=0; i<n; i++)
23 |     {
24 |         cin>>arr[i];
25 |     }
26 |     bubbleSort(arr, n);
27 |     for(int i=0; i<n; i++)
28 |     {
29 |         cout<<arr[i]<<", ";
30 |     }
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/Class16/CountSetBits.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int countSetBits(int n)
 5 | {
 6 |     int ans = 0;
 7 |     while(n>0)
 8 |     {
 9 |         ans += (n&1);
10 |         n = n>>1;
11 |     }
12 |     return ans;
13 | }
14 | 
15 | int countSetBitsOptimised(int n)
16 | {
17 |     int ans = 0;
18 |     while(n>0)
19 |     {
20 |         n = n & (n-1);
21 |         ans++;
22 |     }
23 |     return ans;
24 | }
25 | 
26 | int main(){
27 | 
28 |     int n;
29 |     cin>>n;
30 |     // cout<<countSetBits(n)<<endl;
31 |     cout<<countSetBitsOptimised(n)<<endl;
32 |     cout<<__builtin_popcount(n)<<endl;
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Class5/MoveZeros.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void moveZeros(int arr[], int n)
 5 | {
 6 |     int j=0; // index of non-zero element
 7 | 
 8 |     for(int i=0; i<n; i++)
 9 |     {
10 |         if(arr[i]!=0)
11 |         {
12 |             swap(arr[i], arr[j]);
13 |             j++;
14 |         }
15 |     }
16 | }
17 | 
18 | int main(){
19 | 
20 |     int n;
21 |     cin>>n;
22 |     int arr[n];
23 |     for(int i=0; i<n; i++)
24 |     {
25 |         cin>>arr[i];
26 |     }
27 | 
28 |     moveZeros(arr, n);
29 | 
30 |     for(int i=0; i<n; i++)
31 |     {
32 |         cout<<arr[i]<<", ";
33 |     }
34 | 
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Class6/KadanesAlgo.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int maximumSumSubarray(int arr[], int n)
 5 | {
 6 |     int currSum = 0;
 7 |     int maxSum = INT_MIN;
 8 | 
 9 |     for(int i=0; i<n; i++)
10 |     {
11 |         currSum += arr[i];
12 |         maxSum = max(maxSum, currSum);
13 |         if(currSum < 0)
14 |         {
15 |             currSum = 0;
16 |         }
17 |     }
18 |     return maxSum;
19 | }
20 | 
21 | int main(){
22 | 
23 |     int n;
24 |     cin>>n;
25 |     int arr[n];
26 |     for(int i=0; i<n; i++)
27 |     {
28 |         cin>>arr[i];
29 |     }
30 | 
31 |     cout<<maximumSumSubarray(arr, n);
32 | 
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Class4/PrimeNumUsingFun.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<math.h>
 3 | using namespace std;
 4 | 
 5 | bool checkPrime(int num)
 6 | {
 7 |     for(int i=2; i<=sqrt(num); i++)
 8 |     {
 9 |         if(num%i==0)
10 |         {
11 |             return false; // not prime
12 |         }
13 |     }
14 |     return true; // prime
15 | }
16 | 
17 | int main(){
18 | 
19 |     if(checkPrime(19)){
20 |         cout<<"Prime Number"<<endl;
21 |     }
22 |     else{
23 |         cout<<"Not a prime"<<endl;
24 |     }
25 | 
26 |     if(checkPrime(9)){
27 |         cout<<"Prime Number";
28 |     }
29 |     else{
30 |         cout<<"Not a prime";
31 |     }
32 | 
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Class3/Forloop.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // int n = 7;
 7 | 
 8 |     // for(int i=0; i<n; i++)
 9 |     // {
10 |     //     cout<<"Hello!"<<endl;
11 |     // }
12 | 
13 |     // for(int i=1; i<=10; i++)
14 |     // {
15 |     //     cout<<i<<endl;
16 |     // }
17 | 
18 |     // for(int i=10; i>=1; i--)
19 |     // {
20 |     //     cout<<i<<endl;
21 |     // }
22 | 
23 |     // for(int i=0; i<=20; i+=2)
24 |     // {
25 |     //      cout<<i<<endl;
26 |     // }
27 | 
28 |     int sum = 0;
29 |     for(int i=1; i<=10; i++)
30 |     {
31 |         sum += i;
32 |     }
33 |     cout<<sum;
34 | 
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Class3/MinAndMax.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<climits>
 3 | using namespace std;
 4 | 
 5 | int main(){
 6 |     int n;
 7 |     cin>>n;
 8 |     int no;
 9 |     int minSoFar = INT_MAX; // biggest int val
10 |     int maxSoFar = INT_MIN; // smallest int val
11 |     //4 6 -3 10 2 -6 1
12 |     for(int i=0; i<n; i++)
13 |     {
14 |         cin>>no;
15 |         if(no < minSoFar){
16 |             minSoFar = no; // 4, -3, -6
17 |         }
18 |         if(no > maxSoFar){
19 |             maxSoFar = no; // 4, 6, 10 
20 |         }
21 |     }
22 | 
23 |     cout<<"Minimum Value is : "<<minSoFar<<endl;
24 |     cout<<"Maximum value is : "<<maxSoFar;    
25 | 
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/Class7/Vector.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | using namespace std;
 4 | 
 5 | int main(){
 6 |     int n;
 7 |     cin>>n;
 8 |     vector<int> v;
 9 |     vector<int> a(n);
10 |     vector<int> b(5, 10);
11 |     vector<int> c{1,3,4,2,6};
12 | 
13 |     // iterate over vector
14 |     for(int i=0; i<c.size(); i++)
15 |     {
16 |         cout<<c[i]<<", ";
17 |     }
18 |     cout<<endl;
19 | 
20 |     // input elements
21 |     for(int i=0; i<n; i++)
22 |     {
23 |         int no;
24 |         cin>>no;
25 |         v.push_back(no);
26 |     }
27 | 
28 |     // for each loop
29 |     for(int i:v)
30 |     {
31 |         cout<<i<<", ";
32 |     }
33 | 
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Class14/Sqrt(x).cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/sqrtx/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int mySqrt(int x) {
 6 |         
 7 |         int s = 0;
 8 |         int e = x;
 9 |         int res = 0;
10 |         
11 |         while(s<=e)
12 |         {
13 |             long long int mid = (s+e)/2;
14 |             if(mid*mid == x)
15 |             {
16 |                 return mid;
17 |             }
18 |             else if(mid*mid < x)
19 |             {
20 |                 res = mid;
21 |                 s = mid+1;
22 |             }
23 |             else
24 |             {
25 |                 e = mid-1;
26 |             }
27 |         }
28 |         return res;
29 |     }
30 | };


--------------------------------------------------------------------------------
/Class11/RobotReturnToOrigin.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/robot-return-to-origin/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     bool judgeCircle(string moves) {
 6 |         
 7 |         int x = 0;
 8 |         int y = 0;
 9 |         
10 |         for(char i:moves)
11 |         {
12 |             if(i=='L')
13 |             {
14 |                 x--;
15 |             }
16 |             else if(i=='R')
17 |             {
18 |                 x++;
19 |             }
20 |             else if(i=='U')
21 |             {
22 |                 y++;
23 |             }
24 |             else
25 |             {
26 |                 y--;
27 |             }
28 |         }
29 |         return x==0 && y==0;
30 |     }
31 | };


--------------------------------------------------------------------------------
/Class5/ArrayBasics.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int arr[5] = {3, 1, 2, 6, 8};
 7 | 
 8 |     cout<<arr[1]<<endl; // 1
 9 |     cout<<arr[4]<<endl; // 8
10 |     cout<<arr[2]<<endl; // 2
11 | 
12 |     //update the index
13 |     arr[1] = 5;
14 |     cout<<arr[1]<<endl;
15 |     int n;
16 |     cin>>n;
17 |     int arr[n];
18 |     for(int i=0; i<n; i++)
19 |     {
20 |         cin>>arr[i];
21 |     }
22 | 
23 |     for(int i=0; i<n; i++)
24 |     {
25 |         cout<<arr[i]<<", ";
26 |     }
27 | 
28 |     int arr[] = {5, 2, 3, 1, 8, 9, 7};
29 |     int n = sizeof(arr)/sizeof(arr[0]);
30 |     int m = sizeof(arr)/sizeof(int);
31 |     cout<<n;
32 | 
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Class6/GeneratingSubarrays.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void generateSubarrays(int arr[], int n)
 5 | {
 6 |     // starting point 
 7 |     for(int i=0; i<n; i++)
 8 |     {
 9 |         // ending point
10 |         for(int j=i; j<n; j++)
11 |         {
12 |             // printing subarrays
13 |             for(int k=i; k<=j; k++)
14 |             {
15 |                 cout<<arr[k]<<", ";
16 |             }
17 |             cout<<endl;
18 |         }
19 |     }
20 | }
21 | 
22 | int main(){
23 | 
24 |     int n;
25 |     cin>>n;
26 |     int arr[n];
27 |     for(int i=0; i<n; i++)
28 |     {
29 |         cin>>arr[i];
30 |     }
31 | 
32 |     generateSubarrays(arr, n);
33 | 
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Class8/MergeSortedArray.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/merge-sorted-array/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
 6 |         
 7 |         int i = m-1;
 8 |         int j = n-1;
 9 |         int k = m+n-1;
10 |         
11 |         while(i>=0 && j>=0)
12 |         {
13 |             if(nums1[i] > nums2[j])
14 |             {
15 |                 nums1[k--] = nums1[i--];
16 |             }
17 |             else
18 |             {
19 |                 nums1[k--] = nums2[j--];
20 |             }
21 |         }
22 |         
23 |         while(j>=0)
24 |         {
25 |             nums1[k--] = nums2[j--];
26 |         }
27 |         
28 |     }
29 | };


--------------------------------------------------------------------------------
/Class10/SelectionSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void selectionSort(int arr[], int n)
 5 | {
 6 |     for(int i=0; i<n-1; i++)
 7 |     {
 8 |         int minIndex = i;
 9 |         for(int j=i+1; j<n; j++)
10 |         {
11 |             if(arr[j] < arr[minIndex])
12 |             {
13 |                 minIndex = j;
14 |             }
15 |         }
16 |         swap(arr[i], arr[minIndex]);
17 |     }
18 | }
19 | 
20 | int main(){
21 |     int n;
22 |     cin>>n;
23 |     int arr[n];
24 |     for(int i=0; i<n; i++)
25 |     {
26 |         cin>>arr[i];
27 |     }
28 |     selectionSort(arr, n);
29 |     for(int i=0; i<n; i++)
30 |     {
31 |         cout<<arr[i]<<", ";
32 |     }
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Class8/ProductOfArrayExceptSelf.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/product-of-array-except-self/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<int> productExceptSelf(vector<int>& nums) {
 6 |         
 7 |         int n = nums.size();
 8 |         vector<int> res;
 9 |         
10 |         int product = 1;
11 |         for(int i=0; i<n; i++)
12 |         {
13 |             product *= nums[i];
14 |             res.push_back(product);
15 |         }
16 |         
17 |         product = 1; // rightArray
18 |         for(int i=n-1; i>=1; i--)
19 |         {
20 |             res[i] = res[i-1]*product;
21 |             product *= nums[i]; 
22 |         }
23 |         res[0] = product;
24 |         
25 |         return res;
26 |     }
27 | };


--------------------------------------------------------------------------------
/Class13/SplitInBalancedStrings.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/split-a-string-in-balanced-strings/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int balancedStringSplit(string s) {
 6 |         
 7 |         int n = s.size();
 8 |         int l = 0;
 9 |         int r = 0;
10 |         int count = 0;
11 |         
12 |         for(int i=0; i<n; i++)
13 |         {
14 |             if(s[i]=='L')
15 |             {
16 |                 l++;
17 |             }
18 |             else
19 |             {
20 |                 r++;
21 |             }
22 |             if(l==r)
23 |             {
24 |                 count++;
25 |                 l=0;
26 |                 r=0;
27 |             }
28 |         }
29 |         return count;
30 |     }
31 | };


--------------------------------------------------------------------------------
/Class9/RowWithMax1s.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | using namespace std;
 4 | 
 5 | int rowWithMax1s(vector<vector<int>> matrix, int n, int m)
 6 | {
 7 |     int row=-1;
 8 |     int j=m-1;
 9 |     for(int i=0; i<n; i++)
10 |     {
11 |         while(matrix[i][j]==1)
12 |         {
13 |             j--;
14 |             row = i;
15 |         }
16 |     }
17 |     return row;
18 | }
19 | 
20 | int main(){
21 |     int n, m;
22 |     cin>>n>>m;
23 |     vector<vector<int>> matrix(n, vector<int>(m));
24 |     for(int i=0; i<n; i++)
25 |     {
26 |         for(int j=0; j<m; j++)
27 |         {
28 |             cin>>matrix[i][j];
29 |         }
30 |     }
31 | 
32 |     cout<<rowWithMax1s(matrix, n, m);
33 | 
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Class10/SortColors.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/sort-colors/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     void sortColors(vector<int>& nums) {
 6 |         
 7 |         int n = nums.size();
 8 |         int s = 0;
 9 |         int i = 0;
10 |         int e = n-1;
11 |         
12 |         while(i<=e)
13 |         {
14 |             if(nums[i]==0)
15 |             {
16 |                 swap(nums[i], nums[s]);
17 |                 s++;
18 |                 i++;
19 |             }
20 |             else if(nums[i]==1)
21 |             {
22 |                 i++;
23 |             }
24 |             else
25 |             {
26 |                 swap(nums[e], nums[i]);
27 |                 e--;
28 |             }
29 |         }
30 |         
31 |     }
32 | };


--------------------------------------------------------------------------------
/Class5/MaxAndMin.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int n;
 7 |     cin>>n;
 8 |     int arr[n];
 9 |     for(int i=0; i<n; i++)
10 |     {
11 |         cin>>arr[i];
12 |     }
13 | 
14 |     int minVal = INT_MAX;
15 |     int maxVal = INT_MIN;
16 | 
17 |     for(int i=0; i<n; i++)
18 |     {
19 |         if(arr[i] > maxVal)
20 |         {
21 |             maxVal = arr[i];
22 |         }
23 |         // maxVal = max(arr[i], maxVal);
24 |         if(arr[i] < minVal)
25 |         {
26 |             minVal = arr[i];
27 |         }
28 |         // minVal = min(arr[i], minVal);
29 |     }
30 | 
31 |     cout<<"Minimum value is "<<minVal<<endl;
32 |     cout<<"Maximum value is "<<maxVal<<endl;
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Class5/SecondLargest.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int secondLargest(int arr[], int n)
 5 | {
 6 |     int firstMax = INT_MIN;
 7 |     int secondMax = INT_MIN;
 8 | 
 9 |     for(int i=0; i<n; i++)
10 |     {
11 |         if(arr[i] > firstMax)
12 |         {
13 |             secondMax = firstMax;
14 |             firstMax = arr[i];
15 |         }
16 |         else if(arr[i] > secondMax)
17 |         {
18 |             secondMax = arr[i];
19 |         }
20 |     }
21 | 
22 |     return secondMax;
23 | }
24 | 
25 | int main(){
26 | 
27 |     int n;
28 |     cin>>n;
29 |     int arr[n];
30 |     for(int i=0; i<n; i++)
31 |     {
32 |         cin>>arr[i];
33 |     }
34 | 
35 |     cout<<secondLargest(arr, n);
36 | 
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Class2/Operators.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     int a = 4;
 7 |     // a = a + 5;
 8 |     a += 5;
 9 |     a -= 5;
10 | 
11 |     a++; // increment 1
12 |     a--; // decrement 1
13 | 
14 |     int x = 3;
15 |     int y = 3;
16 |     cout<<(x>y)<<endl;
17 |     cout<<(x<y)<<endl;
18 | 
19 |     // = assignment
20 |     // == comparsion
21 | 
22 |     cout<<(x==y)<<endl;
23 |     cout<<(x!=y)<<endl;
24 | 
25 |     int p = 2; // greater than 5
26 |     int q = 4; // less than 10
27 | 
28 |     cout<<(p > 5 && q < 10)<<endl;
29 | 
30 |     cout<<(p > 5 || q < 10)<<endl;
31 | 
32 |     cout<<max(50, 100)<<endl;
33 |     cout<<min(50, 100)<<endl;
34 | 
35 |     cout<<max(50, max(100, 80));
36 | 
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Class6/PivotIndex.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int pivotIndex(int arr[], int n)
 5 | {
 6 |     int totalSum = 0;
 7 |     for(int i=0; i<n; i++)
 8 |     {
 9 |         totalSum += arr[i];
10 |     }
11 | 
12 |     int leftSum = 0;
13 |     int rightSum = totalSum;
14 | 
15 |     for(int i=0; i<n; i++)
16 |     {
17 |         rightSum -= arr[i];
18 |         if(leftSum == rightSum)
19 |         {
20 |             return i;
21 |         }
22 |         leftSum += arr[i];
23 |     }
24 |     return -1;
25 | }
26 | 
27 | int main(){
28 | 
29 |     int n;
30 |     cin>>n;
31 |     int arr[n];
32 |     for(int i=0; i<n; i++)
33 |     {
34 |         cin>>arr[i];
35 |     }
36 | 
37 |     cout<<pivotIndex(arr, n);
38 | 
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/Class13/Pointers.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // int x = 5;
 7 |     // cout<<&x<<endl;
 8 | 
 9 |     // int y = 8.7;
10 |     // cout<<&y<<endl;
11 | 
12 |     // int a = 10;
13 |     // int *aptr = &a;
14 |     // cout<<a<<endl;
15 |     // cout<<aptr<<endl;
16 |     // cout<<&a<<endl;
17 | 
18 |     // // reassign
19 |     // int b = 20;
20 |     // aptr = &b;
21 |     // cout<<&b<<endl;
22 |     // cout<<aptr<<endl;
23 | 
24 |     int x = 10;
25 |     int *xptr = &x;
26 | 
27 |     cout<<&x<<endl;
28 |     cout<<xptr<<endl;
29 | 
30 |     cout<<*(&x)<<endl;
31 |     cout<<*xptr<<endl;
32 | 
33 |     cout<<&(*xptr)<<endl;
34 |     cout<<*(&xptr)<<endl;
35 | 
36 |     cout<<&xptr<<endl;
37 | 
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/Class9/2DArrayBasics.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 |     // int matrix[5][3] = {0};
 6 |     // for(int i=0; i<5; i++)
 7 |     // {
 8 |     //     for(int j=0; j<3; j++)
 9 |     //     {
10 |     //         cout<<matrix[i][j]<<" ";
11 |     //     }
12 |     //     cout<<endl;
13 |     // }
14 | 
15 |     int n,m;
16 |     cin>>n>>m;
17 |     int matrix[n][m];
18 |     for(int i=0; i<n; i++)
19 |     {
20 |         for(int j=0; j<m; j++)
21 |         {
22 |             cin>>matrix[i][j];
23 |         }
24 |     }
25 | 
26 |     for(int i=0; i<n; i++)
27 |     {
28 |         for(int j=0; j<m; j++)
29 |         {
30 |             cout<<matrix[i][j]<<", ";
31 |         }
32 |         cout<<endl;
33 |     }
34 | 
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Class16/BitBasics.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool isOdd(int n)
 5 | {
 6 |     return n&1;
 7 | }
 8 | 
 9 | int getBit(int n, int i)
10 | {
11 |     int mask = 1<<i;
12 |     int bit = (n&mask) > 0 ? 1 : 0;
13 |     return bit;
14 | }
15 | 
16 | int setBit(int n, int i)
17 | {
18 |     int mask = 1<<i;
19 |     int bit = n|mask;
20 |     return bit;
21 | }
22 | 
23 | int clearBit(int n, int i)
24 | {
25 |     int mask = ~(1<<i);
26 |     int bit = n&mask;
27 |     return bit;
28 | }
29 | 
30 | int main(){
31 | 
32 |     int n;
33 |     cin>>n;
34 |     // cout<<isOdd(n)<<endl;
35 |     int i;
36 |     cin>>i;
37 |     // cout<<getBit(n, i)<<endl;
38 |     // cout<<setBit(n, i)<<endl;
39 |     cout<<clearBit(n, i)<<endl;
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Class15/FindPeakElement.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/find-peak-element/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int findPeakElement(vector<int>& nums) {
 6 |         
 7 |         int n = nums.size();
 8 |         int s = 0;
 9 |         int e = n-1;
10 |         
11 |         while(s<=e)
12 |         {
13 |             int mid = (s+e)/2;
14 |             if((mid==0 || nums[mid] > nums[mid-1]) && (mid==n-1 || nums[mid] > nums[mid+1]))
15 |             {
16 |                 return mid;
17 |             }
18 |             else if(mid < n-1 && nums[mid] < nums[mid+1])
19 |             {
20 |                 s = mid+1;
21 |             }
22 |             else
23 |             {
24 |                 e = mid-1;
25 |             }
26 |         }
27 |         return -1;
28 |     }
29 | };


--------------------------------------------------------------------------------
/Class12/LongestCommonPrefix.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/longest-common-prefix/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     string longestCommonPrefix(vector<string>& strs) {
 6 |         
 7 |         string ans="";
 8 |         int n = strs.size();
 9 |         
10 |         sort(strs.begin(), strs.end());
11 |         string first = strs[0];
12 |         string last = strs[n-1];
13 |         int length = min(first.size(), last.size());
14 |         
15 |         for(int i=0; i<length; i++)
16 |         {
17 |             if(first[i]==last[i])
18 |             {
19 |                 ans += first[i];
20 |             }
21 |             else
22 |             {
23 |                 break;
24 |             }
25 |         }
26 |         
27 |         return ans;
28 |         
29 |     }
30 | };


--------------------------------------------------------------------------------
/Class4/PatternOddEven.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void patternOddEven(int n)
 5 | {
 6 |     int row = 1;
 7 |     while(row<=n)
 8 |     {
 9 |         int col = 1;
10 |         // odd row
11 |         if(row%2!=0)
12 |         {
13 |             while(col<=row)
14 |             {
15 |                 cout<<1<<" ";
16 |                 col++;
17 |             }
18 |         }
19 |         // even row
20 |         else
21 |         {
22 |             cout<<1<<" ";
23 |             while(col<=row-2)
24 |             {
25 |                 cout<<0<<" ";
26 |                 col++;
27 |             }
28 |             cout<<1<<" ";
29 |         }
30 |         cout<<endl;
31 |         row++;
32 |     }
33 | }
34 | 
35 | int main(){
36 | 
37 |     patternOddEven(6);
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/Class19/Subsets.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/subsets/
 2 | 
 3 | class Solution {  
 4 |     
 5 |     void generateSubsets(vector<int>& nums, vector<vector<int>>& res, vector<int>& path, int i)
 6 |     {
 7 |         if(i==nums.size())
 8 |         {
 9 |             res.push_back(path);
10 |             return;
11 |         }
12 |         
13 |         // include
14 |         path.push_back(nums[i]);
15 |         generateSubsets(nums, res, path, i+1);
16 |         path.pop_back();
17 |         
18 |         // exclude
19 |         generateSubsets(nums, res, path, i+1);
20 |     }
21 |     
22 | public:
23 |     vector<vector<int>> subsets(vector<int>& nums) {
24 |         
25 |         vector<vector<int>> res;
26 |         vector<int> path;
27 |         
28 |         generateSubsets(nums, res, path, 0);
29 |         return res;
30 |     }
31 | };


--------------------------------------------------------------------------------
/Class19/Permutations.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/permutations/
 2 | 
 3 | class Solution { 
 4 |     
 5 |     void generatePermutations(vector<int>& nums, int i, vector<vector<int>>& res)
 6 |     {
 7 |         if(i==nums.size())
 8 |         {
 9 |             res.push_back(nums);
10 |             return;
11 |         }
12 |         
13 |         for(int j=i; j<nums.size(); j++)
14 |         {
15 |             swap(nums[i], nums[j]);
16 |             generatePermutations(nums, i+1, res);
17 |             // backtracking, to restore original array back
18 |             swap(nums[i], nums[j]);
19 |         }
20 |         
21 |     }
22 |     
23 | public:
24 |     vector<vector<int>> permute(vector<int>& nums) {
25 |         
26 |         vector<vector<int>> res;
27 |         generatePermutations(nums, 0, res);
28 |         return res;
29 |     }
30 | };


--------------------------------------------------------------------------------
/Class9/WavePrint.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 |     
 6 |     int n,m;
 7 |     cin>>n>>m;
 8 |     int matrix[n][m];
 9 |     for(int i=0; i<n; i++)
10 |     {
11 |         for(int j=0; j<m; j++)
12 |         {
13 |             cin>>matrix[i][j];
14 |         }
15 |     }
16 | 
17 |     for(int col=0; col<m; col++)
18 |     {
19 |         if(col%2==0)
20 |         {
21 |             // even column Top down
22 |             for(int row=0; row<n; row++)
23 |             {
24 |                 cout<<matrix[row][col]<<" ";
25 |             }
26 |         }
27 |         else
28 |         {
29 |             // odd column Bottom Up
30 |             for(int row=n-1; row>=0; row--)
31 |             {
32 |                 cout<<matrix[row][col]<<" ";
33 |             }
34 |         }
35 |     }
36 | 
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Class11/ValidAnagram.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/valid-anagram/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     bool isAnagram(string s, string t) {
 6 |         
 7 |         if(s.size()!=t.size())
 8 |         {
 9 |             return false;
10 |         }
11 |         
12 |         // sort(s.begin(), s.end());
13 |         // sort(t.begin(), t.end());
14 |         // return s==t;
15 |         
16 |         vector<int> map(26, 0);
17 |         
18 |         for(char i:s)
19 |         {
20 |             map[i-'a']++;
21 |         }
22 |         
23 |         for(char i:t)
24 |         {
25 |             map[i-'a']--;
26 |         }
27 |         
28 |         for(int i=0; i<26; i++)
29 |         {
30 |             if(map[i]!=0)
31 |             {
32 |                 return false;
33 |             }
34 |         }
35 |         return true;
36 |     }
37 | };


--------------------------------------------------------------------------------
/Class12/AddBinary.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/add-binary/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     string addBinary(string a, string b) {
 6 |         
 7 |         int i=0;
 8 |         int lenA = a.size();
 9 |         int lenB = b.size();
10 |         int carry = 0;
11 |         string res;
12 |         
13 |         while(i<lenA || i<lenB || carry!=0)
14 |         {
15 |             int x = 0;
16 |             int y = 0;
17 |             if(i<lenA && a[lenA-i-1]=='1')
18 |             {
19 |                 x = 1;
20 |             }
21 |             if(i<lenB && b[lenB-i-1]=='1')
22 |             {
23 |                 y = 1;
24 |             }
25 |             int sum = x+y+carry;
26 |             res = to_string(sum%2) + res;
27 |             carry = sum/2;
28 |             i++;
29 |         }
30 |         return res;
31 |         
32 |     }
33 | };


--------------------------------------------------------------------------------
/Class9/RotateImage.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/rotate-image/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     void rotate(vector<vector<int>>& matrix) { 
 6 |         
 7 |         int n = matrix.size(); 
 8 |         
 9 |         // transpose
10 |         for(int i=0; i<n; i++)
11 |         {
12 |             for(int j=0; j<i; j++)
13 |             {
14 |                 swap(matrix[i][j], matrix[j][i]);
15 |             }
16 |         }
17 |         
18 |         // reverse
19 |         for(int i=0; i<n; i++)
20 |         {
21 |             // reverse(matrix[i].begin(), matrix[i].end());
22 |             int s=0;
23 |             int e=n-1;
24 |             while(s<e)
25 |             {
26 |                 swap(matrix[i][s], matrix[i][e]);
27 |                 s++;
28 |                 e--;
29 |             }
30 |         }
31 |         
32 |     }
33 | };


--------------------------------------------------------------------------------
/Class14/BinarySearch.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int binarySearch(vector<int> arr, int target)
 5 | {
 6 |     int n = arr.size()-1;
 7 |     int s=0;
 8 |     int e=n-1;
 9 |     while(s<=e)
10 |     {
11 |         int mid = (s+e)/2;
12 |         if(arr[mid]==target)
13 |         {
14 |             return mid;
15 |         }
16 |         else if(arr[mid] < target)
17 |         {
18 |             s = mid+1;
19 |         }
20 |         else
21 |         {
22 |             e = mid-1;
23 |         }
24 |     }
25 |     return -1;
26 | }
27 | 
28 | int main(){
29 |     int n;
30 |     cin>>n;
31 |     int target;
32 |     cin>>target;
33 |     vector<int> arr;
34 |     for(int i=0; i<n; i++)
35 |     {
36 |         int no;
37 |         cin>>no;
38 |         arr.push_back(no);
39 |     }
40 |     cout<<binarySearch(arr, target);
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Class7/TrappingRainWater.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/trapping-rain-water/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int trap(vector<int>& height) {
 6 | 
 7 |         int n = height.size();
 8 |         vector<int> leftMax(n);
 9 |         vector<int> rightMax(n);
10 |         
11 |         leftMax[0] = height[0];
12 |         for(int i=1; i<n; i++)
13 |         {
14 |             leftMax[i] = max(leftMax[i-1], height[i]);
15 |         }
16 |         
17 |         rightMax[n-1] = height[n-1];
18 |         for(int i=n-2; i>=0; i--)
19 |         {
20 |             rightMax[i] = max(rightMax[i+1], height[i]);
21 |         }
22 |         
23 |         int water = 0;
24 |         for(int i=1; i<n-1; i++)
25 |         {
26 |             water += min(leftMax[i], rightMax[i]) - height[i];
27 |         }
28 |         
29 |         return water;
30 |         
31 |     }
32 | };


--------------------------------------------------------------------------------
/Class14/SearchA2dMatrix.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/search-a-2d-matrix/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     bool searchMatrix(vector<vector<int>>& matrix, int target) {
 6 |         
 7 |         int n = matrix.size();
 8 |         int m = matrix[0].size();
 9 |         
10 |         int s = 0;
11 |         int e = n*m-1;
12 |         
13 |         while(s<=e)
14 |         {
15 |             int mid = (s+e)/2;
16 |             int row = mid/m;
17 |             int col = mid%m;
18 |             
19 |             if(matrix[row][col]==target)
20 |             {
21 |                 return true;
22 |             }
23 |             else if(matrix[row][col] < target)
24 |             {
25 |                 s = mid+1;
26 |             }
27 |             else
28 |             {
29 |                 e = mid-1;
30 |             }
31 |         }
32 |         return false;
33 |     }
34 | };


--------------------------------------------------------------------------------
/Class5/LinearSearch.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | // int linearSearch(int arr[], int n, int key)
 5 | // {
 6 | //     // 6
 7 | //     // 4, 2, 16, 8
 8 | //     for(int i=0; i<n; i++)
 9 | //     {
10 | //         if(arr[i]==key)
11 | //         {
12 | //             return i;
13 | //         }
14 | //     }
15 | //     return -1;
16 | // }
17 | 
18 | void linearSearch(int arr[], int n, int key)
19 | {
20 |     int index = -1;
21 |     for(int i=0; i<n; i++)
22 |     {
23 |         if(arr[i]==key)
24 |         {
25 |             index = i;
26 |             break;
27 |         }
28 |     }
29 |     cout<<index;
30 | }
31 | 
32 | int main(){
33 | 
34 |     int n;
35 |     cin>>n;
36 |     int arr[n];
37 |     for(int i=0; i<n; i++)
38 |     {
39 |         cin>>arr[i];
40 |     }
41 |     int key;
42 |     cin>>key;
43 |     linearSearch(arr, n, key);
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Class16/SingleNumber(iii).cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/single-number-iii/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<int> singleNumber(vector<int>& nums) {
 6 |         
 7 |         int n = nums.size();
 8 |         int res = 0;
 9 |         for(int i=0; i<n; i++)
10 |         {
11 |             res ^= nums[i];
12 |         }
13 |         
14 |         int temp = res;
15 |         int pos = 0;
16 |         while((temp&1)!=1)
17 |         {
18 |             pos++;
19 |             temp = temp>>1;
20 |         }
21 |         
22 |         int mask = 1<<pos;
23 |         int num1 = 0;
24 |         int num2 = 0;
25 |         
26 |         for(int i=0; i<n; i++)
27 |         {
28 |             if((nums[i]&mask) > 0)
29 |             {
30 |                 num1 ^= nums[i];
31 |             }
32 |         }
33 |         
34 |         num2 = res^num1;
35 |         return {num1, num2};
36 |     }
37 | };


--------------------------------------------------------------------------------
/Class12/ValidPalindrome(ii).cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/valid-palindrome-ii/
 2 | 
 3 | class Solution {
 4 |     
 5 |     // check whether substring is palindrome or not
 6 |     bool deleteString(string s, int i, int j)
 7 |     {
 8 |         while(i<j)
 9 |         {
10 |             if(s[i]!=s[j])
11 |             {
12 |                 return false;
13 |             }
14 |             i++;
15 |             j--;
16 |         }
17 |         return true;
18 |     }
19 |     
20 | public:
21 |     bool validPalindrome(string s) {
22 |         
23 |         int n = s.size();
24 |         int i=0;
25 |         int j=n-1;
26 |         
27 |         while(i<j)
28 |         {
29 |             if(s[i]!=s[j])
30 |             {
31 |                 return deleteString(s, i+1, j) || deleteString(s, i, j-1);
32 |             }
33 |             i++;
34 |             j--;
35 |         }
36 |         return true;
37 |     }
38 | };


--------------------------------------------------------------------------------
/Class10/CountingSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void countingSort(int arr[], int n)
 5 | {
 6 |     int maxVal = -1;
 7 |     for(int i=0; i<n; i++)
 8 |     {
 9 |         maxVal = max(arr[i], maxVal);
10 |     }
11 | 
12 |     int freq[maxVal+1] = {0};
13 | 
14 |     for(int i=0; i<n; i++)
15 |     {
16 |         freq[arr[i]]++;
17 |     }
18 | 
19 |     // put element back in original array
20 |     int j=0;
21 |     for(int i=0; i<=maxVal; i++)
22 |     {
23 |         while(freq[i]>0)
24 |         {
25 |             arr[j]=i;
26 |             j++;
27 |             freq[i]--;
28 |         }
29 |     } 
30 | }
31 | 
32 | int main(){
33 |     int n;
34 |     cin>>n;
35 |     int arr[n];
36 |     for(int i=0; i<n; i++)
37 |     {
38 |         cin>>arr[i];
39 |     }
40 |     countingSort(arr, n);
41 |     for(int i=0; i<n; i++)
42 |     {
43 |         cout<<arr[i]<<", ";
44 |     }
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Class18/QuickSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int partition(int arr[], int s, int e)
 5 | {
 6 |     int j = s;
 7 |     int i = s-1;
 8 |     int pivot = arr[e];
 9 |     for(j=s; j<e; j++)
10 |     {
11 |         if(arr[j] <= pivot)
12 |         {
13 |             i++;
14 |             swap(arr[i], arr[j]);
15 |         }
16 |     }
17 |     swap(arr[i+1], arr[e]);
18 |     return i+1;
19 | }
20 | 
21 | void quickSort(int arr[], int s, int e)
22 | {
23 |     if(s>=e)
24 |     {
25 |         return;
26 |     }
27 |     int p = partition(arr, s, e);
28 |     quickSort(arr, s, p-1);
29 |     quickSort(arr, p+1, e);
30 | }
31 | 
32 | int main(){
33 |     int arr[100];
34 |     int n;
35 |     cin>>n;
36 |     for(int i=0; i<n; i++)
37 |     {
38 |         cin>>arr[i];
39 |     }
40 |     quickSort(arr, 0, n-1);
41 |     for(int i=0; i<n; i++)
42 |     {
43 |         cout<<arr[i]<<", ";
44 |     }
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Class2/DataTypes.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     //data types
 7 |     int num = 5;
 8 |     char val = 'A';
 9 |     string a = "Hello";
10 |     float b = 3.14;
11 |     double c = 4.5612398;
12 |     bool myBoolean = false;
13 | 
14 |     cout<<"Integer : "<<num<<endl;
15 |     cout<<"Character : "<<val<<endl;
16 |     cout<<"string : "<<a<<endl;
17 |     cout<<"float : "<<b<<endl;
18 |     cout<<"double : "<<c<<endl;
19 |     cout<<"bool : "<<myBoolean<<endl;
20 | 
21 |     cout<<"Size of int : "<<sizeof(num)<<endl;
22 |     cout<<"Size of character : "<<sizeof(val)<<endl;
23 | 
24 |     int minVal = INT_MIN;
25 |     int maxVal = INT_MAX;
26 | 
27 |     cout<<minVal<<endl;
28 |     cout<<maxVal;
29 | 
30 |     int x = 7;
31 |     x = 10;
32 |     cout<<x;
33 | 
34 |     // const int y = 9;
35 |     // y = 11;
36 |     // cout<<y;
37 | 
38 |     const float PI = 3.14;
39 | 
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Class20/GenerateParenthesis.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {        
 2 |     
 3 |     void parenthesis(vector<string>&res, string& curr, int n, int i, int open, int close)
 4 |     {
 5 |         if(i==n*2)
 6 |         {
 7 |             res.push_back(curr);
 8 |             return;
 9 |         }
10 |         
11 |         if(open<n)
12 |         {
13 |             curr.push_back('(');
14 |             parenthesis(res, curr, n, i+1, open+1, close);
15 |             curr.pop_back();
16 |         }
17 |         
18 |         if(close < open)
19 |         {
20 |             curr.push_back(')');
21 |             parenthesis(res, curr, n, i+1, open, close+1);
22 |             curr.pop_back();
23 |         }
24 |         
25 |     }
26 |     
27 | public:
28 |     vector<string> generateParenthesis(int n) {
29 |         
30 |         vector<string> res;
31 |         string curr="";
32 |         
33 |         parenthesis(res, curr, n, 0, 0, 0);
34 |         return res;
35 |     }
36 | };


--------------------------------------------------------------------------------
/Class10/MergeIntervals.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/merge-intervals/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<vector<int>> merge(vector<vector<int>>& intervals) {
 6 |         
 7 |         int n = intervals.size();
 8 |         vector<vector<int>> result;
 9 |         
10 |         sort(intervals.begin(), intervals.end());
11 |         
12 |         int s1 = intervals[0][0];
13 |         int e1 = intervals[0][1];
14 |         
15 |         for(int i=1; i<n; i++)
16 |         {
17 |             int s2 = intervals[i][0];
18 |             int e2 = intervals[i][1];
19 |             
20 |             if(s2 <= e1)
21 |             {
22 |                 e1 = max(e1, e2);
23 |             }
24 |             else
25 |             {
26 |                 result.push_back({s1,e1});
27 |                 s1 = s2;
28 |                 e1 = e2;
29 |             }
30 |         }
31 |         
32 |         result.push_back({s1,e1});
33 |         return result;
34 |     }
35 | };


--------------------------------------------------------------------------------
/Class3/SwitchCase.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     // char ch;
 7 |     // cin>>ch;
 8 | 
 9 |     // switch(ch){
10 |     //     case 'B':
11 |     //         cout<<"Burger"<<endl;
12 |     //         break;
13 |     //     case 'M':
14 |     //         cout<<"Maggi"<<endl;
15 |     //         break;
16 |     //     case 'P':
17 |     //         cout<<"Pizza"<<endl;
18 |     //         break;
19 |     //     case 'C':
20 |     //         cout<<"Coke"<<endl;
21 |     //         break;
22 |     //     default : 
23 |     //         cout<<"Item is not present";
24 |     // }
25 | 
26 |     int day;
27 |     cin>>day;
28 | 
29 |     switch(day)
30 |     {
31 |         case 6:
32 |             cout<<"Saturday"<<endl;
33 |             break;
34 |         case 7:
35 |             cout<<"Sunday"<<endl;
36 |             break;
37 |         default:
38 |             cout<<"Looking forward to the weekend";
39 |     }
40 | 
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Class20/LetterCombinationsOfPhoneNumber.cpp:
--------------------------------------------------------------------------------
 1 | class Solution { 
 2 |     
 3 |     void phone(string digits, vector<string>& res, string mappings[], string curr, int index)
 4 |     {
 5 |         if(index==digits.size())
 6 |         {
 7 |             res.push_back(curr);
 8 |             return;
 9 |         }
10 |         
11 |         string val = mappings[digits[index]-'0']; //a  b  c
12 |         
13 |         for(int i=0; i<val.size(); i++)
14 |         {
15 |             phone(digits, res, mappings, curr+val[i], index+1);
16 |         }
17 |         
18 |     }
19 |     
20 | public:
21 |     vector<string> letterCombinations(string digits) {
22 |         
23 |         vector<string> res;
24 |         if(digits.size()==0)
25 |         {
26 |             return res;
27 |         }
28 |         
29 |         string mappings[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
30 |         
31 |         phone(digits, res, mappings, "", 0);
32 |         return res;
33 |     }
34 | };


--------------------------------------------------------------------------------
/Class13/LongestPalindromicSubstring.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/longest-palindromic-substring/
 2 | 
 3 | class Solution {
 4 |     
 5 |     void longestSubstring(int l, int r, string &s, int &maxLen, int &start)
 6 |     {
 7 |         int n = s.size();
 8 |         while(l>=0 && r<n && s[l]==s[r])
 9 |         {
10 |             l--;
11 |             r++;
12 |         }
13 |         int currLen = r-l-1;
14 |         if(currLen > maxLen)
15 |         {
16 |             start = l+1;
17 |             maxLen = currLen;
18 |         }
19 |     }
20 |     
21 | public:
22 |     string longestPalindrome(string s) {
23 |         
24 |         int n = s.size();
25 |         int maxLen = 1;
26 |         int start = 0;
27 |         
28 |         for(int i=0; i<n; i++)
29 |         {
30 |             // odd length
31 |             longestSubstring(i, i, s, maxLen, start);
32 |             // even length
33 |             longestSubstring(i, i+1, s, maxLen, start);
34 |         }
35 |         return s.substr(start, maxLen);
36 |     }
37 | };


--------------------------------------------------------------------------------
/Class8/TripletSumArray.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | 
 5 | int triplet(int arr[], int n, int sum)
 6 | {
 7 |     sort(arr, arr+n);
 8 |     for(int k=0; k<n-2; k++)
 9 |     {
10 |         int i=k+1;
11 |         int j=n-1;
12 |         while(i<j)
13 |         {
14 |             if(arr[i]+arr[j]+arr[k]==sum)
15 |             {
16 |                return 1;
17 |             }
18 |             else if(arr[i]+arr[j]+arr[k]<sum)
19 |             {
20 |                 i++;
21 |             }
22 |             else
23 |             {
24 |                 j--;
25 |             }
26 |         }
27 |     }
28 |     return 0;
29 | }
30 | 
31 | int main(){
32 | 
33 |     int n;
34 |     cin>>n;
35 |     int arr[n];
36 |     for(int i=0; i<n; i++)
37 |     {
38 |         cin>>arr[i];
39 |     }
40 |     int sum;
41 |     cin>>sum;
42 | 
43 |     if(triplet(arr, n, sum))
44 |     {
45 |         cout<<"True";
46 |     }
47 |     else
48 |     {
49 |         cout<<"False";
50 |     }
51 | 
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Class13/MultiplyStrings.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/multiply-strings/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     string multiply(string num1, string num2) {
 6 |         
 7 |         if(num1=="0" || num2=="0")
 8 |         {
 9 |             return "0";
10 |         }
11 |         
12 |         int n = num1.size();
13 |         int m = num2.size();
14 |         vector<int> res(n+m, 0);
15 |         
16 |         for(int i=n-1; i>=0; i--)
17 |         {
18 |             for(int j=m-1; j>=0; j--)
19 |             {
20 |                 res[i+j+1] += (num1[i]-'0') * (num2[j]-'0');
21 |                 res[i+j] += res[i+j+1]/10; //adding carry
22 |                 res[i+j+1] %=10;
23 |             }
24 |         }
25 |         
26 |         int skip=0;
27 |         while(skip<res.size() && res[skip]==0)
28 |         {
29 |             skip++;
30 |         }
31 |         
32 |         string ans="";
33 |         while(skip<res.size())
34 |         {
35 |             ans += to_string(res[skip]);
36 |             skip++;
37 |         }
38 |         return ans;
39 |     }
40 | };


--------------------------------------------------------------------------------
/Class19/FloodFill.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/flood-fill/
 2 | 
 3 | class Solution {     
 4 |     
 5 |     void dfs(vector<vector<int>>& image, int sr, int sc, int newColor, int original)
 6 |     {
 7 |         int n = image.size();
 8 |         int m = image[0].size();
 9 |         
10 |         if(sr<0 || sr>=n || sc<0 || sc>=m || image[sr][sc]!=original)
11 |         {
12 |             return;
13 |         }
14 |         
15 |         image[sr][sc] = newColor;
16 |         
17 |         dfs(image, sr-1, sc, newColor, original);
18 |         dfs(image, sr+1, sc, newColor, original);
19 |         dfs(image, sr, sc-1, newColor, original);
20 |         dfs(image, sr, sc+1, newColor, original);
21 |     }
22 |     
23 | public:
24 |     vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor)
25 |     {
26 |         if(newColor == image[sr][sc])
27 |         {
28 |             return image;
29 |         }
30 |         int original = image[sr][sc];
31 |         
32 |         dfs(image, sr, sc, newColor, original);
33 |         return image;
34 |     }
35 | };


--------------------------------------------------------------------------------
/Class18/NumberOfIslands.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/number-of-islands/
 2 | 
 3 | class Solution {    
 4 |     
 5 |     void dfs(vector<vector<char>>& grid, int i, int j)
 6 |     {
 7 |         int n = grid.size();
 8 |         int m = grid[0].size();
 9 |         
10 |         if(i>=n || i<0 || j>=m || j<0 || grid[i][j]!='1')
11 |         {
12 |             return;
13 |         }
14 |         
15 |         grid[i][j] = '2';
16 |         
17 |         dfs(grid, i-1, j);
18 |         dfs(grid, i+1, j);
19 |         dfs(grid, i, j-1);
20 |         dfs(grid, i, j+1);
21 |     }
22 |     
23 | public:
24 |     int numIslands(vector<vector<char>>& grid) {
25 |         
26 |         int n = grid.size();
27 |         int m = grid[0].size();
28 |         int count = 0;
29 |         
30 |         for(int i=0; i<n; i++)
31 |         {
32 |             for(int j=0; j<m; j++)
33 |             {
34 |                 if(grid[i][j]=='1')
35 |                 {
36 |                     count++;
37 |                     dfs(grid, i, j);
38 |                 }
39 |             }
40 |         }
41 |         return count;
42 |     }
43 | };


--------------------------------------------------------------------------------
/Class8/NextPermutation.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/next-permutation/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     void nextPermutation(vector<int>& nums) {
 6 |         
 7 |         int n = nums.size();
 8 |         if(n==1)
 9 |         {
10 |             return;
11 |         }
12 |         
13 |         //1. find decreasing point
14 |         int replaceIdx = -1;
15 |         for(int i=n-1; i>=1; i--)
16 |         {
17 |             if(nums[i-1] < nums[i])
18 |             {
19 |                 replaceIdx = i-1;
20 |                 break;
21 |             }
22 |         }
23 |         
24 |         //2. Swap
25 |         if(replaceIdx==-1)
26 |         {
27 |             reverse(nums.begin(), nums.end());
28 |             return;
29 |         }
30 |         
31 |         for(int i=n-1; i>replaceIdx; i--)
32 |         {
33 |             if(nums[i] > nums[replaceIdx])
34 |             {
35 |                 swap(nums[replaceIdx], nums[i]);
36 |                 //3. sorting
37 |                 sort(nums.begin()+replaceIdx+1, nums.end());
38 |                 break;
39 |             }
40 |         }
41 |     }
42 | };


--------------------------------------------------------------------------------
/Class20/CombinationalSum.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     
 3 |     void allCombinations(vector<int>& candidates, int index, int target, vector<int>& path, vector<vector<int>>& res)
 4 |     {
 5 |         if(index==candidates.size())
 6 |         {
 7 |             return;
 8 |         }
 9 |         
10 |         if(target==0)
11 |         {
12 |             res.push_back(path);
13 |             return;
14 |         }
15 |         
16 |         // include
17 |         if(candidates[index]<=target)
18 |         {
19 |             path.push_back(candidates[index]);
20 |             allCombinations(candidates, index, target-candidates[index], path, res);
21 |             path.pop_back();
22 |         }
23 |         
24 |         //exclude
25 |         allCombinations(candidates, index+1, target, path, res);
26 |     }
27 |     
28 | public:
29 |     vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
30 |         
31 |         vector<vector<int>> res;
32 |         vector<int> path;
33 |         
34 |         allCombinations(candidates, 0, target, path, res);
35 |         
36 |         return res;
37 |     }
38 | };


--------------------------------------------------------------------------------
/Class6/CountPairsWithSum.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | // int countPairs(int arr[], int n, int sum)
 5 | // {
 6 | //     int count = 0;
 7 | //     for(int i=0; i<n-1; i++)
 8 | //     {
 9 | //         for(int j=i+1; j<n; j++)
10 | //         {
11 | //             if(arr[i]+arr[j]==sum)
12 | //             {
13 | //                 count++;
14 | //             }
15 | //         }
16 | //     }
17 | //     return count==0 ? -1 : count;
18 | // }
19 | 
20 | int countPairs(int arr[], int n, int sum)
21 | {
22 |     int count = 0;
23 |     int i=0;
24 |     int j=n-1;
25 |     while(i<j)
26 |     {
27 |         if(arr[i]+arr[j]==sum)
28 |         {
29 |             count++;
30 |             i++;
31 |             j--;
32 |         }
33 |         else if(arr[i]+arr[j]<sum)
34 |         {
35 |             i++;
36 |         }
37 |         else
38 |         {
39 |             j--;
40 |         }
41 |     }
42 |     return count==0 ? -1 : count;
43 | }
44 | 
45 | int main(){
46 | 
47 |     int n;
48 |     cin>>n;
49 |     int arr[n];
50 |     for(int i=0; i<n; i++)
51 |     {
52 |         cin>>arr[i];
53 |     }
54 |     int sum;
55 |     cin>>sum;
56 | 
57 |     cout<<countPairs(arr, n, sum);
58 | 
59 |     return 0;
60 | }


--------------------------------------------------------------------------------
/Class15/SearchInRotatedSortedArray.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/search-in-rotated-sorted-array/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int search(vector<int>& nums, int target) {
 6 |         
 7 |         int n = nums.size();
 8 |         int s = 0;
 9 |         int e = n-1;
10 |         
11 |         while(s<=e)
12 |         {
13 |             int mid = (s+e)/2;
14 |             if(nums[mid]==target)
15 |             {
16 |                 return mid;
17 |             }
18 |             // left half is sorted
19 |             else if(nums[s]<=nums[mid])
20 |             {
21 |                 if(nums[s] <= target && target <= nums[mid])
22 |                 {
23 |                     e = mid-1;
24 |                 }
25 |                 else
26 |                 {
27 |                     s = mid+1;
28 |                 }
29 |             }
30 |             // right half is sorted
31 |             else
32 |             {
33 |                 if(nums[mid] <= target && target <= nums[e])
34 |                 {
35 |                     s = mid+1;
36 |                 }
37 |                 else
38 |                 {
39 |                     e = mid-1;
40 |                 }
41 |             }
42 |         }
43 |         return -1;
44 |     }
45 | };


--------------------------------------------------------------------------------
/Class21/PalindromePartitioning.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/palindrome-partitioning/
 2 | 
 3 | class Solution {   
 4 |     
 5 |     bool validPalindrome(string s, int start, int end)
 6 |     {
 7 |         while(start<=end)
 8 |         {
 9 |             if(s[start]!=s[end])
10 |             {
11 |                 return false;
12 |             }
13 |             start++;
14 |             end--;
15 |         }
16 |         return true;
17 |     }
18 |     
19 |     void validPartitions(int index, string s, vector<vector<string>>& ans, vector<string>& curr)
20 |     {
21 |         // base case
22 |         if(index == s.size())
23 |         {
24 |             ans.push_back(curr);
25 |             return;
26 |         }
27 |         
28 |         for(int i=index; i<s.size(); i++)
29 |         {
30 |             if(validPalindrome(s, index, i))
31 |             {
32 |                 curr.push_back(s.substr(index, i-index+1));
33 |                 validPartitions(i+1, s, ans, curr);
34 |                 curr.pop_back();
35 |             }
36 |         }
37 |         
38 |     }
39 |     
40 | public:
41 |     vector<vector<string>> partition(string s) {
42 |         
43 |         vector<vector<string>> ans;
44 |         vector<string> curr;
45 |         validPartitions(0, s, ans, curr);
46 |         return ans;
47 |     }
48 | };


--------------------------------------------------------------------------------
/Class21/RatInAMaze.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | char maze[1001][1001]={0};
 5 | int sol[1001][1001]={0};
 6 | 
 7 | bool ratInMaze(int i, int j, int m, int n)
 8 | {
 9 |     // base case
10 |     if(i==m-1 && j==n-1)
11 |     {
12 |         sol[i][j] = 1;
13 |         //print path
14 |         for(int i=0; i<m; i++)
15 |         {
16 |             for(int j=0; j<n; j++)
17 |             {
18 |                 cout<<sol[i][j]<<" ";
19 |             }
20 |             cout<<endl;
21 |         }
22 |         cout<<endl;
23 |         return true;
24 |     }
25 | 
26 |     // rat should be inside
27 |     if(i>=m || j>=n || maze[i][j]=='X')
28 |     {
29 |         return false;
30 |     }
31 |     sol[i][j] = 1;
32 | 
33 |     // recursive
34 |     bool rightSuccess = ratInMaze(i,j+1,m,n);
35 |     bool downSuccess = ratInMaze(i+1,j,m,n);
36 | 
37 |     sol[i][j] = 0;
38 | 
39 |     if(rightSuccess || downSuccess)
40 |     {
41 |         return true;
42 |     }
43 |     return false;
44 | }
45 | 
46 | int main(){
47 |     int m,n;
48 |     cin>>m>>n;
49 |     for(int i=0; i<m; i++)
50 |     {
51 |         for(int j=0; j<n; j++)
52 |         {
53 |             cin>>maze[i][j];
54 |         }
55 |     }
56 |     bool res = ratInMaze(0, 0, m, n);
57 |     if(!res)
58 |     {
59 |         cout<<-1<<endl;
60 |     }
61 |     return 0;
62 | }


--------------------------------------------------------------------------------
/Class18/MergeSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void merge(int arr[], int s, int e)
 5 | {
 6 |     int mid = (s+e)/2;
 7 |     int i = s;
 8 |     int j = mid+1;
 9 |     int k = s;
10 |     int temp[100];
11 |     while(i<=mid && j<=e)
12 |     {
13 |         if(arr[i] < arr[j])
14 |         {
15 |             temp[k++] = arr[i++];
16 |             // i++;
17 |             // k++;
18 |         }
19 |         else
20 |         {
21 |             temp[k++] = arr[j++];
22 |         }
23 |     }
24 |     while(i<=mid)
25 |     {
26 |         temp[k++] = arr[i++];
27 |     }
28 |     while(j<=e)
29 |     {
30 |         temp[k++] = arr[j++];
31 |     }
32 |     for(int i=s; i<=e; i++)
33 |     {
34 |         arr[i] = temp[i];
35 |     }
36 | }
37 | 
38 | void mergeSort(int arr[], int s, int e)
39 | {
40 |     if(s>=e)
41 |     {
42 |         return;
43 |     }
44 |     // 1. divide
45 |     int mid = (s+e)/2;
46 |     // 2. recursively sort
47 |     mergeSort(arr, s, mid);
48 |     mergeSort(arr, mid+1, e);
49 |     // 3. merge
50 |     merge(arr, s, e);
51 | }
52 | 
53 | int main(){
54 |     int arr[100];
55 |     int n;
56 |     cin>>n;
57 |     for(int i=0; i<n; i++)
58 |     {
59 |         cin>>arr[i];
60 |     }
61 |     mergeSort(arr, 0, n-1);
62 |     for(int i=0; i<n; i++)
63 |     {
64 |         cout<<arr[i]<<", ";
65 |     }
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/Class9/SpiralMatrix.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/spiral-matrix/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<int> spiralOrder(vector<vector<int>>& matrix) {
 6 |         
 7 |         int n = matrix.size(); // rows
 8 |         int m = matrix[0].size(); // columns
 9 |         
10 |         int sr = 0;
11 |         int sc = 0;
12 |         int er = n-1;
13 |         int ec = m-1;
14 |         
15 |         vector<int> res;
16 |         
17 |         while(sr<=er && sc<=ec)
18 |         {
19 |             for(int i=sc; i<=ec; i++)
20 |             {
21 |                 res.push_back(matrix[sr][i]);
22 |             }
23 |             sr++;
24 |             
25 |             for(int i=sr; i<=er; i++)
26 |             {
27 |                 res.push_back(matrix[i][ec]);
28 |             }
29 |             ec--;
30 |             
31 |             if(sr<=er)
32 |             {
33 |                 for(int i=ec; i>=sc; i--)
34 |                 {
35 |                     res.push_back(matrix[er][i]);
36 |                 }
37 |             }
38 |             er--;
39 |             
40 |             if(sc<=ec)
41 |             {
42 |                 for(int i=er; i>=sr; i--)
43 |                 {
44 |                     res.push_back(matrix[i][sc]);
45 |                 }
46 |             }
47 |             sc++;
48 |             
49 |         }
50 |         return res;
51 |     }
52 | };


--------------------------------------------------------------------------------
/Class20/WordSearch.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     
 3 |     bool check(vector<vector<char>>& board, string word, int index, int n, int m, int i, int j)
 4 |     {
 5 |         if(i<0 || i>=n || j<0 || j>=m || board[i][j]!=word[index])
 6 |         {
 7 |             return false;
 8 |         }
 9 |         
10 |         if(index == word.size()-1)
11 |         {
12 |             return true;
13 |         }
14 |         
15 |         bool found = false;
16 |         char temp = board[i][j];
17 |         board[i][j] = '$';
18 |         
19 |         found = check(board, word, index+1, n, m, i-1, j) ||
20 |                 check(board, word, index+1, n, m, i+1, j) ||
21 |                 check(board, word, index+1, n, m, i, j-1) || 
22 |                 check(board, word, index+1, n, m, i, j+1);
23 |         
24 |         board[i][j] = temp;
25 |         return found;
26 |     }
27 |     
28 | public:
29 |     bool exist(vector<vector<char>>& board, string word) {
30 |         
31 |         int n = board.size();
32 |         int m = board[0].size();
33 |         
34 |         for(int i=0; i<n; i++)
35 |         {
36 |             for(int j=0; j<m; j++)
37 |             {
38 |                 if(board[i][j]==word[0] && check(board, word, 0, n, m, i, j))
39 |                 {
40 |                     return true;
41 |                 }
42 |             }
43 |         }
44 |         return false;
45 |     }
46 | };


--------------------------------------------------------------------------------
/Class14/FirstAndLastPositionOfElement.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     vector<int> searchRange(vector<int>& nums, int target) {
 6 |         
 7 |         int n = nums.size();
 8 |         int s = 0;
 9 |         int e = n-1;
10 |         int first = -1, last = -1;
11 |         
12 |         // first occurence
13 |         while(s<=e)
14 |         {
15 |             int mid = (s+e)/2;
16 |             if(nums[mid]==target)
17 |             {
18 |                 first = mid;
19 |                 e = mid-1;
20 |             }
21 |             else if(nums[mid] > target)
22 |             {            
23 |                 e = mid-1;
24 |             }
25 |             else
26 |             {
27 |                 s = mid+1;
28 |             }
29 |         }
30 |         
31 |         s = 0;
32 |         e = n-1;
33 |         // last occurence
34 |         while(s<=e)
35 |         {
36 |             int mid = (s+e)/2;
37 |             if(nums[mid]==target)
38 |             {
39 |                 last = mid;
40 |                 s = mid+1;
41 |             }
42 |             else if(nums[mid] > target)
43 |             {            
44 |                 e = mid-1;
45 |             }
46 |             else
47 |             {
48 |                 s = mid+1;
49 |             }
50 |         }
51 |         return {first, last};
52 |     }
53 | };


--------------------------------------------------------------------------------
/Class15/SingleElementInSortedArray.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/single-element-in-a-sorted-array/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int singleNonDuplicate(vector<int>& nums) {
 6 |         
 7 |         int n = nums.size();
 8 |         if(n==1 || nums[0]!=nums[1])
 9 |         {
10 |             return nums[0];
11 |         }
12 |         if(nums[n-1]!=nums[n-2])
13 |         {
14 |             return nums[n-1];
15 |         }
16 |         
17 |         int s = 0;
18 |         int e = n-1;
19 |         while(s<=e)
20 |         {
21 |             int mid = (s+e)/2;
22 |             if(nums[mid]!=nums[mid-1] && nums[mid]!=nums[mid+1])
23 |             {
24 |                 return nums[mid];
25 |             }
26 |             // index is even
27 |             else if(mid%2==0)
28 |             {
29 |                 if(nums[mid]==nums[mid+1])
30 |                 {
31 |                     s = mid+1;
32 |                 }
33 |                 else
34 |                 {
35 |                     e = mid-1;
36 |                 }
37 |             }
38 |             // odd index
39 |             else
40 |             {
41 |                 if(nums[mid]==nums[mid-1])
42 |                 {
43 |                     s = mid+1;
44 |                 }
45 |                 else
46 |                 {
47 |                     e = mid-1;
48 |                 }
49 |             }
50 |         }
51 |         return -1;
52 |     }
53 | };


--------------------------------------------------------------------------------
/Class18/InversionCount.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int merge(int arr[], int s, int e)
 5 | {
 6 |     int mid = (s+e)/2;
 7 |     int i = s;
 8 |     int j = mid+1;
 9 |     int k = s;
10 |     int temp[100];
11 |     int count = 0;
12 |     while(i<=mid && j<=e)
13 |     {
14 |         if(arr[i] < arr[j])
15 |         {
16 |             temp[k++] = arr[i++];
17 |             // i++;
18 |             // k++;
19 |         }
20 |         else
21 |         {
22 |             temp[k++] = arr[j++];
23 |             count += mid-i+1;
24 |         }
25 |     }
26 |     while(i<=mid)
27 |     {
28 |         temp[k++] = arr[i++];
29 |     }
30 |     while(j<=e)
31 |     {
32 |         temp[k++] = arr[j++];
33 |     }
34 |     for(int i=s; i<=e; i++)
35 |     {
36 |         arr[i] = temp[i];
37 |     }
38 |     return count;
39 | }
40 | 
41 | int findInversion(int arr[], int s, int e)
42 | {
43 |     if(s>=e)
44 |     {
45 |         return 0;
46 |     }
47 |     // 1. divide
48 |     int mid = (s+e)/2;
49 |     // 2. recursively sort
50 |     int x = findInversion(arr, s, mid);
51 |     int y = findInversion(arr, mid+1, e);
52 |     // 3. merge
53 |     int z = merge(arr, s, e);
54 |     return x+y+z;
55 | }
56 | 
57 | int main(){
58 |     int arr[100];
59 |     int n;
60 |     cin>>n;
61 |     for(int i=0; i<n; i++)
62 |     {
63 |         cin>>arr[i];
64 |     }
65 |     cout<<findInversion(arr, 0, n-1);
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/Class12/RomanToInteger.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/roman-to-integer/
 2 | 
 3 | class Solution {   
 4 |     
 5 |     int val(char c)
 6 |     {
 7 |         if(c=='I')
 8 |         {
 9 |             return 1;
10 |         }
11 |         else if(c=='V')
12 |         {
13 |             return 5;
14 |         }
15 |         else if(c=='X')
16 |         {
17 |             return 10;
18 |         }
19 |         else if(c=='L')
20 |         {
21 |             return 50;
22 |         }
23 |         else if(c=='C')
24 |         {
25 |             return 100;
26 |         }
27 |         else if(c=='D')
28 |         {
29 |             return 500;
30 |         }
31 |         else
32 |         {
33 |             return 1000;
34 |         }
35 |     }
36 |     
37 | public:
38 |     int romanToInt(string s) {
39 |         
40 |         int n = s.size();
41 |         int res = 0;
42 |         for(int i=0; i<n; i++)
43 |         {
44 |             int s1 = val(s[i]);
45 |             if(i+1<n)
46 |             {
47 |                 int s2 = val(s[i+1]);
48 |                 if(s1>=s2)
49 |                 {
50 |                     res += s1;
51 |                 }
52 |                 else
53 |                 {
54 |                     res += s2-s1;
55 |                     i++;
56 |                 }
57 |             }
58 |             else
59 |             {
60 |                 res += s1;
61 |             }
62 |         }
63 |         return res;
64 |     }
65 | };
66 | 
67 | 


--------------------------------------------------------------------------------
/Class21/SurroundedRegions.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/surrounded-regions/
 2 | 
 3 | class Solution {  
 4 |     
 5 |     void marking(vector<vector<char>>& board, int i, int j, int row, int col)
 6 |     {
 7 |         if(i<0 || j<0 || i>=row || j>=col || board[i][j]!='O')
 8 |         {
 9 |             return;
10 |         }
11 |         board[i][j] = '$';
12 |         marking(board, i+1, j, row, col);
13 |         marking(board, i-1, j, row, col);
14 |         marking(board, i, j+1, row, col);
15 |         marking(board, i, j-1, row, col);
16 |     }
17 |     
18 | public:
19 |     void solve(vector<vector<char>>& board) {
20 |         
21 |         int row = board.size();
22 |         int col = board[0].size();
23 |         
24 |         for(int i=0; i<row; i++)
25 |         {
26 |             for(int j=0; j<col; j++)
27 |             {
28 |                 if(board[i][j]=='O' && (i==0 || j==0 || i==row-1 || j==col-1))
29 |                 {
30 |                     marking(board, i, j, row, col);
31 |                 }
32 |             }
33 |         }
34 |         
35 |         for(int i=0; i<row; i++)
36 |         {
37 |             for(int j=0; j<col; j++)
38 |             {
39 |                 if(board[i][j]=='$')
40 |                 {
41 |                     board[i][j] = 'O';
42 |                 }
43 |                 else if(board[i][j]=='O')
44 |                 {
45 |                     board[i][j] = 'X';
46 |                 }
47 |             }
48 |         }
49 |     }
50 | };


--------------------------------------------------------------------------------
/Class15/MedianOfTwoSortedArrays.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/median-of-two-sorted-arrays/
 2 | 
 3 | class Solution {
 4 |     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
 5 |         
 6 |         int n = nums1.length;
 7 |         int m = nums2.length;
 8 |         
 9 |         if(m<n)
10 |         {
11 |             return findMedianSortedArrays(nums2, nums1);
12 |         }
13 |         
14 |         int s = 0;
15 |         int e = n;
16 |         int total = n+m;
17 |         
18 |         while(s<=e)
19 |         {
20 |             int mid1 = (s+e)/2;
21 |             int mid2 = (total+1)/2 - mid1;
22 |             
23 |             int l1 = (mid1 == 0 ? Integer.MIN_VALUE : nums1[mid1-1]);
24 |             int l2 = (mid2 == 0 ? Integer.MIN_VALUE : nums2[mid2-1]);
25 |             
26 |             int r1 = (mid1 == n ? Integer.MAX_VALUE : nums1[mid1]);
27 |             int r2 = (mid2 == m ? Integer.MAX_VALUE : nums2[mid2]);
28 |             
29 |             if(l1<=r2 && l2<=r1)
30 |             {
31 |                 if(total % 2 == 0)
32 |                 {
33 |                     return (Math.max(l1, l2) + Math.min(r1, r2)) / 2.0;
34 |                 }
35 |                 else
36 |                 {
37 |                     return Math.max(l1, l2);
38 |                 }
39 |             }
40 |             else if(l1 > r2)
41 |             {
42 |                 e = mid1-1;
43 |             }
44 |             else
45 |             {
46 |                 s = mid1+1;
47 |             }
48 |             
49 |         }
50 |         return 0.0;
51 |     }
52 | }


--------------------------------------------------------------------------------
/Class7/MaxProductOf3Num.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/maximum-product-of-three-numbers/
 2 | 
 3 | class Solution {
 4 | public:
 5 |     int maximumProduct(vector<int>& nums) {
 6 |         
 7 |         sort(nums.begin(), nums.end());
 8 |         
 9 |         int n = nums.size();
10 |         
11 |         int op1 = nums[n-1]*nums[n-2]*nums[n-3];
12 |         int op2 = nums[0]*nums[1]*nums[n-1];
13 |         
14 |         return op2>op1 ? op2 : op1;
15 |         
16 |     }
17 | };
18 | 
19 | class Solution {
20 | public:
21 |     int maximumProduct(vector<int>& nums) {
22 |         
23 |         int n = nums.size();
24 |         int min1 = INT_MAX, min2 = INT_MAX;
25 |         int max1 = INT_MIN, max2 = INT_MIN, max3 = INT_MIN;
26 |         
27 |         for(int i=0; i<n; i++)
28 |         {
29 |             if(nums[i] <= min1)
30 |             {
31 |                 min2 = min1;
32 |                 min1 = nums[i];
33 |             }
34 |             else if(nums[i] < min2)
35 |             {
36 |                 min2 = nums[i];
37 |             }
38 |             
39 |             if(nums[i] >= max1)
40 |             {
41 |                 max3 = max2;
42 |                 max2 = max1;
43 |                 max1 = nums[i];
44 |             }
45 |             else if(nums[i] >= max2)
46 |             {
47 |                 max3 = max2;
48 |                 max2 = nums[i];
49 |             }
50 |             else if(nums[i] > max3)
51 |             {
52 |                 max3 = nums[i];
53 |             }
54 |             
55 |         }
56 |         
57 |         int op1 = max1 * max2 * max3;
58 |         int op2 = min1 * min2 * max1;
59 |         return max(op1, op2);
60 |         
61 |     }
62 | };


--------------------------------------------------------------------------------
/Class11/BasicsString.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | 
 5 | int main(){
 6 |     //1. Input/Output
 7 |     // string firstName;
 8 |     // cin>>firstName;
 9 |     // cout<<firstName<<endl;
10 | 
11 |     // string fullName;
12 |     // getline(cin, fullName);
13 |     // cout<<fullName;
14 | 
15 |     // 2. Append
16 |     string a = "Python";
17 |     string b = "Hello";
18 |     // a.append(b);
19 |     // cout<<a<<endl;
20 |     // cout<<a+b<<endl;
21 | 
22 |     //3. Compare
23 |     // cout<<a.compare(b)<<endl;
24 | 
25 |     //4. Access and update
26 |     // cout<<a[2]<<endl;
27 |     // a[0] = 'J';
28 |     // cout<<a<<endl;
29 | 
30 |     //5. clear
31 |     cout<<a<<endl;
32 |     // a.clear();
33 |     // cout<<a<<endl;
34 | 
35 |     //6. Empty
36 |     if(a.empty())
37 |     {
38 |         cout<<"String is empty"<<endl;
39 |     }
40 | 
41 |     //7. size / length
42 |     cout<<a.size()<<endl;
43 |     cout<<a.length()<<endl;
44 | 
45 |     //8. find
46 |     cout<<a.find("llo")<<endl;
47 | 
48 |     //9. insert
49 |     a.insert(3, "apple");
50 |     cout<<a<<endl;
51 | 
52 |     //10. delete
53 |     a.erase(3, 5);
54 |     cout<<a<<endl;
55 | 
56 |     //11. substr
57 |     cout<<a.substr(1, 2)<<endl;
58 | 
59 |     //12. sort
60 |     sort(a.begin(), a.end());
61 |     cout<<a<<endl;
62 | 
63 |     //13. reverse
64 |     reverse(a.begin(), a.end());
65 |     cout<<a<<endl;
66 | 
67 |     //14. convert
68 |     int x = 10;
69 |     cout<<to_string(x)+"4"<<endl;
70 | 
71 |     string y = "234";
72 |     cout<<stoi(y)<<endl;
73 | 
74 |     //15. iterate
75 |     string p = "Hello";
76 |     for(char c:p)
77 |     {
78 |         cout<<c<<", ";
79 |     }
80 |     cout<<endl;
81 |     for(int i=0; i<p.size(); i++)
82 |     {
83 |         cout<<p[i]<<"! ";
84 |     }
85 |     return 0;
86 | }


--------------------------------------------------------------------------------
/Class21/SudokuSolver.cpp:
--------------------------------------------------------------------------------
 1 | https://leetcode.com/problems/sudoku-solver/
 2 | 
 3 | class Solution { 
 4 |     
 5 |     bool isValidBoard(vector<vector<char>>& board, int i, int j, char c)
 6 |     {
 7 |         // row-column
 8 |         for(int k=0; k<9; k++)
 9 |         {
10 |             if(board[i][k]==c || board[k][j]==c)
11 |             {
12 |                 return false;
13 |             }
14 |         }
15 |         
16 |         int sr = (i/3)*3;
17 |         int sc = (j/3)*3;
18 |         
19 |         // sub-board
20 |         for(int a=sr; a<sr+3; a++)
21 |         {
22 |             for(int b=sc; b<sc+3; b++)
23 |             {
24 |                 if(board[a][b]==c)
25 |                 {
26 |                     return false;
27 |                 }
28 |             }
29 |         }
30 |         
31 |         return true;
32 |         
33 |     }
34 |     
35 |     bool fillSudoku(vector<vector<char>>& board)
36 |     {
37 |         for(int i=0; i<9; i++)
38 |         {
39 |             for(int j=0; j<9; j++)
40 |             {
41 |                 if(board[i][j]=='.')
42 |                 {
43 |                     for(char c='1'; c<='9'; c++)
44 |                     {
45 |                         if(isValidBoard(board, i, j, c))
46 |                         {
47 |                             board[i][j] = c;
48 |                             
49 |                             if(fillSudoku(board))
50 |                             {
51 |                                 return true;
52 |                             }
53 |                             else
54 |                             {
55 |                                 board[i][j] = '.';
56 |                             }
57 |                         }
58 |                     }
59 |                     return false;
60 |                 }
61 |             }
62 |         }
63 |         return true;
64 |     }
65 |     
66 | public:
67 |     void solveSudoku(vector<vector<char>>& board) {
68 |         
69 |         fillSudoku(board);
70 |     }
71 | };


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