Repository: Prince-1501/Hello_world-Competiitve-Programming
Branch: master
Commit: 6bab395fbefe
Files: 212
Total size: 192.6 KB

Directory structure:
gitextract_md51_btr/

├── 35_hacker_two_strings.cpp
├── 36_codechef_Encoding_message.cpp
├── 37_codechef_spell_bob.cpp
├── 38_codechef_fits_square_in_triangle.cpp
├── 39_codechef_chef_and_Eid.cpp
├── 40_codechef_chef_judges_competition.cpp
├── 41_codechef_chef_and_glove.cpp
├── 42_codechef_the_great_run.cpp
├── 43_codechef_attendance.cpp
├── 44_codechef_making_a_meal.cpp
├── 45_codechef_uncle_johny.cpp
├── 46_drink_codeforce.cpp
├── 47_candles_codeforces.cpp
├── 49_two_buttons_codeforces.cpp
├── 50_vanya_and_books_codeforces.cpp
├── 51_eleven_codeforces.cpp
├── 52_codechef_flatland.cpp
├── 53_codeforces_MUH_and_sticks.cpp
├── 54_print_subset_of_size_k_of_array.cpp
├── 55_codechef_Easy_Fibonacci.cpp
├── 56_codechef_Chef_and_Interesting_Subsequences.cpp
├── 57_codechef_A-books.cpp
├── 58_codechef_phone_prices.cpp
├── 59_codechef_operations_on_a_matrix.cpp
├── 60_Adding_one_to_the_numbers.cpp
├── Chef and Price Control.cpp
├── Data Structures/
│   ├── Add a node at the Middle of linked list.cpp
│   ├── Add a node at the end of linked list.cpp
│   ├── Add a node at the front of linked list.cpp
│   ├── Array_in_data_structures.cpp
│   ├── Circular Linked List data_structure.cpp
│   ├── Delete a node of a linked list.cpp
│   ├── Doubly Linked list.cpp
│   ├── Find the middle of a given linked list.cpp
│   ├── Insert Node at the End of Doubly Linked List.cpp
│   ├── Insert Node in Middle of Doubly Linkedlist.cpp
│   ├── LinkedList_Code_Practice.cpp
│   ├── Vectors_in_STL_data_structure.cpp
│   ├── main.cpp
│   └── structure_in_c++.cpp
├── Kadane's_algorithm.cpp
├── Kadane's_algorithm.pptx
├── Lecture - 15.cpp
├── Lecture - 16.cpp
├── Lecture - 17.cpp
├── Lecture - 18.cpp
├── Lecture - 19.cpp
├── Lecture - 20.cpp
├── Lecture - 21.cpp
├── Lecture - 22.cpp
├── Lecture - 24.cpp
├── Lecture - 25.cpp
├── Lecture - 26.cpp
├── Lecture - 27.cpp
├── Lecture - 31.cpp
├── Lecture - 32.cpp
├── Lecture - 33.cpp
├── Lecture - 34.cpp
├── Leetcode/
│   ├── Add Digits.cpp
│   ├── Add Two Numbers Leetcode Solutions in Linkedlist.cpp
│   ├── Binary Search leetcode Solution.cpp
│   ├── Boolean Matrix.cpp
│   ├── Count the Number of Consistent Strings.cpp
│   ├── Graph/
│   │   ├── All Paths From Source to Target.cpp
│   │   ├── Course Schedule.cpp
│   │   ├── Detect cycle in a directed graph.cpp
│   │   ├── Find Eventual Safe States.cpp
│   │   ├── Find if Path Exists in Graph.cpp
│   │   ├── Find the Town Judge.cpp
│   │   ├── Flood Fill.cpp
│   │   ├── Keys and Rooms.cpp
│   │   ├── Max Area of Island.cpp
│   │   ├── Minimum Time to Collect All Apples in a Tree.cpp
│   │   ├── Number of Enclaves.cpp
│   │   ├── Number of Islands.cpp
│   │   ├── Number of Provinces.cpp
│   │   ├── Number of closed Islands.cpp
│   │   ├── Rotting Oranges.cpp
│   │   ├── Steps by Knight.cpp
│   │   ├── Surrounded Regions.cpp
│   │   ├── Time Needed to Inform All Employees.cpp
│   │   ├── Topological sort .cpp
│   │   └── Topological sort using dfs.cpp
│   ├── Hashing/
│   │   ├── Check if two arrays are equal or not.cpp
│   │   ├── Custom Sort String.cpp
│   │   ├── First Repeating Element.cpp
│   │   ├── Group Anagrams.cpp
│   │   ├── Intersection of two arrays.cpp
│   │   ├── Key Pair.cpp
│   │   ├── LFU Cache.cpp
│   │   ├── Non-Repeating Element.cpp
│   │   ├── Pairs with Positive Negative values.cpp
│   │   ├── Relative Sort Array.cpp
│   │   ├── Sort Array by Increasing Frequency.cpp
│   │   ├── Subarray with 0 sum.cpp
│   │   ├── Winner of an election.cpp
│   │   ├── unordered_map.cpp
│   │   └── unordered_set.cpp
│   ├── Interchanging the rows of a Matrix.cpp
│   ├── Majority Element Geeksforgeeks leetcode Moore's Voting Algorithm.cpp
│   ├── Median of Two sorted arrays.cpp
│   ├── Middle of the Linked List Leetcode.cpp
│   ├── Middle of the Linked List.cpp
│   ├── Move Zeroes.cpp
│   ├── Multiply two matrices.cpp
│   ├── Naive Pattern Search.cpp
│   ├── Next Greater Element.cpp
│   ├── Non Repeating Character.cpp
│   ├── Peak element.cpp
│   ├── Rearrange Array Alternately Geeksforgeeks.cpp
│   ├── Recursion/
│   │   ├── 0-1 Knapsack Problem Top down.cpp
│   │   ├── Best Time to Buy and Sell Stock.cpp
│   │   ├── Climbing Stairs.cpp
│   │   ├── Decode Ways.cpp
│   │   ├── Delete middle element of a stack.cpp
│   │   ├── Divisor Game.cpp
│   │   ├── Factorial.cpp
│   │   ├── Fibonacci Number.cpp
│   │   ├── House Robber.cpp
│   │   ├── Largest Element in Array.cpp
│   │   ├── Min Cost Climbing Stairs.cpp
│   │   ├── Nth Fibonacci Number.cpp
│   │   ├── Partition Equal Subset Sum.cpp
│   │   ├── Perfect Squares.cpp
│   │   ├── Perfect Sum Problem.cpp
│   │   ├── Power Of Numbers.cpp
│   │   ├── Print 1 To N Without Loop.cpp
│   │   ├── Reverse a String.cpp
│   │   ├── Subset Sum Problem.cpp
│   │   ├── Sum of Array.cpp
│   │   ├── Target Sum.cpp
│   │   └── Tower Of Hanoi.cpp
│   ├── Reverse Linked List.cpp
│   ├── Rotate Array Leetcode.cpp
│   ├── Rotate List.cpp
│   ├── Search in a row-column sorted Matrix.cpp
│   ├── Single Number Leetcode solution.cpp
│   ├── Sort Array By Parity.cpp
│   ├── Sort Colors.cpp
│   ├── Spirally traversing a matrix.cpp
│   ├── Square root.cpp
│   ├── Subarray sum equals K.cpp
│   ├── Trapping Rain Water.cpp
│   ├── Tree/
│   │   ├── Balanced Binary Tree.cpp
│   │   ├── Binary Tree Inorder Traversal.cpp
│   │   ├── Binary Tree Right Side View.cpp
│   │   ├── Binary Tree Zigzag Level Order Traversal.cpp
│   │   ├── Children Sum Parent.cpp
│   │   ├── Construct Binary Tree from Preorder and Inorder Traversal.cpp
│   │   ├── Diameter of Binary Tree.cpp
│   │   ├── Invert Binary Tree.cpp
│   │   ├── Level Order Traversal.cpp
│   │   ├── Lowest Common Ancestor of a Binary Tree.cpp
│   │   ├── Maximum Depth of Binary Tree.cpp
│   │   ├── Populating Next Right Pointers in Each Node.cpp
│   │   ├── Subtree of Another Tree.cpp
│   │   ├── Symmetric Tree.cpp
│   │   ├── Vertical Width of a Binary Tree .cpp
│   │   └── same Tree.cpp
│   ├── count 1's in binary array.cpp
│   ├── linked-list-cycle.cpp
│   ├── linkedlist/
│   │   ├── Copy List with Random Pointer.cpp
│   │   ├── Delete Node in a Linked List.cpp
│   │   ├── Intersection of Two Linked Lists.cpp
│   │   ├── Linked List Cycle II.cpp
│   │   ├── Merge Two Sorted Lists.cpp
│   │   ├── Palindrome Linked List.cpp
│   │   ├── Remove Duplicates from Sorted List.cpp
│   │   ├── Remove Nth Node From End of List.cpp
│   │   ├── Remove duplicates from an unsorted linked list.cpp
│   │   ├── Reverse Linked List.cpp
│   │   ├── Sort List.cpp
│   │   ├── Swap Nodes in Pairs.cpp
│   │   └── Swapping Nodes in a Linked List.cpp
│   ├── stack/
│   │   ├── Evaluate Reverse Polish Notation.cpp
│   │   ├── Implement Queue using Stacks.cpp
│   │   ├── Implement Stack using Queues.cpp
│   │   ├── Largest Rectangle in Histogram.cpp
│   │   ├── Min Stack.cpp
│   │   ├── Next Greater Element I.cpp
│   │   ├── Online Stock Span.cpp
│   │   ├── Remove All Adjacent Duplicates In String.cpp
│   │   ├── Remove All Adjacent Duplicates in String II.cpp
│   │   ├── Reverse First K elements of Queue.cpp
│   │   └── Valid Parentheses.cpp
│   ├── string/
│   │   ├── Find the Index of the First Occurrence in a String.cpp
│   │   ├── Gas Station.cpp
│   │   └── Maximum Ice Cream Bars.cpp
│   └── sum of numbers in string.cpp
├── README.md
├── STL/
│   ├── Array_Algorithms_in_stl.cpp
│   ├── Binary search in STL.cpp
│   ├── List_in_STL.cpp
│   ├── Queue_in_STL.cpp
│   ├── Vectors_Functions_in_STL.cpp
│   ├── What is STL.cpp
│   ├── deque_in_STL.cpp
│   ├── pair_in_STL.cpp
│   ├── priority Queue in STL.cpp
│   ├── sort_in_STL.cpp
│   └── stack in STL data structure.cpp
├── Templates_in_c++.cpp
├── Tree/
│   ├── Binary seacrh tree
│   ├── Binary_tree.cpp
│   ├── Code of Deletion of Node in BST.cpp
│   ├── Code of Inorder Traversal.cpp
│   ├── Insertion in BST.cpp
│   ├── code of Hashing in C++.cpp
│   └── code of preorer and Postorder traversal.cpp
├── chef and Icecream.cpp
├── chef and string.cpp
└── map_in_c++

================================================
FILE CONTENTS
================================================

================================================
FILE: 35_hacker_two_strings.cpp
================================================
//
//  main.cpp
//  Lecture 34
//
//  Created by Prince  Kumar on 17/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//                      HACKER EARTH

//       --- **    Problems on Two Strings   ** ---           //


#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        string s1,s2; cin>>s1>>s2;
        // declare array for s1 and s2;
        
        // for s1
        int a[26]={0};
        
        // for s2
        int b[26]={0};
        
        // length of string
        int k = (int)s1.size();
        
        for(int i=0;i<k;i++)
        {
            int x = s1[i]-97;  //  In c++ automatic data type conversion in char to int
            a[x]++;
            
            int y = s2[i]-97;
            b[y]++;
        }
        
        
        // we declare count
        int count=0;
        
        // we got completer array a and b
        
        for(int j=0;j<26;j++)
        {
            if(a[j]!=b[j])
                count++;
        }
        if(count==0)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
}




================================================
FILE: 36_codechef_Encoding_message.cpp
================================================
//
//  main.cpp
//  Lecture 36
//
//  Created by Prince  Kumar on 17/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//                      CODE-CHEF

//       --- **    Problems on Encoding Message   ** ---       //


#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; cin>>n; // lenght of string
        string s; cin>>s;
        
        // 1st step of encoding
        if(n%2==0)
        {
            // even
            for(int i=0;i<n;i=i+2)  // len= 6 ; index -> 0 to 5
            {
                char z = s[i+1];  // z='h'
                s[i+1] = s[i] ;  //
                s[i]=z;
            }
        }
        else
        {
            // odd
            for(int i=0;i<n-1;i=i+2)
            {
                char z = s[i+1];  // z='h'
                s[i+1] = s[i] ;  //
                s[i]=z;
            }
        }
        
        // 2nd stage of encoding
        
        for(int i=0;i<n;i++)
        {
            char c = s[i];   // recent character  // b --> 98
            //int index  =  s[i]-97;
            int index  =  c-97;   // 1
            int req = 25-index;   // 24
            
            //  range 97 to 122
            req = req + 97;
            char y = (char)req;  // real ASCII code
            cout<<y;
            
        }
        cout<<endl;
        
        
        
    }
}






================================================
FILE: 37_codechef_spell_bob.cpp
================================================
//
//  main.cpp
//  Lecture 37
//
//  Created by Prince  Kumar on 17/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//                      CODE-CHEF

//       --- **    Problems on Spell bob   ** ---       //


#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        string s1,s2; cin>>s1>>s2;
        int a[3]={0};  // b count
        for(int i=0;i<3;i++)  // 'b' present  or not
        {
            if(s1[i]=='b' || s2[i]=='b')
                a[i]=1;
        }
        int b_count=0;
        for(int i=0;i<3;i++)
        {
            if(a[i]==1)
                b_count++;
        }
        if(b_count<=1)
            cout<<"no"<<endl;
        else if(b_count==2)
        {
            int index=0;
            for(int i=0;i<3;i++)
            {
                if(a[i]==0)
                    index=i;
            }
            if(s1[index]=='o' || s2[index]=='o')
                cout<<"yes"<<endl;
            else
                cout<<"no"<<endl;
        }
        else if(b_count==3)
        {
            int o_count=0;
            for(int i=0;i<3;i++)
            {
                if(s1[i]=='o' || s2[i]=='o')
                    o_count++;
            }
            if(o_count==0)
                cout<<"no"<<endl;
            else
                cout<<"yes"<<endl;
        }
    }
}




================================================
FILE: 38_codechef_fits_square_in_triangle.cpp
================================================
//
//  main.cpp
//  CODECHEF
//
//  Created by Prince  Kumar on 14/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//   --- **  Fits square in the triangle ** ---

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int b; cin>>b;
        if(b==1 || b==2 ||b==3)
            cout<<"0"<<endl;
        else
        {
            if(b%2==0)  // for EVEN
            {
                int area = 0.5 * b *b;
                int res =  (area - b )/4;
                cout<<res<<endl;
            }
            else   // for ODD
            {
                b=b-1;
                int area = 0.5 * b *b;
                int res =  (area - b )/4;
                cout<<res<<endl;
            }
               
        }
    }
}


================================================
FILE: 39_codechef_chef_and_Eid.cpp
================================================
//
//  main.cpp
//  CODE-CHEF
//
//  Created by Prince  Kumar on 14/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
// ---- ** Chef and Eid ** ------

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    int T;cin>>T;
    while(T--)
    {
        int n ; cin>>n;
        vector<int > v;
        for(int i=0;i<n;i++)
        {
            // cin>>v[i];
            int x; cin>>x;
            v.push_back(x);
        }
        sort(v.begin(),v.end());
        // sort
        
        vector<int> res;
        for(int i=0;i<n-1;i++)
        {
            res.push_back(v[i+1]-v[i]);
        }
        sort(res.begin(),res.end());
        cout<<res[0]<<endl;
        
        
    }
}



================================================
FILE: 40_codechef_chef_judges_competition.cpp
================================================
//
//  main.cpp
//  CODE-CHEF
//
//  Created by Prince  Kumar on 15/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
// ---- ** chef judges a competition ** --- //


#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    int T;cin>>T;
    while(T--)
    {
        int n; cin>>n;
        int a[n] ; // for ALICE
        int b[n] ; // for BOB
        
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
        }
        
        for(int i=0;i<n;i++)
        {
            cin>>b[i];
        }
        
        // sorting in ARRAY
        sort(a,a+n);
        sort(b,b+n);
        
        int suma =0;
        int sumb = 0;
        
        for(int i=0;i<n-1;i++)
        {
            suma = suma + a[i];
            sumb = sumb + b[i];
        }
        // we get sum results
        
        if(suma==sumb)
            cout<<"Draw"<<endl;
        else if( suma < sumb)
            cout<<"Alice"<<endl;
        else
            cout<<"Bob"<<endl;
        
    }
}









================================================
FILE: 41_codechef_chef_and_glove.cpp
================================================
//
//  main.cpp
//  CODE-CHEF
//
//  Created by Prince  Kumar on 17/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//   ---- ** CHEF AND GLOVE ** ------- //


#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; cin>>n;
        // numbering 1 to n
        
        int len[n+1];  // length of finger
        int glov [n+1]; // lenght of sheath
        
        for(int i=1;i<n+1;i++)
        {
            cin>>len[i];
        }
        for(int i=1;i<n+1;i++)
        {
            cin>>glov[i];
        }
        
        // front
        int front=0;
        for(int i=1;i<n+1;i++)  // loop runs n times
        {
            if(len[i]<=glov[i])
                front++;
        }
        
        // back
        int back=0;
        for(int i=1;i<n+1;i++)
        {
            if(len[i]<=glov[n+1-i])  // i=1 --> 8+1-1 = 8
                back++;                // i=2  --> 8+1-2 =7
        }
        
        if(front==n && back==n)
        {
            cout<<"both"<<endl;
        }
        else if(front!=n && back!=n )
            cout<<"none"<<endl;
        else if(front==n && back!=n)
            cout<<"front"<<endl;
        else if( front!=n && back ==n)
            cout<<"back"<<endl;
    }
}










================================================
FILE: 42_codechef_the_great_run.cpp
================================================
//
//  main.cpp
//  CODE-CHEF
//
//  Created by Prince  Kumar on 17/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//  ------ ** The Great Run ** ---------- //

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--){
        
        int n,k; cin>>n>>k;
        int a[n];  // no. of girls per km
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
        }
        // we get values of girls
        
        int max=0;
        for(int i=0;i<=n-k;i++)
        {
            int sum=0;
            for(int j=i;j<i+k;j++)
            {
                sum+=a[j];
            }
            if(max<sum)
                max=sum;
        }
        cout<<max<<endl;
        
    }
}






================================================
FILE: 43_codechef_attendance.cpp
================================================
//
//  main.cpp
//  CODE-CHEF
//
//  Created by Prince  Kumar on 18/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
// ------- ** Attendance ** --------- //

#include <iostream>
using namespace std;
int main()
{
    int T;cin>>T;
    while(T--)
    {
        int n; cin>>n;
        string f[n];
        string l[n];
        
        for(int i=0;i<n;i++)
        {
            cin>>f[i]>>l[i];  // first name and last name
        }
        
        int a[n];
        for(int i=0;i<n;i++){a[i]=0;}
        
        // initalise the array - a --> to 0
        
        for(int i=0;i<n-1;i++)
        {
            for(int j=i+1;j<n;j++)
            {
                if(f[i]==f[j])
                {a[i]++; a[j]++;}
            }
        }
        
        // we check the condition on array a
        
        for(int i=0;i<n;i++)
        {
            if(a[i]==0)
            {
                cout<<f[i]<<endl;
            }
            else
            {
                cout<<f[i]<<" "<<l[i]<<endl;
            }
        }
    }
}








================================================
FILE: 44_codechef_making_a_meal.cpp
================================================
//
//  main.cpp
//  CODE-CHEF
//
//  Created by Prince  Kumar on 18/05/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//  ------ ** Making a Meal ** -------- //

#include<iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    int T;cin>>T;
    while(T--)
    {
        int n;cin>>n;
        int bowl[26]={0};
        for(int i=0;i<n;i++)
        {
            string s;cin>>s;
            for(int j=0;j<s.size();j++)
            {
                int x = s[j] - 97;
                bowl[x]++;
            }
        }
        // we get all letters
        
        vector<int> v;
        v.push_back(bowl[2]/2); // for 'c'
        v.push_back(bowl[3]/1);  // for 'd'
        v.push_back(bowl[4]/2);  // for 'e'
        v.push_back(bowl[5]/1);  // for 'f'
        v.push_back(bowl[7]/1);  // for 'h'
        v.push_back(bowl[14]/1);  // for 'o'
        
        sort(v.begin(),v.end());
        cout<<v[0]<<endl;
        
    }
}





================================================
FILE: 45_codechef_uncle_johny.cpp
================================================
//
//  main.cpp
//  lecture 45
//
//  Created by Prince  Kumar on 25/07/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
// codechef question --** Uncle johny ** ---- //


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; cin>>n;
        vector<int> v;
        for(int i=0;i<n;i++)
        {
            int x; cin>>x;
            v.push_back(x);
            // v.push_back(cin);
        }
        int k; cin>>k; // index of jhony unle song
        // vector use --> indexing start from 0
        int val  = v[k-1]; // uncle jhony
        sort(v.begin(),v.end());
        for(int i=0;i<n;i++)
        {
            if(v[i]==val)
            {
                cout<<i+1<<endl;
                break;
            }
        }
    }
}







================================================
FILE: 46_drink_codeforce.cpp
================================================
//
//  main.cpp
//  hello
//
//  Created by Prince  Kumar on 01/08/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

#include <iostream>
using namespace std;
int main()
{
    int n; cin>>n;
    // p[i] =  how much ml of orange juice
    int p[n]; for(int i=0;i<n;i++)
    {
        int x ;cin>>x;
        x = x*10;
        p[i] = x;
    }
    // we calculate total orange juice
    
    int tot_orange  = 0;
    for(int i=0;i<n;i++)
    {
        tot_orange+=p[i];
    }
    
    double x = tot_orange*100.00;
    //  / we calculate total orange juice
    
    int tot_vol = n*1000; //integer
    
    // we calcuate total volume
    
    double res = (x/tot_vol);
    cout<<res<<endl;
    
     
}


================================================
FILE: 47_candles_codeforces.cpp
================================================
//
//  main.cpp
//  candles

// codeforces question
//                   A. New Year Candles


#include <iostream>
using namespace std;
int main()
{
    int a,b; cin>>a>>b;
    
    int x = a;
    while(a>=b)
    {
        x = x + (a/b);
        a = (a/b) + (a%b);
    }
    cout<<x<<endl;
    
}


================================================
FILE: 49_two_buttons_codeforces.cpp
================================================
//
//  main.cpp
//  Two Buttons

//
//  Created by Prince  Kumar on 13/08/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

///             TWO BUTTONS --> Code-forces

#include <iostream>
using namespace std;
int main()
{
    int n,m; cin>>n>>m;
    if(n>=m)
    { // 10  1
        cout<<n-m<<endl;
    }
    else
    {
        // back tracking
        int count=0;
        while(m>n)
        {
            if(m%2==0)
            {m/=2; count++;}
            else
            {
                m+=1; count++;
            }
        }
        cout<<count+(n-m)<<endl;
    }
}


================================================
FILE: 50_vanya_and_books_codeforces.cpp
================================================
//
//  main.cpp
//  books
//
//  Created by Prince  Kumar on 15/08/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//    codeforce --> Vanya and Books

#include <iostream>
#include <math.h>
#define ll long long
using namespace std;
int main()
{
    ll int n; cin>>n;
    ll int a[13]={0};
    for(int i=1;i<13;i++)
    {
        a[i]=pow(10,i)-1;
    }
    for(int i=2;i<13;i++)
    {
        for(int j=1;j<=i-1;j++)
        {
            a[i] = a[i]-a[j];
        }
    }
//    for(int i=1;i<13;i++)
//    {
//        cout<<a[i]<<endl;
//    }
    // value in array is to set
    
    ll int count=0;
    for(int i=1;i<13;i++ )
    {
        if(n-a[i]>=0)
        {
            count+=a[i]*i;
            n=n-a[i];
        }
        else
        {
            count+=n*i;
            break;
        }
    }
    cout<<count<<endl;
    
}









================================================
FILE: 51_eleven_codeforces.cpp
================================================
//
//  main.cpp
//  eleven
//
//  Created by Prince  Kumar on 21/08/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

//.      PROBLEMS --> ELEVEN from Codeforces

#include <iostream>
#include <cstring>
#define ll long long
using namespace std;
int main()
{
    ll int a[20]={0}; // store fibonacci series
    a[0]=a[1]=a[2]=1;
    for(int i=3;i<20;i++)
    {
        a[i]=a[i-1]+a[i-2];
    }
    //cout<<a[19]<<endl;
    // 1 1 2 3 5 8 ...  if n==10
    int n; cin>>n;
    int b[n+1]; memset(b,0,sizeof(b));
    
    
    // 1 represent 'O'
    // 0 represent 'o'
    for(int i=1;i<20;i++)
    {
        if(a[i]<=n)
        {
            b[a[i]]=1;
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(b[i]==1)
            cout<<"O";
        else
            cout<<"o";
    }
    cout<<endl;
    
}





================================================
FILE: 52_codechef_flatland.cpp
================================================
//
//  main.cpp
//  faltland
//
//  Created by Prince  Kumar on 05/09/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

//  Code Of "FLATLAND" codechef 
#include <iostream>
using namespace std;
int main()
{
    int a[36];
    for(int i=1;i<36;i++)
    {
        a[i]=i*i;
    }
    // we got a array of perfect square
    
    int T;cin>>T;
    while(T--)
    {
        int n;cin>>n;
        int count=0;
        while(n!=0)
        {
            for(int i=1;i<36;i++)
            {
                if(a[i]<=n && a[i+1]>n)
                {
                    n=n-a[i];
                unt++;
                }
            }
        }
        cout<<count<<endl;
    }
}




================================================
FILE: 53_codeforces_MUH_and_sticks.cpp
================================================
//
//  main.cpp
//  code
//
//  Created by Prince  Kumar on 07/09/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//  codeforces --> MUH and Sticks

#include <iostream>
using namespace std;
int main()
{
    int a[10]={0};
    for(int i=1;i<=6;i++)
    {
        int x; cin>>x;
        a[x]++;
    }
    
    int leg =0;
    int leg_value=0;
    for(int i=1;i<=9;i++)
    {
        if(a[i]>=4)
        {
            leg=1;
            leg_value=i;
            a[i]=a[i]-4;
            break;
        }
        
    }
    
    int body=0;
    int body_value=0;
    
    for(int i=1;i<=9;i++)
    {
        if(a[i]>=1)
        {
            body=1;
            body_value=i;
            a[i]=a[i]-1;
            break;
        }
        
    }
    
    int head=0;
    int head_value=0;
    
    for(int i=1;i<=9;i++)
    {
        if(a[i]>=1)
        {
            head=1;
            head_value=i;
            a[i]=a[i]-1;
            break;
        }
        
    }
    
    // we got leg leg_value / body body_value / head head_value
    
    if(leg==1 && body==1 && head==1)
    {
        if(leg_value!=head_value && leg_value!=body_value && head_value!=body_value)
            cout<<"Bear"<<endl;
        else if(body_value!=head_value && (leg_value!=head_value || leg_value!=body_value))
            cout<<"Bear"<<endl;
        else if(leg_value!=head_value && leg_value!=body_value && head_value==body_value)
            cout<<"Elephant"<<endl;
        else if(leg_value==head_value && leg_value==body_value && head_value==body_value)
            cout<<"Elephant"<<endl;
    }
    else
        cout<<"Alien"<<endl;
}


================================================
FILE: 54_print_subset_of_size_k_of_array.cpp
================================================
//
//  main.cpp
//  subset
//
//  Created by Prince  Kumar on 09/09/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//      Print all subset of size 'k' of array of size 'n'

#include <iostream>
#include<vector>
#include <math.h>
#include <algorithm>
using namespace std;
int main()
{
    cout<<"Enter number of elemnets in array : "<<endl;
    int n; cin>>n;
    cout<<"Enter the size of subset : "<<endl;
    int k ; cin>>k;
    
    int a[n];
    cout<<"Enter the numbers : "<<endl;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    for(int i=1;i<pow(2,n);i++)
    {
        vector<int> v;
        int x=i; // x=8
        while(x>0)
        {
            int z = x%2;  //  0  0  0   1
            v.push_back(z);
            x=x/2;  // 4  2  1 0
        }
        int p  = n- (int)v.size();
        for(int j=1;j<=p;j++)
        {
            v.push_back(0);
        }
        reverse(v.begin(), v.end());
        int count=0;
        for(int i=0;i<v.size();i++)
        {
            if(v[i]==1)
                count++;
        }
        if(count==k)
        {
            for(int i=0;i<v.size();i++)
            {
                if(v[i]==1)
                {
                    cout<<a[i]<<" ";
                }
            }
            cout<<endl;
        }
        v.clear();
        
    }
}


================================================
FILE: 55_codechef_Easy_Fibonacci.cpp
================================================
//
//  main.cpp
//  fibonacciii
//
//  Created by Prince  Kumar on 23/09/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//  code of Easy Fibonacci

#include <iostream>
#include <math.h>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        long long int x; cin>>x;
        long long int z = log2((long double)x);
        if(z==0)
            cout<<"0"<<endl;
        else if(z==1)
            cout<<"1"<<endl;
        else
        {
            int a = z%4;
            if(a==2)
                cout<<"2"<<endl;
            else if(a==3)
                cout<<"3"<<endl;
            else if(a==0)
                cout<<"0"<<endl;
            else if(a==1)
                cout<<"9"<<endl;
        }
    }
}






================================================
FILE: 56_codechef_Chef_and_Interesting_Subsequences.cpp
================================================
//
//  main.cpp
//  code
//
//  Created by Prince  Kumar on 23/09/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//  code of Chef and Interesting Subsequences
//  ** --- September long challenge  -- ** //

#include <iostream>
#include <vector>
#include <algorithm>
#define ll long long
using namespace std;
ll int gcd(ll int a, ll int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);
}
void nCr(int n, int r)
{
    
    // p holds the value of n*(n-1)*(n-2)...,
    // k holds the value of r*(r-1)...
    long long p = 1, k = 1;
    
    // C(n, r) == C(n, n-r),
    // choosing the smaller value
    if (n - r < r)
        r = n - r;
    
    if (r != 0) {
        while (r) {
            p *= n;
            k *= r;
            
            // gcd of p, k
            long long m = gcd(p, k);
            
            // dividing by gcd, to simplify product
            // division by their gcd saves from the overflow
            p /= m;
            k /= m;
            
            n--;
            r--;
        }
        
        // k should be simplified to 1
        // as C(n, r) is a natural number
        // (denominator should be 1 ) .
    }
    
    else
        p = 1;
    
    // if our approach is correct p = ans and k =1
    cout << p << endl;
}
int main()
{
    int T; cin>>T;
    while(T--)
    {
        vector<int> v;
        int n,k;cin>>n>>k;
        for(int i=0;i<n;i++)
        {
            int x; cin>>x;
            v.push_back(x);
        }
        sort(v.begin(),v.end());
        int last_index_of_k = v[k-1];
        int count=0;
        for(int i=0;i<n;i++)
        {
            if(v[i]==last_index_of_k)
                count++;
        }
        // we get total number of last_element
        
        int num=0;
        for(int i=0;i<k;i++)
        {
            if(v[i]==last_index_of_k)
                num++;
        }
        nCr(count,num);  // countCnum
        
    }
}










================================================
FILE: 57_codechef_A-books.cpp
================================================
//
//  main.cpp
//  jdjd
//
//  Created by Prince  Kumar on 26/09/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
//   --- codechef --> A-Books ---
#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; cin>>n;
        int a[n];
        int b[1000001]={0};
        // in b[]  we store last index of elements
        for(int i=0;i<n;i++)  // i->index
        {
            int x; cin>>x;
            a[i]=x;
            b[x]=i;
            
//            cin>>a[i];
//            b[a[i]]=i;
        }
        for(int i=0;i<n;i++)
        {
            //cout<<n-1-b[a[i]]<<endl;
            int x = a[i];
            int last_index = b[x];
            cout<<n-1-last_index<<" ";
        }
        cout<<endl;
        
    }
}





================================================
FILE: 58_codechef_phone_prices.cpp
================================================
//
//  main.cpp
//  test1
//
//  Created by Prince  Kumar on 06/10/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

//                                 **-- October Long Challenge --**
//                                       **-- Phone prices --**

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; cin>>n;
        int a[n+1]; for(int i=1;i<=n;i++){cin>>a[i];}
        // we have now prices on respective days
        int count=1;
        for(int i=2;i<=n;i++)
        {
            int price = a[i];
            if(i==2)
            {
                if(price<a[i-1])
                    count++;
            }
            else if(i==3)
            {
                if(price<a[i-1] && price<a[i-2])
                    count++;
            }
            else if(i==4)
            {
                if(price<a[i-1] && price<a[i-2] && price<a[i-3])
                    count++;
            }
            else if(i==5)
            {
                if(price<a[i-1] && price<a[i-2] && price<a[i-3] && price<a[i-4])
                    count++;
            }
            else
            {
                if(price<a[i-1] && price<a[i-2] && price<a[i-3] && price<a[i-4] && price<a[i-5])
                    count++;
            }
        }
        cout<<count<<endl;
    }
}


================================================
FILE: 59_codechef_operations_on_a_matrix.cpp
================================================
//
//  main.cpp
//  bbcfjc
//
//  Created by Prince  Kumar on 06/10/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

//                              ***-- October Long Challeneg 2019 --***
/                                      ***-- Operations on a Matrix --****

#include <iostream>
#include <cstring>
#include <string>
#include <string.h>
#define ll long long
using namespace std;
int main()
{
    ll int T; cin>>T;
    while(T--)
    {
        ll int n,m,q;cin>>n>>m>>q;
        ll int a[n+1]; memset(a,0,sizeof(a)); // row
        ll int c[m+1]; memset(c,0,sizeof(c)); // column
        for(ll int i=0;i<q;i++)
        {
            ll int a1, a2;cin>>a1>>a2;
            a[a1]++; c[a2]++;
        }
        ll int odd=0,even=0,a_zero=0;
        for(ll int i=1;i<=n;i++)
        {// row
            
            if(a[i]>0)
            {
            if(a[i]%2!=0)
                odd++;
            else
                even++;
                
            }
            else
                a_zero++;
        }
        // for column
        ll int count=0;
        for(ll int i=1;i<=m;i++)
        {
            if(c[i]>0)
            {
                if(c[i]%2!=0)
                {
                    count+=even+a_zero;
                }
                else
                {
                    // even
                    count+=odd;
                }
            }
            else
                count+=odd;
        }
        cout<<count<<endl;
        
    }
}


================================================
FILE: 60_Adding_one_to_the_numbers.cpp
================================================
//
//  main.cpp
//
//  Created by Prince  Kumar on 16/04/20.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** ADD ONE TO THE NUMBER **---

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    cout<<"Enter The size of Vector : "<<endl;
    int n; cin>>n;
    
    vector<int> v; v.push_back(0);
    for(int i=0;i<n;i++){
        int x;
        cin>>x;
        v.push_back(x);
    }
    
    // check conditions
    int k = (int)v.size() - 1;
    
    if(v[k]<9){
        v[k]+=1;  // v[k] = v[k] + 1;
    }else{
        
        while(v[k]==9){
            v[k]=0;
            k= k-1;
        }
        
        v[k]= v[k]+1;
    }
    
    // Print the result
    // we have to omit the leading zero's
    
    int s = 0;
    for(int i=0;i<(int)v.size() ;i++){
        if(v[i]!=0){
            s=i;  // here we store index
            break;
        }
    }
    
    for (int i=s;i<(int)v.size();i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;
}


================================================
FILE: Chef and Price Control.cpp
================================================
//
//  COMPETITIVE PROGRAMMING .cpp
//
//  Created by Prince  Kumar on 15/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                       ---** COMPETITIVE PROGRAMMING in C++ **---
//                            ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
int main(){
    int T; cin>>T;
    while(T--){
        int n, k; cin>>n>>k;
        int prev_amt=0;
        int ori_amt=0;
        // 2 3 4 7 10     5
        for(int i=0;i<n;i++){
            int x; cin>>x;   // x = 2
            prev_amt+=x;  // profit initially   prev_Amt = 2
            
            if(x>k){
                x=k;
            }               // x= 5
            ori_amt+=x;    // ori_amt = 2
        }
        cout<<prev_amt-ori_amt<<endl;
        
//        int a[n];
//        for(int i=0;i<n;i++){
//            cin>>a[i];
//            prev_amt+=a[i];
//        }
//        for(int i=0;i<n;i++){
//            if(a[i]>k){
//                a[i]=k;
//            }
//            ori_amt+=a[i];
//        }
    }
}


================================================
FILE: Data Structures/Add a node at the Middle of linked list.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 23/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** INSERTION OF NODE IN  LINKED LIST in C++ **---

//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Linked list Node  ------ */
struct node{
    int data;
    node *next;
};

/* -------  Print the Linked List  -------*/
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in linked list is : "<<count<<endl;
}

/* ------  INSERTION OF NODE AT FRONT OF LINKED LIST --------*/

void push(node **head_ref , int newData){
    node *newNode = new node();
    newNode -> data = newData;
    newNode -> next = *head_ref;
    *head_ref = newNode;
}

/* ------  INSERTION OF NODE AT MIDDLE OF LINKED LIST --------*/

void insertAfter(node *prev_node , int newData){
    node *newNode = new node();
    newNode->data = newData;
    newNode->next = prev_node->next;
    prev_node->next = newNode;
}

int main(){
   
    node *head = NULL;
    push(&head , 5);
    push(&head , 7);
    push(&head , -3);
    // -3 7 5
    
    insertAfter(head->next,79);
    
    printList(head);
    
}


================================================
FILE: Data Structures/Add a node at the end of linked list.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 24/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** INSERTION OF NODE IN  LINKED LIST in C++ **---

//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Linked list Node  ------ */
struct node{
    int data;
    node *next;
};

/* -------  Print the Linked List  -------*/
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in linked list is : "<<count<<endl;
}

/* ------  INSERTION OF NODE AT FRONT OF LINKED LIST --------*/

void push(node **head_ref , int newData){
    node *newNode = new node();
    newNode -> data = newData;
    newNode -> next = *head_ref;
    *head_ref = newNode;
}

/* ------  INSERTION OF NODE AT MIDDLE OF LINKED LIST --------*/

void insertAfter(node *prev_node , int newData){
    node *newNode = new node();
    newNode->data = newData;
    newNode->next = prev_node->next;
    prev_node->next = newNode;
}

/* ------  INSERTION OF NODE AT END OF LINKED LIST --------*/


void append(node **head_ref, int newData){
    
    node *newNode = new node();
    newNode->data = newData;
    newNode->next = NULL;
    
    node *last = *head_ref;
    
    if(*head_ref == NULL){
        *head_ref = newNode;
        return;
    }
    
    while(last->next != NULL){
        last = last->next;
    }
    
    last->next = newNode;
    return;
    
}

int main(){
   
    node *head = NULL;
    push(&head , 5);
    push(&head , 7);
    push(&head , -3);
    // -3 7 5
    
    insertAfter(head->next,79);
    // -3 7 79 5
    
    append(&head, 90);
    printList(head);
    
}




================================================
FILE: Data Structures/Add a node at the front of linked list.cpp
================================================

//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 22/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** INSERTION OF NODE IN  LINKED LIST in C++ **---

//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Linked list Node  ------ */
struct node{
    int data;
    node *next;
};

/* -------  Print the Linked List  -------*/
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in linked list is : "<<count<<endl;
}

//node *push(node *head , int newData){
//    node *newNode = new node();
//    newNode -> data = newData;
//    newNode -> next = head;
//    head = newNode;
//    return head;
//}

void push(node **head_ref , int newData){
    node *newNode = new node();
    newNode -> data = newData;
    newNode -> next = *head_ref;
    *head_ref = newNode;
}

int main(){
   
    node *head = NULL;
    push(&head , 5);
    push(&head , 7);
    push(&head , -3);
    
    printList(head);
    
}





================================================
FILE: Data Structures/Array_in_data_structures.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 08/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** ARRAYS in C++ **---

#include <iostream>
using namespace std;
int main(){
    
    //1st method
//    int arr[5];
//    arr[0] = 4;
//    arr[1] = 3;
//    arr[2] = -10;
//    arr[3] = 8;
//    arr[4] = -6;
    
    // 2nd method
    int arr[5] = {4 , 3, -10, 8,-9};
    
    int arr1[] = {4 , 3, -10, 8,7 , 4, 2 , 11};
    //int arr2[];
    
    
    cout<<arr[3]<<endl;
    cout<<arr1[5]<<endl;
    cout<<"Ans : "<<arr1[3/2]<<endl;
    
    
    int a[5]={0};
    cout<<a[4]<<endl;
    
//    int b[5]={1};
//    cout<<b[3]<<endl;
}





================================================
FILE: Data Structures/Circular Linked List data_structure.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 20/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** CIRCULAR LINKED LIST in C++ **---

//                     ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

//Linked list Node
struct node{
    int data;
    node *next;
};

void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in linked list is : "<<count<<endl;
}

void printCircularList(node * first){
    node *temp = first;
    
    if(first!=NULL){
        cout<<temp->data<<endl;
        temp = temp->next;  // this changes in temp
        
        while(temp != first){
            cout<<temp->data<<endl;
            temp = temp->next;
        }
    }
}

int main(){
    
//    /*                   Make A linked List                            */
    node *head  = new node(); node *second = new node(); node *third = new node();
    node *four  = new node(); node *five = new node(); node *six = new node();
    node *seven  = new node(); node *eight = new node(); node *nine = new node();

    head -> data = 5;   head -> next = second;
    second->data = 1;   second ->next = third;
    third -> data = -3; third ->next = four;
    four -> data = 11;  four -> next = five;
    five->data = 10;    five ->next = six;
    six -> data = 2;    six ->next = seven;
    seven -> data = 7;  seven -> next = eight;
    eight->data = 9;    eight ->next = nine;
    nine -> data = 18;  nine ->next = head;

    printCircularList(four);
}


================================================
FILE: Data Structures/Delete a node of a linked list.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 25/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** DELETION OF NODE IN  LINKED LIST in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Linked list Node  ------ */
struct node{
    int data;
    node *next;
};

/* -------  Print the Linked List  -------*/
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in linked list is : "<<count<<endl;
}

/* ------  INSERTION OF NODE AT FRONT OF LINKED LIST --------*/

void push(node **head_ref , int newData){
    node *newNode = new node();
    newNode -> data = newData;
    newNode -> next = *head_ref;
    *head_ref = newNode;
}

/* ------  DELETION OF NODE IN LINKED LIST --------*/


void deleteNode(node **head_ref , int key){
    // initialise prev and temp
    node *prev, *temp;
    
    //store head to the temp;
    temp  = *head_ref;
    
    //if key is present in head
    if(temp!=NULL && temp->data == key){
        *head_ref = temp->next;
        free(temp);
        return;
    }
    
    //we traverse the linkedlist and keep track og prev node
    // because we have to perform prev->next
    
    while(temp!=NULL && temp->data!=key){
        prev=temp;
        temp = temp->next;
    }
    
    // we travserse whole linked list and we didn't got the key
    if(temp==NULL) return;
    
    // but, if we found the key
    prev->next = temp->next;
    free(temp);
}


int main(){
   
    node *head = NULL;
    push(&head , 5);
    push(&head , 7);
    push(&head , -3);
    push(&head , 2);
    push(&head , 9);
    
    printList(head);
    
    deleteNode(&head, 2);
    
    printList(head);
    
    
}


================================================
FILE: Data Structures/Doubly Linked list.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 27/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** INSETION OF NODE IN DOUBLY LINKED LIST in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Doubly Linked list Node  ------ */
struct node{
    int data;
    node *next;
    node *prev;
};


/*-------  Print the Douubly Linked List  ------- */
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in Doubly linked list is : "<<count<<endl;
}

/*-------  Insert node in Doubly Linked List  ------- */

void push(node **head_ref, int new_data){
    
    node *new_node = new node();
    new_node->data=  new_data;
    new_node->next = *head_ref;
    new_node->prev = NULL;
    
    if((*head_ref) != NULL){
        (*head_ref)->prev = new_node;
    }
    
    (*head_ref) = new_node;
}


int main(){
    
    node *head= NULL;
    push(&head, 4);
    push(&head, 11);
    push(&head, -3);
    
    // -3 11 4
    
    printList(head);
}



================================================
FILE: Data Structures/Find the middle of a given linked list.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 20/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** LINKED LIST in C++ **---

//                     ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

//Linked list Node
struct node{
    int data;
    node *next;
};

void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    
    cout<<"No. of element in linked list is : "<<count<<endl;
}

void printMiddleElement( node *head){
    node *slow_ptr = head;
    node *fast_ptr = head;
    
    if(head!=NULL){
        while(fast_ptr!=NULL && fast_ptr->next!=NULL){
            fast_ptr = fast_ptr->next->next;
            slow_ptr = slow_ptr->next;
        }
        cout<<"Middle Element is : "<<slow_ptr->data<<endl;
    }
    
}

int main(){
    
    /*                   Make A linked List                            */
    node *head  = new node(); node *second = new node(); node *third = new node();
    node *four  = new node(); node *five = new node(); node *six = new node();
    node *seven  = new node(); node *eight = new node(); node *nine = new node();
    
    head -> data = 5;   head -> next = second;
    second->data = 1;   second ->next = third;
    third -> data = -3; third ->next = four;
    four -> data = 11;  four -> next = five;
    five->data = 10;    five ->next = six;
    six -> data = 2;    six ->next = seven;
    seven -> data = 7;  seven -> next = eight;
    eight->data = 9;    eight ->next = nine;
    nine -> data = 18;  nine ->next = NULL;
    
    
    //printList(head);
    
//    node *start = head;
//    for(int i=0;i<5;i++){
//        cout<<start->data<<endl;
//        start= start->next;
//    }
    
    printMiddleElement(head);
}


================================================
FILE: Data Structures/Insert Node at the End of Doubly Linked List.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 30/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** INSETION OF NODE IN DOUBLY LINKED LIST in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Doubly Linked list Node  ------ */
struct node{
    int data;
    node *next;
    node *prev;
};


/*-------  Print the Doubly Linked List  ------- */
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in Doubly linked list is : "<<count<<endl;
}

/*-------  Insert node in Front of Doubly Linked List  ------- */

void push(node **head_ref, int new_data){
    
    node *new_node = new node();
    new_node->data=  new_data;
    new_node->next = *head_ref;
    new_node->prev = NULL;
    
    if((*head_ref) != NULL){
        (*head_ref)->prev = new_node;
    }
    
    (*head_ref) = new_node;
}

/*-------  Insert node in Middle of Doubly Linked List  ------- */

void insertAfter(node *prev_node, int new_data){
    
    if(prev_node == NULL){
        cout<<"given prev node can't be null"<<endl;
        return;
    }
    
    node *new_node = new node();
    new_node->data = new_data;
    new_node->next = prev_node->next;
    
    prev_node->next = new_node;
    new_node->prev = prev_node;
    
    if(new_node->next != NULL){
        new_node->next->prev = new_node;
    }
}

/*-------  Insert node in End of Doubly Linked List  ------- */

void append(node **head_ref, int new_data){
    node *new_node = new node();
    new_node->data = new_data;
    new_node->next = NULL;
    
    node *last  = *head_ref;  //head
    if(*head_ref == NULL){
        new_node->prev = NULL;
        *head_ref = new_node;
        return;
    }
    
    while(last->next != NULL){
        last = last->next;
    }
    
    last->next = new_node;
    new_node->prev = last;
    
    return;
}


int main(){
    
    node *head= NULL;
    push(&head, 4);
    push(&head, 11);
    push(&head, -3);
    // -3 11 4
    
    insertAfter(head->next, 10);
    // -3 11 10 4
    
    append(&head, 9);
    // -3 11 10 4 9
    
    printList(head);
}


================================================
FILE: Data Structures/Insert Node in Middle of Doubly Linkedlist.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 30/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** INSETION OF NODE IN DOUBLY LINKED LIST in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

/* ----- Doubly Linked list Node  ------ */
struct node{
    int data;
    node *next;
    node *prev;
};


/*-------  Print the Doubly Linked List  ------- */
void printList (node *n){
    int count=0;
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
        count++;
    }
    cout<<"No. of element in Doubly linked list is : "<<count<<endl;
}

/*-------  Insert node in Front of Doubly Linked List  ------- */

void push(node **head_ref, int new_data){
    
    node *new_node = new node();
    new_node->data=  new_data;
    new_node->next = *head_ref;
    new_node->prev = NULL;
    
    if((*head_ref) != NULL){
        (*head_ref)->prev = new_node;
    }
    
    (*head_ref) = new_node;
}

/*-------  Insert node in Middle of Doubly Linked List  ------- */

void insertAfter(node *prev_node, int new_data){
    
    if(prev_node == NULL){
        cout<<"given prev. node can't be null"<<endl;
        return;
    }
    
    node *new_node = new node();
    new_node->data = new_data;
    new_node->next = prev_node->next;
    
    prev_node->next = new_node;
    new_node->prev = prev_node;
    
    if(new_node->next != NULL){
        new_node->next->prev = new_node;
    }
}

int main(){
    
    node *head= NULL;
    push(&head, 4);
    push(&head, 11);
    push(&head, -3);
    // -3 11 4
    
    insertAfter(head->next, 10);
    // -3 11 10 4
    
    printList(head);
}


================================================
FILE: Data Structures/LinkedList_Code_Practice.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 15/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** LINKED LIST in C++ **---

//                     ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;

//Linked list Node
struct node{
    int data;
    node *next;
};

void printList (node *n){
    while(n!=NULL){
        cout<<n->data<<endl;
        n = n->next;
    }
}

int main(){
    node *head = new node();
    node *second = new node();
    node *third = new node();
    
    head -> data = 5;
    head -> next = second;
    
    second->data = 1;
    second ->next = third;
    
    third -> data = 3;
    third ->next = NULL;
    
    printList(head);

}


================================================
FILE: Data Structures/Vectors_in_STL_data_structure.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 3/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> v;    /*  3 10 7*/
    vector<int> :: iterator it;
    v.push_back(3);
    v.push_back(10);
    v.push_back(7);
    
    auto a = v.begin();   // it provides iterator which points first element of vector
    cout<<"first element  : "<<a[0]<<endl;
    //v.pop_back();
    
    it = v.begin();
    cout<<"iterator points : "<<it[0]<<endl;
    
    it = v.end();
    //cout<<it<<endl;
    
    int size = (int)v.size();

    for(int i=0;i<size;i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;
}




================================================
FILE: Data Structures/main.cpp
================================================
main file


================================================
FILE: Data Structures/structure_in_c++.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 11/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** STRUCTURE & CLASSES in C++ **---

#include <iostream>
using namespace std;
struct student{
  
    int roll;
    string name;
    int age;
    
    void studentDetails(){
        cout<<"name is : "<<name<<endl;
        cout<<"age is : "<<age<<endl;
        cout<<"roll is : "<<roll<<endl;
    }
    
};
int main(){
    
//    struct student prince;
    student simran;
    student prince;
    prince.age= 21;
    prince.name = "prince";
    prince.roll = 44;
    
    struct student prateek = { 21, "prateek" ,20};
    
    prince.studentDetails();
    cout<<endl;
    prateek.studentDetails();
    cout<<endl;
    
    
}


================================================
FILE: Kadane's_algorithm.cpp
================================================
//
//  main.cpp
//
//  Created by Prince  Kumar on 21/04/20.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** MAX SUM CONTIGUOUS SUBARRAY **---

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    cout<<"Enter the size of Array : "<<endl;
    int n; cin>>n;
    
    int a[n];
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    
    int max_so_far = a[0], max_ending_here =0;  // It store sum
    int start = 0 , end=0 , s=0;  // it store index
    
    for(int i=0;i<n;i++){
        max_ending_here+=a[i];
        if(max_so_far < max_ending_here){
            max_so_far=max_ending_here;
            start = s; end=i;
        }
        
        if(max_ending_here<0){
            max_ending_here = 0;
            s = i+1;
        }
    }
    
    int sum=0;
    for(int i=start ;i<=end ; i++){
        sum+=a[i];
        cout<<a[i]<<" ";
        
    }
    cout<<endl;
    cout<<sum<<endl;
    
    
}


================================================
FILE: Lecture - 15.cpp
================================================
//
//  main.cpp
//  lecture 15
//
//  Created by Prince  Kumar on 14/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int > v;
    v.push_back(10);
    v.push_back(23);
    v.push_back(22);
    v.push_back(78);
    v.push_back(98);
    
    // iterators // pointers
    
    // sort // ascending to descending...
    sort(v.begin(),v.end());  // important
    
    v.pop_back();
    int k  = (int)v.size();   // k=5
    
    
    
    
    for(int i=0;i<k;i++)
    {
        cout<<v[i]<<" ";
    }
    cout<<endl;
    
}


================================================
FILE: Lecture - 16.cpp
================================================
//
//  main.cpp
//  lecture -16
//
//  Created by Prince  Kumar on 15/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

#include <iostream>
#include <sstream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; cin>>n;    // int n= 7929024
        ostringstream str1;
        str1<<n;
        string s = str1.str();
        
        // single char  'a', '3' ' $'
        // set of char == string  == "prince"  , "78292"
        // string  s = 7929024    k = 7
        // find the string size
        int count=0;
        int k = (int)s.size();
        for(int i=0;i<k;i++)
        {
            if(s[i]=='4')
                count++;
            else
                count=count;
        }
        cout<<count<<endl;
    }
}


================================================
FILE: Lecture - 17.cpp
================================================
//
//  main.cpp
//  lecture -17
//
//  Created by Prince  Kumar on 17/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int a,b,c,d; cin>>a>>b>>c>>d;
        if((a==c && b==d)|| (a==b && c==d)||(a==d && c==b))
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
}


================================================
FILE: Lecture - 18.cpp
================================================
#include <iostream>
using namespace std;
int main()
{
    int T;cin>>T;
    while(T--)
    {
        int n; cin>>n;
        int k ; cin>>k;
        string s; cin>>s;
        int cap=0;
        int small=0;
        for(int i=0;i<n;i++)
        {
            char x = s[i];
            int p = int(x); // ASCII CODE
            // CAPITAL   ASCII    65 to 90
            // SMALL     ASCII    97  to 122
            if(p>=65 && p<=90)
                cap++;
            else
                small++;
        }
        // we have no. of small and capital letters.
        if(cap==small)
        {
            if(k>=cap)
                cout<<"both"<<endl;
            else if(k<cap)
                cout<<"none"<<endl;
        }
        else if(small>cap)
        {
            if(k>=small)
                cout<<"both"<<endl;
            else if(k<cap)
                cout<<"none"<<endl;
            else
                cout<<"chef"<<endl;
                
        }
        else if(cap>small)
        {
            if(k>=cap)
                cout<<"both"<<endl;
            else if(k<small)
                cout<<"none"<<endl;
            else
                cout<<"brother"<<endl;
        }
    }
}


================================================
FILE: Lecture - 19.cpp
================================================

// ** -- code of "Studying alphabet " --Code chef -- **
#include <iostream>
using namespace std;
int main()
{
    string s; cin>>s;
    int a[26]={0}; // we put the value 0 in all the blocks
    int len = (int)s.size();  // length of string
    for(int i=0;i<len;i++)
    {
        char x = s[i]; // lets suppose x ='c'
        int p = int(x); // p =99
        p = p-97;  // index of that character // p =2
        a[p]=1;
    }
    int n; cin>>n;
    for(int i=0;i<n;i++)
    {
        int count=0;  // no. of charcter that not present in string s
        string k; cin>>k;  // k--> words
        for(int j=0;j<k.size();j++)
        {
            char z = k[j]; // let's supose z= 'f'
            int h = int(z);  // h=102
            h = h-97;  // h=5
            if(a[h]==0)
                count++;
            else
                count=count;
        }
        if(count>0)
            cout<<"No"<<endl;
        else
            cout<<"Yes"<<endl;
        
    }
}


================================================
FILE: Lecture - 20.cpp
================================================
#include <iostream>
#include <sstream>
using namespace std;
int main()
{
    string s;
    //cin>>s;
    getline(cin,s);
    cout<<s<<endl;
    cout<<s[0]<<endl;
    cout<<s[1]<<endl;
    cout<<s[2]<<endl;
    cout<<s[3]<<endl;
    cout<<s[4]<<endl;
    
    // -- we want to extrat the words --
    stringstream str(s);
    string word;   // it stores the words present in the string s
    while(str>>word)
    {
        cout<<word<<endl;
    }
}


================================================
FILE: Lecture - 21.cpp
================================================
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    // problem 1.
    /*int a[10]={0};
    cout<<a[5]<<endl;
    
    int b[10]={21};  // method wrong ... and luckily valid for only 0 (zero )
    cout<<b[5]<<endl;  */
    
    // problem 2.
   /* int n ; cin>>n;
    int a[n]={0};
    cout<<a[5]<<endl; */
    
    // solution of these problem
    // memset ()
    int n;
    cout<<"Input the size of array"<<endl;
    cin>>n;
    int a[n]; // block name --- a
    memset(a,0 ,sizeof(a));  // value --> 0 & -1
    cout<<a[4]<<endl;
    
    int val[9];
    memset(val, -1 , sizeof(val));
    for(int i=0;i<9;i++)
    {
        cout<<val[i]<<" ";
    }
    cout<<endl;
    
}


================================================
FILE: Lecture - 22.cpp
================================================
// **--- program of print prime numbers ---**//

#include <iostream>
using namespace std;
int main()
{
    int n;
    cout<<"Enter value of n upto which you want to print prime number : "<<endl;
    cin>>n;
    for(int i=2;i<=n;i++)   /// 10
    {
        int x = i;  // 10
        int count=0;
        for(int j=1;j<=x;j++)  // j=1 to j=10
        {
            if(x%j==0) // 10%2==0
                count++;
        }
        if(count==2)
            cout<<x<<endl;
    }
}


================================================
FILE: Lecture - 24.cpp
================================================
//
//  main.cpp
//  Lecture - 24
//
//  Created by Prince  Kumar on 28/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//  seive of eratosthenes -- //

#include <iostream>
#include <cstring>
using namespace std;

void seive( int n)
{
    // create boolean array
    bool prime[n+1];
    memset(prime, true ,sizeof(prime));
    
    for(int p=2;p*p<=n;p++)
    {
        //  if prime[p] --> false  --> it is not prime
        if(prime[p]==true)
        {
            for(int i=p*p;i<=n;i=i+p)
            {
                prime[i]=false;
            }
        }
    }
    
    // print prime numbers
    for(int j=2;j<=n;j++)
    {
        if(prime[j]==true)
            cout<<j<<endl;
    }
}
int main()
{
    cout <<"Enter number upto which you want to print prime numbers "<<endl;
    int n ; cin>>n;
    seive(n);
}


================================================
FILE: Lecture - 25.cpp
================================================
//
//  main.cpp
//  hbhbhbs
//
//  Created by Prince  Kumar on 29/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
// ** --- Euclidean Algorithm -- for finding GCD of 2 number **//

#include <iostream>
using namespace std;
int gcd(int a, int b)
{
    if(a==0)
        return b;
    else
        return gcd(b%a ,a);
    
}
int main()
{
    int a,b;
    cout<<"Enter two numbers "<<endl;
    cin>>a>>b;
    int result = gcd(a,b);
    cout<<result<<endl;
}


================================================
FILE: Lecture - 26.cpp
================================================
//
//  main.cpp
//  hsgts
//
//  Created by Prince  Kumar on 29/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//   Chef and his daily routine Problem Code: CHEFROUT

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        string s; cin>>s;
        int count=0;
        for(int i=0;i<s.size()-1;i++)
        {
            if(s[i]=='C')
            {
                if(s[i+1]=='E' ||s[i+1]=='S' || s[i+1]=='C')
                    count++;
            }
            else if(s[i]=='E')
            {
                if(s[i+1]=='S' || s[i+1]=='E')
                    count++;
            }
            else if(s[i]=='S')
            {
                if(s[i+1]=='S')
                    count++;
            }
        }
        if(count==s.size()-1)
            cout<<"yes"<<endl;
        else
            cout<<"no"<<endl;
    }
}


================================================
FILE: Lecture - 27.cpp
================================================
//
//  main.cpp
//  lecture 27
//
//  Created by Prince  Kumar on 31/03/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//  code of codechef problem - Two vs Ten

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int x; cin>>x;
        if(x%10==0)
            cout<<"0"<<endl;
        else if(x%5==0)
            cout<<"1"<<endl;  // 5*2 =10
        else
            cout<<"-1"<<endl;
    }
}


================================================
FILE: Lecture - 31.cpp
================================================
//
//  main.cpp
//  lecture 31
//
//  Created by Prince  Kumar on 04/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//
// --- * Check the number is power of 2 * --- //
#include <iostream>
using namespace std;
int main()
{
    cout<<"Enter the number "<<endl;
    int x;
    cin>>x;
    int a = x & (x-1);
    if(a==0)
        cout<<"Number is the power of 2"<<endl;
    else
        cout<<"Number is NOT the power of 2"<<endl;
        
}


================================================
FILE: Lecture - 32.cpp
================================================
//
//  main.cpp
//  lecture 32
//
//  Created by Prince  Kumar on 05/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//  -- ** code of COUNT THE THE NUMBER OF ONE'S IN THE BINARY REPRESENTATION OF GIVEN NUMBER ** --- //

#include <iostream>
using namespace std;
int main()
{
    cout<<"Enter the number :"<<endl;
    int n; cin>>n;
    int x = n & (n-1);
    int count=1;
    while(x!=0)
    {
        count++;
        x = x & (x-1);
    }
    cout<<count<<endl;
    
    /*
     
     cout<<"Enter the number :"<<endl;
     int n; cin>>n;
     n = n & (n-1);
     int count=1;
     while(n!=0)
     {
     count++;
     n = n & (n-1);
     }
     
     
     */
}


================================================
FILE: Lecture - 33.cpp
================================================
//
//  main.cpp
//  lecture 33
//
//  Created by Prince  Kumar on 05/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//  -- **  code of  --> Check the ith bit is set in the binary form of given number ** --- //

#include <iostream>
using namespace std;
int main()
{
    cout<<"Enter the number : "<<endl;
    int n ; cin>>n;
    bool  a = n & ( 1<<3);
    if(a==true)
        cout<<"Yes, bit is set"<<endl;
    else
        cout<<"No,  bit is not set"<<endl;
        
}


================================================
FILE: Lecture - 34.cpp
================================================
//
//  main.cpp
//  Lecture 34
//
//  Created by Prince  Kumar on 17/04/19.
//  Copyright © 2019 Prince  Kumar. All rights reserved.
//   -- * Problems from codechef -> Train Partner -- ANKTRAIN * -//

#include <iostream>
using namespace std;
int main()
{
    int T; cin>>T;
    while(T--)
    {
        int n; // berth number
        cin>>n;
        if(n%8==0)
        {cout<<n-1<<"SL"<<endl;}
        else if(n%8==7)
        {cout<<n+1<<"SU"<<endl;}
        else if(n%8==1)
        {cout<<n+3<<"LB"<<endl;}
        else if(n%8==4)
        {cout<<n-3<<"LB"<<endl;}
        else if(n%8==2)
        {cout<<n+3<<"MB"<<endl;}
        else if(n%8==5)
        {cout<<n-3<<"MB"<<endl;}
        else if(n%8==3)
        {cout<<n+3<<"UB"<<endl;}
        else if(n%8==6)
        {cout<<n-3<<"UB"<<endl;}
    }
}


================================================
FILE: Leetcode/Add Digits.cpp
================================================
// https://leetcode.com/problems/add-digits/


class Solution {
public:
    
    int addDigitsHelper(int num){
        int sum = 0;
        while(num != 0){
            int digit = num % 10;
            sum += digit;
            num = num / 10;
        }
        return sum;
    }
    
    int addDigits(int num) {
        
        while(num > 9){
            num = addDigitsHelper(num);
        }
        
        return num;
    }
};


================================================
FILE: Leetcode/Add Two Numbers Leetcode Solutions in Linkedlist.cpp
================================================
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 
 *     https://leetcode.com/problems/add-two-numbers/
 
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *ans = new ListNode(0);
        ListNode *p = l1, *q=l2, *curr = ans;
        int carry=0;
        while(p!=NULL || q!=NULL){
            int x = (p!=NULL) ? p->val : 0;
            int y = (q!=NULL) ? q->val : 0;
            int sum = carry + x+ y;
            carry = sum/10;
            curr->next = new ListNode(sum%10);
            curr = curr->next;
            if(p!=NULL) p = p->next;
            if(q!=NULL) q = q->next;
        }
        if(carry>0){
            curr->next = new ListNode(carry);
        }
        return ans->next;
    }
};


================================================
FILE: Leetcode/Binary Search leetcode Solution.cpp
================================================
// https://leetcode.com/problems/binary-search/


class Solution {
public:
    int search(vector<int>& nums, int target) {
        
        int n = (int)nums.size();
        
        int low = 0;
        int high = n-1;
        
        while(low<=high){
            int mid = (low+high)/2;
            
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target ){
                low = mid+1;
            }else{
                high = mid-1;
            }
        }
        
        return -1;
        
    }
};


================================================
FILE: Leetcode/Boolean Matrix.cpp
================================================
// Boolean Matrix: https://practice.geeksforgeeks.org/problems/boolean-matrix-problem-1587115620/1#

void booleanMatrix(vector<vector<int> > &matrix)
    {
        // code here 
        int row = matrix.size();
        int col = matrix[0].size();
        
        bool arr_row[row]; fill(arr_row, arr_row+row, false);
        bool arr_col[col]; fill(arr_col, arr_col+col, false);
        
        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++){
                if(matrix[i][j] == 1){
                    arr_row[i] = true;
                    arr_col[j] = true;
                }
            }
        }
        
        for(int i=0;i<row;i++){
            if(arr_row[i]){
                for(int j=0;j<col;j++){
                    matrix[i][j]= 1;
                }
            }
        }
        
        for(int i=0;i<col;i++){
            if(arr_col[i]){
                for(int j=0;j<row;j++){
                    matrix[j][i] = 1;
                }
            }
        }
        
    }


================================================
FILE: Leetcode/Count the Number of Consistent Strings.cpp
================================================
// https://leetcode.com/problems/count-the-number-of-consistent-strings/

class Solution {
public:
    int countConsistentStrings(string allowed, vector<string>& words) {
        unordered_set<char> s;
        for(auto x: allowed)
            s.insert(x);
        
        int count = 0;
        for(auto word: words){
            
            bool status = true;
            for(int i=0; i<word.size(); i++){
                if(s.find(word[i]) == s.end()){
                    status = false;
                    break;
                }
            }
            if(status)
                count++;
        }
        
        return count;
    }
};


================================================
FILE: Leetcode/Graph/All Paths From Source to Target.cpp
================================================
// https://leetcode.com/problems/all-paths-from-source-to-target/

class Solution {
public:
    
    void dfs(vector<vector<int>>& graph, vector<vector<int>>& ans, vector<int>&path, int curr){
        
        path.push_back(curr);
        if(curr == graph.size()-1){
            ans.push_back(path);
        }
        else{
            for(auto x: graph[curr]){
                dfs(graph, ans, path, x);
            }
        }
        
        path.pop_back();
        
    }
    
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        vector<vector<int>> ans;
        vector<int>path;
        
        dfs(graph, ans, path, 0);
        
        return ans;
    }
};


================================================
FILE: Leetcode/Graph/Course Schedule.cpp
================================================
// https://leetcode.com/problems/course-schedule/

class Solution {
public:
    
    bool DFSRec(int s, vector<bool>&visited, vector<bool>&currVisited, vector<int>adj[]){
        visited[s] = true;
        currVisited[s] = true;
        
        vector<int>data = adj[s];
        for(auto x: data){
            if(!visited[x]){
                if(DFSRec(x, visited, currVisited, adj)){
                    return true;
                }
            }
            else if(visited[x] && currVisited[x]){
                return true;
            }
        }
        
        currVisited[s] = false;
        return false;
    }
    
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        
        int n = numCourses;
        vector<bool>visited(n, false), currVisited(n, false);
        
        vector<int>adj[n];
        for(auto x: prerequisites){
            vector<int>data = x;
            int a = data[0];
            int b = data[1];
            adj[a].push_back(b);
        }
        
        for(int i=0; i<n; i++){
            if(!visited[i]){
                if(DFSRec(i, visited, currVisited, adj)){
                    return false;
                }
            }
        }
        
        return true;
    }
};


================================================
FILE: Leetcode/Graph/Detect cycle in a directed graph.cpp
================================================
// https://practice.geeksforgeeks.org/problems/detect-cycle-in-a-directed-graph/1

class Solution {
  public:
    // Function to detect cycle in a directed graph.
    
    bool cycle(int s, vector<bool>&visited, vector<bool>&currVisited, vector<int> adj[]){
        visited[s] = true;
        currVisited[s] = true;
        
        for(auto x: adj[s]){
            if(!visited[x]){
                if(cycle(x, visited, currVisited, adj))
                    return true;
            }
            else if(visited[x] == true && currVisited[x] == true){
                return true;
            }
        }
        
        currVisited[s] = false;
        return false;
    }
    
    bool isCyclic(int V, vector<int> adj[]) {
        // code here
        vector<bool>visited(V, false), currVisited(V, false);
        for(int i=0; i<V; i++){
            if(!visited[i]){
                if(cycle(i, visited, currVisited, adj))
                    return true;
            }
        }
        
        return false;
    }
};



================================================
FILE: Leetcode/Graph/Find Eventual Safe States.cpp
================================================
// https://leetcode.com/problems/find-eventual-safe-states/

class Solution {
public:
    
    bool DFSRec(int s, vector<bool>&visited, vector<bool>&dfsVisited, vector<vector<int>>& graph, vector<bool> &present_cycle){
        visited[s] = true;
        dfsVisited[s] = true;
        
        vector<int>data = graph[s];
        for(auto x: data){
            if(!visited[x]){
                if(DFSRec(x, visited, dfsVisited, graph, present_cycle)){
                    return present_cycle[s] = true;
                }
            }
            else if(visited[x] && dfsVisited[x]){
                return present_cycle[s] = true;
            }
        }
        
        dfsVisited[s] = false;
        return false;
    }
    
    vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
        vector<int> ans;
        
        int n = graph.size();
        vector<bool>visited(n, false), dfsVisited(n, false);
        vector<bool> present_cycle(n, false);
        
        for(int i=0; i<n; i++){
            if(!visited[i]){
                DFSRec(i, visited, dfsVisited,graph, present_cycle);
            }
        }
        
        for(int i=0; i<n; i++){
            if(!present_cycle[i]){
                ans.push_back(i);
            }
        }
        
        return ans;
    }
};


================================================
FILE: Leetcode/Graph/Find if Path Exists in Graph.cpp
================================================
// https://leetcode.com/problems/find-if-path-exists-in-graph/

class Solution {
public:
    bool validPath(int n, vector<vector<int>>& edges, int start, int end) {
        
        unordered_map<int, vector<int>> umap;
        for(auto x: edges){
            vector<int>temp = x;
            
            int u = temp[0];
            int v = temp[1];
            
            umap[u].push_back(v);
            umap[v].push_back(u);
        }
        
        vector<bool>visited(n+1, false);
        
        queue<int>q;
        q.push(start);
        visited[start] = true;
        
        while(!q.empty()){
            
            int v = q.front();
            q.pop();
            
            vector<int>temp = umap[v];
            for(int i=0; i<temp.size(); i++){
                int vertex = temp[i];
                if(visited[vertex] == false){
                    q.push(vertex);
                    visited[vertex] = true;
                }

            }
            
            if(visited[end])
                return visited[end];
        }
        
        return visited[end];
        
        
        
        
        
    }
};


================================================
FILE: Leetcode/Graph/Find the Town Judge.cpp
================================================
// https://leetcode.com/problems/find-the-town-judge/

class Solution {
public:
    int findJudge(int n, vector<vector<int>>& trust) {
        
        vector<int>data(n+1, 0);
        for(auto x: trust)
        {
            data[x[0]]--;
            data[x[1]]++;
        }
        
        for(int i=1; i<=n; i++){
            int x = data[i];
            if(x == n-1)
                return i;
        }
        
        return -1;
    }
};


================================================
FILE: Leetcode/Graph/Flood Fill.cpp
================================================
// https://leetcode.com/problems/flood-fill/

class Solution {
public:
    
    bool isValid(vector<vector<int>>& image, int i, int j, int n, int m , int color){
        
        if(i>=0 && i<n && j>=0 && j<m && image[i][j] == color)
            return true;
        
        return false;
    }
        
    void floodFillRec(vector<vector<int>>& image, int i, int j, int n, int m , int color, int newColor){
        
        image[i][j] = newColor;
        
        if(isValid(image, i+1, j, n, m , color))
            floodFillRec(image, i+1, j, n, m , color, newColor);
        
        if(isValid(image, i-1, j, n, m , color))
            floodFillRec(image, i-1, j, n, m , color, newColor);
        
        if(isValid(image, i, j+1, n, m , color))
            floodFillRec(image, i, j+1, n, m , color, newColor);
        
        if(isValid(image, i, j-1, n, m , color))
            floodFillRec(image, i, j-1, n, m , color, newColor);
    }
    
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        
        int n = image.size();
        int m = image[0].size();
        
        int color = image[sr][sc];
        
        if(color == newColor)
            return image;
        
        floodFillRec(image, sr, sc, n, m, color, newColor);
        
        return image;
    }
};


================================================
FILE: Leetcode/Graph/Keys and Rooms.cpp
================================================
// https://leetcode.com/problems/keys-and-rooms/

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        
        int n = rooms.size();
        vector<bool>visited(n, false);
        
        queue<int>q;
        q.push(0);
        visited[0] = true;
        
        while(!q.empty()){
            int room = q.front();
            q.pop();
            
            for(auto key : rooms[room]){
                if(!visited[key]){
                    visited[key] = true;
                    q.push(key);
                }
            }
        }
        
        
        for(auto x: visited){
            if(!x)
                return x;
        }
        
        return true;
    }
};


================================================
FILE: Leetcode/Graph/Max Area of Island.cpp
================================================
// https://leetcode.com/problems/max-area-of-island/

class Solution {
public:
    
    bool isValid(int i, int j, int n, int m, vector<vector<int>>& grid){
        if(i>=0 && i<n && j>=0 && j<m && grid[i][j] == 1){
            return true;
        }
        return false;
    }
    
    void dfs(vector<vector<int>>& grid, int i, int j, int n, int m, int &area){
        area++;
        grid[i][j] = 0;
        
        if(isValid(i+1, j, n, m, grid)){
            dfs(grid, i+1, j, n, m, area);
        }
        if(isValid(i-1, j, n, m, grid)){
            dfs(grid, i-1, j, n, m, area);
        }
        if(isValid(i, j+1, n, m, grid)){
            dfs(grid, i, j+1, n, m, area);
        }
        if(isValid(i, j-1, n, m, grid)){
            dfs(grid, i, j-1, n, m, area);
        }
    }
    
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        
        int n = grid.size();
        int m = grid[0].size();
        int ans = 0;
        
        for(int i=0; i<n;i++){
            for(int j=0; j<m; j++){
                if(grid[i][j] == 1){
                    int area = 0;
                    dfs(grid, i, j, n, m, area);
                    ans = max(ans, area);
                }
            }
        }
        
        return ans;
    }
};


================================================
FILE: Leetcode/Graph/Minimum Time to Collect All Apples in a Tree.cpp
================================================
// https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree/

class Solution {
public:
    vector<bool>visited;
    int dfs(vector<vector<int>>&adj, int node, int mycost, vector<bool>& hasApple){
        if(visited[node]) return 0;
        visited[node]= true;

        int childCost = 0;
        for(auto x: adj[node]){
            childCost += dfs(adj, x, 2, hasApple);
        }
        if(childCost == 0 && !hasApple[node]) return 0;
        return childCost + mycost;
    }
    int minTime(int n, vector<vector<int>>& edges, vector<bool>& hasApple) {
        vector<vector<int>>adj(n, vector<int>(0, -1));
        for(auto x: edges){
            adj[x[0]].push_back(x[1]);
            adj[x[1]].push_back(x[0]);
        }
        for(int i=0; i<n; i++){visited.push_back(false);}
        int time = 0;
        time = dfs(adj, 0, 0, hasApple);
        return time;
    }
};


================================================
FILE: Leetcode/Graph/Number of Enclaves.cpp
================================================
// https://leetcode.com/problems/number-of-enclaves/

class Solution {
public:
    
    int count(vector<vector<int>>& grid){
        int n = grid.size();
        int m = grid[0].size();
        int ans = 0;
        
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(grid[i][j] == 1)
                    ans++;
            }
        }
        
        return ans;
    }
    
    bool isValid(int i, int j, int n, int m, vector<vector<int>>& grid){
        if(i>=0 && i<n && j>=0 && j<m && grid[i][j] == 1 ){
            return true;
        }
        return false;
    }
    
    void dfs(int i, int j, int n, int m, vector<vector<int>>& grid){
        grid[i][j] = 0;
        
        int ax[4] = {1, -1, 0, 0};
        int ay[4] = {0, 0, 1, -1};
        
        for(int k=0; k<4; k++){
            int nx = i + ax[k];
            int ny = j + ay[k];
            
            if(isValid(nx,ny, n, m, grid)){
                dfs(nx, ny, n, m, grid);
            }
        }
    }
    
    int numEnclaves(vector<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        
        
        // boundary travers
        for(int i=0; i<n; i++){
            
            int j = 0;
            if(grid[i][j] == 1){
                dfs(i, j, n, m, grid);
            }
            
            j = m-1;
            if(grid[i][j] == 1){
                dfs(i, j, n, m, grid);
            }
            
        }
        
        
        for(int j=0; j<m; j++){
            
            int i = 0;
            if(grid[i][j] == 1){
                dfs(i, j, n, m, grid);
            }
            
            i = n-1;
            if(grid[i][j] == 1){
                dfs(i, j, n, m, grid);
            }
            
        }
        
        return count(grid);
        
    }
};


================================================
FILE: Leetcode/Graph/Number of Islands.cpp
================================================
// https://leetcode.com/problems/number-of-islands/

class Solution {
public:
    
    
    bool isValid(int i, int j, int n , int m, vector<vector<char>>& grid){
        if(i>=0 && i<n && j>=0 && j<m && grid[i][j] == '1')
            return true;
        
        return false;
    }
    
    void numIslandsRec(int i, int j, int n , int m, vector<vector<char>>& grid){
        
        grid[i][j] = '0';
        
        if(isValid(i+1, j, n, m , grid))
            numIslandsRec(i+1, j, n, m, grid);
        
        if(isValid(i-1, j, n, m , grid))
            numIslandsRec(i-1, j, n, m, grid);
        
        if(isValid(i, j+1, n, m , grid))
            numIslandsRec(i, j+1, n, m, grid);
        
        if(isValid(i, j-1, n, m , grid))
            numIslandsRec(i, j-1, n, m, grid);
        
    }
    
    int numIslands(vector<vector<char>>& grid) {
        
        int n = grid.size();
        int m = grid[0].size();
        int ans = 0;
        
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(grid[i][j] == '1'){
                    ans++;
                    numIslandsRec(i, j, n, m, grid);
                }
            }
        }
        
        return ans;
    }
};


================================================
FILE: Leetcode/Graph/Number of Provinces.cpp
================================================
// https://leetcode.com/problems/number-of-provinces/

class Solution {
public:
    
    void dfs(int s, int n, vector<vector<int>>& isConnected, vector<bool>&visited){
        visited[s] = true;
        // s = 1
        
        // 0 1 2 3 4  -- index
        // 1 2 3 4 5  -- city name
        // 1 1 0 1 0  -- connection
        
        vector<int>adj;
        for(int i=0; i<n; i++ ){
            int x =  isConnected[s][i];  // x = connection
            if(x == 1)
                adj.push_back(i);
        }
        
        for(auto x: adj){
            if(!visited[x]){
                dfs(x, n, isConnected, visited);
            }
        }
        
        
    }
    
    int findCircleNum(vector<vector<int>>& isConnected) {
        
        int n = isConnected.size();
        vector<bool>visited(n, false);
        int count = 0;
        
        for(int i=0; i<n; i++){
            if(!visited[i]){
                count++;
                dfs(i, n, isConnected, visited);
            }
        }
        
        return count;
    }
};


================================================
FILE: Leetcode/Graph/Number of closed Islands.cpp
================================================
// https://leetcode.com/problems/number-of-closed-islands/

class Solution {
public:
    
    
    bool isValid(int i, int j, int n, int m ,vector<vector<int>>& grid){
        if(i>=0 && i<n && j>=0 && j<m && grid[i][j] == 0){
            return true;
        }
        return false;
    }
    
    void dfs(int i, int j, int n, int m ,vector<vector<int>>& grid){
        grid[i][j] = 1;
        
        int ax[4] = {1, -1, 0, 0};
        int ay[4] = {0, 0, 1, -1};
        
        for(int k =0; k<4; k++){
            int nx = i + ax[k];
            int ny = j + ay[k];
            
            if(isValid(nx, ny, n, m, grid)){
                dfs(nx, ny, n, m, grid);
            }
        }
    }
    
    int closedIsland(vector<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        
        // boundary DFS
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(i*j == 0 || i == n-1 || j==m-1){
                    // cout<<i<<" "<<j<<endl;
                    if(grid[i][j] == 0){
                        dfs(i, j, n, m, grid);
                    }
                }
            }
        }
        
        // call DFS in whole grid
        int ans = 0;
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(grid[i][j] == 0){
                    ans++;
                    dfs(i, j, n, m, grid);
                }
            }
        }
        
        return ans;
    }
    
};


================================================
FILE: Leetcode/Graph/Rotting Oranges.cpp
================================================
// https://leetcode.com/problems/rotting-oranges/

class Solution {
public:
    
    
    bool isValid(int i, int j, int n, int m, vector<vector<int>>& grid){
        if(i>=0 && i<n && j>=0 && j<m && grid[i][j] == 1){
            return true;
        }
        return false;
    }
    
    int orangesRotting(vector<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        
        int fresh = 0, time = 0;
        queue<pair<int, int>>q;
        
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(grid[i][j] == 2){
                    // push into queue
                    q.push({i, j});
                }
                else if(grid[i][j] == 1){
                    fresh++;
                }
            }
        }
        if(fresh == 0) return 0;
        
        // start BFS traversal
        while(!q.empty()){
            
            int size_q = q.size();
            int temp = 0;
            while(size_q != 0){
                
                pair<int, int>p = q.front();
                q.pop();
                
                int x1 = p.first;
                int y1 = p.second;
                
                int ax[4] = { 1, -1, 0, 0};
                int ay[4] = { 0, 0 , 1 , -1};
                
                for(int i=0; i<4; i++){
                    int x = ax[i] + x1;
                    int y = ay[i] + y1;
                    
                    if(isValid(x, y, n, m, grid)){
                        temp++;
                        grid[x][y] = 2;
                        q.push({x, y});
                    }
                }
                
                size_q--;
                
            }
            if(temp != 0) time++;
        }
        
        
        
        // we checked if any fresh oranges are still there
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(grid[i][j] == 1){
                    time = 0;
                    break;
                }
            }
        }
        
        
        
        return (time == 0) ? -1 : time ;
        
    }
};


================================================
FILE: Leetcode/Graph/Steps by Knight.cpp
================================================
// https://practice.geeksforgeeks.org/problems/steps-by-knight5927/1

class Solution 
{
    public:
    //Function to find out minimum steps Knight needs to reach target position.
    
    bool isValid(int i, int j, int n, vector<vector<bool>>&visited){
        if(i>=0 && i<n && j>=0 && j<n && visited[i][j] == false){
            return true;
        }
        return false;
    }
    
	int minStepToReachTarget(vector<int>&KnightPos,vector<int>&TargetPos,int N)
	{
	    // Code here
	    int n = N;
	    int tx = TargetPos[0]-1, ty = TargetPos[1]-1;
	    int x1 = KnightPos[0]-1, y1 = KnightPos[1]-1;
	    
	    if(x1 == tx && y1 == ty) return 0;
	    
	    vector<vector<bool>>visited(n, vector<bool>(n, false));
	    
	    queue<pair<int, int>>q;
	    q.push({x1, y1});
	    visited[x1][y1] = true;
	    
	    int ans = 0;
	    while(!q.empty()){
	        
	        int size = q.size();
	        ans++;
	        while(size != 0){
	            pair<int,int>p = q.front();
	            q.pop();
	            
	            int xx = p.first;
	            int yy = p.second;
	            
	            int ax[8] = {1, 1, -1, -1, 2, -2, 2, -2};
	            int ay[8] = {2, -2, 2, -2, 1, 1, -1, -1};
	            
	            for(int i=0; i<8; i++){
	                int nx = xx + ax[i];
	                int ny = yy + ay[i];
	                
	                if(nx == tx && ny == ty) return ans;
	                
	                if(isValid(nx, ny, n, visited)){
	                    visited[nx][ny] = true;
	                    q.push({nx, ny});
	                }
	            }
	           
	            size--;
	        }
	    }
	    
	    
	    return ans;
	    
	    
	}
};


================================================
FILE: Leetcode/Graph/Surrounded Regions.cpp
================================================
// https://leetcode.com/problems/surrounded-regions/

class Solution {
public:
    
    void convert(vector<vector<char>>& board){
        int n = board.size();
        int m = board[0].size();
        
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(board[i][j] == 'B'){
                    board[i][j] = 'O';
                }
                else if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
            }
        }
    }
    
    bool isValid(int i , int j, int n, int m, vector<vector<char>>& board){
        if(i>=0 && i<n && j>=0 && j<m && board[i][j] == 'O'){
            return true;
        }
        return false;
    }
    
    void dfs(vector<vector<char>>& board, int i , int j, int n, int m){
        board[i][j] = 'B';
        
        if(isValid(i+1, j, n, m, board)){
            dfs(board, i+1, j, n, m);
        }
        if(isValid(i-1, j, n, m, board)){
            dfs(board, i-1, j, n, m);
        }
        if(isValid(i, j+1, n, m, board)){
            dfs(board, i, j+1, n, m);
        }
        if(isValid(i, j-1, n, m, board)){
            dfs(board, i, j-1, n, m);
        }
    }
    
    void solve(vector<vector<char>>& board) {
        int n = board.size();
        int m = board[0].size();
        
        for(int i=0; i<n; i++){
            
            // left -> top bottom
            int j =0;
            if(board[i][j] == 'O'){
                dfs(board, i, j, n, m);
            }
            
            j = m-1;
            // right -> top bootm 
            if(board[i][j] == 'O'){
                dfs(board, i, j, n, m);
            }
        }
        
        for(int j=0; j<m; j++){
            
            // top -> left right
            int i =0;
            if(board[i][j] == 'O'){
                dfs(board, i, j, n, m);
            }
            
            i = n-1;
            // bottom -> left right
            if(board[i][j] == 'O'){
                dfs(board, i, j, n, m);
            }
        }
        
        convert(board);
    }
};


================================================
FILE: Leetcode/Graph/Time Needed to Inform All Employees.cpp
================================================
// https://leetcode.com/problems/time-needed-to-inform-all-employees/


class Solution {
public:
    
    unordered_map<int, vector<int>>umap;
    int ans =0 , mx= 0;
    
    void dfs(int manager, vector<int>& informTime){
        mx = max(mx, ans);
        for(auto employee : umap[manager]){
            ans += informTime[manager];
            
            dfs(employee, informTime);
            
            ans -= informTime[manager];
        }
        
    }
    
    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
        
        // Fill umap
        for(int i=0; i<n; i++){
            int val = manager[i];
            if(val != -1){
                umap[val].push_back(i);
            }
        }
        
        dfs(headID, informTime);
        return mx;
        
    }
};


================================================
FILE: Leetcode/Graph/Topological sort .cpp
================================================
// https://practice.geeksforgeeks.org/problems/topological-sort/1

class Solution
{
	public:
	//Function to return list containing vertices in Topological order. 
	vector<int> topoSort(int V, vector<int> adj[]) 
	{
	    // code here
	    vector<int> ans;
	    queue<int>q;
	    
	    vector<int> indegree(V, 0);
	    for(int i=0; i<V; i++){
	        vector<int> data = adj[i];
	        for(auto x: data){
	            indegree[x]++;
	        }
	    }
	    
	    for(int i=0; i<V; i++){
	        if(indegree[i] == 0)
	            q.push(i);
	    }
	    
	    while(! q.empty()){
	        int u = q.front();
	        q.pop();
	        ans.push_back(u);
	        
	        for(auto v: adj[u]){
	            indegree[v]--;
	            if(indegree[v] == 0)
	                q.push(v);
	        }
	    }
	    
	    return ans;
	}
};


================================================
FILE: Leetcode/Graph/Topological sort using dfs.cpp
================================================
// https://practice.geeksforgeeks.org/problems/topological-sort/1

#include <bits/stdc++.h>
using namespace std;

 // } Driver Code Ends
class Solution
{
	public:
	//Function to return list containing vertices in Topological order. 
	
	void DFSRec(int s, stack<int>&st, vector<bool>&visited, vector<int> adj[]){
	    visited[s] = true;
	    
	    vector<int>data = adj[s];
	    for(auto v: data){
	        if(!visited[v]){
	            DFSRec(v, st, visited, adj);
	        }
	    }
	    
	    st.push(s);
	}
	
	vector<int> topoSort(int V, vector<int> adj[]) 
	{
	    // code here
	    stack<int>st;
	    vector<bool>visited(V, false);
	    
	    for(int i=0; i<V; i++){
	        if(!visited[i]){
	            DFSRec(i, st, visited, adj);
	        }
	    }
	    
	    vector<int>ans;
	    while(!st.empty()){
	        int x = st.top();
	        st.pop();
	        ans.push_back(x);
	    }
	    
	    return ans;
	    
	}
};


================================================
FILE: Leetcode/Hashing/Check if two arrays are equal or not.cpp
================================================
// Question Link: https://practice.geeksforgeeks.org/problems/check-if-two-arrays-are-equal-or-not3847/1

class Solution{
    public:

    //Function to check if two arrays are equal or not.
    bool check(vector<ll> A, vector<ll> B, int n) {
        //code here
        unordered_map<ll,ll>umap;
        for(int i=0;i<n;i++)
            umap[A[i]]++;
        for(int i=0;i<n;i++){
            ll key = B[i];
            if(umap.find(key)!=umap.end()){
                auto itr = umap.find(key);
                
                if(itr->second>0)
                    itr->second--;
                else
                    return false;
                
            }else
                return false;
        }
        
        return true;
    }
};


================================================
FILE: Leetcode/Hashing/Custom Sort String.cpp
================================================
// https://leetcode.com/problems/custom-sort-string/

class Solution {
public:
    string customSortString(string order, string str) {
        map<char, int>mp;
        string ans = "";
        
        for(auto x: str)
            mp[x]++;
        for(auto x: order){
            if(mp.find(x)!=mp.end()){
                auto temp = mp.find(x);
                int count = temp->second;
                // c-> 5  || ccccc
                string s(count, x);
                ans+=s;
                mp.erase(x);
            }
        }
        
        for(auto x: mp){
            string s(x.second, x.first);
            ans+=s;
        }
        return ans;
    }
};


================================================
FILE: Leetcode/Hashing/First Repeating Element.cpp
================================================
// Question Link: https://practice.geeksforgeeks.org/problems/first-repeating-element4018/1

class Solution{
    public:
    //Function to return the position of the first repeating element.
    int firstRepeated(int arr[], int n) {
        //code here
        unordered_map<int,int> umap;
        for(int i=0;i<n;i++)
            umap[arr[i]]++;
        for(int i=0;i<n;i++){
            int key = arr[i];
            
            auto temp = umap.find(key); 
            int val= temp->second;
            if(val >1)
                return i+1;
        }
        
        return -1;
    }
};


================================================
FILE: Leetcode/Hashing/Group Anagrams.cpp
================================================
// https://leetcode.com/problems/group-anagrams/

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> ans;
        unordered_map<string, vector<string>>umap;
        
        for(auto x: strs){
            string temp = x;
            sort(x.begin(), x.end());
            umap[x].push_back(temp);
        }
      
        for(auto x : umap){
            ans.push_back(x.second);
        }
        return ans;
        
    }
};


================================================
FILE: Leetcode/Hashing/Intersection of two arrays.cpp
================================================
// Question Link: https://practice.geeksforgeeks.org/problems/intersection-of-two-arrays2404/1

int NumberofElementsInIntersection (int a[], int b[], int n, int m )
{
    // Your code goes here
    unordered_set<int>s;
    for(int i=0;i<n;i++)    
        s.insert(a[i]);
    
    int count=0;
    for(int i=0;i<m;i++){
        int key = b[i];
        if(s.find(key)!=s.end()){
            count++;
            s.erase(key);
        }
    }
    return count;
}


================================================
FILE: Leetcode/Hashing/Key Pair.cpp
================================================
// Problem Link: https://practice.geeksforgeeks.org/problems/key-pair5616/1

class Solution{
public:	
	// Function to check if array has 2 elements
	// whose sum is equal to the given value
	bool hasArrayTwoCandidates(int arr[], int n, int x) {
	    // code here
	    unordered_map<int,int> umap;
	    for(int i=0;i<n;i++)
	        umap[arr[i]]++;
	    for(auto itr = umap.begin(); itr!=umap.end(); itr++){
	        int key = itr->first;
	        int val = itr->second;
	        
	        int pair = x-key;
	        if(pair==key){
	            if(val>1)
	                return true;
	        }else{
	            if(umap.find(pair)!=umap.end())
	                return true;
	        }
	    }
	    
	    return false;
	}
};


================================================
FILE: Leetcode/Hashing/LFU Cache.cpp
================================================
/* https://leetcode.com/problems/lfu-cache/ */

class LFUCache {
public:
    int capacity, minFreq;
    unordered_map<int, pair<int, int>>keyVal;
    unordered_map<int, list<int>> freqList;
    unordered_map<int, list<int>::iterator > pos;

    void updateFreq(int key){
        // update the Frequency  
        // -- delete key from curr_freq 
        // -- increment freq 
        // -- insert key in new freq
        // -- update new pos of key
        // -- check for minFreq 
        int curr_freq = keyVal[key].second; 
        freqList[curr_freq].erase(pos[key]);

        keyVal[key].second++;
        curr_freq = keyVal[key].second;

        freqList[curr_freq].push_back(key);

        pos[key] = --freqList[curr_freq].end();

        if(freqList[minFreq].empty()){
            minFreq++;
        }
    }

    LFUCache(int capacity) {
        this->capacity = capacity;
        minFreq = 0;
    }
    int get(int key) {
        if(keyVal.find(key) == keyVal.end()){
            return -1;
        }
        updateFreq(key);
        return keyVal[key].first;
    }
    
    void put(int key, int value) {
        if(capacity == 0) return;
        if(keyVal.find(key) != keyVal.end()){
            // update Case
            keyVal[key].first = value;
            updateFreq(key);
            return;
        }
        if(keyVal.size() == capacity){
            // Find the LRU;
            int delKey = freqList[minFreq].front();
            keyVal.erase(delKey);
            pos.erase(delKey);
            freqList[minFreq].pop_front();
        }
        keyVal[key] = {value, 1};
        freqList[1].push_back(key);
        pos[key] = --freqList[1].end();
        minFreq = 1;
    }
};

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache* obj = new LFUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */


================================================
FILE: Leetcode/Hashing/Non-Repeating Element.cpp
================================================
// Question Link: https://practice.geeksforgeeks.org/problems/non-repeating-element3958/1


class Solution{
    public:
    int firstNonRepeating(int arr[], int n) 
    { 
        // Complete the function
        unordered_map<int, int> umap;
        for(int i=0;i<n;i++)
            umap[arr[i]]++;
        
        // int key = arr[i];
        // umap[key]++;
        
        for(int i=0;i<n;i++){
            int key = arr[i];
            auto temp = umap.find(key);
            if(temp->second ==1)
                return key;
        }
        
        return 0;
    } 
  
};


================================================
FILE: Leetcode/Hashing/Pairs with Positive Negative values.cpp
================================================
// https://practice.geeksforgeeks.org/problems/pairs-with-positive-negative-values3719/1


class Solution{
  public:
    vector<int> PosNegPair(int a[], int n) {
        vector<int>v, ans;
        map<int,int>mp;
        
        for(int i=0;i<n;i++){
            if(a[i]<0)
                v.push_back(a[i]);
            else
                mp[a[i]]++;
        }
        
        sort(v.begin(), v.end());
        
        for(int i=(int)v.size()-1; i>=0 ; i--){
            int data = abs(v[i]);
            if(mp[data]>0){
                ans.push_back(v[i]);
                ans.push_back(data);
                mp[data]-=1;
            }
        }
        return ans;
    }
};


================================================
FILE: Leetcode/Hashing/Relative Sort Array.cpp
================================================
// https://leetcode.com/problems/relative-sort-array/

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        vector<int> ans;
        
        map<int, int>mp;
        for(auto x: arr1)
            mp[x]++;
        for(auto temp :  arr2){
            if(mp.find(temp)!=mp.end()){
                auto x  = mp.find(temp);
                int count = x->second;  // 5->2
                vector<int>v(count, temp); // v = 5 5 
                ans.insert(ans.end(), v.begin(), v.end());
                mp.erase(temp);
            }
        }
        
        for(auto x : mp){
            int ele = x.first;
            int count = x.second;
            vector<int>v(count, ele);
            ans.insert(ans.end(), v.begin(), v.end());
        }
        
        return ans;
    }
};


================================================
FILE: Leetcode/Hashing/Sort Array by Increasing Frequency.cpp
================================================
// https://leetcode.com/problems/sort-array-by-increasing-frequency/

class Solution {
public:
    vector<int> frequencySort(vector<int>& nums) {
        unordered_map<int, int>umap;
        for(auto x: nums){
            umap[x]++;
        }
        
        sort(nums.begin(), nums.end() , [&](int a , int b) 
             { return  umap[a] != umap[b] ? umap[a] < umap[b] :  a > b ; } );
        
        return nums;
    }
};


================================================
FILE: Leetcode/Hashing/Subarray with 0 sum.cpp
================================================
// Link: https://practice.geeksforgeeks.org/problems/subarray-with-0-sum-1587115621/1

class Solution{
    public:
    //Complete this function
    //Function to check whether there is a subarray present with 0-sum or not.
    bool subArrayExists(int arr[], int n)
    {
        //Your code here
        unordered_set<int>s;
        int pre_sum=0;
        for(int i=0;i<n;i++){
            pre_sum += arr[i];
            
            if(pre_sum == 0)
                return true;
            if(s.find(pre_sum)!=s.end())
                return true;
            
            s.insert(pre_sum);
        }
        return false;
    }
};


================================================
FILE: Leetcode/Hashing/Winner of an election.cpp
================================================
//  https://practice.geeksforgeeks.org/problems/winner-of-an-election-where-votes-are-represented-as-candidate-names-1587115621/1

class Solution{
  public:
  
    //Function to return the name of candidate that received maximum votes.
    vector<string> winner(string arr[],int n)
    {
        // Your code here
        // Return the string containing the name and an integer
        // representing the number of votes the winning candidate got
        
        unordered_map<string , int>umap;
        for(int i=0;i<n;i++){
            umap[arr[i]]++;
        }
        
        string name = "";
        int max_vote = 0;
        
        for(auto itr = umap.begin(); itr!=umap.end(); itr++){
            string key = itr->first;
            int val = itr->second;
            
            if(val>max_vote){
                max_vote = val;
                name = key;
            }
            else if(val == max_vote){
                if(key<name)
                    name = key;
            }
        }
        
        vector<string> ans;
        ans.push_back(name);
        string temp = to_string(max_vote);
        ans.push_back(temp);
        
        return ans;
    }  
};


================================================
FILE: Leetcode/Hashing/unordered_map.cpp
================================================
#include<bits/stdc++.h>
#include<unordered_map>

using namespace std;
int main(){
    unordered_map<string,int> umap;
    umap["prince"] = 44;
    umap["gfg"] = 56;
    umap["helloworld"] = 90;

    for(auto x : umap)
        cout<<x.first<<" "<<x.second<<endl;

    

    string key = "prince";
    
    if(umap.find(key) != umap.end())
        cout<<"key found"<<endl;
    else 
        cout<<"key not found"<<endl;

    if(umap.find(key) != umap.end()){
        auto temp = umap.find(key);
        cout<<"key is : "<<temp->first<<endl;
        cout<<"value is : "<<temp->second<<endl;
    }

    umap.insert(make_pair("mobile", 17000));

    key = "helloworld";
    umap.erase(key);

    for(auto itr = umap.begin() ; itr!=umap.end() ; itr++)
        cout<<itr->first<<" "<<itr->second<<endl;

    cout<<umap.size()<<endl;


    int arr[] = {7, 1, 0, 3, 5, 0, 1, 3, 2, 5, 7, 3, 8, 9, 9};
    unordered_map<int,int> umaped;

    for(int i=0;i<15;i++){
        int key = arr[i];
        umaped[key]++;
    }


    for(auto itr = umaped.begin() ; itr!=umaped.end() ; itr++)
        cout<<itr->first<<" "<<itr->second<<endl;
}


================================================
FILE: Leetcode/Hashing/unordered_set.cpp
================================================
#include<bits/stdc++.h>
#include<unordered_set>

using namespace std;
int main(){

    unordered_set<int> s;
    s.insert(10);
    s.insert(5);
    s.insert(15);
    s.insert(20);
    
    for(auto it = s.begin() ; it!=s.end() ;it++)
        cout<<(*it)<<endl;
    
    cout<<"number of element : "<<s.size()<<endl;

    s.clear();
    cout<<"number of element : "<<s.size()<<endl;


    int key = 20;

    if(s.find(key) == s.end()){
        cout<<"key not found"<<endl;
    }else{
        
        auto temp = s.find(key);
        s.erase(temp);

    }

    int deleted_key = 25;
    s.erase(deleted_key);

    for(auto it = s.begin() ; it!=s.end() ;it++)
        cout<<(*it)<<endl;

    cout<<"number of element : "<<s.size()<<endl;


    if(s.find(key)!=s.end())
        cout<<"key found"<<endl;


    if(s.count(5))
        cout<<"key found"<<endl;
    else
        cout<<"not found"<<endl;
}


================================================
FILE: Leetcode/Interchanging the rows of a Matrix.cpp
================================================
// problems: https://practice.geeksforgeeks.org/problems/reversing-the-rows-of-a-matrix-1587115621/1/?track=DSASP-Matrix&batchId=154


void interchangeRows(vector<vector<int> > &matrix)
    {
        // code here
        int row = matrix.size();
        int col = matrix[0].size();
        
        for(int i=0;i<(row/2);i++){
            for(int j=0;j<col;j++)
                swap(matrix[i][j], matrix[row-1-i][j]);
        }
    }


================================================
FILE: Leetcode/Majority Element Geeksforgeeks leetcode Moore's Voting Algorithm.cpp
================================================
// https://practice.geeksforgeeks.org/problems/majority-element/0


#include<bits/stdc++.h>
using namespace std;

// Function to find majority element in the array
int majorityElement(int arr[], int n)
{
    int count=1; int res=0;
    for(int i=1; i<n; i++){
        if(arr[res] == arr[i])
            count++;
        else
            count--;
            
        if(count==0){
            count=1;
            res=i;
        }
    }
    
    //2nd   res 
    count=0;
    for(int i=0;i<n;i++){
        if(arr[res]==arr[i])
            count++;
    }
    
    if(count <= (n/2))
        return -1;
    else
        return arr[res];
}

int main(){

    int t;
    cin >> t;

    while(t--){
        int n;
        cin >> n;
        int arr[n];
        
        for(int i = 0;i<n;i++){
            cin >> arr[i];
        }
        
        cout << majorityElement(arr, n) << endl;
    }

    return 0;
}


================================================
FILE: Leetcode/Median of Two sorted arrays.cpp
================================================
// https://practice.geeksforgeeks.org/problems/median-of-two-sorted-arrays1618/1/?track=DSASP-Searching&batchId=154


// arr : given array with size n 
// brr : given array with size m
int findMedian(int arr[], int n, int brr[], int m){
    // code here
    int begin1 = 0 ; int end1 = n;
    while(begin1<=end1){
        int i1 = (begin1+end1)/2;
        int i2 = (n+m+1)/2 - i1;
        
        int min1 = (i1==n) ? INT_MAX : arr[i1];
        int max1 = (i1==0) ? INT_MIN : arr[i1-1];
        
        int min2 = (i2==m) ? INT_MAX : brr[i2];
        int max2 = (i2==0) ? INT_MIN : brr[i2-1];
        
        if((max1<=min2) && (max2<=min1) ){
            if((n+m)%2==0){
                return ((double) (max(max1,max2) + min(min1, min2)) / 2) ;
            }else{
                return ((double) max(max1, max2));
            }
        }
        else if(max1>min2){
            end1 = i1-1;
        }else{
            begin1 = i1+1;
        }
    }
}


================================================
FILE: Leetcode/Middle of the Linked List Leetcode.cpp
================================================
// https://leetcode.com/problems/middle-of-the-linked-list/


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    
    int size(ListNode* head){
        int n=0;
        while(head != NULL){
            n++;
            head = head->next;
        }
        return n;
    }
    
    ListNode* middleNode(ListNode* head) {
        int n  = size(head);
        
        n = (n/2) + 1;
        
        int i=0;
        while(head != NULL){
            i++;
            if(i==n)
                return head;
            head = head->next;
        }
        
        return head;
    }
};


================================================
FILE: Leetcode/Middle of the Linked List.cpp
================================================
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        
        vector<ListNode*> v = {head};
        while(v.back()->next!=NULL){
            v.push_back(v.back()->next);
        }
        return v[(int)v.size()/2];
        
        
        
//       int count=0;
//         ListNode* temp = head;
//         while(temp!=NULL){
//             count++;
//             temp = temp->next;
//         }
        
//         count/=2;
//         int i=0;
//         ListNode* ans;
        
//         while(i<=count){
//             ans = head;
//             head = head->next;
//             i++;
//         }
        
//         return ans;
    }
};


================================================
FILE: Leetcode/Move Zeroes.cpp
================================================
// https://leetcode.com/problems/move-zeroes/

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        
        int n = nums.size();
        int j=0;
        
        for(int i=0; i<n; i++){
            if(nums[i]!=0){
                nums[j] = nums[i];
                j++;
            }
        }
        
        for(; j<n; j++){
            nums[j] = 0;
        }
    }
};


================================================
FILE: Leetcode/Multiply two matrices.cpp
================================================
// Problem link: https://practice.geeksforgeeks.org/problems/multiply-the-matrices-1587115620/1

vector<vector<int> > multiplyMatrix( const vector<vector<int> >& A, const vector<vector<int> >& B)
    {
        // code here
        int n1,m1, n2, m2;
        n1 = A.size();
        n2 = B.size();
        
        //col
        m1 = A[0].size();
        m2 = B[0].size();
        vector<vector<int>> ans;

        if(m1 == n2){
            for(int i=0;i<n1;i++){
                vector<int> temp;
                
                for(int j=0; j<m2;j++){
                    int sum=0;
                    for(int k=0;k<m1;k++){
                        sum = sum + (A[i][k] * B[k][j]);
                    }
                    temp.push_back(sum);
                }
                ans.push_back(temp);
            }
        }
        
        return ans;
    }


================================================
FILE: Leetcode/Naive Pattern Search.cpp
================================================
GFG : https://practice.geeksforgeeks.org/problems/naive-pattern-search-1587115620/1/
Leetcode : https://leetcode.com/problems/implement-strstr/


bool search(string pat, string txt) 
{ 
	
	// Your code here
	int m = txt.size();
	int n = pat.size();
	
	for(int i=0; i<=(m-n) ;i++){
	    
	    bool isBool = true;
	    for(int j=0; j<n ;j++){
	        if(pat[j]!=txt[j+i]){
	            isBool = false;
	            break;
	        }
	    }
	    
	    if(isBool){
	        return true;
	    }
	    
	}
	
	return false;
}


================================================
FILE: Leetcode/Next Greater Element.cpp
================================================
// https://practice.geeksforgeeks.org/problems/next-larger-element-1587115620/1


{
    public:
    //Function to find the next greater element for each element of the array.
    vector<long long> nextLargerElement(vector<long long> arr, int n){
        // Your code here
        stack<long long> st;
        vector<long long>ans;
        
        ans.push_back(-1);
        st.push(arr[n-1]);
        
        for(long long i= n-2; i>=0; i--){
            
            while(!st.empty() && st.top() <= arr[i])
                st.pop();
                
            long long next = (st.empty()) ? -1 : st.top();
            ans.push_back(next);
            st.push(arr[i]);
        }
        
        reverse(ans.begin(), ans.end());
        return ans;
    }
};


================================================
FILE: Leetcode/Non Repeating Character.cpp
================================================
// Complete this function
char nonrepeatingCharacter(string s)
{
   int chars = 256;
   int n = s.size();
   
   int arr[chars];
   fill(arr, arr+chars, 0);
   
   for(int i=0;i<n;i++){
       arr[s[i]]++;
   }
   
   // 1 1 2 1
   
   for(int i=0;i<n;i++){
       if(arr[s[i]] == 1)
            return (char)s[i];
   }
   
   return '$';
   
}


================================================
FILE: Leetcode/Peak element.cpp
================================================
// https://practice.geeksforgeeks.org/problems/peak-element/1

int peakElement(int arr[], int n)
{
   // Your code here
   int low = 0;
   int high = n-1;
   
   while(low<=high){
       int mid = (low+high)/2;
       
       if(
          (mid==0 || arr[mid]>=arr[mid-1]) &&
          (mid == n-1 || arr[mid]>=arr[mid+1])
         ){
             return mid;
         }
        else if(arr[mid]<=arr[mid+1]){
            low = mid+1;
        }else{
            high = mid-1;
        }
   }
   
   return -1;
}


================================================
FILE: Leetcode/Rearrange Array Alternately Geeksforgeeks.cpp
================================================
// https://practice.geeksforgeeks.org/problems/-rearrange-array-alternately/0

#include <iostream>
using namespace std;

void rearrange(long long int arr[], int n){
    int max_index = n-1;
    int min_index = 0;
    int max = arr[n-1]+1;
    
    for(int i=0;i<n;i++){
        if(i%2==0){
            arr[i] = ( arr[max_index]%max ) * max + arr[i];
            max_index--;
        }else{
            arr[i] = ( arr[min_index]%max ) * max + arr[i];
            min_index++;
        }
    }
    
    for(int i=0;i<n;i++){
        arr[i]/=max; // arr[i] = arr[i]/max;
    }
}

int main() 
{
    int t;
    
    //testcases
    cin >> t;
    
    while(t--){
        
        //size of array
        int n;
        cin >> n;
        
        long long int arr[n];
        
        //adding elements to the array
        for(int i = 0;i<n;i++){
            cin >> arr[i];
        }
        
        //calling rearrange() function
        rearrange(arr, n);
        
        //printing the elements
        for (int i = 0; i < n; i++) 
		    cout << arr[i] << " ";
		
		cout << endl;
    }
	return 0; 
}


================================================
FILE: Leetcode/Recursion/0-1 Knapsack Problem Top down.cpp
================================================
// https://practice.geeksforgeeks.org/problems/0-1-knapsack-problem0945/1

class Solution
{
    public:
    //Function to return max value that can be put in knapsack of capacity W.
    int knapSack(int W, int wt[], int val[], int n) 
    {
       // Your code here
       vector<vector<int>>dp(n+1, vector<int>(W+1, -1));
       for(int i=0; i<=n; i++){
           dp[i][0] = 0;
       }
       for(int i=0; i<=W; i++){
           dp[0][i] = 0;
       }
       
       for(int i=1; i<=n; i++){
           for(int j=1; j<=W; j++){
               if(wt[i-1] <= j){
                   dp[i][j] = max( val[i-1] + dp[i-1][j-wt[i-1]], 
                                   dp[i-1][j]    );
               }else{
                   dp[i][j] = dp[i-1][j];
               }
           }
       }
       
       return dp[n][W];
    }
};


================================================
FILE: Leetcode/Recursion/Best Time to Buy and Sell Stock.cpp
================================================
// https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int i=1, profit = 0, min_price = prices[0], n = prices.size();
        while(i<n){
            if(prices[i] < min_price){
                min_price = prices[i];
            }else{
                profit = max(profit, prices[i]-min_price);
            }
            i++;
        }
        return profit;
    }
};


================================================
FILE: Leetcode/Recursion/Climbing Stairs.cpp
================================================
// https://leetcode.com/problems/climbing-stairs/

vector<int>dp(46, -1);
class Solution {
public:
    int climbStairs(int n) {
        if(dp[n] != -1) return dp[n];
        if(n<=2){
            return dp[n] = n;
        }
        return dp[n] = climbStairs(n-1) + climbStairs(n-2);
    }
};


================================================
FILE: Leetcode/Recursion/Decode Ways.cpp
================================================
// https://leetcode.com/problems/decode-ways/

vector<int>dp(101, -1);
class Solution {
public:
    int n = 0;
    int numDecodingsHelper(string s, int pos){
        if(pos == n) return 1;
        if(s[pos] == '0') return 0;
        
        if(dp[pos] != -1) return dp[pos];

        int count = numDecodingsHelper(s , pos+1);
        if(pos < n-1 && s.substr(pos, 2) < "27"){
            count += numDecodingsHelper(s, pos+2);
        }
        return dp[pos] = count;
    }
    int numDecodings(string s) {
        n = s.size();
        fill(dp.begin(), dp.end(), -1);
        return numDecodingsHelper(s, 0);
    }
};


================================================
FILE: Leetcode/Recursion/Delete middle element of a stack.cpp
================================================
// https://practice.geeksforgeeks.org/problems/delete-middle-element-of-a-stack/1

class Solution
{
    public:
    //Function to delete middle element of a stack.
    
    void deleteMidHelper(stack<int>&st, int count, int &pos){
        if(st.empty()) return;
        if(count == pos) {st.pop(); return;}
        
        int top = st.top(); st.pop();
        deleteMidHelper(st, count+1, pos);
        
        st.push(top);
    }
    
    void deleteMid(stack<int>&s, int sizeOfStack)
    {
        // code here.. 
        int pos = ceil((sizeOfStack+1)/2.0);
        deleteMidHelper(s, 1, pos);
        
    }
};


================================================
FILE: Leetcode/Recursion/Divisor Game.cpp
================================================
// https://leetcode.com/problems/divisor-game/

class Solution {
public:
    bool divisorGame(int n) {
        // if(n<=1) return false;
        // for(int x=1; x<n; x++){
        //     if(n%x==0){
        //         return !divisorGame(n-x);
        //     }
        // }
        // return false;

        if(n%2==0)return true;
        return false;
    }
};


================================================
FILE: Leetcode/Recursion/Factorial.cpp
================================================
// https://practice.geeksforgeeks.org/problems/factorial5739/1

class Solution{
public:
    long long int factorial(int N){
        //code here
        if(N<=1) return 1;
        return N * factorial(N-1);
    }
};


================================================
FILE: Leetcode/Recursion/Fibonacci Number.cpp
================================================
// https://leetcode.com/problems/fibonacci-number/

class Solution {
public:
    int fib(int n) {
        if(n<=1) return n;
        return fib(n-1)+fib(n-2);
    }
};


================================================
FILE: Leetcode/Recursion/House Robber.cpp
================================================
// https://leetcode.com/problems/house-robber/

vector<int>dp(101, -1);
class Solution {
public:
    int fun(vector<int>& nums, int n){
        if(n<=0) return 0;
        if(dp[n] != -1) return dp[n];
        return dp[n] = max(
            fun(nums, n-1),
            nums[n-1] + fun(nums, n-2)
        );
    }
    int rob(vector<int>& nums) {
        int n = nums.size();
        fill(dp.begin(), dp.end(), -1);
        return fun(nums, n);
    }
};


================================================
FILE: Leetcode/Recursion/Largest Element in Array.cpp
================================================
// https://practice.geeksforgeeks.org/problems/largest-element-in-array4009/1

class Solution
{
public:
    int largest(vector<int> &arr, int n)
    {
        if(n==1) return arr[0];
        return max( largest(arr, n-1), arr[n-1] );
    }
};


================================================
FILE: Leetcode/Recursion/Min Cost Climbing Stairs.cpp
================================================
// https://leetcode.com/problems/min-cost-climbing-stairs/

vector<int>dp(1001, -1);
class Solution {
public:

    int minCost(vector<int>& cost, int n){
        if(dp[n] != -1) return dp[n];
        if(n<=1) return dp[n] = 0;
        if(n==2) return dp[n] =  min(cost[0], cost[1]);
        return dp[n] =  min( minCost(cost, n-1) + cost[n-1],
                    minCost(cost, n-2) + cost[n-2] );
    }
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        fill(dp.begin(), dp.end(), -1);
        return minCost(cost, n);
    }
};


================================================
FILE: Leetcode/Recursion/Nth Fibonacci Number.cpp
================================================
// https://practice.geeksforgeeks.org/problems/nth-fibonacci-number1335/1

vector<long long int>dp(1001, -1);
class Solution {
  public:
    int mod = 1000000007;
    long long int nthFibonacci(long long int n){
        if(dp[n] != -1) return dp[n];
        // code here
        if(n<=1){
            return dp[n] = n;
        };
        return dp[n] = (nthFibonacci(n-1)%mod + nthFibonacci(n-2)%mod)%mod;
    }
};


================================================
FILE: Leetcode/Recursion/Partition Equal Subset Sum.cpp
================================================
// https://leetcode.com/problems/partition-equal-subset-sum/

/****************************** RECURSION *************************************************/
/****************************** TIME LIMIT EXCEEDED *************************************************/

class Solution {
public:

    bool subsetSum(vector<int>& nums, int n, int sum){
        if(n==0) return false;
        if(sum==0) return true;
        if(nums[n-1] <= sum){
            return subsetSum(nums, n-1, sum-nums[n-1]) || subsetSum(nums, n-1, sum);
        }else{
            return subsetSum(nums, n-1, sum);
        }
    }
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        int sum = 0;
        for(auto x: nums){
            sum += x;
        }
        if(sum%2 != 0) return false;
        
        sum = sum/2;
        return subsetSum(nums, n, sum);
    }
};




/****************************** MEMOIZATION *************************************************/
class Solution {
public:

    bool subsetSum(vector<int>& nums, int n, int sum, vector<vector<int>>&dp){
        if(dp[n][sum] != -1) return dp[n][sum];
        if(nums[n-1] <= sum){
            return dp[n][sum] = subsetSum(nums, n-1, sum-nums[n-1], dp) || subsetSum(nums, n-1, sum, dp);
        }else{
            return dp[n][sum] = subsetSum(nums, n-1, sum, dp);
        }
    }
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        int sum = 0;
        for(auto x: nums){
            sum += x;
        }
        if(sum%2 != 0) return false;
        
        sum = sum/2;
        vector<vector<int>>dp(n+1, vector<int>(sum+1, -1));
        for(int i=0; i<=sum; i++){
            dp[0][i] = false;
        }
        for(int i=0; i<=n; i++){
            dp[i][0] = true;
        }
        return subsetSum(nums, n, sum, dp);
    }
};




/****************************** TOP DOWN *************************************************/

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0, n = nums.size();
        for(auto x: nums) sum += x;
        if(sum % 2 != 0) return false; 
        sum /= 2;
        vector<vector<bool>>t(n+1, vector<bool>(sum+1, false));
        for(int i=0; i<n+1; i++){t[i][0] = true;}
        for(int i=1; i<n+1; i++){
            for(int j=1; j<sum+1; j++){
                if(nums[i-1]<=j){
                    t[i][j] = ( t[i-1][j-nums[i-1]] || t[i-1][j] );
                }else{
                    t[i][j] = t[i-1][j];
                }
            }
        }
        return t[n][sum];
    }
};


================================================
FILE: Leetcode/Recursion/Perfect Squares.cpp
================================================
// https://leetcode.com/problems/perfect-squares/

vector<int>dp(10001, -1);
class Solution {
public:
    int solve(int n){
        if(n<=0) return 0;
        int ans = INT_MAX;
        if(dp[n] != -1) return dp[n];

        for(int i=1; i*i<=n; i++){
            int sqnum = i*i;
            int count = 1+ solve(n-sqnum);
            ans = min(ans, count);
        }
        return dp[n] = ans;
    }
    int numSquares(int n) {
        return solve(n);
    }
};


================================================
FILE: Leetcode/Recursion/Perfect Sum Problem.cpp
================================================
// https://practice.geeksforgeeks.org/problems/perfect-sum-problem5633/1


/****************************** RECURSION *************************************************/
/****************************** TIME LIMIT EXCEEDED *************************************************/

class Solution{

	public:
	int mod = 1e9+7;  // 1000000007
	int countSubset(int arr[], int n, int sum){
	    if(n==0 and sum > 0) return 0;
	    else if(n==1){
	        if(sum==0){
	            if(arr[0] == 0) return 2;
	            else return 1;
	        }else{
	            if(arr[0] == sum) return 1;
	            else return 0;
	        }
	    }
	    else if(n==0 and sum==0) return 1;
	    
	    if(arr[n-1] <= sum){
	        return countSubset(arr,n-1, sum-arr[n-1]) + countSubset(arr, n-1, sum);
	    }else
	        return countSubset(arr, n-1, sum);
	}
	int perfectSum(int arr[], int n, int sum)
	{
        // Your code goes here
        return countSubset(arr, n, sum);
        
	}
	  
};


/****************************** MEMOIZATION *************************************************/

class Solution{

	public:
	int mod = 1e9+7;  // 1000000007
	int countSubset(int arr[], int n, int sum, vector<vector<int>>&dp){
	    if(dp[n][sum] != -1) return dp[n][sum];
	    if(n==0 and sum > 0) return 0;
	    else if(n==1){
	        if(sum==0){
	            if(arr[0] == 0) return 2;
	            else return 1;
	        }else{
	            if(arr[0] == sum) return 1;
	            else return 0;
	        }
	    }
	    else if(n==0 and sum==0) return 1;
	    
	    int ans = countSubset(arr, n-1, sum, dp) % mod;
	    if(arr[n-1] <= sum){
	        ans+=countSubset(arr,n-1, sum-arr[n-1], dp);
	        ans %= mod;
	    }
	    return dp[n][sum] = ans;
	}
	int perfectSum(int arr[], int n, int sum)
	{
        // Your code goes here
        vector<vector<int>>dp(n+1, vector<int>(sum+1, -1));
        return countSubset(arr, n, sum, dp) % mod;
        
	}
	  
};


================================================
FILE: Leetcode/Recursion/Power Of Numbers.cpp
================================================
// https://practice.geeksforgeeks.org/problems/power-of-numbers-1587115620/1

class Solution{
    public:
    //You need to complete this fucntion
    
    long long power(int N,int R)
    {
        int MOD = 1e9+7;
       //Your code here
       if(N==0) return 0;
       if(R==0) return 1;
       if(R%2==0){
           long long ans = power(N, R/2);
           return ( ans%MOD * ans%MOD  )%MOD;
       }else{
           long long ans = power(N, (R-1)/2);
           return ( ans%MOD * ans%MOD * N%MOD)%MOD;
       }
    }

};


================================================
FILE: Leetcode/Recursion/Print 1 To N Without Loop.cpp
================================================
// https://practice.geeksforgeeks.org/problems/print-1-to-n-without-using-loops-1587115620/1

class Solution{
    public:
    //Complete this function
    void printNos(int N)
    {
        //Your code here
        if(N==0) return;
        printNos(N-1);
        cout<<N<<" ";
    }
};


================================================
FILE: Leetcode/Recursion/Reverse a String.cpp
================================================
// https://practice.geeksforgeeks.org/problems/reverse-a-string/1

string reverseWord(string str){
    
  //Your code here
  if(str.size() == 0 || str.size()== 1) return str;
  return reverseWord(str.substr(1)) + str[0];
}


================================================
FILE: Leetcode/Recursion/Subset Sum Problem.cpp
================================================
// https://practice.geeksforgeeks.org/problems/subset-sum-problem-1611555638/1

/****************************** RECURSION *************************************************/
/****************************** TIME LIMIT EXCEEDED *************************************************/

class Solution{   
public:
    bool subsetSum(vector<int>arr, int n, int sum){
        if(n==0) return false;
        if(sum==0) return true;
        if(arr[n-1] <= sum){
            return subsetSum(arr, n-1, sum-arr[n-1]) || subsetSum(arr, n-1, sum);
        }else{
            return subsetSum(arr, n-1, sum);
        }
    }
    bool isSubsetSum(vector<int>arr, int sum){
        // code here
        int n = arr.size();
        return subsetSum(arr, n, sum);
    }
};



/****************************** MEMOIZATION *************************************************/
class Solution{   
public:
    bool subsetSum(vector<int>arr, int n, int sum, vector<vector<int>>&dp){
        if(dp[n][sum] != -1) return dp[n][sum];
        if(arr[n-1] <= sum){
            return dp[n][sum] = subsetSum(arr, n-1, sum-arr[n-1], dp) || subsetSum(arr, n-1, sum, dp);
        }else{
            return dp[n][sum] = subsetSum(arr, n-1, sum, dp);
        }
    }
    bool isSubsetSum(vector<int>arr, int sum){
        // code here
        int n = arr.size();
        vector<vector<int>>dp(n+1, vector<int>(sum+1, -1));
        for(int i=0; i<=sum; i++){
            dp[0][i] = false;
        }
        for(int i=0; i<=n; i++){
            dp[i][0] = true;
        }
        return subsetSum(arr, n, sum, dp);
    }
};


================================================
FILE: Leetcode/Recursion/Sum of Array.cpp
================================================
// https://practice.geeksforgeeks.org/problems/sum-of-array2326/1

class Solution{
public:
	// function to return sum of elements
	// in an array of size n
	int sum(int arr[], int n) {
	    // code here
	    if(n == 0) return 0;
	    return arr[n-1] + sum(arr, n-1);
	}
};


================================================
FILE: Leetcode/Recursion/Target Sum.cpp
================================================
// https://leetcode.com/problems/target-sum/

class Solution {
public:

		int countSubset(vector<int>& nums, int n, int sum, vector<vector<int>>&dp){
	    if(dp[n][sum] != -1) return dp[n][sum];
	    if(n==0 and sum > 0) return 0;
	    else if(n==1){
	        if(sum==0){
	            if(nums[0] == 0) return 2;
	            else return 1;
	        }else{
	            if(nums[0] == sum) return 1;
	            else return 0;
	        }
	    }
	    else if(n==0 and sum==0) return 1;
	    
	    int ans = countSubset(nums, n-1, sum, dp);
	    if(nums[n-1] <= sum){
	        ans+=countSubset(nums,n-1, sum-nums[n-1], dp);
	    }
	    return dp[n][sum] = ans;
	}
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
				int sum = 0;
				for(auto x: nums) {sum += x;}
				if(sum < abs(target) || (target + sum) % 2 !=0 ) return 0;
				
				sum = (sum+target)/2;
				vector<vector<int>>dp(n+1, vector<int>(sum+1, -1));
        return countSubset(nums, n, sum, dp);
    }
};


================================================
FILE: Leetcode/Recursion/Tower Of Hanoi.cpp
================================================
// https://practice.geeksforgeeks.org/problems/tower-of-hanoi-1587115621/1

class Solution{
    public:
    // You need to complete this function

    // avoid space at the starting of the string in "move disk....."
    long long count = 0;
    void TOHHelper(int N, int from, int to, int aux){
        if(N>0){
            TOHHelper(N-1, from, aux, to);
            cout << "move disk " << N << " from rod " << from << " to rod " << to << endl;
            count++;
            TOHHelper(N-1, aux, to, from);
        }
    } 
    long long toh(int N, int from, int to, int aux) {
        // Your code here
        TOHHelper(N, from, to , aux);
        return count;
    }

};


================================================
FILE: Leetcode/Reverse Linked List.cpp
================================================
// https://leetcode.com/problems/reverse-linked-list/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* new_head = NULL;
         
        while( head != NULL){
             ListNode* temp = head;
             head = head->next;
             temp->next = new_head;
             new_head = temp;
        }
        
        return new_head;
    }
};


================================================
FILE: Leetcode/Rotate Array Leetcode.cpp
================================================
class Solution {
public:
    
    void reverse(vector<int> &num, int low, int high){
        while(low < high){
            swap(num[low], num[high]);
            low++;
            high--;
        }
    }
    void rotate(vector<int>& nums, int k) {
        
        int n = (int)nums.size();
        k = k%n;
        reverse(nums, 0, n-k-1);
        reverse(nums, n-k, n-1);
        reverse(nums, 0, n-1);
    }
};


================================================
FILE: Leetcode/Rotate List.cpp
================================================
// https://leetcode.com/problems/rotate-list/


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    
    int size(ListNode* head){
        int n = 0;
        while(head != NULL){
            n++;
            head = head->next;
        }
        return n;
    }
    
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == NULL)
            return head;
        
        int n = size(head);
        int loop = k % n;
        loop = n - loop;
        
        if( n == 1 || loop == n)
            return head;
        
        int j=0;
        ListNode* temp = head;
        ListNode* firstAddress = head;
        
        while(temp != NULL){
            j++;
            if(j == loop){
                firstAddress = temp->next;
                temp->next = NULL;
                break;
            }
            temp = temp->next;
        }
        
        temp = firstAddress;
        while(temp->next != NULL){
            temp = temp->next;
        }
        
        temp->next = head;
        return firstAddress;
        
        
    }
};



================================================
FILE: Leetcode/Search in a row-column sorted Matrix.cpp
================================================
// https://practice.geeksforgeeks.org/problems/search-in-a-matrix-1587115621/1



bool search(vector<vector<int> > matrix, int n, int m, int x) 
{
    // code here
    int row=0;
    for(int i=0;i<n;i++){
        if(matrix[i][0] == x)
            return true;
        else if(matrix[i][0] > x)
        {
            row = i-1;  
            break;
        }else{
            row = i;
        }
    }
    
    if(row>=0){
        for(int i=0;i<m;i++){
            if(matrix[row][i] == x)
                return true;
        }
    }
    
    return false;
    
}


================================================
FILE: Leetcode/Single Number Leetcode solution.cpp
================================================
//https://leetcode.com/problems/single-number/



class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int n = (int)nums.size();
        int a=0;
        for(int i=0;i<n;i++){
            //a= a^nums[i];
            a ^= nums[i];
        }
        return a;
    }
};


================================================
FILE: Leetcode/Sort Array By Parity.cpp
================================================
class Solution {
public:
    vector<int> sortArrayByParity(vector<int>& A) {
       vector<int> odd;
       vector<int> even;
        
        int n = (int)A.size();
        for(int i=0;i<n;i++){
            if(A[i]%2==0){even.push_back(A[i]);}
            else{odd.push_back(A[i]);}
        }
        
        even.insert(even.end(), odd.begin(), odd.end() );
        return even;
        
        
    }
};


================================================
FILE: Leetcode/Sort Colors.cpp
================================================
// https://leetcode.com/problems/sort-colors/

// or

// https://practice.geeksforgeeks.org/problems/sort-an-array-of-0s-1s-and-2s4231/1


class Solution {
public:
    void sortColors(vector<int>& nums) {
        
        // Method 1:
        //sort(nums.begin(), nums.end());
        
        
        // Method 2:
        
        /*
        int n = (int)nums.size();
        
        int f=0, s=0,t=0;
        for(int i=0;i<n;i++){
            if(nums[i]==0)
                f++;
            else if(nums[i]==1)
                s++;
            else
                t++;
        }
        
        for(int i=0;i<f;i++){
            nums[i]=0;
        }
        for(int i=f;i<f+s;i++){
            nums[i]=1;
        }
        for(int i=f+s;i<f+s+t;i++){
            nums[i]=2;
        }
        
        */
        
        
        // Method 3:
        
        int l=0;
        int m=0;
        int h=n-1;
        
        while(m<=h){
            int x = nums[m];
            if(x==0){
                swap(nums[l], nums[m]);
                l++;
                m++;
            }
            else if(x==1){
                m++;
            }
            else{
                swap(nums[h], nums[m]);
                h--;
            }
        }
        
    }
};


















================================================
FILE: Leetcode/Spirally traversing a matrix.cpp
================================================
Spirally traversing a matrix: https://practice.geeksforgeeks.org/problems/spirally-traversing-a-matrix-1587115621/1

class Solution
{   
public:     
    vector<int> spirallyTraverse(vector<vector<int> > matrix, int r, int c) 
    {
        // code here
        int top = 0;
        int bottom = r-1;
        int left = 0;
        int right = c-1;
        
        vector<int> ans;
        
        while(top<=bottom && left<=right){
            
            for(int i=left; i<=right ; i++)
                ans.push_back(matrix[top][i]);
            top++;
            
            for(int i=top;i<=bottom;i++)
                ans.push_back(matrix[i][right]);
            right--;
            
            if(top<=bottom){
                for(int i=right;i>=left;i--)
                    ans.push_back(matrix[bottom][i]);
                bottom--;
            }
            
            if(left<=right){
                for(int i=bottom;i>=top;i--)
                    ans.push_back(matrix[i][left]);
                left++;
            }
        }
        
        return ans;
    }
};


================================================
FILE: Leetcode/Square root.cpp
================================================
// https://practice.geeksforgeeks.org/problems/square-root/1



#include<bits/stdc++.h>
using namespace std;

long long int floorSqrt(long long int x);
  
  
// Function to find square root
// x: element to find square root
long long int floorSqrt(long long int x) 
{
    // Your code goes here
    int low = 1;
    int high = x;
    int ans = -1;
    
    while(low<=high){
        long long int mid = (low+high)/2;
        
        long long int sqr = mid*mid;
        
        if(sqr == x)
            return mid;
        else if(sqr < x){
            ans = mid;
            low = mid+1;
        }else{
            high = mid-1;
        }
    }
    
    return ans;
    
}

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		long long n;
		cin>>n;
		cout << floorSqrt(n) << endl;
	}
    return 0;   
}


================================================
FILE: Leetcode/Subarray sum equals K.cpp
================================================
class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n  =(int)nums.size();
        
        int count=0;
        
        unordered_map<int, int> prevSum;
        int sum=0;
        
        for(int i=0;i<n;i++){
            sum+=nums[i];
            
            if(sum==k)
                count++;
            
            if(prevSum.find(sum-k) != prevSum.end())
                count+=prevSum[sum-k];
            
            prevSum[sum]++;
        }
        
        return count;
    }
};


================================================
FILE: Leetcode/Trapping Rain Water.cpp
================================================
#include <iostream>
using namespace std;

// function to find the trapped water in between buildings
// arr: input array
// n: size of array
int trappingWater(int arr[], int n){
    
    int lmax[n]; lmax[0] = arr[0];
    for(int i=1;i<n;i++){
        int temp = max(arr[i], lmax[i-1]);
        lmax[i] = temp;
    }
    
    int rmax[n]; rmax[n-1] = arr[n-1];
    for(int i=n-2; i>=0 ;i--){
        int temp = max(arr[i], rmax[i+1]);
        rmax[i] = temp;
    }
    
    int water=0;
    for(int i=1;i<n-1;i++){
        water+= min(lmax[i], rmax[i]) - arr[i];
    }
    
    return water;
}


// { Driver Code Starts.

int main(){
    
    int t;
    //testcases
    cin >> t;
    
    while(t--){
        int n;
        
        //size of array
        cin >> n;
        
        int a[n];
        
        //adding elements to the array
        for(int i =0;i<n;i++){
            cin >> a[i];            
        }
        
        //calling trappingWater() function
        cout << trappingWater(a, n) << endl;
        
    }
    
    return 0;
}  // } Driver Code Ends


================================================
FILE: Leetcode/Tree/Balanced Binary Tree.cpp
================================================
// https://leetcode.com/problems/balanced-binary-tree/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    int height(TreeNode* root){
        if(root == NULL)
            return 0;
        else 
            return max( height(root->left), height(root->right) ) +1;
    }
    
    void inorderUtil(TreeNode* root, bool & ans){
        if(root!=NULL){
            inorderUtil(root->left, ans);
            
            int lh = height(root->left);
            int rh = height(root->right);
            
            if(abs(lh-rh) >1)
                ans = ans && false;
            
            inorderUtil(root->right, ans);
        }
    }
    
    bool isBalanced(TreeNode* root) {
        bool ans = true;
        inorderUtil(root, ans);
        return ans;
    }
};


================================================
FILE: Leetcode/Tree/Binary Tree Inorder Traversal.cpp
================================================
// https://leetcode.com/problems/binary-tree-inorder-traversal/


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    void preorder(TreeNode* root, vector<int>  &ans){
        if(root!=NULL){
            ans.push_back(root->val);
            preorder(root->left, ans);
            preorder(root->right, ans);
        }
    }
    
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        preorder(root, ans);
        return ans;
    }
};


================================================
FILE: Leetcode/Tree/Binary Tree Right Side View.cpp
================================================
// https://leetcode.com/problems/binary-tree-right-side-view/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ans;
        queue<TreeNode*>q;
        q.push(root);
        
        if(root == NULL)
            return ans;
        while(1){
            int size = q.size();
            if(size==0)
                return ans;
            int data = 0;
            while(size>0){
                TreeNode* temp = q.front();
                q.pop();
                
                data = (temp->val);
                if(temp->left!=NULL)
                    q.push(temp->left);
                if(temp->right!=NULL)
                    q.push(temp->right);
                size--;
                   
            }
            ans.push_back(data);
        }
        return ans;
    }
};


================================================
FILE: Leetcode/Tree/Binary Tree Zigzag Level Order Traversal.cpp
================================================
// https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/

vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> q;
        q.push(root);
        
        int count = 0;
        if(root == NULL)
            return ans;
        
        while(1){
            int size = q.size();
            if(size == 0)
                return ans;
            count++;
            vector<int>data;
            
            while(size>0){
                TreeNode* temp = q.front();
                q.pop();

                data.push_back(temp->val);
                if(temp->left != NULL)
                    q.push(temp->left);
                if(temp->right != NULL)
                    q.push(temp->right);
                size--;
            }
            if(count%2==0)
                reverse(data.begin(), data.end());
            ans.push_back(data);
            
        }
        return ans;
    
    }


================================================
FILE: Leetcode/Tree/Children Sum Parent.cpp
================================================
// https://practice.geeksforgeeks.org/problems/children-sum-parent/1/

int isSumProperty(Node *root)
{
  if( root == NULL  || (root->left == NULL && root->right==NULL))
    return 1;
  
  int left_sum = 0, right_sum = 0;
  if(root->left != NULL)
    left_sum = root->left->data;
  if(root->right != NULL)
    right_sum = root->right->data;
 
  if( root->data == (left_sum+right_sum) &&
      isSumProperty(root->left) &&
      isSumProperty(root->right) ){
          return 1;
      }
  else
     return 0;
 
}


================================================
FILE: Leetcode/Tree/Construct Binary Tree from Preorder and Inorder Traversal.cpp
================================================
// https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    int preIndex = 0;
    
    TreeNode* buildTreeUtil(vector<int>& preorder, vector<int>& inorder, int is, int ie){
        if(is > ie)
            return NULL;
        
        TreeNode* root = new TreeNode(preorder[preIndex]);
        preIndex++;
        
        
        int inIndex;
        for(int i=is; i<=ie; i++){
            if(inorder[i] == root->val){
                inIndex = i;
                break;
            }
        }
        
        root->left = buildTreeUtil(preorder, inorder, is, inIndex-1);
        root->right = buildTreeUtil(preorder, inorder, inIndex+1, ie);
        
        return root;
        
    }
    
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        TreeNode* ans = buildTreeUtil(preorder, inorder, 0, inorder.size()-1);
        return ans;
    }
};


================================================
FILE: Leetcode/Tree/Diameter of Binary Tree.cpp
================================================
// https://leetcode.com/problems/diameter-of-binary-tree/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    int res = 0;
    
    int height(TreeNode* root){
        if(root == NULL)
            return 0;
        
        int lh = height( root-> left);
        int rh = height( root-> right);
        
        res = max(res, 1+lh+rh);
        
        return 1+ max(lh, rh);
        
    }
    
    int diameterOfBinaryTree(TreeNode* root) {
        int data = height(root);
        return res-1;
    }
};


================================================
FILE: Leetcode/Tree/Invert Binary Tree.cpp
================================================
// https://leetcode.com/problems/invert-binary-tree/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack <TreeNode*> st;
        st.push(root);
        
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            
            if(node != NULL){
                st.push(node->left);
                st.push(node->right);
                swap(node->left, node->right);
            }
        }
        
        return root;
    }
};


================================================
FILE: Leetcode/Tree/Level Order Traversal.cpp
================================================
// https://leetcode.com/problems/binary-tree-level-order-traversal/

vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*>q;
        q.push(root);
        
        if(root == NULL)
            return ans;
        while(1){
            int size = q.size();
            if(size==0)
                return ans;
            vector<int>data;
            while(size>0){
                TreeNode* temp = q.front();
                q.pop();
                
                data.push_back(temp->val);
                if(temp->left!=NULL)
                    q.push(temp->left);
                if(temp->right!=NULL)
                    q.push(temp->right);
                size--;
                   
            }
            ans.push_back(data);
        }
        return ans;
    }


================================================
FILE: Leetcode/Tree/Lowest Common Ancestor of a Binary Tree.cpp
================================================
// https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/


//                  METHOD - 01


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    
    bool findPath(TreeNode* root,  vector<TreeNode*> &path, TreeNode* n){
        if(root == NULL)
            return false;
        path.push_back(root);
        if(root == n) return true;
        
        if( findPath(root->left, path, n) || findPath(root->right, path, n) )
            return true;
        
        path.pop_back();
        return false;
    }
    

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
      
        vector<TreeNode*> path1, path2;
        if( !findPath(root, path1, p) || !findPath(root, path2, q)  )
            return NULL;
        TreeNode* ans = NULL;
        for(int i=0; i<path1.size() && i<path2.size(); i++){
            if(path1[i] == path2[i])
                ans = path2[i];
        }
        return ans;
        
    }

};






//                  METHOD - 02



/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
      
        if(root == NULL)
            return NULL;
        if(root == p || root == q)
            return root;
        
        TreeNode* lca1 = lowestCommonAncestor(root->left, p, q);
        TreeNode* lca2 = lowestCommonAncestor(root->right, p, q);
        
        if(lca1 != NULL && lca2 != NULL)
            return root;
        if(lca1 != NULL)
            return lca1;
        else
            return lca2;
        
    }

};





================================================
FILE: Leetcode/Tree/Maximum Depth of Binary Tree.cpp
================================================
// https://leetcode.com/problems/maximum-depth-of-binary-tree/

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL)
            return 0;
        else
            return max( maxDepth(root->left), maxDepth(root->right) ) + 1;
    }
};


================================================
FILE: Leetcode/Tree/Populating Next Right Pointers in Each Node.cpp
================================================
// https://leetcode.com/problems/populating-next-right-pointers-in-each-node/

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(root == NULL)
            return root;
        
        queue<Node*>q;
        q.push(root);
        
        while(!q.empty()){
            int size = q.size();
            if( size == 0)
                return root;
            
            while(size>0){
                Node* temp;
                
                if(size>1){
                    temp = q.front();
                    q.pop();
                    
                    Node* nextAdd = q.front();
                    temp->next = nextAdd;
                    
                }
                else{
                    temp = q.front();
                    q.pop();
                }
                
                if(temp->left != NULL)
                    q.push(temp->left);
                if(temp->right != NULL)
                    q.push(temp->right);
                
                size--;
                
            }
        }
        
        return root;
    }
};


================================================
FILE: Leetcode/Tree/Subtree of Another Tree.cpp
================================================
// https://leetcode.com/problems/subtree-of-another-tree/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    bool ans = false;
    
    
    bool match(TreeNode* root, TreeNode* subRoot){
        
        if(root!=NULL && subRoot!=NULL){
            bool a = match(root->left, subRoot->left);
            bool b = match(root->right, subRoot->right);
            
            if( (root->val == subRoot->val) && a && b ){
                return true;
            }else
                return false;
        }
        else if(root==NULL && subRoot==NULL)
            return true;
        else
            return false;
    }
    
    
    void inorder(TreeNode* root, TreeNode* subRoot){
        if(root!=NULL){
            inorder(root->left, subRoot);
            
            bool x = match(root, subRoot);
            if(x){ans = x;}
            
            inorder(root->right, subRoot);
        }
    }
    
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        inorder(root, subRoot);
        return ans;
    }
};


================================================
FILE: Leetcode/Tree/Symmetric Tree.cpp
================================================
// https://leetcode.com/problems/symmetric-tree/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    bool match(TreeNode* root1, TreeNode* root2){
        if(root1 != NULL && root2 != NULL){
            bool a = match(root1->left, root2->right);
            bool b = match(root1->right, root2->left);
            
            if((root1->val == root2->val) && a && b)
                return true;
            else
                return false;
            
        }
        else if(root1 == NULL && root2 == NULL){
            return true;
        }else
            return false;
    }
    
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        
        return match(root->left, root->right);
    }
};


================================================
FILE: Leetcode/Tree/Vertical Width of a Binary Tree .cpp
================================================
// https://practice.geeksforgeeks.org/problems/vertical-width-of-a-binary-tree/1



/*Structure of node of binary tree is as follows
struct Node
{
    int data;
    struct Node* left;
    struct Node* right;
    
    Node(int x){
        data = x;
        left = right = NULL;
    }
};
*/

unordered_set<int>st;

void inorderUtil(Node* root, int hd){
    if(root != NULL){
        inorderUtil(root->left, hd-1);
        st.insert(hd);
        inorderUtil(root->right, hd+1);
    }
}

//Function to find the vertical width of a Binary Tree.
int verticalWidth(Node* root)
{
    // Code here
    st.clear();
    inorderUtil(root, 0);
    return st.size();
    
}


================================================
FILE: Leetcode/Tree/same Tree.cpp
================================================
// https://leetcode.com/problems/same-tree/


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    void inorder(TreeNode* root, vector<int>&v){
        if(root!=NULL){
            inorder(root->left, v);
            v.push_back(root->val);
            inorder(root->right, v);
        }else
            v.push_back(100000);
    }
    
    void preorder(TreeNode* root, vector<int>&v){
        if(root!=NULL){
            v.push_back(root->val);
            preorder(root->left, v);
            preorder(root->right, v);
        }else
            v.push_back(100000);
    }
    
    bool isSameTree(TreeNode* p, TreeNode* q) {
        
        vector<int> inp, inq, prep, preq;
        inorder(p, inp);
        inorder(q, inq);
        
        preorder(p, prep);
        preorder(q, preq);
        
        if(inp == inq  && prep == preq)
            return true;
        else
            return false;
    }
};


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Recursive Solution

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p==NULL && q==NULL)
            return true;
        if(p==NULL || q==NULL)
            return false;
        return ( p->val == q->val  && 
                 isSameTree( p->left, q->left ) && 
                 isSameTree( p->right, q->right )  );
    }
};


================================================
FILE: Leetcode/count 1's in binary array.cpp
================================================
// https://practice.geeksforgeeks.org/problems/count-1s-in-binary-array-1587115620/1



#include <bits/stdc++.h>
using namespace std;

// Function to count number of Ones
// arr: input array 
// N: size of input array
int countOnes(int arr[], int N)
{
    
    // Your code here
    int low=0;
    int high=N-1;
    
    while(low<=high){
        int mid = (low+high)/2;
        
        if(arr[mid]==0){
            high = mid-1;
        }
        else{
            if(arr[mid+1]==0 || mid==N-1){
                return mid+1;
            }else{
                low = mid+1;
            }
        }
        
         
    }
    
    return 0;
    
}

int main()
{
    int t;
    cin>>t;
    
    while(t--)
    {
        int n;
        cin>>n;
        int *arr = new int[n]; 
        for(int i = 0; i < n; i++)
            cin>>arr[i];
        
        cout <<countOnes(arr, n)<<endl;
    }
    return 0;
}




/*



#include <bits/stdc++.h>
using namespace std;

// Function to count number of Ones
// arr: input array 
// N: size of input array
int countOnes(int arr[], int N)
{
    
    // Your code here
    int low= 0;
    int high = N-1;
    
    while(low<=high){
        int mid = (low+high) /2;
        
        if(arr[mid]==0){
            if(arr[mid-1]==1 || mid == 0){
                return mid;
            }else{
                high = mid-1;
            }
            
        }
        else{
            
            if(arr[mid+1]==0 || mid == N-1){
                return mid+1;
            }else{
                low = mid+1;
            }
        }
    }
    
    return 0;
    
}

int main()
{
    int t;
    cin>>t;
    
    while(t--)
    {
        int n;
        cin>>n;
        int *arr = new int[n]; 
        for(int i = 0; i < n; i++)
            cin>>arr[i];
        
        cout <<countOnes(arr, n)<<endl;
    }
    return 0;
}


*/


================================================
FILE: Leetcode/linked-list-cycle.cpp
================================================
// https://leetcode.com/problems/linked-list-cycle/


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL || head->next == NULL){
            return false;
        }
        
        ListNode *slow = head;
        ListNode *fast = head->next;
        
        while(slow!=fast){
            if(fast==NULL || fast->next == NULL){
                return false;
            }
            slow = slow->next;
            fast = fast->next->next;
        }
        return true;
    }
};


================================================
FILE: Leetcode/linkedlist/Copy List with Random Pointer.cpp
================================================
// https://leetcode.com/problems/copy-list-with-random-pointer/


/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if( head == NULL) return head;
        Node* newhead = new Node(0);
        Node* new_curr = newhead;
        Node* curr = head;
        unordered_map<Node*, Node*> umap;
        
        while(curr){
            Node* temp = new Node(curr->val);
            umap.insert({curr, temp});
            
            new_curr->next = temp;
            new_curr = new_curr->next;
            curr = curr->next;
        }
        curr = head;
        new_curr = newhead->next;
        
        while(curr){
            Node* random = curr->random;
            Node* newNode = umap[random];
            new_curr->random = newNode;
            
            new_curr = new_curr->next;
            curr = curr->next;
        }
        
        return newhead->next;
    }
};


================================================
FILE: Leetcode/linkedlist/Delete Node in a Linked List.cpp
================================================
// https://leetcode.com/problems/delete-node-in-a-linked-list/

class Solution {
public:
    void deleteNode(ListNode* node) {
        ListNode* curr = node->next;
        node->val = curr->val;
        node->next = curr->next;
    }
};


================================================
FILE: Leetcode/linkedlist/Intersection of Two Linked Lists.cpp
================================================
// https://leetcode.com/problems/intersection-of-two-linked-lists/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curr = headA;
        int a =0, b=0;
        while(curr){
            a++;
            curr = curr->next;
        }
        curr =headB;
        while(curr){
            b++;
            curr = curr->next;
        }
        int diff = abs(a-b);
        if(a<b){
            while(diff--){
                headB = headB->next;
            }
        }else{
            while(diff--){
                headA = headA->next;
            }
        }
        
        while(headA and headB){
            if(headA == headB){
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
        }
        return NULL;
    }
};


================================================
FILE: Leetcode/linkedlist/Linked List Cycle II.cpp
================================================
// https://leetcode.com/problems/linked-list-cycle-ii/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == NULL) return NULL;
        ListNode* slow = head, *fast = head, *entry = head;
        while(fast->next != NULL && fast->next->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
            
            if(slow == fast){
                while(entry != slow){
                    slow = slow->next;
                    entry = entry->next;
                }
                return slow;
            }
        }
        return NULL;
        
        /*
        
        unordered_set<ListNode*> set;
        ListNode* curr = head;
        while(curr != NULL){
            if(set.find(curr) != set.end()){
                return curr;
            }else{
                set.insert(curr);
                curr = curr->next;
            }
        }
        return NULL;
        
        */
    }
};


================================================
FILE: Leetcode/linkedlist/Merge Two Sorted Lists.cpp
================================================
// https://leetcode.com/problems/merge-two-sorted-lists/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* head;
        
        if(list1->val <= list2->val){
              head = list1;
             list1 = list1->next;
        }else{
             head = list2;
            list2 = list2->next;
        }
        
        ListNode* curr = head;

        while(list1 != NULL && list2 != NULL){
            if(list1->val <= list2->val){
                curr->next = list1;
                list1 = list1->next;
            }else{
                curr->next = list2;
                list2 = list2->next;
            }
            curr = curr->next;
        }
        
        if(list1 != NULL) curr->next = list1;
        if(list2 != NULL) curr->next = list2;
            
        return head;
    }
};


================================================
FILE: Leetcode/linkedlist/Palindrome Linked List.cpp
================================================
// https://leetcode.com/problems/palindrome-linked-list/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode* slow = head, *fast = head;
        while(fast and fast->next){
            slow = slow->next;
            fast = fast->next->next;
        }
        if(fast != NULL and fast->next == NULL ){
            slow = slow->next;
        }
        
        ListNode* prev = NULL;
        while(slow and slow->next){
            ListNode* temp = slow->next;
            slow->next = prev;
            prev = slow;
            slow = temp;
        }
        if(slow != NULL){slow->next = prev;}
        fast = head;
        while(slow and fast){
            if(slow->val != fast->val)
                return false;
            slow = slow->next;
            fast = fast->next;
        }
        return true;
        
    }
};


================================================
FILE: Leetcode/linkedlist/Remove Duplicates from Sorted List.cpp
================================================
// https://leetcode.com/problems/remove-duplicates-from-sorted-list/

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* curr = head;
        while(curr != NULL && curr->next != NULL){
            if(curr->val == curr->next->val){
                // same 
                ListNode* temp = curr->next;
                curr->next = temp->next;
                delete(temp);
            }else{
                curr = curr->next;
            }
        }
        return head;
    }
};


================================================
FILE: Leetcode/linkedlist/Remove Nth Node From End of List.cpp
================================================
// https://leetcode.com/problems/remove-nth-node-from-end-of-list/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *slow = head, *fast = head;
        while(n--){
            fast = fast->next;
        }
        if(fast == NULL) return slow->next;
        
        while(fast->next != NULL){
            slow = slow->next;
            fast = fast->next;
        }
        
        slow->next = slow->next->next;
        return head;
        
    }
};


================================================
FILE: Leetcode/linkedlist/Remove duplicates from an unsorted linked list.cpp
================================================
// https://practice.geeksforgeeks.org/problems/remove-duplicates-from-an-unsorted-linked-list/0

/*
The structure of linked list is the following

struct Node {
  int data;
  struct Node *next;
  Node(int x) {
    data = x;
    next = NULL;
  }
};
*/


class Solution
{
    public:
    //Function to remove duplicates from unsorted linked list.
    Node * removeDuplicates( Node *head) 
    {
     // your code goes here
        unordered_set<int>seen;
        Node* curr = head;
        
        if(curr == NULL)
            return head;
        else
            seen.insert(curr->data);
            
        while(curr != NULL && curr->next != NULL){
            if(seen.find(curr->next->data) != seen.end()){
                // same 
                curr->next = curr->next->next;
            }else{
                // not same
                seen.insert(curr->next->data);
                curr = curr->next;
            }
        }
        return head;
    }
};


================================================
FILE: Leetcode/linkedlist/Reverse Linked List.cpp
================================================
// https://leetcode.com/problems/reverse-linked-list/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* prev = NULL, *curr = head;
        while(curr != NULL){
            ListNode *temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
};


================================================
FILE: Leetcode/linkedlist/Sort List.cpp
================================================
// https://leetcode.com/problems/sort-list/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    
    ListNode* Mid(ListNode* head){
        ListNode* slow = head;
        ListNode* fast = head;
        
        while(fast->next != NULL and fast->next->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
    
    ListNode* mergeSortedList(ListNode *p1, ListNode *p2){
        if(p1 == NULL or p2 == NULL){
            return (p1==NULL) ? p2 : p1;
        }
        
        ListNode * ans = new ListNode(0);
        ListNode* curr = ans;
        
        while(p1 != NULL and p2 != NULL){
            if(p1->val < p2->val){
                curr->next = p1;
                p1= p1->next;
            }else{
                curr->next = p2;
                p2 = p2->next;
            }
            curr = curr->next;
        }
        
        if(p1 != NULL or p2 != NULL){
            curr->next = (p1 != NULL) ?  p1 : p2;
        }
        return ans->next;
    }
    
    ListNode* sortList(ListNode* head) {
        if( head == NULL or head->next == NULL) return head;
        ListNode* mid = Mid(head);
        ListNode* newhead = mid->next;
        mid->next = NULL;
        
        ListNode* left_half = sortList(head);
        ListNode* right_half = sortList(newhead);
        
        return mergeSortedList(left_half, right_half);
    }
};


================================================
FILE: Leetcode/linkedlist/Swap Nodes in Pairs.cpp
================================================
// https://leetcode.com/problems/swap-nodes-in-pairs/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode *curr = head->next->next;
        ListNode * prev = head;
        head = head->next;
        head->next = prev;
        
        while(curr != NULL && curr->next != NULL){
            prev->next = curr->next;
            prev = curr;
            ListNode * temp = curr->next->next;
            curr->next->next = curr;
            curr = temp;
        }
        
        prev->next = curr;
        return head;
    }
};


================================================
FILE: Leetcode/linkedlist/Swapping Nodes in a Linked List.cpp
================================================
// https://leetcode.com/problems/swapping-nodes-in-a-linked-list/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapNodes(ListNode* head, int k) {
        ListNode* slow = head,  *fast = head;
        while(--k){
            fast = fast->next;
        }
        ListNode *first = fast;
        
        while(fast->next != NULL){
            slow = slow->next;
            fast = fast->next;
        }
        
        swap(first->val, slow->val);
        return head;
    }
};


================================================
FILE: Leetcode/stack/Evaluate Reverse Polish Notation.cpp
================================================
// https://leetcode.com/problems/evaluate-reverse-polish-notation/

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int>st;
        for(auto x: tokens){
            if(x == "+" || x == "-" || x =="/" || x == "*"){
                int op2 = st.top(); st.pop();
                int op1 = st.top(); st.pop();
                
                if(x == "+"){
                    st.push(op1 + op2);
                }
                if(x == "-"){
                    st.push(op1 - op2);
                }
                if(x == "*"){
                    st.push(op1 * op2);
                }
                if(x == "/"){
                    st.push(op1 / op2);
                }
            }
            else{
                stringstream ss(x);
                int data;
                ss >> data;
                st.push(data);
            }
        }
        
        return st.top();
    }
};


================================================
FILE: Leetcode/stack/Implement Queue using Stacks.cpp
================================================
// https://leetcode.com/problems/implement-queue-using-stacks/

class MyQueue {

private:
    stack<int>input, output;
    
public:
    MyQueue() {
        
    }
    
    void push(int x) {
        input.push(x);
    }
    
    int pop() {
        int val = peek();
        output.pop();
        return val;
    }
    
    int peek() {
        if( output.empty() ){
            while( input.empty() != true ){
                output.push(input.top());
                input.pop();
            }
        }
        
        return output.top();
    }
    
    bool empty() {
        return input.empty() && output.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */


================================================
FILE: Leetcode/stack/Implement Stack using Queues.cpp
================================================
// https://leetcode.com/problems/implement-stack-using-queues/

class MyStack {
public:
    queue<int>q1,q2;
    
    
    MyStack() {
        
    }
    
    void push(int x) {
        while(!q1.empty()){
            q2.push(q1.front());
            q1.pop();
        }
        q1.push(x);
        while(!q2.empty()){
            q1.push(q2.front());
            q2.pop();
        }
        
    }
    
    int pop() {
        int val = q1.front();
        q1.pop();
        return val;
        
    }
    
    int top() {
        return q1.front();
    }
    
    bool empty() {
        return q1.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */


================================================
FILE: Leetcode/stack/Largest Rectangle in Histogram.cpp
================================================
// https://leetcode.com/problems/largest-rectangle-in-histogram/

class Solution {
public:
    
    vector<int> previous_smaller(vector<int>& heights){
        vector<int> ans;
        stack<int>st;
        int n = heights.size();
        
        for(int i=0; i<n; i++){
            while(st.empty() == false && heights[st.top()] >= heights[i] ){
                st.pop();
            }
            int ele = (st.empty()) ? -1 : st.top();
            ans.push_back(ele);
            st.push(i);
        }
        return ans;
    }

    vector<int> next_smaller(vector<int>& heights){
        vector<int> ans;
        stack<int>st;
        int n = heights.size();
        
        for(int i=n-1; i>=0; i--){
            while(st.empty() == false && heights[st.top()] >= heights[i] ){
                st.pop();
            }
            int ele = (st.empty()) ? n : st.top();
            ans.push_back(ele);
            st.push(i);
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
    
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;
        int n = heights.size();
        vector<int>ps = previous_smaller(heights);
        vector<int>ns = next_smaller(heights);
        
        for(int i=0; i<n; i++){
            int curr = ( ns[i] - ps[i] -1 ) * heights[i];
            res = max(res , curr);
        }
        return res;
    }
};




================================================
FILE: Leetcode/stack/Min Stack.cpp
================================================
// https://leetcode.com/problems/min-stack/

class MinStack {
public:
    
    stack<int>st, s2;
    MinStack() {
        
    }
    
    void push(int val) {
        if( s2.empty() || val <= s2.top() ){
            s2.push(val);
        }
        
        st.push(val);
    }
    
    void pop() {
        
        if(st.top() == s2.top()){
            s2.pop();
        }
        st.pop();
        
    }
    
    int top() {
        return st.top();
    }
    
    int getMin() {
        return s2.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */


================================================
FILE: Leetcode/stack/Next Greater Element I.cpp
================================================
// https://leetcode.com/problems/next-greater-element-i/

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int>umap;
        stack<int>st;
        int n = nums2.size();
        
        for(int i=n-1; i>=0; i--){
            int ele = nums2[i];
            while(!st.empty() && st.top() <= ele){
                st.pop();
            }
            int res = (st.empty()) ? -1 : st.top();
            umap.insert({ele, res});
            st.push(ele);
        }
        
        vector<int> ans;
        for(auto x: nums1){
            ans.push_back(umap[x]);
        }
        
        return ans;
    }
};


================================================
FILE: Leetcode/stack/Online Stock Span.cpp
================================================
// https://leetcode.com/problems/online-stock-span/

class StockSpanner {
public:
    stack<pair<int,int>>st; // price, span
    StockSpanner() {
        
    }
    
    int next(int price) {
        int span = 1;
        
        while(!st.empty() && st.top().first <= price){
            span += st.top().second;
            st.pop();
        }
        
        st.push({price, span});
        return span;
    }
};

/**
 * Your StockSpanner object will be instantiated and called as such:
 * StockSpanner* obj = new StockSpanner();
 * int param_1 = obj->next(price);
 */


================================================
FILE: Leetcode/stack/Remove All Adjacent Duplicates In String.cpp
================================================
// https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/

class Solution {
public:
    string removeDuplicates(string s) {
        int n = s.size(), i=0;
        stack<char>st;
        
        while(i<n){
            if(st.empty() || st.top() != s[i])
                st.push(s[i]);
            else
                st.pop();
            
            i++;
        }
        
        string ans = "";
        while(!st.empty()){
            char ele = st.top();
            st.pop();
            
            ans += ele;
        }
        
        reverse(ans.begin(), ans.end());
        return ans;
    }
};


================================================
FILE: Leetcode/stack/Remove All Adjacent Duplicates in String II.cpp
================================================
// https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string-ii/

class Solution {
public:
    string removeDuplicates(string s, int k) {
        
        vector<pair<char, int>>st;
        for(auto c : s){
            if(st.size() == 0 || st.back().first != c ){
                st.push_back({c, 1});
            }
            else{
                st.back().second++;
            }
            
            if(st.back().second == k){
                st.pop_back();
            }
        }
        
        string res ;
        for(auto x: st){
            res.append(x.second, x.first);
        }
            
        return res;
    }
};


================================================
FILE: Leetcode/stack/Reverse First K elements of Queue.cpp
================================================
// https://practice.geeksforgeeks.org/problems/reverse-first-k-elements-of-queue/1/

// { Driver Code Starts
// Initial Template for C++

#include <bits/stdc++.h>
using namespace std;
queue<int> modifyQueue(queue<int> q, int k);
int main() {
    int t;
    cin >> t;
    while (t-- > 0) {
        int n, k;
        cin >> n >> k;
        queue<int> q;
        while (n-- > 0) {
            int a;
            cin >> a;
            q.push(a);
        }
        queue<int> ans = modifyQueue(q, k);
        while (!ans.empty()) {
            int a = ans.front();
            ans.pop();
            cout << a << " ";
        }
        cout << endl;
    }
}// } Driver Code Ends


// User function Template for C++

// Function to reverse first k elements of a queue.
queue<int> modifyQueue(queue<int> q, int k) {
    // add code here.
    
    queue<int> ans;
    stack<int>st;
    
    while(k--){
        st.push(q.front());
        q.pop();
    }
    
    while(!st.empty()){
        ans.push(st.top());
        st.pop();
    }
    
    while(!q.empty()){
        ans.push(q.front());
        q.pop();
    }
    
    return ans;
}


================================================
FILE: Leetcode/stack/Valid Parentheses.cpp
================================================
// https://leetcode.com/problems/valid-parentheses/

class Solution {
public:
    bool isValid(string s) {
        stack<char>st;
        for(auto c : s){
            if(st.empty()){
                st.push(c);
            }
            else if( (st.top() == '(' && c == ')') || 
                     (st.top() == '[' && c == ']') || 
                     (st.top() == '{' && c == '}') ){
                st.pop();
            }
            else{
                st.push(c);
            }
        }
        
        if(st.size() == 0)
            return true;
        
        return false;
    }
};


================================================
FILE: Leetcode/string/Find the Index of the First Occurrence in a String.cpp
================================================
// https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/
// Pattern Matching Algorithm by using KMP Algorithm

class Solution {
public:
    
    vector<int> fillLPS(string str){
        int n = str.size();
        vector<int>lps(n,0);
        int len =0, i = 1;
        lps[0]=0;
        while(i<n){
            if(str[len] == str[i]){
                len++;
                lps[i] = len;
                i++;
            }else{
                if(len == 0){
                    lps[i]=0;
                    i++;
                }else{
                    len = lps[len-1];
                }
            }
        }
        return lps;
    }
    
    int strStr(string haystack, string needle) {
        int n = haystack.size();
        int m = needle.size();
        vector<int>lps = fillLPS(needle);
        int i=0, j=0;
        while(i<n){
            if(haystack[i] == needle[j]){
                i++;
                j++;
                if(j==m){
                    return i-j;
                }
            }
            else if(i<n && haystack[i] != needle[j]){
                if(j==0)
                    i++;
                else{
                    j = lps[j-1];
                }
            }
        }
        return -1;
    }
    
    
};



/* SOLUTION NAIVE APPROACH */

class Solution {
public:
    int strStr(string haystack, string needle) {
        int i=0, j=0, n= haystack.size(), m = needle.size();
        if(haystack == needle) return 0;
        while(i<n){
            if(haystack[i] == needle[j]){
                int index = i;
                string temp = "";
                while(i<n && j<m && haystack[i] == needle[j]){
                    temp += haystack[i];
                    i++;
                    j++;
                }
                if(temp == needle){
                    return index;
                }else{
                    i=index+1;
                    j = 0;
                }

            }else{
                i++;
            }
        }
        return -1;
    }
};


================================================
FILE: Leetcode/string/Gas Station.cpp
================================================
// https://leetcode.com/problems/gas-station/

Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int totalDiff =0, n = gas.size(), fuel =0, index =0;
        for(int i=0; i<n; i++){
            int diff = gas[i] - cost[i];
            totalDiff += diff;
            fuel += diff;
            if(fuel < 0){
                index = i+1;
                fuel = 0;
            }
        }
        return (totalDiff < 0) ? -1 : index;
    }
};


================================================
FILE: Leetcode/string/Maximum Ice Cream Bars.cpp
================================================
// https://leetcode.com/problems/maximum-ice-cream-bars/

class Solution {
public:
    int maxIceCream(vector<int>& costs, int coins) {
        int ans = 0;
        sort(costs.begin(), costs.end());
        for(auto x: costs){
            if(coins >= x){
                ans++; coins-=x;
            }
        }
        return ans;
    }
};


================================================
FILE: Leetcode/sum of numbers in string.cpp
================================================
// https://practice.geeksforgeeks.org/problems/sum-of-numbers-in-string/0

#include <iostream>
using namespace std;

int findSum(string s)
{
	// Your code here
	int n = (int)s.size();
	int num=0;
	int sum=0;
	for(int i=0;i<n;i++){
	    
	    if(s[i]>='0' && s[i]<='9')
	        num = num*10 + (s[i]-'0');
	    else{
	        sum += num;
	        num = 0;
	    }
	}
	
	return sum+num;
}

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
	    string str;
	    cin>>str;
	    cout << findSum(str);
        cout<<endl;
	}
	return 0;
}


================================================
FILE: README.md
================================================
# Competitive Programming by </ <a href="https://www.youtube.com/channel/UCbW63uLlDnsL7l992Z9nF_Q/" target="_blank">HELLO WORLD </a> >

[Hello World](https://www.youtube.com/channel/UCbW63uLlDnsL7l992Z9nF_Q/)

This section will provide you the pdf of my lecture and codes.

I have Youtube channel named - "Hello World" 


My channel contains Courses on 

* Competitive Programming
* Data Structure
* Algorithms like sorting , searching , graph etc
* C++ Language
* And lots of stuffs 

You can contact me on my Email ID : Helloworldbyprince@gmail.com


================================================
FILE: STL/Array_Algorithms_in_stl.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 26/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---
//                  all_of | any_of | none_of | copy_n | iota


#include <iostream>
#include <algorithm>
#include <numeric>
using namespace std;
int main(){
    int a[6] = {2, 5 , -6, 7, 9,100};
//    int count=0;
//    for(int i=0;i<6;i++){
//        if(a[i]>=0){
//            count++;
//        }
//    }
    
    all_of(a, a+6, [](int x){ return x>0;}) ? cout<<"all elements of array is +ve"<<endl : cout<<"All elements of array is not necessary to be +ve"<<endl;
    
    any_of(a, a+6, [](int x){return x<0;}) ? cout<<"we have atleast one -ve element"<<endl : cout<<"All elements are +ve"<<endl;
    
    none_of(a, a+6, [](int x){return x==100;}) ? cout<<"we have none of element exactly is equal to 100 "<<endl : cout<<"It means we have atleast one element  = 100"<<endl;
    
    
    int arr1[6];
    copy_n(a, 6 , arr1);  // aaray  size  new_array
    for(int i=0;i<6;i++){cout<<arr1[i]<<" ";} //
    
    cout<<endl;
    int arr2[6]; // 2 3 4 5 6 7
    iota(arr2, arr2+6 , 20);
    for(int i=0;i<6;i++){cout<<arr2[i]<<" ";} //
    cout<<endl;

}


================================================
FILE: STL/Binary search in STL.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 28/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <algorithm>
using namespace std;
void show(int a[], int asize){
    for(int i=0;i<asize;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
}
int main(){
    int a[] = { 2, 3, 0 , 9, 5, 6, 8, 1, 4};
    int size = sizeof(a)/sizeof(a[0]);
    
    show(a, size);
    
    cout<<"array after sorting"<<endl;
    sort(a, a+size);//
    show(a, size);
    
    if(binary_search(a, a+size, 18)){
        cout<<"Yes our element is present in the array"<<endl;
    }else{
        cout<<"Our element is not present in the array"<<endl;
    }
}



================================================
FILE: STL/List_in_STL.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 8/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <list>
using namespace std;

void show(list<int> l){
    list<int> :: iterator it;
    for(it = l.begin(); it!=l.end(); it++){
        cout<<*it<<" ";
    }
    cout<<endl;
}

int main(){
    list<int> list1;
    list<int> :: iterator it;
    list1.push_back(9);
    list1.push_back(2);
    list1.push_back(-7);
    list1.push_back(3);

    
    it = list1.begin();
    cout<<*it<<endl;
    
    show(list1);
    
    //list1.pop_back();
    //show(list1);
    
    cout<<"front : "<<list1.front()<<endl;
    cout<<"back : "<<list1.back()<<endl;
    
    //list1.clear();
    cout<<"empty or not : "<<list1.empty()<<endl;
    
    list1.erase(list1.begin());
    show(list1);


}




================================================
FILE: STL/Queue_in_STL.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 8/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <queue>
using namespace std;

void show(queue<int> QUEUE){
    queue<int> q = QUEUE;
    while(!q.empty()){
        cout<<q.front()<<" ";
        q.pop();
    }
    cout<<endl;
}

int main(){
    queue<int> q;
    q.push(10);
    q.push(11);
    q.push(-3);
    q.push(2);
    
    show(q);
    
    cout<<"size : "<<q.size()<<endl;
    cout<<"front : "<<q.front()<<endl;
    cout<<"back : "<<q.back()<<endl;
    
    q.pop();
    show(q);
}


================================================
FILE: STL/Vectors_Functions_in_STL.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 29/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
using namespace std;
void show(vector<int>v){
    for(int i=0;i<(int)v.size();i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;
}
int main(){
    vector<int> v;
    v.push_back(3);
    v.push_back(0);
    v.push_back(-4);
    v.push_back(7);
    v.push_back(13);
    v.push_back(8);
    v.push_back(2);

    show(v);
    //sort(v.begin(), v.end());
    //show(v);
    reverse(v.begin(), v.end());
    show(v);
    cout<<*max_element(v.begin(), v.end())<<endl;
    
    int x;
    x = *min_element(v.begin(), v.end());
    cout<<"Minimum element : "<<x<<endl;
    
    //cout<<accumulate(v.begin(), v.end(),0 )<<endl;
    
    //2  3  4 5
    int sum=0;
    sum = accumulate(v.begin(), v.end(),sum);
    cout<<sum<<endl;

    
}


================================================
FILE: STL/What is STL.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 31/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <algorithm>
using namespace std;
int main(){
    int a[10]= {1, 5, 8, 9, 6, 7, 3, 4, 2, 0};
    sort(a,a+10);
    for(int i=0;i<10;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
}


================================================
FILE: STL/deque_in_STL.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 13/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <deque>
using namespace std;

void showDeque(deque<int> q){
    deque<int> :: iterator it;
    for(it = q.begin(); it!=q.end() ;it++){
        cout<<*it<<" ";
    }
    cout<<endl;
}

int main(){
    deque<int> dq;
    dq.push_back(10);     //   7  10     -3  8
    dq.push_front(-3);
    dq.push_back(7);
    dq.push_front(8);
    
    showDeque(dq);
    cout<<"size of deque : "<<dq.size()<<endl;
    cout<<"max size : "<<dq.max_size()<<endl;
    
    cout<<dq.at(1)<<endl;
    cout<<dq.front()<<endl;
    cout<<dq.back()<<endl;
    
    //dq.pop_back();
    //showDeque(dq);
    
    dq.pop_front();
    showDeque(dq);
}


================================================
FILE: STL/pair_in_STL.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 19/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <utility>
using namespace std;
int main(){
    pair<int, char> PAIR1;
    PAIR1.first = 100;
    PAIR1.second = 'G';
    
    cout<<PAIR1.first<<" "<<PAIR1.second<<endl;
    
    pair<string, double>PAIR2 ("prince" , 78.8);
    cout<<PAIR2.first<<" "<<PAIR2.second<<endl;
    
    pair<string, double>PAIR3;
    PAIR3 = make_pair("krishna", 90.3);
    cout<<PAIR3.first<<" "<<PAIR3.second<<endl;

    pair<int, int> pair1 = make_pair(1, 19);
    pair<int, int> pair2 = make_pair(2, 7);
    pair<int, int> pair3(pair2);  // we copied pair2 data in the pair3
    cout<<pair1.first<<" "<<pair1.second<<endl;
    cout<<pair3.first<<" "<<pair3.second<<endl;
    
    cout<<(pair1==pair2)<<endl;
    cout<<(pair1!=pair2)<<endl;
    cout<<(pair1 >= pair2)<<endl;
    cout<<(pair1 <= pair2)<<endl;

    // swapping of data in between pairs
    pair1.swap(pair2);
    cout<<pair1.first<<" "<<pair1.second<<endl;
    cout<<pair2.first<<" "<<pair2.second<<endl;

    

}



================================================
FILE: STL/priority Queue in STL.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 14/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <queue>
using namespace std;

void showPriorityQueue(priority_queue<int> pq){
    priority_queue<int> q = pq;
    while(!q.empty()){
        cout<<q.top()<<" ";
        q.pop();
    }
    cout<<endl;
}

int main(){
    priority_queue<int> q;
    q.push(10);
    q.push(-3);
    q.push(7);
    q.push(8);
    
    showPriorityQueue(q);
    cout<<q.size()<<endl;
    
    q.pop();
    q.pop();
    cout<<q.empty()<<endl;
    showPriorityQueue(q);

}


================================================
FILE: STL/sort_in_STL.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 25/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
void showArray(int a[]){
    for(int i=0;i<10;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
}
int main(){
    int a[10]={9, 8, 1, 2, 7 , 4, 0, 5, 3, 5};
    showArray(a);
    
    sort(a, a+10);
    showArray(a);
    
    vector<int> v;
    v.push_back(10);
    v.push_back(-3);
    v.push_back(2);
    v.push_back(91);
    v.push_back(5);
    v.push_back(7);
    
    sort(v.begin(), v.end());
    for(int i=0;i<(int)v.size();i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;

    
}


================================================
FILE: STL/stack in STL data structure.cpp
================================================
//
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 6/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <stack>
using namespace std;

void printElementOfStack(stack<int> s){
    while(!s.empty()){
        cout<<s.top()<<endl;
        s.pop();
    }
}

int main(){
    stack<int> s;
    s.push(3);
    s.push(10);
    s.push(-3);
    s.push(9);
    
    cout<<s.empty()<<endl;
    cout<<s.size()<<endl;
    
    printElementOfStack(s);
}







================================================
FILE: Templates_in_c++.cpp
================================================
//
//  main.cpp
//
//  Created by Prince  Kumar on 03/05/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** TEMPLATES in C++ **---

#include <iostream>
using namespace std;
template <typename T>
//template <class T>

T MAX ( T a , T b){
    return a>b ? a : b;
}

template <class Y>
class boy {
public:
    Y name;
};
int main(){
    //cout<<add(3,4)<<endl;
    auto x = MAX<char>('a', 'c');
    cout<<x<<endl;
    
    boy<string> person;
    person.name="prince";
    cout<<(person.name)<<endl;
    
}


================================================
FILE: Tree/Binary seacrh tree
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 26/07/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                      ---** TREE DATA STRUCTURE in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
struct node{
    int data;
    node* left;
    node* right;
};

node* newNode(int data){
    node* temp = new node();
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;

    return temp;
}

node * search(node * root, int key){
    if(root==NULL || root->data == key)
        return root;
    
    // if key is greater than root
    if( root->data < key){
        return search(root->right, key);
    }
    
    return search(root->left, key);
}

int main(){
    node * root = newNode(4);
    root->left = newNode(2);
    root->right = newNode(5);
    root->left->left = newNode(1);
    root->left->right = newNode(3);
    
    /*
                   4
                 /   \
                2     5
               / \
              1   3
        
        */
    
    node* address = search(root, 5);
    cout<<address->data<<endl;
}


================================================
FILE: Tree/Binary_tree.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 05/07/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
struct node{
    int data;
    node* left;
    node* right;
};
node* newNode(int data){
    node* element = new node();
    element->data = data;
    element->left = NULL;
    element->right = NULL;

    return element;
}
//node* newNode(int data){
//    node* node = new struct node();
//    node->data = data;
//    node->left = NULL;
//    node->right = NULL;
//
//    return node;
//}

void printNode(node *n){
    while( n!=NULL){
        cout<<n->data<<" ";
        n = n->left;
    }
    cout<<endl;
}
int main(){
    // make root node
    node* root  = newNode(1);
    
    /*
            1
          /   \
        NULL  NULL
     
     */
    
    root->left = newNode(2);
    /*
           1
         /   \
       2      NULL
      /  \
    NULL  NULL
     
    
    */
    root->right = newNode(3);
    root->left->left = newNode(4);
    
    printNode(root);
}

// 1 2 3 4 5 6 7


================================================
FILE: Tree/Code of Deletion of Node in BST.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 04/08/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                      ---** TREE DATA STRUCTURE in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
struct node{
    int data;
    node* left ,* right;
};

node* newNode(int data){
    node* temp = new node();
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;

    return temp;
}

void inorder(node* root){
    if(root!=NULL){
        inorder(root->left);
        cout<<(root->data)<<" ";
        inorder(root->right);
    }
}

node *insert(node * node, int key){
    
    // tree empty
    if(node == NULL) return newNode(key);
    
    // key is smaller than node->data
    if(key < (node->data)){
        node->left = insert(node->left, key);
    }
    else if( key > (node->data)){
        node->right = insert(node->right, key);
    }
    
    // else
    return node;
}

/* Given a non-empty binary search tree, return the node with minimum
key value found in that tree. Note that the entire tree does not
need to be searched. */

node * minValueNode(node * node){
    struct  node *current = node;
    
    /* loop down to find the leftmost leaf */
    while(current && current->left != NULL )
        current = current->left;
    
    return current;
}


/* Given a binary search tree and a key, this function deletes the key
and returns the new root */
node * deleteNode(node * root, int key){
    // base case
    if(root == NULL) return root;
    
    // If the key to be deleted is smaller than the root's key, then it lies in left subtree
    if(key < root->data){
        root->left  = deleteNode(root->left, key);
    }
    
    // If the key to be deleted is greater than the root's key, then it lies in right subtree
    else if(key > root->data){
        root->right  = deleteNode(root->right, key);
    }
    
    // if key is same as root's key, then This is the node to be deleted
    else{
        // node with only one child or no child
        if(root->left == NULL){
            node * temp = root->right;
            free(root);
            return temp;
        }
        else if(root->right == NULL){
            node * temp = root->left;
            free(root);
            return temp;
        }
        
        // node with two children: Get the inorder successor (smallest in the right subtree)
        
        node * temp = minValueNode(root->right);
        
        // Copy the inorder successor's content to this node
        root->data = temp->data;
        
        // Delete the inorder successor
        root->right = deleteNode(root->right, temp->data);
        
    }
    
    return root;

}


int main(){
    /* Let us create following BST
              50
           /     \
          30      70
         /  \    /  \
       20   40  60   80 */
    
    node *root = NULL;
    root = insert(root, 50);
    root = insert(root, 30);
    root = insert(root, 20);
    root = insert(root, 40);
    root = insert(root, 70);
    root = insert(root, 60);
    root = insert(root, 80);
    
    root = deleteNode(root, 20);
    inorder(root);
    cout<<endl;
    root = deleteNode(root, 30);
    inorder(root);
    cout<<endl;
    root = deleteNode(root, 50);
    inorder(root);
}


================================================
FILE: Tree/Code of Inorder Traversal.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 21/07/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
struct node{
    int data;
    node* left;
    node* right;
};

node* newNode(int data){
    node* temp = new node();
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;

    return temp;
}

void printInorder(node *node){
    if(node == NULL)
        return;
    
    /* first traverse left part of tree */
    printInorder(node->left);
    
    /* then print data  */
    cout<<node->data<<" ";
    
    /* and last  traverse right part of tree */
    printInorder(node->right);
}


int main(){
    node * root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    
    /*
                   1
                 /   \
                2     3
               / \
              4   5
        
        */
    cout<<"Inorder Traversl of Tree : "<<endl;
    printInorder(root);
}


================================================
FILE: Tree/Insertion in BST.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 29/07/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                      ---** TREE DATA STRUCTURE in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
struct node{
    int data;
    node* left ,* right;
};

node* newNode(int data){
    node* temp = new node();
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;

    return temp;
}

void inorder(node* root){
    if(root!=NULL){
        inorder(root->left);
        cout<<(root->data)<<" ";
        inorder(root->right);
    }
}

node *insert(node * node, int key){
    
    // tree empty
    if(node == NULL) return newNode(key);
    
    // key is smaller than node->data
    if(key < (node->data)){
        node->left = insert(node->left, key);
    }
    else if( key > (node->data)){
        node->right = insert(node->right, key);
    }
    
    // else
    return node;
}

int main(){
    /*     50
        /     \
       30      70
      /  \    /  \
    20   40  60   80  */
    
    node *root = NULL;
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 70);
    insert(root, 20);
    insert(root, 40);
    insert(root, 60);
    insert(root, 80);

    inorder(root);
    cout<<endl;

}


================================================
FILE: Tree/code of Hashing in C++.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 14/08/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                      ---** TREE DATA STRUCTURE in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
#include <math.h>
using namespace std;
#define MAX 1000

bool hashTable[MAX+1][2];

bool search(int x){
    if(x>=0){
        if(hashTable[x][0] == 1 ){
            return true;
        }else{
            return false;
        }
    }else{
        x = abs(x);
        if(hashTable[x][1] == 1 ){
            return true;
        }else{
            return false;
        }
    }
}

void insert(int a[], int n){
    for(int i=0;i<n;i++ ){
        if(a[i]>=0){
            hashTable[a[i]][0] = 1;
        }
        else{
            hashTable[abs(a[i])][1] = 1;
        }
    }
}

int main(){
    int arr[] = {-1, 9, 2, -5, 3, 1};
    int n = sizeof(arr)/sizeof(arr[0]);
    insert(arr, n);
    
    int find  = -1;
    if(search(find)){
        cout<<"Element is present"<<endl;
    }else{
        cout<<"Element is not present "<<endl;
    }
    
}


================================================
FILE: Tree/code of preorer and Postorder traversal.cpp
================================================
//  DATA STRUCTURES.cpp
//
//  Created by Prince  Kumar on 23/07/2020.
//  Copyright © 2020 Prince Kumar. All rights reserved.
//
//                 ---** STANDARD TEMPLATE LIBRARY (STL) in C++ **---
//                         ---** PRACTICE CODING SKILLS **---


#include <iostream>
using namespace std;
struct node{
    int data;
    node* left;
    node* right;
};

node* newNode(int data){
    node* temp = new node();
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;

    return temp;
}

void printInorder(node *node){
    if(node == NULL)
        return;
    
    /* first traverse left part of tree */
    printInorder(node->left);
    
    /* then print data  */
    cout<<node->data<<" ";
    
    /* and last  traverse right part of tree */
    printInorder(node->right);
}

void printPreorder(node *node){
    if(node == NULL)
        return;
    
    /* then print data  */
    cout<<node->data<<" ";
    
    
    /* first traverse left part of tree */
    printPreorder(node->left);
    
    
    /* and last  traverse right part of tree */
    printPreorder(node->right);
}


void printPostorder(node *node){
    if(node == NULL)
        return;
    
    /* first traverse left part of tree */
    printPostorder(node->left);
    
    
    /* and last  traverse right part of tree */
    printPostorder(node->right);
    
    /* then print data  */
    cout<<node->data<<" ";
}


int main(){
    node * root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    
    /*
                   1
                 /   \
                2     3
               / \
              4   5
        
        */
    cout<<"Inorder Traversl of Tree : "<<endl;
    printInorder(root);
    cout<<"preorder Traversl of Tree : "<<endl;
    printPreorder(root);
    cout<<"postorder Traversl of Tree : "<<endl;
    printPostorder(root);

}


================================================
FILE: chef and Icecream.cpp
================================================
//
//  COMPETITIVE PROGRAMMING .cpp
//
//  Created by Prince  Kumar on 15/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                       ---** COMPETITIVE PROGRAMMING in C++ **---
//                            ---** PRACTICE CODING SKILLS **---
//                               ---** CHEF AND ICECREAM **---


#include <iostream>
using namespace std;
int main(){
    int T; cin>>T;
    while(T--){
        int n; cin>>n;
        int a[3]= {0,0,0};  // 5 10 15
        int check=0;
        for(int i=0;i<n;i++){
            int x; cin>>x;
            
            if(x==5){
                a[0]+=1;
            }else if(x==10){
                if(a[0]>=1){
                    a[1]+=1;
                    a[0]-=1;
                }else{
                    check++;
                }
            }else{
                if(a[1]>=1){
                    a[2]+=1;
                    a[1]-=1;
                }else if(a[0]>=2){
                    a[2]+=1;
                    a[0]-=2;
                }else{
                    check++;
                }
            }
        }
        if(check==0){
            cout<<"YES"<<endl;
        }else{
            cout<<"NO"<<endl;
        }
    }
}


================================================
FILE: chef and string.cpp
================================================
//
//  COMPETITIVE PROGRAMMING .cpp
//
//  Created by Prince  Kumar on 15/06/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                       ---** COMPETITIVE PROGRAMMING in C++ **---
//                            ---** PRACTICE CODING SKILLS **---
//                                   ---** CHEF AND STRING **---


#include <iostream>
using namespace std;
int main(){
    int T; cin>>T;
    while(T--){
        string s; cin>>s;
        int n = (int)s.size();
        int i=0;
        int count=0;
        // 0 1 2 3 4 5    i=5
        while(i<n){
            if(s[i]!=s[i+1] && (i+1)<n){
                count++;
                i+=2;
            }else{
                i++;
            }
        }
        cout<<count<<endl;
    }
}


================================================
FILE: map_in_c++
================================================
//
//  main.cpp
//
//  Created by Prince  Kumar on 30/04/2020.
//  Copyright © 2020 Prince  Kumar. All rights reserved.
//
//                      ---** MAP in C++ **---

#include <iostream>
#include <map>
using namespace std;
int main(){
    // roll_num   weight of student
    map < int , int > person;
    
    // Insert the values in map
    person.insert(pair<int, int>(1,35));
    person.insert({2, 40});
    person.insert({3,50});
    person.insert({5, 10});
    
    
//    auto it = person.find(3);
//    person.erase(it);
    
    //person.erase(5);
    
    
    // print
    for(auto itr = person.begin() ; itr!=person.end() ; ++itr){
        cout<<itr->first <<"  " <<itr->second<<endl;
    }
    
    // .begin()  --> return iterator
    //auto var  = person.begin();
    //cout<<"By var iterator  " <<var->first <<" "<<var->second<<endl;
    
    // .end()  --> return iterator
    //auto var  = person.end();   // Not actual map
    //cout<<"By var iterator  " <<var->first <<" "<<var->second<<endl;
    
    //cout<<person.size()<<endl;
    //cout<<person.max_size()<<endl;
    
    // .erase()
    
    // .empty()  -->whether map is empty or not
    // 0 --> map is not empty
    // 1 --> map is empty
    
    
    person.clear();   // delete all the values in map
    cout<<"map is empty or not ?  "<<person.empty()<<endl;
    
    
    
   
}