├── .github
    └── workflows
    │   └── greetings.yml
├── Code Chef
    ├── A Problem On Sticks.cpp
    ├── Ada King.cpp
    ├── Ada Matrix.cpp
    ├── Ada and Dishes.cpp
    ├── Another Card Game Problem.cpp
    ├── Bowling Strategy.cpp
    ├── Cache Hit.cpp
    ├── Chef And Card Game.cpp
    ├── Chef And Demonetisation.cpp
    ├── Chef And Strings.cpp
    ├── Chef And Work.cpp
    ├── Chef Wars.cpp
    ├── Chef and Division 3.cpp
    ├── Chef and Easy Queries.cpp
    ├── Chef and Linear Chess.cpp
    ├── Chef and Wedding Arrangements.cpp
    ├── Chefina And Swaps.cpp
    ├── Chefina and Swap.cpp
    ├── Chopsticks.cpp
    ├── Compress The List.cpp
    ├── Covid Run.cpp
    ├── Doctor Chef.cpp
    ├── Encoded String.cpp
    ├── Even-tual Reduction.cpp
    ├── Iron, Magnet and Wall.cpp
    ├── Is this a give away.cpp
    ├── Khaled in HIT.cpp
    ├── Linked List-K Append.cpp
    ├── Maximum Production.cpp
    ├── Missing A Point.cpp
    ├── Mode Of Frequencies.cpp
    ├── Positive AND.cpp
    ├── Relativity.cpp
    ├── Replace for X.cpp
    ├── Restore Sequence.cpp
    ├── Smallest KMP.cpp
    ├── Usain Bolt.cpp
    ├── Vaccine Production.cpp
    ├── Weapon Value.cpp
    ├── What Is This a Crossover Episode.cpp
    ├── XxOoRr.cpp
    └── isolation_centres.cpp
├── Geeks For Geeks
    ├── Addition Under Modulo.cpp
    ├── Case-specific Sorting of Strings.cpp
    ├── Closing bracket index.cpp
    ├── Count Leaves in Binary Tree.cpp
    ├── Count the Zeros.cpp
    ├── Delete without head pointer.cpp
    ├── Digits In Factorial.cpp
    ├── Exactly 3 Divisors.cpp
    ├── Height of Binary Tree.cpp
    ├── Min Heap Implementation.cpp
    ├── Minimum indexed character.cpp
    ├── Minimum number to form the sum even.cpp
    ├── Red OR Green.cpp
    ├── Remove Duplicate Elements.cpp
    ├── Reverse Array In Groups.cpp
    ├── Reverse a string.cpp
    ├── Smallest Divisible Number.cpp
    ├── Sum of numbers in string.cpp
    └── Unique Numbers.cpp
├── Hacker Blocks
    ├── Activity Selection Problem.cpp
    ├── Aggressive Cows.cpp
    ├── All Indices Problem.cpp
    ├── Balanced Parenthesis.cpp
    ├── Binary To Decimal.cpp
    ├── Book Allocation Problem.cpp
    ├── Broken Calculator.cpp
    ├── Build BST.cpp
    ├── Can You Read This.cpp
    ├── Circular Linked List.cpp
    ├── Convert String To Integer.cpp
    ├── Count N Queen.cpp
    ├── Create tree from Inorder and Preorder.cpp
    ├── Cycle Detection & Removal In LL.cpp
    ├── Decimal to Octal.cpp
    ├── Dictionary Order(Larger).cpp
    ├── Dictionary Order(Smaller).cpp
    ├── Difference in ASCII Codes.cpp
    ├── Duplicate Character Formatting.cpp
    ├── Even After Odd.cpp
    ├── FIBONACCI PATTERN (PATTERN 4).cpp
    ├── Find Last Element.cpp
    ├── Find The Greater Element.cpp
    ├── Form Biggest Number.cpp
    ├── Generate Parentheses.cpp
    ├── Help Rahul To Search.cpp
    ├── Help Ramu.cpp
    ├── Hollow Diamond Pattern.cpp
    ├── Hostel Visit.cpp
    ├── I Am Busy Man.cpp
    ├── Importance Of Time.cpp
    ├── Intersection Point Of Two Linked List.cpp
    ├── Is Balanced Binary Tree.cpp
    ├── Is Palindrome.cpp
    ├── Keypad Codes.cpp
    ├── Kth Element from The Last.cpp
    ├── Kth Root.cpp
    ├── Largest BST in a Binary Tree.cpp
    ├── Level Order (ZigZag).cpp
    ├── Linked List K Reverse.cpp
    ├── Manmohan Loves Patterns - I.cpp
    ├── Manmohan Loves Patterns- II.cpp
    ├── Mapped Strings.cpp
    ├── Matrix Search.cpp
    ├── Max Frequency Characters.cpp
    ├── Maximum Circular Sum.cpp
    ├── Maximum Length Bitonic Subarray.cpp
    ├── Maximum Subarray Sum.cpp
    ├── Median of Sorted Arrays.cpp
    ├── Merge K sorted Arrays.cpp
    ├── Merge Sorted Linked List.cpp
    ├── Modular Exponentiation.cpp
    ├── Mountain Pattern.cpp
    ├── Move All X At End.cpp
    ├── Painter Partition Problem.cpp
    ├── Palindrome Linked List.cpp
    ├── Pattern Double Sided Arrow.cpp
    ├── Pattern Inverted Hour Glass.cpp
    ├── Pattern Triangle.cpp
    ├── Pattern With Zeroes.cpp
    ├── Piyush and Magical Park.cpp
    ├── Playing With Bits.cpp
    ├── Prateek Loves Candy.cpp
    ├── Prateek Sir And Coding.cpp
    ├── Print BST keys in the Given Range.cpp
    ├── Pythagorean Triplet.cpp
    ├── Queue Using Stack.cpp
    ├── Rain Water Harvesting.cpp
    ├── Rat In A Maze.cpp
    ├── Recover BST.cpp
    ├── Redundant Parentheses.cpp
    ├── Remove Duplicates.cpp
    ├── Replace PI.cpp
    ├── Replace With Sum of Greater Nodes.cpp
    ├── Rotate Image.cpp
    ├── Sanket And Strings.cpp
    ├── Smart Keypad - Advanced.cpp
    ├── Smart Keypad - I.cpp
    ├── Sorted Array.cpp
    ├── Sorting In Linear Time.cpp
    ├── Spiral Print Anticlockwise.cpp
    ├── Stock Span.cpp
    ├── String Compression.cpp
    ├── String Sort.cpp
    ├── Strongest Fighter.cpp
    ├── Subsequences.cpp
    ├── Subset Sum Easy.cpp
    ├── Sudoku Solver.cpp
    ├── Sum At Level K.cpp
    ├── Sum of Two Arrays.cpp
    ├── Target Sum Pairs.cpp
    ├── Target Sum Triplets.cpp
    ├── Towers Of Hanoi.cpp
    ├── Tree Bottom View.cpp
    ├── Tree Left View.cpp
    ├── Tree Right View.cpp
    ├── Tree Top View.cpp
    ├── Tricky Permutations.cpp
    ├── Ultra Fast Mathematics.cpp
    ├── Unique Number - I.cpp
    ├── Unique Number - II.cpp
    ├── Unique Number - III.cpp
    ├── Von Neuman Loves Binary.cpp
    ├── Wave Print Column Wise.cpp
    ├── Winning CB Scholarship.cpp
    └── XOR Profit Problem.cpp
├── Hacker Rank
    ├── Counting Valley.cpp
    ├── Jumping On Clouds.cpp
    ├── Mini Max Sum.cpp
    ├── Ransom Note.cpp
    ├── Repeated String.cpp
    ├── Simple Array Sum.cpp
    ├── Sock Merchant.cpp
    └── Two Strings.cpp
├── Interview Bit
    ├── Add One To Number.cpp
    ├── Largest Number.cpp
    ├── Longest Common Prefix.cpp
    ├── Max Non Negative Subarray.cpp
    ├── Max Sum Contiguous Subarray.cpp
    ├── Min Steps In Infinite Grid.cpp
    ├── Spiral Order Matrix II.cpp
    └── Triplets With Sum Between Given Range.cpp
├── LICENSE
├── Leet Code
    ├── 3sum.cpp
    ├── Add Binary.cpp
    ├── Add Digits.cpp
    ├── Add Two Numbers II.cpp
    ├── Add Two Numbers.cpp
    ├── All Elements in Two BST.cpp
    ├── All Paths From Source to Target.cpp
    ├── Alphabet Board Path.cpp
    ├── Angle Between Hands of a Clock.cpp
    ├── Append Characters to String to Make Subsequence.cpp
    ├── Arithmetic Subarrays.cpp
    ├── Balanced Binary Tree.cpp
    ├── Best Time to Buy and Sell Stock.cpp
    ├── Binary Search Tree Iterator.cpp
    ├── Binary Tree Inorder Traversal.cpp
    ├── Binary Tree Level Order Traversal II.cpp
    ├── Binary Tree Level Order Traversal.cpp
    ├── Binary Tree Postorder Traversal.cpp
    ├── Binary Tree Preorder Traversal.cpp
    ├── Binary Tree Right Side View.cpp
    ├── Binary Tree Zigzag Level Order Traversal.cpp
    ├── Bitwise AND of Numbers Range.cpp
    ├── Boats to Save People.cpp
    ├── Build an Array With Stack Operations.cpp
    ├── Buy Sell Stock.cpp
    ├── Climbing Stairs.cpp
    ├── Combination Sum.cpp
    ├── Combinations.cpp
    ├── Concatenation of Array.cpp
    ├── Construct BT from Preorder and Inorder Traversal.cpp
    ├── Construct Binary Tree from Inorder and Postorder Traversal.cpp
    ├── Container With Most Water.cpp
    ├── Contains Duplicate II.cpp
    ├── Contains Duplicate.cpp
    ├── Convert Binary Number in a Linked List to Integer.cpp
    ├── Convert Sorted Array to BST.cpp
    ├── Convert an Array Into a 2D Array With Conditions.cpp
    ├── Copy List with Random Pointer.cpp
    ├── Count Good Nodes in Binary Tree.cpp
    ├── Count Primes.cpp
    ├── Count the Number of Consistent Strings.cpp
    ├── Counting Bits.cpp
    ├── Course Schedule II.cpp
    ├── Custom Sort String.cpp
    ├── DI String Match.cpp
    ├── Daily Temperatures.cpp
    ├── Delete Node From BST.cpp
    ├── Delete Node in a Linked List.cpp
    ├── Design Hashset.cpp
    ├── Destination City.cpp
    ├── Detect Capital.cpp
    ├── Element Appearing More Than 25% In Sorted Array.cpp
    ├── Excel Sheet Column Number.cpp
    ├── Fibonacci Number.cpp
    ├── Final Prices With a Special Discount in a Shop.cpp
    ├── Find All Anagrams in a String.cpp
    ├── Find All Duplicates in an Array.cpp
    ├── Find First and Last Position in a Sorted Array.cpp
    ├── Find Minimum In Rotated Sorted Array II.cpp
    ├── Find Minimum In Rotated Sorted Array.cpp
    ├── Find Peak Element.cpp
    ├── Find The Duplicate Number.cpp
    ├── Find and Replace Pattern.cpp
    ├── Find the Pivot Integer.cpp
    ├── Find the Prefix Common Array of Two Arrays.cpp
    ├── First Missing Positive.cpp
    ├── First Unique Character in a String.cpp
    ├── FizzBuzz.cpp
    ├── Flatten a Multilevel Doubly Linked List.cpp
    ├── Gas Station.cpp
    ├── Generate Parentheses.cpp
    ├── Gray Code.cpp
    ├── Group the People Given the Group Size They Belong To.cpp
    ├── Hamming Distance.cpp
    ├── Happy Number.cpp
    ├── House Robber.cpp
    ├── Implement Queue using Stacks.cpp
    ├── Implement Stack using Queues.cpp
    ├── Implement strStr.cpp
    ├── Insert Interval.cpp
    ├── Insert into a BST.cpp
    ├── Invert Binary Tree.cpp
    ├── Is Subsequence.cpp
    ├── Island Perimeter.cpp
    ├── Isomorphic Strings.cpp
    ├── Iterator for Combination.cpp
    ├── Jump Game II.cpp
    ├── Jump Game.cpp
    ├── Kth Largest Element in an Array.cpp
    ├── Kth Smallest Element in a BST.cpp
    ├── LRU Cache.cpp
    ├── Largest Local Values in a Matrix.cpp
    ├── Left and Right Sum Differences.cpp
    ├── Length of Last Word.cpp
    ├── Length of the Longest Alphabetical Continuous Substring.cpp
    ├── Letter Case Permutation.cpp
    ├── Letter Combinations of a Phone Number.cpp
    ├── Linked List Cycle II.cpp
    ├── Linked List Cycle.cpp
    ├── Longest Common Prefix.cpp
    ├── Longest Consecutive Sequence.cpp
    ├── Longest Increasing Subsequence.cpp
    ├── Longest Mountain in Array.cpp
    ├── Longest Palindrome.cpp
    ├── Longest Repeating Character Replacement.cpp
    ├── Longest Substring Without Repeating Characters.cpp
    ├── Majority Element II.cpp
    ├── Majority Element.cpp
    ├── Make The String Great.cpp
    ├── Max Consecutive Ones III.cpp
    ├── Maximum Absolute Sum of Any Subarray.cpp
    ├── Maximum Depth of Binary Tree.cpp
    ├── Maximum Erasure Value.cpp
    ├── Maximum Ice Cream Bars.cpp
    ├── Maximum Non Negative Product in a Matrix.cpp
    ├── Maximum Number of Balloons.cpp
    ├── Maximum Number of Vowels in a Substring of Given Length.cpp
    ├── Maximum Number of Words You Can Type.cpp
    ├── Maximum Sub Array.cpp
    ├── Maximum Sum Circular Subarray.cpp
    ├── Maximum Sum With Exactly K Elements.cpp
    ├── Maximum Twin Sum of a Linked List.cpp
    ├── Maximum Value of a String in an Array.cpp
    ├── Maximum Width Of Binary Tree.cpp
    ├── Merge 2 Sorted Lists.cpp
    ├── Merge In Between Linked Lists.cpp
    ├── Merge Intervals.cpp
    ├── Merge Sorted Array.cpp
    ├── Merge k Sorted Lists.cpp
    ├── Minimum Add to Make Parentheses Valid.cpp
    ├── Minimum Flips to Make a OR b Equal to c.cpp
    ├── Minimum Number of Arrows to Burst Balloons.cpp
    ├── Minimum Number of Operations to Move All Balls to Each Box.cpp
    ├── Minimum Path Sum.cpp
    ├── Minimum Recolors to Get K Consecutive Black Blocks.cpp
    ├── Minimum Remove to Make Valid Parentheses.cpp
    ├── Minimum Size Subarray Sum.cpp
    ├── Minimum Window Substring.cpp
    ├── Missing Number.cpp
    ├── Move Zeroes.cpp
    ├── N-Queens II.cpp
    ├── N-Queens.cpp
    ├── N-ary Tree Level Order Traversal.cpp
    ├── N-ary Tree Postorder Traversal.cpp
    ├── N-ary Tree Preorder Traversal.cpp
    ├── Number of 1 Bits.cpp
    ├── Number of Good Ways to Split a String.cpp
    ├── Number of Recent Calls.cpp
    ├── Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold.cpp
    ├── Odd Even Linked List.cpp
    ├── Optimal Partition of String.cpp
    ├── Pallindrome Number.cpp
    ├── Partition List.cpp
    ├── Path Sum III.cpp
    ├── Permutation in String.cpp
    ├── Permutations II.cpp
    ├── Plus One.cpp
    ├── Populating Next Right Pointers in Each Node.cpp
    ├── PowXN.cpp
    ├── Power Of Four.cpp
    ├── Power of Two.cpp
    ├── Prison Cells After N Days.cpp
    ├── Product of Array Except Self.cpp
    ├── Ransom Note.cpp
    ├── Recover Binary Search Tree.cpp
    ├── Remove All Adjacent Duplicates In String.cpp
    ├── Remove All Adjacent Duplicates in String II.cpp
    ├── Remove Duplicates From A Sorted Array.cpp
    ├── Remove Duplicates From Sorted Array.cpp
    ├── Remove Duplicates from Sorted Array II.cpp
    ├── Remove Duplicates from Sorted List II.cpp
    ├── Remove Duplicates from Sorted List.cpp
    ├── Remove Element.cpp
    ├── Remove Linked LIst Elements.cpp
    ├── Remove Nth Node From End of List.cpp
    ├── Removing Stars From a String.cpp
    ├── Reverse Bits.cpp
    ├── Reverse Integer.cpp
    ├── Reverse Linked List.cpp
    ├── Reverse Nodes in k-Group.cpp
    ├── Reverse String.cpp
    ├── Reverse Words In A String.cpp
    ├── Roman to Integer.cpp
    ├── Rotate Array.cpp
    ├── Rotate Image.cpp
    ├── Rotate List.cpp
    ├── Same Tree.cpp
    ├── Search Insert Position.cpp
    ├── Search in Rotated Sorted Array.cpp
    ├── Sender With Largest Word Count.cpp
    ├── Set Matrix Zeroes.cpp
    ├── Single Number III.cpp
    ├── Single Number.cpp
    ├── Sliding Window Maximum.cpp
    ├── Sort Array By Parity.cpp
    ├── Sort Characters By Frequency.cpp
    ├── Spiral Matrix II.cpp
    ├── Spiral Matrix.cpp
    ├── Split Linked List in Parts.cpp
    ├── Subarray Product Less Than K.cpp
    ├── Subarray Sum Equals K.cpp
    ├── Subdomain Visit Count.cpp
    ├── Subsets.cpp
    ├── Substring with Concatenation of All Words.cpp
    ├── Substrings of Size Three with Distinct Characters.cpp
    ├── Sudoku Solver.cpp
    ├── Sum In A Matrix.cpp
    ├── Sum of All Odd Length Subarrays.cpp
    ├── Summary Ranges.cpp
    ├── Swap Nodes in Pairs.cpp
    ├── The k Strongest Values in an Array.cpp
    ├── Time Needed to Buy Tickets.cpp
    ├── Top K Frequent Elements.cpp
    ├── Top K Frequent Words.cpp
    ├── Trapping Rain Water.cpp
    ├── Two Sum II - Input array is sorted.cpp
    ├── Two Sum.cpp
    ├── Ugly Number II.cpp
    ├── Unique Paths II.cpp
    ├── Unique Paths.cpp
    ├── Valid Anagrams.cpp
    ├── Valid Mountain Array.cpp
    ├── Valid Parentheses.cpp
    ├── Valid Sudoku.cpp
    ├── Valid_Palindrome.cpp
    ├── Validate Binary Search Tree.cpp
    ├── Validate Stack Sequences.cpp
    ├── Watering Plants.cpp
    ├── Word Break II.cpp
    ├── Word Break.cpp
    ├── Word Pattern.cpp
    └── Words Search.cpp
├── README.md
└── SPOJ
    ├── Aggressive Cows.cpp
    ├── Arranging Amplifiers.cpp
    ├── Biased Standings.cpp
    ├── Defense of a Kingdom.cpp
    ├── I Am Busy Man.cpp
    ├── Load Balancing.cpp
    ├── TEST.cpp
    ├── The last digit.cpp
    └── Transform The Expression.cpp


/.github/workflows/greetings.yml:
--------------------------------------------------------------------------------
 1 | name: Greetings
 2 | 
 3 | on: [pull_request, issues]
 4 | 
 5 | jobs:
 6 |   greeting:
 7 |     runs-on: ubuntu-latest
 8 |     permissions:
 9 |       issues: write
10 |       pull-requests: write
11 |     steps:
12 |     - uses: actions/first-interaction@v1
13 |       with:
14 |         repo-token: ${{ secrets.GITHUB_TOKEN }}
15 |         issue-message: 'Thanks for finding the issue! Lets solve this together!'
16 |         pr-message: 'Congratulations!! This is your first pull request on this repo :)'
17 | 


--------------------------------------------------------------------------------
/Code Chef/Is this a give away.cpp:
--------------------------------------------------------------------------------
 1 | /* Code Chef*/
 2 | /* Title - Is this a give away*/
 3 | //All submissions for this problem are available.You are given two integers l and r.
 4 | //You have to choose k real numbers in the interval [l,r] uniform randomly.
 5 | //What is the expected count of distinct numbers chosen by you?
 6 | //
 7 | //Input
 8 | //The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
 9 | //The first and only line of each test case contains three space-separated integers l, r and k.
10 | //Output
11 | //For each test case, print a single line containing one integer - the expected count of distinct numbers chosen. It can be proved that the expected count is always an integer.
12 | 
13 | #include <iostream>
14 | using namespace std;
15 | 
16 | int main() {
17 | 	// your code goes here
18 | 	int t;
19 | 	cin>>t;
20 | 	while(t--)
21 | 	{
22 | 	    int l,r,k;
23 | 	    cin>>l>>r>>k;
24 | 	    if(l!=r)
25 | 	    cout<<k<<endl;
26 | 	    else
27 | 	    cout<<1<<endl;
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/Code Chef/isolation_centres.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define int long long
 3 | #define w(t) while(t--)
 4 | #define bpc(n) __builtin_popcount(n)
 5 | #define fr(init, range)	for(int i = init ; i < range ; i++)
 6 | #define judge freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
 7 | #define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
 8 | #define pr(a) for(auto x : a) cout<<x<<" ";
 9 | using namespace std;
10 | int32_t main()
11 | {
12 | 	fast;
13 | 	#ifndef ONLINE_JUDGE
14 | 	judge;
15 | 	#endif
16 | 
17 | 	int t;
18 | 	cin>>t;
19 | 
20 | 	w(t)
21 | 	{
22 | 		int n, q;
23 | 		cin>>n>>q;
24 | 
25 | 		string s;
26 | 		cin>>s;
27 | 
28 | 		map<char, int> mp;
29 | 
30 | 		for(int i = 0 ; i < n ; i++)
31 | 		{
32 | 			mp[s[i]]++;
33 | 		}
34 | 
35 | 		w(q)
36 | 		{
37 | 			int c;
38 | 			cin>>c;
39 | 
40 | 			int ans = 0;
41 | 
42 | 			for(auto x : mp)
43 | 			{
44 | 				x.second -= c;
45 | 
46 | 				if(x.second > 0)
47 | 					ans+=x.second;
48 | 			}
49 | 			cout<<ans<<endl;
50 | 		}
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/Geeks For Geeks/Addition Under Modulo.cpp:
--------------------------------------------------------------------------------
 1 | /* Geeks For Geeks */
 2 | /* Title - Addition Under Modulo */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 13/07/2020 */
 5 | 
 6 | // You are given two numbers a and b. You need to find the sum of a and b under modulo M.
 7 | // Note: Take M as 10e9+7
 8 | 
 9 | // Input:
10 | // The first line of input contains T denoting the number of testcases. T testcases follow. Each testcase contains one line of input containing a and b.
11 | 
12 | // Output:
13 | // For each testcase, in a new line, print sum of a and b under modulo M.
14 | 
15 | // Your Task:
16 | // This is a function problem. You need to complete the function sumUnderModulo that takes a and b as parameters and returns sum of a and b under modulo M.
17 | 
18 | // Note : Solve the problem in Constant time and space complexity.
19 | 
20 | // { Driver Code Starts
21 | //Initial Template for C++
22 | 
23 | 
24 | #include <bits/stdc++.h>
25 | using namespace std;
26 | 
27 | 
28 |  // } Driver Code Ends
29 | 
30 | 
31 | //User function Template for C++
32 | 
33 | 
34 | int sumUnderModulo(long long a,long long b)
35 | {
36 |     int M=1000000007;
37 |     //your code here
38 |     int ans = a%M;
39 |     ans+=(b%M);
40 |     ans = ans%M;
41 |     return ans;
42 | }
43 | 
44 | // { Driver Code Starts.
45 | 
46 | 
47 | int main() {
48 | 	int T;
49 | 	cin>>T;
50 | 	while(T--)
51 | 	{
52 | 	    long long a;
53 | 	    long long b;
54 | 	    cin>>a>>b;
55 | 	    cout<<sumUnderModulo(a,b)<<endl;
56 | 	}
57 | 	return 0;
58 | }  // } Driver Code Ends


--------------------------------------------------------------------------------
/Geeks For Geeks/Count Leaves in Binary Tree.cpp:
--------------------------------------------------------------------------------
 1 | /* Geeks for Geeks */
 2 | /* Title - Count Leaves in Binary Tree */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/08/2021 */
 5 | 
 6 | // Given a Binary Tree of size N , You have to count leaves in it. For example, there are two leaves in following tree
 7 | 
 8 | //         1
 9 | //      /      \
10 | //    10      39
11 | //   /
12 | // 5
13 | 
14 |  
15 | 
16 | // Example 1:
17 | 
18 | 
19 | // Input:
20 | // Given Tree is 
21 | //                4
22 | //              /   \
23 | //             8     10
24 | //            /     /   \
25 | //           7     5     1
26 | //          /
27 | //         3 
28 | // Output:
29 | // 3
30 | // Explanation: 
31 | // Three leaves are 3 , 5 and 1.
32 |  
33 | 
34 | // Your Task:
35 | // You don't have to take input. Complete the function countLeaves() that takes root node of given tree as parameter and returns the count of leaves in tree . The printing is done by the driver code.
36 | 
37 | 
38 | int countLeaves(Node* root)
39 | {
40 |   // Your code here
41 |   
42 |   if(root == NULL){
43 |       return 0;
44 |   }
45 |   
46 |   if(root->left == NULL and root->right == NULL){
47 |       return 1;
48 |   }
49 |   
50 |   return countLeaves(root->left) + countLeaves(root->right);
51 |   
52 | }


--------------------------------------------------------------------------------
/Geeks For Geeks/Reverse a string.cpp:
--------------------------------------------------------------------------------
 1 | /* Geeks for Geeks */
 2 | /* Title - Reverse a string */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 7/11/2020 */
 5 | 
 6 | 
 7 | // You are given a string s. You need to reverse the string.
 8 | 
 9 | // Example 1:
10 | 
11 | // Input:
12 | // s = Geeks
13 | // Output: skeeG
14 | // Example 2:
15 | 
16 | // Input:
17 | // s = for
18 | // Output: rof
19 | // Your Task:
20 | 
21 | // You only need to complete the function reverseWord() that takes s as parameter and returns the reversed string.
22 | 
23 | // Expected Time Complexity: O(|S|).
24 | // Expected Auxiliary Space: O(1).
25 | 
26 | // Constraints:
27 | // 1 <= |s| <= 10000
28 | 
29 | // { Driver Code Starts
30 | //Initial Template for C++
31 | 
32 | 
33 | #include<bits/stdc++.h>
34 | using namespace std;
35 | 
36 | 
37 | string reverseWord(string str);
38 | 
39 | 
40 | int main() {
41 | 	
42 | 	int t;
43 | 	cin>>t;
44 | 	while(t--)
45 | 	{
46 | 	string s;
47 | 	cin >> s;
48 | 	
49 | 	cout << reverseWord(s) << endl;
50 | 	}
51 | 	return 0;
52 | 	
53 | }
54 | 
55 | // } Driver Code Ends
56 | 
57 | 
58 | //User function Template for C++
59 | 
60 | string reverseWord(string str){
61 |     
62 |   //Your code here
63 |   int n = str.length();
64 |   int j = n-1;
65 |   int i = 0;
66 |   
67 |   while(i<j){
68 |       char temp = str[i];
69 |       str[i] = str[j];
70 |       str[j] = temp;
71 |       i++;
72 |       j--;
73 |   }
74 |   return str;
75 |   
76 | }


--------------------------------------------------------------------------------
/Geeks For Geeks/Smallest Divisible Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Geeks For Geeks */
 2 | /* Title - Smallest Divisible Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 13/07/2020 */
 5 | 
 6 | // Given a number n the task is to complete the function which returns an integer denoting the smallest number evenly divisible by each number from 1 to n.
 7 | 
 8 | // Input:
 9 | // The first line of input contains an integer T denoting the no of test cases then T test cases follow. Each line contains an integer N.
10 | 
11 | // Output:
12 | // For each test case output will be in new line denoting the smallest number evenly divisible by each number from 1 to n.
13 | 
14 | #include <bits/stdc++.h>
15 | using namespace std;
16 | 
17 | long long getSmallestDivNum(long long n);
18 | 
19 | int main() {
20 | 	// your code goes here
21 | 	int t;
22 | 	cin>>t;
23 | 	while(t--)
24 | 	{
25 | 		int n;
26 | 		cin>>n;
27 | 		cout<<getSmallestDivNum(n)<<endl;
28 | 	}
29 | 	return 0;
30 | 	
31 | }// } Driver Code Ends
32 | 
33 | 
34 | /*You are required to complete this method */
35 | long long getSmallestDivNum(long long n)
36 | {
37 |     //Your code here
38 |     long long ans=1;
39 |     for(long long i=1;i<=n;i++){
40 |         ans = (ans*i)/(__gcd(ans,i));
41 |     }
42 |     return ans;
43 | }
44 | 


--------------------------------------------------------------------------------
/Hacker Blocks/All Indices Problem.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - All Indices Problem */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 06/07/2020 */
 5 | 
 6 | // Take as input N, the size of array. Take N more inputs and store that in an array. Take as input M, a number. Write a recursive function which returns an array containing indices of all items in the array which have value equal to M. Print all the values in the returned array.
 7 | 
 8 | // Input Format
 9 | // Enter a number N(size of the array) and add N more numbers to the array Enter number M to be searched in the array
10 | 
11 | // Constraints
12 | // 1 <= Size of array <= 10^5
13 | 
14 | // Output Format
15 | // Display all the indices at which number M is found in a space separated manner
16 | 
17 | // Sample Input
18 | // 5
19 | // 3
20 | // 2
21 | // 1
22 | // 2
23 | // 3
24 | // 2
25 | // Sample Output
26 | // 1 3
27 | // Explanation
28 | // 2 is found at indices 1 and 3.
29 | 
30 | #include<iostream>
31 | using namespace std;
32 | void print(int *a,int i,int n,int k){
33 | 	if(i==n)
34 | 	return;
35 | 	if(a[i]==k)
36 | 	cout<<i<<" ";
37 | 	print(a,i+1,n,k);
38 | }
39 | int main() {
40 | 	int n;
41 | 	cin>>n;
42 | 	int a[n];
43 | 	for(int i=0;i<n;i++)
44 | 	cin>>a[i];
45 | 	int m;
46 | 	cin>>m;
47 | 	print(a,0,n,m);
48 | 	return 0;
49 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Binary To Decimal.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Binary To Decimal */
 3 | //Take N (number in binary format). Write a function that converts it to decimal format and Print the value returned.
 4 | 
 5 | #include<iostream>
 6 | #include<cmath>
 7 | using namespace std;
 8 | int convert(int num)
 9 | {
10 |     int count = 0;
11 | 	int sum =0;
12 | 	int temp;
13 | 	while(num>0)
14 | 	{
15 | 		temp = (num%10)*pow(2,count++);
16 | 		sum += temp;
17 | 		num /= 10;
18 | 	}
19 |     return sum;
20 | }
21 | int main() {
22 | 	int n,num;
23 | 	cin>>n;
24 | 	num = convert(n);
25 | 	cout<<num<<endl;
26 | 	
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Broken Calculator.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Broken Calculator */
 3 | // Andrew was attempting a mathematics test where he needed to solve problems with factorials. One such problem had an answer which equaled 100! ,He wondered what would this number look like. He tried to calculate 100! On his scientific calculator but failed to get a correct answer. Can you write a code to help Andrew calculate factorials of such large numbers?
 4 | 
 5 | // Input Format
 6 | // a single lined integer N
 7 | 
 8 | // Constraints
 9 | // 1 < = N < = 500
10 | 
11 | // Output Format
12 | // Print the factorial of N
13 | 
14 | // Sample Input
15 | // 5
16 | // Sample Output
17 | // 120
18 | // Explanation
19 | // for factorial of 5 we have 5 x 4 x 3 x 2 x 1 = 120
20 | 
21 | #include<iostream>
22 | using namespace std;
23 | #define MAX 100000
24 | 
25 | int calc(int n, int res[], int resultSize){
26 | 	int i = 0;
27 | 	int carry = 0;
28 | 	while(i<resultSize){
29 | 		int temp = (res[i] * n + carry);
30 | 		res[i] = temp%10;
31 | 		carry = temp/10;
32 | 		
33 | 		i++;
34 | 	}
35 | 	while(carry){
36 | 		res[resultSize] = carry%10;
37 | 		carry/=10;
38 | 		resultSize++;
39 | 	}
40 | 	return resultSize;
41 | }
42 | int main() {
43 | 	int n;
44 | 	cin>>n;
45 | 	int res[MAX];
46 | 	int resultSize = 1;
47 | 	res[0] = 1;
48 | 	if(n==0 || n==1)
49 | 	cout<<1;
50 | 	for(int i = 2;i<=n;i++)
51 | 	resultSize = calc(i,res,resultSize);
52 | 	for(int i = resultSize-1;i>=0;i--)
53 | 	cout<<res[i];
54 | 
55 | 	return 0;
56 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Can You Read This.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Can You Read This */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/6/2020 */
 5 | 
 6 | // One of the important aspect of object oriented programming is readability of the code. To enhance the readability of code, developers write function and variable names in Camel Case. You are given a string, S, written in Camel Case. FindAllTheWordsContainedInIt.
 7 | 
 8 | // Input Format
 9 | // A single line contains the string.
10 | 
11 | // Constraints
12 | // |S|<=1000
13 | 
14 | // Output Format
15 | // Print words present in the string, in the order in which it appears in the string.
16 | 
17 | // Sample Input
18 | // IAmACompetitiveProgrammer
19 | // Sample Output
20 | // I
21 | // Am
22 | // A
23 | // Competitive
24 | // Programmer
25 | // Explanation
26 | // There are 5 words in the string.
27 | 
28 | #include<iostream>
29 | using namespace std;
30 | int main() {
31 | 	string s;
32 | 	cin>>s;
33 | 	int n = s.length();
34 | 	cout<<s[0];
35 | 	for(int i=1;i<n;i++){
36 | 		if(isupper(s[i]))
37 | 		{
38 | 			cout<<endl<<s[i];
39 | 		}
40 | 		else
41 | 			cout<<s[i];
42 | 
43 | 	}
44 | 	return 0;
45 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Convert String To Integer.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Convert String to Integer */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // Take as input str, a number in form of a string. Write a recursive function to convert the number in string form to number in integer form. E.g. for “1234” return 1234. Print the value returned.
 7 | 
 8 | // Input Format
 9 | // Enter a number in form of a String
10 | 
11 | // Constraints
12 | // 1 <= Length of String <= 10
13 | 
14 | // Output Format
15 | // Print the number after converting it into integer
16 | 
17 | // Sample Input
18 | // 1234
19 | // Sample Output
20 | // 1234
21 | // Explanation
22 | // Convert the string to int. Do not use any inbuilt functions.
23 | 
24 | #include<iostream>
25 | #include<cstring>
26 | using namespace std;
27 | int convert(char *a,int n){
28 | 	if(n==0)
29 | 	return 0;
30 | 	int digit = a[n-1]-'0';
31 | 	int ans = convert(a,n-1);
32 | 	return ans*10+digit;
33 | }
34 | int main() {
35 | 	char temp[1000];
36 | 	cin>>temp;
37 | 	cout<<convert(temp,strlen(temp));
38 | 	return 0;
39 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Decimal to Octal.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Decimal to Octal */
 3 | //Take N (number in decimal format). Write a function that converts it to octal format. Print the value returned.
 4 | 
 5 | #include<iostream>
 6 | using namespace std;
 7 | int convert(int x){
 8 |     int octal=0;
 9 |     int i=1;
10 |     while(x>0)
11 |     {
12 |         octal = octal + (x%8) *i;
13 |         i *= 10;
14 |         x /= 8;
15 |     }
16 |     return octal;
17 | }
18 | int main() {
19 |     int x;
20 |     cin>>x;
21 |     cout<<convert(x);
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Difference in ASCII Codes.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Difference in ASCII Codes */
 3 | 
 4 | // Take as input S, a string. Write a program that inserts between each pair of characters the difference between their ascii codes and print the ans.
 5 | 
 6 | // Input Format
 7 | // String
 8 | 
 9 | // Constraints
10 | // Length of String should be between 2 to 1000.
11 | 
12 | // Output Format
13 | // String
14 | 
15 | // Sample Input
16 | // acb
17 | // Sample Output
18 | // a2c-1b
19 | // Explanation
20 | // For the sample case, the Ascii code of a=97 and c=99 ,the difference between c and a is 2.Similarly ,the Ascii code of b=98 and c=99 and their difference is -1. So the ans is a2c-1b.
21 | 
22 | #include<iostream>
23 | #include<string>
24 | using namespace std;
25 | int main() {
26 | 	string s;
27 | 	cin>>s;
28 | 	int i = 0;
29 | 	int n = s.length();
30 | 	while(i<n-1){
31 | 		cout<<s[i]<<(int)s[i+1]-(int)s[i];
32 | 		i++;
33 | 	}
34 | 	cout<<s[i];
35 | 	return 0;
36 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Duplicate Character Formatting.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Duplicate Character Formatting */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // Take as input str, a string. Write a recursive function which returns a new string in which all duplicate consecutive characters are separated by a ‘ * ’. E.g. for “hello” return “hel*lo”. Print the value returned
 7 | 
 8 | // Input Format
 9 | // Enter a String
10 | 
11 | // Constraints
12 | // 1<= Length of string <= 10^4
13 | 
14 | // Output Format
15 | // Display the resulting string (i.e after inserting (*) b/w all the duplicate characters)
16 | 
17 | // Sample Input
18 | // hello
19 | // Sample Output
20 | // hel*lo
21 | // Explanation
22 | // We insert a "*" between the two consecutive 'l' .
23 | 
24 | #include<iostream>
25 | #include<cstring>
26 | using namespace std;
27 | void gen(char* inp,int i){
28 | 	if(inp[i]=='\0' || inp[i+1]=='\0')
29 | 	{
30 | 		return ;
31 | 	}
32 | 	if(inp[i]==inp[i+1]){
33 | 		// int j=i+1;
34 | 		for(int k=strlen(inp);k>i+1;k--)
35 | 		inp[k]=inp[k-1];
36 | 		inp[i+1]='*';
37 | 		gen(inp,i+2);
38 | 	}
39 | 	else
40 | 	 gen(inp,i+1);
41 | }
42 | int main() {
43 | 	char inp[10000];
44 | 	cin>>inp;
45 | 	
46 | 	gen(inp,0);
47 | 	cout<<inp<<endl;
48 | 	return 0;
49 | }


--------------------------------------------------------------------------------
/Hacker Blocks/FIBONACCI PATTERN (PATTERN 4).cpp:
--------------------------------------------------------------------------------
 1 | /* Coding Blocks Hacker Blocks*/
 2 | /* Title - FIBONACCI PATTERN (PATTERN 4) */
 3 | //Take N (number of rows), print the following pattern (for N = 4)
 4 | //0
 5 | //1 1
 6 | //2 3 5
 7 | //8 13 21 34
 8 | #include<iostream>
 9 | using namespace std;
10 | int main() {
11 | 	int a=0,b=1,c,n;
12 | 	cin>>n;
13 | 	for(int i=1;i<=n;i++)
14 | 	{
15 | 		for(int k=1;k<=i;k++)
16 | 		{
17 | 			cout<<a<<" ";
18 | 			c=a+b;
19 | 			a=b;
20 | 			b=c;
21 | 		}
22 | 		cout<<endl;
23 | 	}
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Find Last Element.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Find Last Element */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 06/07/2020 */
 5 | 
 6 | // Take as input N, the size of array. Take N more inputs and store that in an array. Take as input M, a number. Write a recursive function which returns the last index at which M is found in the array and -1 if M is not found anywhere. Print the value returned.
 7 | 
 8 | // Input Format
 9 | // There will be three lines of input:
10 | 
11 | // N - the size of the array
12 | // N space separated integers that make up the array
13 | // M
14 | // Constraints
15 | // 1 < N < 1000
16 | // -10^9 < i,M < 10^9 , where i is any number within the array
17 | 
18 | // Output Format
19 | // For each case, print the integer value of the last index that M is found at within the given array.
20 | // If it is not found, print '-1' (without the quotes).
21 | 
22 | // Sample Input
23 | // 7
24 | // 86 -16 77 65 45 77 28
25 | // 77
26 | // Sample Output
27 | // 5
28 | // Explanation
29 | // Last occurence of 77 is found at index = 5.
30 | 
31 | #include<iostream>
32 | using namespace std;
33 | int fun(int *a,int n,int k){
34 | 	if(n==0)
35 | 	return -1;
36 | 	int i=fun(a+1,n-1,k);
37 | 	if(i==-1){
38 | 		if(a[0]==k)
39 | 		return 0;
40 | 		else
41 | 		return -1;
42 | 	}
43 | 	return i+1;
44 | }
45 | int main() {
46 | 	int n;
47 | 	cin>>n;
48 | 	int a[n];
49 | 	for(int i=0;i<n;i++)
50 | 	cin>>a[i];
51 | 	int m;
52 | 	cin>>m;
53 | 	cout<<fun(a,n,m)<<endl;
54 | 	return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Find The Greater Element.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Find The Greater Element */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 5/8/2020 */
 5 | /* Topic - Stack & Queue */
 6 | 
 7 | // We are given a circular array, print the next greater number for every element. If it is not found print -1 for that number. To find the next greater number for element Ai , start from index i + 1 and go uptil the last index after which we start looking for the greater number from the starting index of the array since array is circular.
 8 | 
 9 | // Input Format
10 | // First line contains the length of the array n. Second line contains the n space separated integers.
11 | 
12 | // Constraints
13 | // 1 <= n <= 10^6
14 | // -10^8 <= Ai <= 10^8 , 0<= i< n
15 | 
16 | // Output Format
17 | // Print n space separated integers each representing the next greater element.
18 | 
19 | // Sample Input
20 | // 3
21 | // 1 2 3
22 | // Sample Output
23 | // 2 3 -1
24 | // Explanation
25 | // Next greater element for 1 is 2,
26 | // for 2 is 3 but not present for 3 therefore -1
27 | 
28 | #include<iostream>
29 | using namespace std;
30 | int main() {
31 | 	int n;
32 | 	cin>>n;
33 | 	int a[n];
34 | 	for(int i=0;i<n;i++)
35 | 	cin>>a[i];
36 | 	for(int i=0;i<n;i++){
37 | 		bool flag = false;
38 | 		int front =i;
39 | 		int rear = (i+1)%n;
40 | 		while(front!=rear){
41 | 			if(a[front]<a[rear]){
42 | 				cout<<a[rear]<<" ";
43 | 				flag = true;
44 | 				break;
45 | 			}
46 | 			rear = (rear+1)%n;
47 | 		}
48 | 		if(!flag)
49 | 		cout<<-1<<" ";
50 | 	}
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Form Biggest Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Form Biggest Number */
 3 | 
 4 | // You are provided an array of numbers. You need to arrange them in a way that yields the largest value.
 5 | 
 6 | // Input Format
 7 | // First line contains integer t which is number of test case.
 8 | // For each test case, you are given a single integer n in the first line which is the size of array A[] and next line contains n space separated integers denoting the elements of the array A .
 9 | 
10 | // Constraints
11 | // 1<=t<=100
12 | // 1<=m<=100
13 | // 1<=A[i]<=10^5
14 | 
15 | // Output Format
16 | // Print the largest value.
17 | 
18 | // Sample Input
19 | // 1
20 | // 4
21 | // 54 546 548 60
22 | // Sample Output
23 | // 6054854654
24 | // Explanation
25 | // Upon rearranging the elements of the array , 6054854654 is the largest possible number that can be generated.
26 | 
27 | #include<iostream>
28 | #include<algorithm>
29 | #include<string>
30 | using namespace std;
31 | bool compare(string s, string r){
32 | 	string sr = s.append(r);
33 | 	string rs = r.append(s);
34 | 	return sr.compare(rs)>0?true:false;
35 | }
36 | int main() {
37 | 	int t;
38 | 	cin>>t;
39 | 	while(t--){
40 | 		int n;
41 | 		cin>>n;
42 | 		string a[n];
43 | 		for(int i=0;i<n;i++)
44 | 			cin>>a[i];
45 | 		sort(a,a+n,compare);
46 | 		for(int i=0;i<n;i++)
47 | 		cout<<a[i];
48 | 		cout<<endl;
49 | 
50 | 	}
51 | 	return 0;
52 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Generate Parentheses.cpp:
--------------------------------------------------------------------------------
 1 | /* Coding Blocks */
 2 | /* Title - Generate Parentheses */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/7/2020 */
 5 | 
 6 | // Given an integer 'n'. Print all the possible pairs of 'n' balanced parentheses.
 7 | // The output strings should be printed in the sorted order considering '(' has higher value than ')'.
 8 | 
 9 | // Input Format
10 | // Single line containing an integral value 'n'.
11 | 
12 | // Constraints
13 | // 1<=n<=11
14 | 
15 | // Output Format
16 | // Print the balanced parentheses strings with every possible solution on new line.
17 | 
18 | // Sample Input
19 | // 2
20 | // Sample Output
21 | // ()() 
22 | // (()) 
23 | 
24 | #include <iostream>
25 | using namespace std;
26 | 
27 | void generateParenthesis(int n, int openB, int closeB, string str) {
28 |     if(closeB == n) {
29 |         cout<<str<<endl;
30 |         return;
31 |     }
32 |     if(openB > closeB) {
33 |         generateParenthesis(n, openB, closeB+1, str+')');
34 |     }
35 |     if(openB < n) {
36 |         generateParenthesis(n, openB+1, closeB, str+'(');
37 |     }
38 | }
39 | 
40 | int main()
41 | {
42 |     int n;
43 |     cin>>n;
44 |     generateParenthesis(n, 0, 0, "");
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Help Ramu.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/akashmodak97/Competitive-Coding-and-Interview-Problems/88a36ee43ccaeacfdd8a521beac04b12c28ffe8e/Hacker Blocks/Help Ramu.cpp


--------------------------------------------------------------------------------
/Hacker Blocks/Hollow Diamond Pattern.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Hollow Diamond Pattern */
 3 | // Take N (number of rows), print the following pattern (for N = 5).
 4 | 
 5 | //      * * * * *
 6 | //      * *   * *
 7 | //      *       *
 8 | //      * *   * *
 9 | //      * * * * *
10 | 
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 | 
14 | int main() {
15 | 
16 |     int n;
17 |     cin>>n;
18 |     for(int i=0;i<n;i++){
19 |         cout<<'*'<<" ";
20 |     }
21 |     cout<<endl;
22 |     int a=n/2;
23 |     for(int i=0;i<n-2;i++){
24 |         if(i<a)
25 |         for(int j=0;j<a-i;j++){
26 |             cout<<'*'<<" ";
27 |         }
28 |         else{
29 |             for(int j=0;j<=i-a+1;j++){
30 |                 cout<<'*'<<" ";
31 |             }
32 |             
33 |         }
34 |         if(i<a)
35 |         for(int j=0;j<2*i+1;j++){
36 |             cout<<" "<<" ";
37 |         }
38 |         else{
39 |             for(int j=0;j<2*(n-2-i)-1;j++){
40 |                 cout<<" "<<" ";
41 |             }
42 |         }
43 |         if(i<a){
44 |             for(int j=0;j<a-i;j++){
45 |                 cout<<'*'<<" ";
46 |             }
47 |         }
48 |         else{
49 |             for(int j=0;j<=i-a+1;j++){
50 |                 cout<<'*'<<" ";
51 |             }
52 |         }
53 |         cout<<endl;
54 |     }
55 |     for(int i=0;i<n;i++){
56 |         cout<<'*'<<" ";
57 |     }
58 |     cout<<endl;
59 |     
60 | }
61 | 


--------------------------------------------------------------------------------
/Hacker Blocks/I Am Busy Man.cpp:
--------------------------------------------------------------------------------
 1 | /* SPOJ / Hacker Blocks */
 2 | /* Title - I Am Very Busy Man */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/8/2020 */
 5 | 
 6 | //Problem link - https://www.spoj.com/problems/BUSYMAN/
 7 | 
 8 | #include<bits/stdc++.h>
 9 | using namespace std;
10 | 
11 | bool compare(pair<int,int> a,pair<int,int> b){
12 | 	return a.second<b.second;
13 | }
14 | 
15 | int main(){
16 | 	int t;
17 | 	cin>>t;
18 | 	while(t--){
19 | 		int n,s,e;
20 | 		cin>>n;
21 | 
22 | 		vector<pair<int,int> > v;
23 | 		for(int i=0;i<n;i++){
24 | 			cin>>s>>e;
25 | 			v.push_back(make_pair(s,e));
26 | 		}
27 | 		sort(v.begin(),v.end(),compare);
28 | 		int activity=1;
29 | 		int taken_activity = v[0].second;
30 | 		for(int i=1;i<v.size();i++){
31 | 			if(v[i].first>=taken_activity){
32 | 				activity++;
33 | 				taken_activity = v[i].second;
34 | 			}
35 | 		}
36 | 		cout<<activity<<endl;
37 | 	}
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Is Palindrome.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Is Palindrome */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/6/2020 */
 5 | 
 6 | // Take as input N, a number. Take N more inputs and store that in an array. Write a recursive function which tests if the array is a palindrome and returns a Boolean value. Print the value returned.
 7 | 
 8 | // Input Format
 9 | // Enter a number N , add N more numbers
10 | 
11 | // Constraints
12 | // None
13 | 
14 | // Output Format
15 | // Display the Boolean result
16 | 
17 | // Sample Input
18 | // 4
19 | // 1
20 | // 2
21 | // 2
22 | // 1
23 | // Sample Output
24 | // true
25 | 
26 | #include<iostream>
27 | using namespace std;
28 | bool pal(int a[],int start,int end){
29 | 	if(start==end)
30 | 	return true;
31 | 	else{
32 | 		while(start<=end){
33 | 			if(a[start]==a[end])
34 | 			return pal(a,start+1,end-1);
35 | 			else
36 | 			return false;
37 | 		}
38 | 	}
39 | 	return true;
40 | }
41 | int main() {
42 | 	int n;
43 | 	cin>>n;
44 | 	int a[n];
45 | 	for(int i=0;i<n;i++)
46 | 	cin>>a[i];
47 | 	pal(a,0,n-1)?cout<<"true":cout<<"false";
48 | 	return 0;
49 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Kth Root.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Kth Root */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/06/2020 */
 5 | 
 6 | // You are given two integers n and k. Find the greatest integer x, such that, x^k <= n.
 7 | 
 8 | // Input Format
 9 | // First line contains number of test cases, T. Next T lines contains integers, n and k.
10 | 
11 | // Constraints
12 | // 1<=T<=10 1<=N<=10^15 1<=K<=10^4
13 | 
14 | // Output Format
15 | // Output the integer x
16 | 
17 | // Sample Input
18 | // 2
19 | // 10000 1
20 | // 1000000000000000 10
21 | // Sample Output
22 | // 10000
23 | // 31
24 | // Explanation
25 | // For the first test case, for x=10000, 10000^1=10000=n
26 | 
27 | #include<iostream>
28 | #include<cmath>
29 | using namespace std;
30 | int main() {
31 | 	int t;
32 | 	cin>>t;
33 | 	while(t--){
34 | 		long long int n,k;
35 | 		cin>>n>>k;
36 | 		long long int s=1,e=n;
37 | 		long long int ans = 0;
38 | 		while(s<=e){
39 | 			long long int mid = (s+e)/2;
40 | 			if(pow(mid,k)<=n){
41 | 				ans = max(ans,mid);
42 | 				s=mid+1;
43 | 			}
44 | 			else
45 | 			e=mid-1;
46 | 
47 | 		}
48 | 		cout<<ans<<endl;
49 | 	}
50 | 	return 0;
51 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Manmohan Loves Patterns - I.cpp:
--------------------------------------------------------------------------------
 1 | /*Coding Blocks Hacker Blocks*/
 2 | /*Title - Manmohan Loves Patterns - I */ 
 3 | 
 4 | //Given N, help Manmohan to print pattern upto N lines. For eg For N=6 , following pattern will be printed.
 5 | //
 6 | //1
 7 | //11
 8 | //111
 9 | //1001
10 | //11111
11 | //100001
12 | //
13 | //Input Format
14 | //Single number N.
15 | #include<iostream>
16 | using namespace std;
17 | int main() {
18 | 	int n;
19 | 	int col,row;
20 | 	cin>>n;
21 | 	row=1;
22 | 	while(row<=n)
23 | 	{
24 | 		col=1;
25 | 		if(row%2==0)
26 | 		{
27 | 			cout<<1;
28 | 			while(col<=row-2){
29 | 			cout<<0;
30 | 			col++;
31 | 			}
32 | 			cout<<1;
33 | 			
34 | 		}
35 | 		else
36 | 		{
37 | 			while(col<=row)
38 | 			{
39 | 				cout<<1;
40 | 				col++;
41 | 			}
42 | 		}
43 | 		cout<<endl;
44 | 		row++;
45 | 	}
46 | 	return 0;
47 | }
48 | 
49 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Manmohan Loves Patterns- II.cpp:
--------------------------------------------------------------------------------
 1 | /*Coding Blocks Hacker Blocks*/
 2 | /*Title - Manmohan Loves Patterns- II */
 3 | 
 4 | //Help Manmohan to print pattern of a given number. See the output pattern for given input n = 5.
 5 | //
 6 | //Input Format
 7 | //Single integer N denoting number of lines of the pattern.
 8 | //
 9 | //Constraints
10 | //N<=1000
11 | //
12 | //Output Format
13 | //Pattern.
14 | //
15 | //Sample Input
16 | //5
17 | //Sample Output
18 | //1
19 | //11
20 | //202
21 | //3003
22 | //40004
23 | //Explanation
24 | //If row number is n (>1), total character is n. First and last character is n-1 and rest are 0.
25 | #include<iostream>
26 | using namespace std;
27 | int main() {
28 | 	int n;
29 | 	int row,col;
30 | 	cin>>n;
31 | 	row = 1;
32 | 	while(row<=n)
33 | 	{
34 | 		col = 1;
35 | 		if(row==1)
36 | 		cout<<1;
37 | 		else
38 | 		{
39 | 			cout<<row-1;
40 | 			while(col<=row-2)
41 | 			{
42 | 				cout<<0;
43 | 				col++;
44 | 			}
45 | 			cout<<row-1;
46 | 		}
47 | 		cout<<endl;
48 | 		row++;
49 | 	}
50 | 	return 0;
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Mapped Strings.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Mapped Strings */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // We are given a hashmap which maps all the letters with number. Given 1 is mapped with A, 2 is mapped with B…..26 is mapped with Z. Given a number, you have to print all the possible strings.
 7 | 
 8 | // Input Format
 9 | // A single line contains a number.
10 | 
11 | // Constraints
12 | // Number is less than 10^6
13 | 
14 | // Output Format
15 | // Print all the possible strings in sorted order in different lines.
16 | 
17 | // Sample Input
18 | // 123
19 | // Sample Output
20 | // ABC
21 | // AW
22 | // LC
23 | // Explanation
24 | // '1' '2' '3' = ABC
25 | // '1' '23' = AW
26 | // '12' '3' = LC
27 | 
28 | #include<iostream>
29 | using namespace std;
30 | void generate(char *inp, char *out,int i,int j){
31 | 	if(inp[i]=='\0'){
32 | 		out[j]='\0';
33 | 		cout<<out<<endl;
34 | 		return ;
35 | 	}
36 | 	//single digit
37 | 	int dig = inp[i]-'0';
38 | 	if(dig==0){
39 | 		generate(inp,out,i+1,j);
40 | 	}
41 | 	else{
42 | 	char ch = dig + 'A' - 1;
43 | 	out[j] = ch;
44 | 	// cout<<ch<<" hi"<<endl;
45 | 	generate(inp,out,i+1,j+1);
46 | 	}
47 | 	if(inp[i+1]!='\0'){
48 | 		int second = inp[i+1]-'0';
49 | 		int num = 10*dig+second;
50 | 		if(num<=26){
51 | 		char ch1 = num+'A'-1;
52 | 		out[j]=ch1;
53 | 		generate(inp,out,i+2,j+1);
54 | 		}
55 | 	}
56 | 	return ;
57 | }
58 | int main() {
59 | 	char a[1000000];
60 | 	cin>>a;
61 | 	char out[1000000];
62 | 	generate(a,out,0,0);
63 | 	return 0;
64 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Max Frequency Characters.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Max Frequency Characters */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/6/2020 */
 5 | 
 6 | // Take as input S, a string. Write a function that returns the character with maximum frequency. Print the value returned.
 7 | 
 8 | // Input Format
 9 | // String
10 | 
11 | // Constraints
12 | // A string of length between 1 to 1000.
13 | 
14 | // Output Format
15 | // Character
16 | 
17 | // Sample Input
18 | // aaabacb
19 | // Sample Output
20 | // a
21 | // Explanation
22 | // For the given input string, a appear 4 times. Hence, it is the most frequent character.
23 | 
24 | #include<iostream>
25 | #include<algorithm>
26 | #include<vector>
27 | using namespace std;
28 | int maxFrequency(){
29 | 	string str;
30 | 	cin>>str;
31 | 	vector<int> ar(26,0);
32 | 	for(int i=0;i<str.length();i++){
33 | 		ar[str[i]-'a']++;
34 | 	}
35 | 	auto it = max_element(ar.begin(),ar.end());
36 | 	// cout<<*it<<endl;
37 | 	return it-ar.begin()+97;
38 | }
39 | int main() {
40 | 	char element = maxFrequency();
41 | 	cout<<element<<endl;
42 | 	return 0;
43 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Merge Sorted Linked List.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Merge Sorted Linked List */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 2/8/2020 */
 5 | 
 6 | // Given 2 sorted linked lists , merge the two given sorted linked list and print the final Linked List.
 7 | 
 8 | // Input Format
 9 | // First Line contains T the number of test cases.
10 | // For each test case :
11 | // Line 1 : N1 the size of list 1
12 | // Line 2 : N1 elements for list 1
13 | // Line 3 : N2 the size of list 2
14 | // Line 4 : N2 elements for list 2
15 | 
16 | // Constraints
17 | // 1 <= T <= 1000
18 | // 0<= N1, N2 <= 10^6
19 | // -10^7 <= Ai <= 10^7
20 | 
21 | // Output Format
22 | // For each testcase , print the node data of merged linked list.
23 | 
24 | // Sample Input
25 | // 1
26 | // 4
27 | // 1 3 5 7
28 | // 3
29 | // 2 4 6
30 | // Sample Output
31 | // 1 2 3 4 5 6 7 
32 | // Explanation
33 | // The two lists after merging give the sorted output as [1,2,3,4,5,6,7] .
34 | 
35 | #include<bits/stdc++.h>
36 | using namespace std;
37 | 
38 | 
39 | int main() {
40 | 	int t;
41 | 	cin>>t;
42 | 	while(t--){
43 | 		int n1,n2;
44 | 		list<int> l1,l2;
45 | 		cin>>n1;
46 | 		for(int i=0;i<n1;i++)
47 | 		{
48 | 			int temp;
49 | 			cin>>temp;
50 | 			l1.push_back(temp);
51 | 		}
52 | 		cin>>n2;
53 | 		for(int i=0;i<n2;i++)
54 | 		{
55 | 			int temp;
56 | 			cin>>temp;
57 | 			l2.push_back(temp);
58 | 		}
59 | 		l1.merge(l2);
60 | 		for(auto x = l1.begin();x!=l1.end();x++){
61 | 			cout<<(*x)<<" ";
62 | 		}
63 | 		cout<<endl;
64 | 	}
65 | 	return 0;
66 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Modular Exponentiation.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Modular exponentiation */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 2/7/2020 */
 5 | 
 6 | // Given three numbers a,b,c. Calculate (a^b)mod c.
 7 | 
 8 | // Input Format
 9 | // Single line containing three integers a,b,c separated by space.
10 | 
11 | // Constraints
12 | // 1<=a,b,c<=100000
13 | 
14 | // Output Format
15 | // Print (a^b)mod c.
16 | 
17 | // Sample Input
18 | // 2 2 3
19 | // Sample Output
20 | // 1
21 | // Explanation
22 | // (2^2)mod 3=4 mod 3 = 1
23 | 
24 | #include<iostream>
25 | #include<cmath>
26 | using namespace std;
27 | long long int power(long long int x, unsigned int y, int p)  
28 | {  
29 |     long long int res = 1;     // Initialize result  
30 |   
31 |     x = x % p; // Update x if it is more than or  
32 |                 // equal to p 
33 |    
34 |     if (x == 0) return 0; // In case x is divisible by p; 
35 |   
36 |     while (y > 0)  
37 |     {  
38 |         // If y is odd, multiply x with result  
39 |         if (y & 1)  
40 |             res = (res*x) % p;  
41 |   
42 |         // y must be even now  
43 |         y = y>>1; // y = y/2  
44 |         x = (x*x) % p;  
45 |     }  
46 |     return res;  
47 | }  
48 |  
49 | int main() {
50 | 	int a,b,c;
51 | 	cin>>a>>b>>c;
52 | 	// long long int x = pow(a%c,b);
53 | 	
54 | 	cout<<power(a,b,c)<<endl;
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Mountain Pattern.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Mountain Pattern */
 3 | //Take N (number of rows), print the following pattern (for N = 4).
 4 | 
 5 | //                       1           1
 6 | //                       1 2       2 1  
 7 | //                       1 2 3   3 2 1
 8 | //                       1 2 3 4 3 2 1  
 9 | 
10 | 
11 | 
12 | #include<iostream>
13 | using namespace std;
14 | int main() {
15 | 	int n;
16 | 	cin>>n;
17 | 	int i,j,k;
18 | 	for(i=1;i<=n;i++)
19 | 	{
20 | 		for(j=1;j<=i;j++)
21 | 		cout<<j<<" ";
22 | 		for(k=((n-i)*2)-1;k>0;k--)
23 | 		cout<<"  ";
24 | 		if(i==n)
25 | 		j--;
26 | 		for(int l=j-1;l>=1;l--)
27 | 		cout<<l<<" ";
28 | 		cout<<endl;
29 | 	}
30 | 	return 0;
31 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Move All X At End.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Move All X At End */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // Take as input str, a string. Write a recursive function which moves all ‘x’ from the string to its end.
 7 | // E.g. for “abexexdexed” return “abeedeedxxx”.
 8 | // Print the value returned
 9 | 
10 | // Input Format
11 | // Single line input containing a string
12 | 
13 | // Constraints
14 | // Length of string <= 1000
15 | 
16 | // Output Format
17 | // Single line displaying the string with all x's moved at the end
18 | 
19 | // Sample Input
20 | // axbxc
21 | // Sample Output
22 | // abcxx
23 | // Explanation
24 | // All x's are moved to the end of string while the order of remaining characters remain the same.
25 | 
26 | #include <bits/stdc++.h>
27 | using namespace std;
28 | void moveatend(char *inp, int i, int l)
29 | {
30 |     if(i>=l){
31 |         return;
32 |     } 
33 |     char x=inp[i];
34 |     if(x!='x'){
35 |         cout<<x;
36 |     }
37 |     moveatend(inp,i+1,l);
38 |     if(x=='x'){
39 |         cout<<x;
40 |     }
41 |     return;
42 | }
43 | int main() {
44 |     char inp[10001];
45 |     cin>>inp;
46 |     int l = strlen(inp);
47 |     moveatend(inp,0,l);
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Pattern Double Sided Arrow.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Pattern Double Sided Arrow */
 3 | // Take N as input. For a value of N=7, we wish to draw the following pattern :
 4 | 
 5 | //                             1 
 6 | //                         2 1   1 2 
 7 | //                     3 2 1       1 2 3 
 8 | //                 4 3 2 1           1 2 3 4 
 9 | //                     3 2 1       1 2 3 
10 | //                         2 1   1 2 
11 | //                             1 
12 | 
13 | #include<iostream>
14 | using namespace std;
15 | int main() {
16 |     int n;
17 |     cin>>n;
18 |     for(int i=1;i<=(n+1)/2;i++){
19 |         for(int j=1;j<=(2*(n+1-2*i));j++){
20 |             cout<<" ";
21 |         }
22 |         for(int j = i;j>0;j--){
23 |             cout<<j<<" ";
24 |         }
25 |         
26 |         for(int j=1;j<(4*(i-1)-1);j++){
27 |             cout<<" ";
28 |         }
29 |         if(i>1){
30 |         for(int j=1;j<=i;j++){
31 |             cout<<j<<" ";
32 |         }
33 |     }
34 |         cout<<endl;
35 |     }
36 |     for(int i=n/2;i>0;i--){
37 |          for(int j=1;j<=(2*(n+1-2*i));j++){
38 |             cout<<" ";
39 |         }
40 |         for(int j = i;j>0;j--){
41 |             cout<<j<<" ";
42 |         }
43 |         
44 |         for(int j=1;j<(4*(i-1)-1);j++){
45 |             cout<<" ";
46 |         }
47 |         if(i>1){
48 |         for(int j=1;j<=i;j++){
49 |             cout<<j<<" ";
50 |         }
51 |         }
52 |         cout<<endl;
53 |     }
54 | 	return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Pattern Inverted Hour Glass.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Pattern Inverted Hour Glass */
 3 | // Take N as input. For a value of N=5, we wish to draw the following pattern :
 4 | 
 5 | //              5                   5 
 6 | //              5 4               4 5 
 7 | //              5 4 3           3 4 5 
 8 | //              5 4 3 2       2 3 4 5 
 9 | //              5 4 3 2 1   1 2 3 4 5 
10 | //              5 4 3 2 1 0 1 2 3 4 5 
11 | //              5 4 3 2 1   1 2 3 4 5 
12 | //              5 4 3 2       2 3 4 5 
13 | //              5 4 3           3 4 5 
14 | //              5 4               4 5 
15 | //              5                   5 
16 | 
17 | #include<iostream>
18 | using namespace std;
19 | 
20 | 
21 | int main(){
22 | 
23 | 	int n;
24 | 	cin>>n;
25 | 
26 | 	//Upper
27 | 
28 | 	for(int i=n;i>=1;i--){
29 | 		for(int j=n;j>=i;j--){
30 | 			cout<<j<<" ";
31 | 		}
32 | 
33 | 		for(int j=2*i-1;j>=1;j--){
34 | 			cout<<"  ";
35 | 		}
36 | 
37 | 		for(int j=i;j<=n;j++){
38 | 			cout<<j<<" ";
39 | 		}
40 | 		cout<<endl;
41 | 	}
42 |     for(int i=n;i>=0;i--)
43 |         cout<<i<<" ";
44 |     for(int i=1;i<=n;i++)
45 |         cout<<i<<" ";
46 |     cout<<endl;
47 | 	//Lower
48 | 
49 | 	for(int i=1;i<=n;i++){
50 | 		for(int j=n; j>=i;j--){
51 | 			cout<<j<<" ";
52 | 		}
53 | 
54 | 		for(int j=1;j<=2*i-1;j++){
55 | 			cout<<"  ";
56 | 		}
57 | 
58 | 		for(int j=i;j<=n;j++){
59 | 			cout<<j<<" ";
60 | 		}
61 | 		cout<<endl;
62 | 	}
63 | 	return 0;
64 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Pattern Triangle.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Pattern Triangle */
 3 | 
 4 | //Take N (number of rows), print the following pattern (for N = 4).
 5 | // 		  	1 
 6 | //        2 3 2
 7 | //      3 4 5 4 3
 8 | //    4 5 6 7 6 5 4
 9 | 
10 | 
11 | #include<iostream>
12 | using namespace std;
13 | int main() {
14 |     int n;
15 |     cin>>n;
16 |     for(int i=1;i<=n;i++)
17 |     {
18 |         for(int j=i;j<n;j++)
19 |             cout<<" ";
20 |         int val = i;
21 |         
22 |         int c = (2*i-1)/2;
23 |         for(int m=1;m<=c+1;m++)
24 |             cout<<val++<<" ";
25 |         val--;
26 |         for(int m=c+2;m<=2*i-1;m++)
27 |             cout<<--val<<" ";
28 |         cout<<endl;
29 |         
30 |     }
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Pattern With Zeroes.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Pattern with zeroes */
 3 | //Take N (number of rows), print the following pattern (for N = 5)
 4 | //1
 5 | //2 2
 6 | //3 0 3
 7 | //4 0 0 4
 8 | //5 0 0 0 5
 9 | 
10 | #include<iostream>
11 | using namespace std;
12 | int main() {
13 | 	int n;
14 | 	int row,col;
15 | 	cin>>n;
16 | 	row = 1;
17 | 	while(row<=n)
18 | 	{
19 | 		col = 1;
20 | 		if(row==1)
21 | 		cout<<1;
22 | 		else
23 | 		{
24 | 			cout<<row<<" ";
25 | 			while(col<=row-2)
26 | 			{
27 | 				cout<<0<<" ";
28 | 				col++;
29 | 			}
30 | 			cout<<row;
31 | 		}
32 | 		cout<<endl;
33 | 		row++;
34 | 	}
35 | 	return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Playing With Bits.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Playing With Bits */
 3 | /* Created By - Akash Modak */
 4 | /* Date 7/1/2020 */
 5 | 
 6 | // Prateek Bhayia likes to play with bits. One day Prateek bhayia decides to assign a task to his student Sanya. You have help Sanya to complete this task. Task is as follows - Prateek Bhayia gives Q queries each query containing two integers a and b. Your task is to count the no of set-bits in for all numbers between a and b (both inclusive)
 7 | 
 8 | // Input Format
 9 | // Read Q - No of Queries, Followed by Q lines containing 2 integers a and b.
10 | 
11 | // Constraints
12 | // Q,a,b are integers.
13 | 
14 | // Output Format
15 | // Q lines, each containing an output for your query.
16 | 
17 | // Sample Input
18 | // 2
19 | // 1 1
20 | // 10 15
21 | // Sample Output
22 | // 1
23 | // 17
24 | 
25 | #include<iostream>
26 | using namespace std;
27 | int countSetBits(int n){
28 | 	int ans=0;
29 | 	while(n>0){
30 | 		if(n&1==1)
31 | 		ans++;
32 | 		n=n>>1;
33 | 	}
34 | 	return ans;
35 | }
36 | int main() {
37 | 	int q,a,b;
38 | 	cin>>q;
39 | 	while(q--){
40 | 		cin>>a>>b;
41 | 		int count =0;
42 | 		for(int i=a;i<=b;i++){
43 | 			count+= countSetBits(i);
44 | 		}
45 | 		cout<<count<<endl;
46 | 	}
47 | 	return 0;
48 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Pythagorean Triplet.cpp:
--------------------------------------------------------------------------------
 1 | /*Hacker Blocks*/
 2 | /*Title - Pythagorean Triplet*/
 3 | #include<iostream>
 4 | #include<cmath>
 5 | using namespace std;
 6 | int main() {
 7 | 	int N;
 8 | 	cin>>N;
 9 | 	if( N == 1 || N == 2 )
10 | 		cout<<-1;
11 | 	else if( N % 2 == 0 )
12 | 	{
13 | 		int temp = pow(N/2,2);
14 | 		cout<<temp-1<<" "<<temp+1;
15 | 	}
16 | 	else
17 | 	{
18 | 		int temp1 = (N+1)/2;
19 | 		int temp2 = (N-1)/2;
20 | 		cout<<2*temp1*temp2<<" "<<pow(temp1,2)+pow(temp2,2);
21 | 
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Queue Using Stack.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Dequeue efficient queue using stack */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/08/2020 */
 5 | 
 6 | // Implement a Queue using two stacks Make it Dequeue efficient.
 7 | 
 8 | // Input Format
 9 | // Enter the size of the queue N add 0 - N-1 numbers in the queue
10 | 
11 | // Constraints
12 | // Output Format
13 | // Display the numbers in the order they are dequeued and in a space separated manner
14 | 
15 | // Sample Input
16 | // 5
17 | // Sample Output
18 | // 0 1 2 3 4
19 | 
20 | 
21 | #include<bits/stdc++.h>
22 | using namespace std;
23 | 
24 | int main() {
25 | 	stack<int> a,b,c;
26 | 	int n;
27 | 	cin>>n;
28 | 	for(int i=0;i<n;i++)
29 | 	a.push(i);
30 | 	while(!a.empty()){
31 | 		b.push(a.top());
32 | 		a.pop();
33 | 	}
34 | 	while(!b.empty()){
35 | 		cout<<b.top()<<" ";
36 | 		b.pop();
37 | 	}
38 | 	return 0;
39 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Remove Duplicates.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Remove Duplicates */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // Take as input S, a string. Write a function that removes all consecutive duplicates. Print the value returned.
 7 | 
 8 | // Input Format
 9 | // String
10 | 
11 | // Constraints
12 | // A string of length between 1 to 1000
13 | 
14 | // Output Format
15 | // String
16 | 
17 | // Sample Input
18 | // aabccba
19 | // Sample Output
20 | // abcba
21 | // Explanation
22 | // For the given example, "aabccba", Consecutive Occurrence of a is 2, b is 1, and c is 2.
23 | 
24 | // After removing all of the consecutive occurences, the Final ans will be : - "abcba".
25 | 
26 | #include<iostream>
27 | #include<cstring>
28 | using namespace std;
29 | void gen(char* inp,int i){
30 | 	if(inp[i]=='\0' or inp[i+1]=='\0')
31 | 	return ;
32 | 	if(inp[i]==inp[i+1]){
33 | 		for(int j=i+1;j<strlen(inp);j++)
34 | 		inp[j]=inp[j+1];
35 | 		gen(inp,i);
36 | 	}
37 | 	else
38 | 	gen(inp,i+1);
39 | }
40 | int main() {
41 | 	char inp[100000];
42 | 	cin>>inp;
43 | 	gen(inp,0);
44 | 	cout<<inp<<endl;
45 | 	return 0;
46 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Replace PI.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Replace PI */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 06/07/2020 */
 5 | 
 6 | // Replace all occurrences of pi with 3.14
 7 | 
 8 | // Input Format
 9 | // Integer N, no of lines with one string per line
10 | 
11 | // Constraints
12 | // 0 < N < 1000
13 | // 0 <= len(str) < 1000
14 | 
15 | // Output Format
16 | // Output result one per line
17 | 
18 | // Sample Input
19 | // 3
20 | // xpix
21 | // xabpixx3.15x
22 | // xpipippixx
23 | // Sample Output
24 | // x3.14x
25 | // xab3.14xx3.15x
26 | // x3.143.14p3.14xx
27 | // Explanation
28 | // All occurrences of pi have been replaced with "3.14".
29 | 
30 | #include<iostream>
31 | using namespace std;
32 | void replacepi(char *a,int i){
33 | 	if(a[i]=='\0' or a[i+1]=='\0')
34 | 	return;
35 | 	if(a[i]=='p' and a[i+1]=='i'){
36 | 		int j=i;
37 | 		while(a[j]!='\0')
38 | 		j++;
39 | 		while(j>=i+2){
40 | 			a[j+2]=a[j];
41 | 			j--;
42 | 		}
43 | 		a[i]='3';
44 | 		a[i+1]='.';
45 | 		a[i+2]='1';
46 | 		a[i+3]='4';
47 | 		replacepi(a,i+4);
48 | 	}
49 | 	else
50 | 	replacepi(a,i+1);
51 | }
52 | int main() {
53 | 	int t;
54 | 	cin>>t;
55 | 	while(t--){
56 | 	char a[1000];
57 | 	cin>>a;
58 | 	// int n = strlen(a);
59 | 	replacepi(a,0);
60 | 	cout<<a<<endl;
61 | 	}
62 | 	return 0;
63 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Rotate Image.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Rotate Image (NxN) */
 3 | 
 4 | // Given a 2D array of size N x N. Rotate the array 90 degrees anti-clockwise.
 5 | // Input Format
 6 | // First line contains a single integer N. Next N lines contain N space separated integers.
 7 | 
 8 | // Constraints
 9 | // N < 1000
10 | 
11 | // Output Format
12 | // Print N lines with N space separated integers of the rotated array.
13 | 
14 | // Sample Input
15 | // 4
16 | // 1 2 3 4
17 | // 5 6 7 8
18 | // 9 10 11 12
19 | // 13 14 15 16
20 | // Sample Output
21 | // 4 8 12 16 
22 | // 3 7 11 15 
23 | // 2 6 10 14 
24 | // 1 5 9 13 
25 | // Explanation
26 | // Rotate the array 90 degrees anticlockwise.
27 | 
28 | #include<iostream>
29 | #include<algorithm>
30 | using namespace std;
31 | 
32 | int main() {
33 | 	int n;
34 | 	cin>>n;
35 | 	int a[n][n];
36 | 	for(int i=0;i<n;i++)
37 | 	for(int j=0;j<n;j++)
38 | 	cin>>a[i][j];
39 | 	for(int i=0;i<n;i++)
40 | 	reverse(a[i],a[i]+n);
41 | 	for(int i=0;i<n;i++)
42 | 		for(int j=0;j<n;j++)
43 | 			if(i<j)
44 | 			swap(a[i][j],a[j][i]);
45 | 	for(int i=0;i<n;i++){
46 | 	for(int j=0;j<n;j++)
47 | 	cout<<a[i][j]<<" ";
48 | 	cout<<endl;
49 | 	}
50 | 	return 0;
51 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Sorted Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // Take as input N, the size of an integer array. Take one more input, which is a list of N integers separated by a space, and store that in an array. Write a recursive function which prints true if the array is sorted, and false otherwise.
 7 | 
 8 | // Input Format
 9 | // N x y z
10 | 
11 | // Constraints
12 | // 1 < N < 1000
13 | // -10^9 < i < 10^9, where i is an element of the array
14 | 
15 | // Output Format
16 | // true OR false
17 | 
18 | // Sample Input
19 | // 5
20 | // 1 2 3 4 5
21 | // Sample Output
22 | // true
23 | 
24 | #include<iostream>
25 | using namespace std;
26 | bool isSorted(int ar[],int N)
27 | {
28 |   if(N==1)
29 |   {
30 |     return true;
31 |   }
32 |   if(ar[0]<=ar[1] && isSorted(ar+1,N-1))
33 |   {
34 |     return true;
35 |   }
36 |   return false;
37 | }
38 | int main()
39 | {
40 | 	int N;
41 | 	cin>>N;
42 | 	int ar[N];
43 | 	for(int i=0;i<N;i++)
44 | 	{
45 | 	  cin>>ar[i];
46 | 	}
47 | 	bool y=isSorted(ar,N);
48 | 	if(y==1)
49 | 	cout<<"true";
50 | 	else
51 | 	cout<<"false";
52 | 	return 0;
53 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Sorting In Linear Time.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Sorting In Linear Time */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/06/2020 */
 5 | 
 6 | // You will be given an array containing only 0s, 1s and 2s. you have sort the array in linear time that is O(N) where N is the size of the array.
 7 | 
 8 | // Input Format
 9 | // The first line contains N, which is the size of the array. The following N lines contain either 0, or 1, or 2.
10 | 
11 | // Constraints
12 | // 1 <= N <= 10^6
13 | // Each input element x, such that x ∈ { 0, 1, 2 }.
14 | 
15 | // Output Format
16 | // Output the sorted array with each element separated by a newline.
17 | 
18 | // Sample Input
19 | // 5
20 | // 0
21 | // 1
22 | // 2
23 | // 1
24 | // 2
25 | // Sample Output
26 | // 0
27 | // 1
28 | // 1
29 | // 2
30 | // 2
31 | 
32 | #include<iostream>
33 | using namespace std;
34 | void swap(int &a,int &b)
35 | {
36 | 	a = a + b;
37 | 	b = a - b;
38 | 	a = a - b;
39 | }
40 | int main() {
41 | 	int n;
42 | 	cin>>n;
43 | 	int a[n];
44 | 	for(int i=0;i<n;i++)
45 | 	cin>>a[i];
46 | 	int low=0,mid=0,high=n-1;
47 | 	while(mid<=high){
48 | 		if(a[mid]==0){
49 | 			swap(a[mid],a[low]);
50 | 			low++;
51 | 			mid++;
52 | 		}
53 | 		else if(a[mid]==1)
54 | 			mid++;
55 | 		else{
56 | 			swap(a[mid],a[high]);
57 | 			high--;
58 | 		}
59 | 	}
60 | 	for(int i=0;i<n;i++)
61 | 	cout<<a[i]<<endl;
62 | 	return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Spiral Print Anticlockwise.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Spiral Print Anticlockwise */
 3 | // Take as input a 2-d array. Print the 2-D array in spiral form anti-clockwise.
 4 | 
 5 | // Input Format
 6 | // Two integers M(row) and N(colomn) and further M * N integers(2-d array numbers).
 7 | 
 8 | // Constraints
 9 | // Both M and N are between 1 to 10.
10 | 
11 | // Output Format
12 | // All M * N integers separated by commas with 'END' written in the end(as shown in example).
13 | 
14 | // Sample Input
15 | // 4 4
16 | // 11 12 13 14
17 | // 21 22 23 24
18 | // 31 32 33 34
19 | // 41 42 43 44
20 | // Sample Output
21 | // 11, 21, 31, 41, 42, 43, 44, 34, 24, 14, 13, 12, 22, 32, 33, 23, END
22 | 
23 | #include<iostream>
24 | using namespace std;
25 | int main() {
26 | 	int m,n;
27 | 	cin>>m>>n;
28 | 	int a[m][n];
29 | 	int i,j,sr,sc,er,ec;
30 | 	for(i=0;i<m;i++)
31 | 		for(j=0;j<n;j++)
32 | 			cin>>a[i][j];
33 | 	sc=sr=0;
34 | 	er=m-1;
35 | 	ec=n-1;
36 | 	while(sr<=er && sc<=ec){
37 | 		for(i=sr;i<=er;i++)
38 | 			cout<<a[i][sc]<<", ";
39 | 		for(i=sc+1;i<=ec;i++)
40 | 			cout<<a[er][i]<<", ";
41 | 		if(sr<er && sc<ec){
42 | 			for(i=er-1;i>sr;i--)
43 | 				cout<<a[i][ec]<<", ";
44 | 			for(i=ec;i>sc;i--)
45 | 				cout<<a[sr][i]<<", ";
46 | 		}
47 | 		sr++;
48 | 		sc++;
49 | 		er--;
50 | 		ec--;
51 | 	}
52 | 	cout<<"END";
53 | 	return 0;
54 | }


--------------------------------------------------------------------------------
/Hacker Blocks/String Compression.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - String Compression */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/6/2020 */
 5 | 
 6 | // Take as input S, a string. Write a function that does basic string compression. Print the value returned. E.g. for input “aaabbccds” print out a3b2c2d1s1.
 7 | 
 8 | // Input Format
 9 | // A single String S
10 | 
11 | // Constraints
12 | // 1 < = length of String < = 1000
13 | 
14 | // Output Format
15 | // The compressed String.
16 | 
17 | // Sample Input
18 | // aaabbccds
19 | // Sample Output
20 | // a3b2c2d1s1
21 | // Explanation
22 | // In the given sample test case 'a' is repeated 3 times consecutively, 'b' is repeated twice, 'c' is repeated twice and 'd and 's' occurred only once.
23 | 
24 | #include<iostream>
25 | using namespace std;
26 | void compressed()
27 | {
28 | 	string str;
29 | 	cin>>str;
30 | 	int n = str.length();
31 | 	int i=0;
32 | 	int count = 0;
33 | 	char current;
34 | 	while(i<n){
35 | 		if(count==0){
36 | 			count++;
37 | 			current = str[i];
38 | 			cout<<str[i];
39 | 			
40 | 		}
41 | 		else if(current==str[i]){ 
42 | 			count++;
43 | 		}
44 | 		else{
45 | 			cout<<count;
46 | 			cout<<str[i];
47 | 			current=str[i];
48 | 			count=1;
49 | 		}
50 | 		i++;
51 | 	}
52 | 	if(n>=1) 
53 | 	cout<<count<<endl;
54 | 	cout<<endl;
55 | }
56 | int main() {
57 | 	compressed();
58 | 	return 0;
59 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Target Sum Pairs.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Target Sum Pairs */
 3 | 
 4 | // Take as input N, the size of array. Take N more inputs and store that in an array. Take as input “target”, a number. Write a function which prints all pairs of numbers which sum to target.
 5 | 
 6 | // Input Format
 7 | // The first line contains input N. Next N lines contains the elements of array and (N+1)th line contains target number.
 8 | 
 9 | // Constraints
10 | // Length of the arrays should be between 1 and 1000.
11 | 
12 | // Output Format
13 | // Print all the pairs of numbers which sum to target. Print each pair in increasing order.
14 | 
15 | // Sample Input
16 | // 5
17 | // 1
18 | // 3
19 | // 4
20 | // 2
21 | // 5
22 | // 5
23 | // Sample Output
24 | // 1 and 4
25 | // 2 and 3
26 | // Explanation
27 | // Find any pair of elements in the array which has sum equal to target element and print them.
28 | 
29 | #include<iostream>
30 | #include<algorithm>
31 | using namespace std;
32 | int main() {
33 | 	int n,t;
34 | 	cin>>n;
35 | 	int a[n];
36 | 	for(int i=0;i<n;i++)
37 | 		cin>>a[i];
38 | 	cin>>t;
39 | 	sort(a,a+n);
40 | 	int l=0,r=n-1;
41 | 	while(l<r){
42 | 		if(a[l]+a[r]<t)
43 | 			l++;
44 | 		else if(a[l]+a[r]>t)
45 | 			r--;
46 | 		else{
47 | 			cout<<a[l]<<" and "<<a[r]<<endl;
48 | 			l++;
49 | 			r--;
50 | 		}
51 | 	}
52 | 
53 | 	return 0;
54 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Tricky Permutations.cpp:
--------------------------------------------------------------------------------
 1 | /* Coding Blocks */
 2 | /* Title - Tricky Permutations */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/7/2020 */
 5 | 
 6 | // Given a string containing duplicates, print all its distinct permutations such that there are no duplicate permutations and all permutations are printed in a lexicographic order.
 7 | 
 8 | // Input Format
 9 | // The first and only line of the test case contains the input string.
10 | 
11 | // Constraints
12 | // Length of the string <= 8
13 | 
14 | // Output Format
15 | // Print all the distinct permutations in a lexicographic order such that each permutation is in a new line. Note that there should not be any duplicate permutations.
16 | 
17 | // Sample Input
18 | // ABA
19 | // Sample Output
20 | // AAB
21 | // ABA
22 | // BAA
23 | // Explanation
24 | // The possible permutations for the given string are { "AAB" , "AAB" , "ABA" , "BAA" } . We skip the repeating "AAB" permutation and only print it in once. Also we print the final output in lexicographical order.
25 | 
26 | #include<iostream>
27 | #include<set>
28 | #include<cstring>
29 | using namespace std;
30 | set<string> s;
31 | void permute(char *inp,int i){
32 | 	if(inp[i]=='\0')
33 | 	{
34 | 		s.insert(inp);
35 | 		return;
36 | 	}
37 | 	for(int j=i;inp[j]!='\0';j++){
38 | 		swap(inp[i],inp[j]);
39 | 		permute(inp,i+1);
40 | 		swap(inp[i],inp[j]);
41 | 	}
42 | 	return;
43 | }
44 | int main() {
45 | 	char inp[10000];
46 | 	cin>>inp;
47 | 	permute(inp,0);
48 | 	for(auto x: s){
49 | 		cout<<x<<endl;
50 | 	}
51 | 	return 0;
52 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Unique Number - I.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Unique Number - I */
 3 | /* Created By - Akash Modak */
 4 | /* Date 7/1/2020 */
 5 | 
 6 | #include<iostream> 
 7 | using namespace std;
 8 | int main() {
 9 | 	int n;
10 | 	cin>>n;
11 | 	int x = 0;
12 | 	for(int i=1;i<=n;i++){
13 | 		int m;
14 | 		cin>>m;
15 | 		x^=m;
16 | 	}
17 | 	cout<<x<<endl;
18 | 	return 0;
19 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Unique Number - II.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Unique Number - II */
 3 | /* Created By - Akash Modak */
 4 | /* Date 7/1/2020 */
 5 | 
 6 | 
 7 | 
 8 | #include<iostream>
 9 | using namespace std;
10 | int main() {
11 | 	int n;
12 | 	cin>>n;
13 | 	int x=0;
14 | 	int a[n];
15 | 	for(int i=0;i<n;i++){
16 | 		cin>>a[i];
17 | 		x = x^a[i];
18 | 	}
19 | 	int temp = x;
20 | 	int pos=0;
21 | 	while((temp&1)==0){
22 | 		pos++;
23 | 		temp=temp>>1;
24 | 	}
25 | 	int mask = (1<<pos);
26 | 	int res=0;
27 | 	for(int i=0;i<n;i++){
28 | 		if((a[i]&mask)>0)
29 | 		res=res^a[i];
30 | 	}
31 | 	int ans = res^x;
32 | 	cout<<min(res,ans)<<" "<<max(res,ans);
33 | 
34 | 	return 0;
35 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Unique Number - III.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Unique Number - III */
 3 | /* Created By - Akash Modak */
 4 | /* Date 7/1/2020 */
 5 | 
 6 | 
 7 | We are given an array containg n numbers. All the numbers are present thrice except for one number which is only present once. Find the unique number. Only use - bitwise operators, and no extra space.
 8 | 
 9 | Input Format
10 | First line contains the number n. Second line contains n space separated number.
11 | 
12 | Constraints
13 | N < 10^5
14 | 
15 | Output Format
16 | Output a single line containing the unique number
17 | 
18 | Sample Input
19 | 7
20 | 1 1 1 2 2 2 3
21 | Sample Output
22 | 3
23 | Explanation
24 | 3 is present only once
25 | 
26 | 
27 | #include<iostream>
28 | #include<numeric>
29 | #include<unordered_set>
30 | using namespace std;
31 | int main() {
32 | 	int n;
33 | 	cin>>n;
34 | 	int a[n];
35 | 	for(int i=0;i<n;i++)
36 | 	cin>>a[i];
37 | 	unordered_set<int> s(a,a+n);
38 | 	int sum_array = accumulate(a,a+n,0);
39 | 	int sum_set = accumulate(s.begin(),s.end(),0);
40 | 	cout<<(3*sum_set-sum_array)/2;	//(k*sum_set-sum_array)/(k-1) where is number of similar elements
41 | 	return 0;
42 | }


--------------------------------------------------------------------------------
/Hacker Blocks/Von Neuman Loves Binary.cpp:
--------------------------------------------------------------------------------
 1 | /*Coding Blocks Hacker Blocks*/
 2 | /* Title - Von Neuman Loves Binary */
 3 | 
 4 | //Given a binary number ,help Von Neuman to find out its decimal representation. For eg 000111 in binary is 7 in decimal.
 5 | //
 6 | //Input Format
 7 | //The first line contains N , the number of binary numbers. Next N lines contain N integers each representing binary represenation of number.
 8 | #include<iostream>
 9 | #include<cmath>
10 | using namespace std;
11 | int main() {
12 | 	int n,num;
13 | 	cin>>n;
14 | 	int i;
15 | 	for(i=1;i<=n;i++)
16 | 	{
17 | 		cin>>num;
18 | 		int count = 0;
19 | 		int sum =0;
20 | 		int temp;
21 | 		while(num>0)
22 | 		{
23 | 			temp = (num%10)*pow(2,count++);
24 | 			sum += temp;
25 | 			num /= 10;
26 | 		}
27 | 		cout<<sum<<endl;
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/Hacker Blocks/Wave Print Column Wise.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Blocks */
 2 | /* Title - Wave Print Column Wise */
 3 | 
 4 | // Take as input a two-d array. Wave print it column-wise.
 5 | 
 6 | // Input Format
 7 | // Two integers M(row) and N(colomn) and further M * N integers(2-d array numbers).
 8 | 
 9 | // Constraints
10 | // Both M and N are between 1 to 10.
11 | 
12 | // Output Format
13 | // All M * N integers seperated by commas with 'END' wriiten in the end(as shown in example).
14 | 
15 | // Sample Input
16 | // 4 4
17 | // 11 12 13 14
18 | // 21 22 23 24
19 | // 31 32 33 34
20 | // 41 42 43 44
21 | // Sample Output
22 | // 11, 21, 31, 41, 42, 32, 22, 12, 13, 23, 33, 43, 44, 34, 24, 14, END
23 | 
24 | #include<iostream>
25 | using namespace std;
26 | int main() {
27 | 	int m,n;
28 | 	cin>>m>>n;
29 | 	int i,j;
30 | 	int a[m][n];
31 | 	for(i=0;i<m;i++)
32 | 	for(j=0;j<n;j++)
33 | 	cin>>a[i][j];
34 | 	for(i=0;i<n;i++){
35 | 		if(i%2==0)
36 | 		{
37 | 			for(j=0;j<m;j++)
38 | 				cout<<a[j][i]<<", ";	
39 | 		}
40 | 		else{
41 | 			for(j=m-1;j>=0;j--)
42 | 				cout<<a[j][i]<<", ";
43 | 		}
44 | 	}
45 | 	cout<<" END";
46 | 
47 | 	return 0;
48 | }


--------------------------------------------------------------------------------
/Hacker Blocks/XOR Profit Problem.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | /* Hacker Blocks */
 3 | /* Title - XOR Profit Problem */
 4 | /* Created By - Akash Modak */
 5 | /* Date 7/1/2020 */
 6 | 
 7 | 
 8 | // We are given two coins of value x and y. We have to find the maximum of value of a XOR b where x <= a <= b <= y.
 9 | 
10 | // Input Format
11 | // We are given two integers x and y
12 | 
13 | // Constraints
14 | // l <= r <= 1000
15 | 
16 | // Output Format
17 | // Print the maximum value of a XOR b
18 | 
19 | // Sample Input
20 | // 5
21 | // 6
22 | // Sample Output
23 | // 3
24 | // Explanation
25 | // If a and b are taken to be 5. Then a xor b = 0
26 | // If a and b are taken to be 6. Then a xor b = 0
27 | // If a is 5 and b is 6. Then a xor b is 3.
28 | 
29 | #include<iostream>
30 | using namespace std;
31 | int main () {
32 | 	int a,b;
33 | 	cin>>a>>b;
34 | 	int x = 0;
35 | 	int i,j;
36 | 	for(i=a;i<b;i++){
37 | 		for(j=i+1;j<=b;j++)
38 | 		x = max(x,i^j);
39 | 	}
40 | 	cout<<x<<endl;
41 | 	return 0;
42 | }


--------------------------------------------------------------------------------
/Hacker Rank/Jumping On Clouds.cpp:
--------------------------------------------------------------------------------
 1 | /*Hacker Rank*/
 2 | /*Title - Jumping on the clouds*/
 3 | //Emma is playing a new mobile game that starts with consecutively numbered clouds. Some of the clouds are thunderheads and others are cumulus. She can jump on any cumulus cloud having a number that is equal to the number of the current cloud plus 1 or 2. She must avoid the thunderheads. Determine the minimum number of jumps it will take Emma to jump from her starting postion to the last cloud. It is always possible to win the game.
 4 | //
 5 | //For each game, Emma will get an array of clouds numbered 0 if they are safe or 1 if they must be avoided. For example, c=[0,1,0,0,0,1,0]  indexed from 0...6. The number on each cloud is its index in the list so she must avoid the clouds at indexes 1 and 5. She could follow the following two paths: 0 -> 2 -> 4 -> 6 or 0 -> 2 -> 3 -> 4 ->6. The first path takes 3 jumps while the second takes 4.
 6 | //
 7 | //Function Description
 8 | //
 9 | //Complete the jumpingOnClouds function in the editor below. It should return the minimum number of jumps required, as an integer.
10 | //
11 | //jumpingOnClouds has the following parameter(s):
12 | //
13 | //c: an array of binary integers
14 | 
15 | int jumpingOnClouds(vector<int> c) {
16 |     int jumps=0;
17 |     int i=0;
18 |     while(i<c.size()) {
19 |         if(c[i+2]==0 && i<c.size()-2)
20 |         {
21 |             i += 2;
22 |         }
23 |         else
24 |             i++;
25 |         jumps++;
26 |     }
27 |     return jumps-1;
28 | }
29 | 


--------------------------------------------------------------------------------
/Hacker Rank/Mini Max Sum.cpp:
--------------------------------------------------------------------------------
 1 | /* Hacker Rank */
 2 | /* Title - Mini-Max Sum */
 3 | //Given five positive integers, find the minimum and maximum values that can be calculated by summing exactly four of the five integers. Then print the respective minimum and maximum values as a single line of two space-separated long integers.
 4 | //
 5 | //For example, arr = {1,3,5,7,9}. Our minimum sum is 1+3+5+7=16  and our maximum sum is 3+5+7+9=24 . We would print
 6 | //
 7 | //16 24
 8 | 
 9 | void miniMaxSum(vector<int> arr) {
10 |     int minSum = INT_MAX;
11 |     int maxSum = INT_MIN;
12 |     int currSum = 0;
13 |     for(int i=0;i<arr.size();i++)
14 |     {
15 |         for(int j=1;j<arr.size();j++)
16 |         {
17 |             if(j!=i)
18 |             for(int k=i;k<=j;k++)
19 |             {
20 |                 currSum += arr[i];
21 |                 
22 |             }
23 |         }
24 |     }
25 | 
26 | }
27 | 
28 | 


--------------------------------------------------------------------------------
/Hacker Rank/Repeated String.cpp:
--------------------------------------------------------------------------------
 1 | /*Hacker Rank*/
 2 | /*Title - Repeated String*/
 3 | //Lilah has a string, s , of lowercase English letters that she repeated infinitely many times.
 4 | //
 5 | //Given an integer, n , find and print the number of letter a's in the first n letters of Lilah's infinite string.
 6 | //
 7 | //For example, if the string s="abcac" and n=10 , the substring we consider is "abcacabcac", the first 10 characters of her infinite string. There are 4 occurrences of a in the substring.
 8 | //
 9 | //Function Description
10 | //
11 | //Complete the repeatedString function in the editor below. It should return an integer representing the number of occurrences of a in the prefix of length n in the infinitely repeating string.
12 | //
13 | //repeatedString has the following parameter(s):
14 | //
15 | //s: a string to repeat
16 | //n: the number of characters to consider
17 | 
18 | long repeatedString(string s, long n) {
19 | 
20 |     long count = 0;
21 |     int i ;
22 |     long p = n/s.size();
23 |     for(i=0;i<s.size();i++)
24 |         if(s[i]=='a')
25 |             count++;
26 |     count *= p;
27 |     for(i=0;i<n%s.size();i++)
28 |         if(s[i]=='a')
29 |             count++;
30 |     
31 |     return count;
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/Hacker Rank/Simple Array Sum.cpp:
--------------------------------------------------------------------------------
 1 | /*Hacker Rank*/
 2 | /*Title - Simple Array Sum*/
 3 | //Given an array of integers, find the sum of its elements.
 4 | //
 5 | //For example, if the array ar={1,2,3} ,1+2+3=6 , so return 6.
 6 | //
 7 | //Function Description
 8 | //
 9 | //Complete the simpleArraySum function in the editor below. It must return the sum of the array elements as an integer.
10 | //
11 | //simpleArraySum has the following parameter(s):
12 | //
13 | //ar: an array of integers
14 | 
15 | int simpleArraySum(vector<int> ar) {
16 |     int sum = 0;
17 |     for(int i=0;i<ar.size();i++)
18 |         sum += ar[i];
19 |     return sum;
20 | }
21 | 
22 | 
23 | 


--------------------------------------------------------------------------------
/Hacker Rank/Sock Merchant.cpp:
--------------------------------------------------------------------------------
 1 | /*Hacker Rank*/
 2 | /*Title - Sock Merchant*/
 3 | //John works at a clothing store. He has a large pile of socks that he must pair by color for sale. Given an array of integers representing the color of each sock, determine how many pairs of socks with matching colors there are.
 4 | //
 5 | //For example, there are n = 7 socks with colors ar = [1,2,1,2,1,3,2] . There is one pair of color 1 and one of color 2. There are three odd socks left, one of each color. The number of pairs is 2.
 6 | //
 7 | //Function Description
 8 | //
 9 | //Complete the sockMerchant function in the editor below. It must return an integer representing the number of matching pairs of socks that are available.
10 | //
11 | //sockMerchant has the following parameter(s):
12 | //
13 | //n: the number of socks in the pile
14 | //ar: the colors of each sock
15 | int sockMerchant(int n, vector<int> ar) {
16 | 
17 | int count=0;
18 | for(int i=0;i<n;i++)
19 | {
20 |     for(int j=0;j<n;j++)
21 |     {
22 |         if(ar[i]==ar[j] && i!=j)
23 |         {
24 |             count++;
25 |             ar[i]=INT_MAX-i;
26 |             ar[j]=INT_MAX-j;
27 |             break;
28 |         }
29 |     }
30 | }
31 | return count;
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/Interview Bit/Add One To Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Interview Bit */
 2 | /* Title - Add One To Number */
 3 | // Given a non-negative number represented as an array of digits,
 4 | 
 5 | // add 1 to the number ( increment the number represented by the digits ).
 6 | 
 7 | // The digits are stored such that the most significant digit is at the head of the list.
 8 | 
 9 | // Example:
10 | 
11 | // If the vector has [1, 2, 3]
12 | 
13 | // the returned vector should be [1, 2, 4]
14 | 
15 | // as 123 + 1 = 124.
16 | 
17 | vector<int> Solution::plusOne(vector<int> &A) {
18 |    
19 |     int n = A.size();
20 |     int carry = 0;
21 |     int s = A[n-1];
22 |     s+=1;
23 |     A[n-1]=s%10;
24 |     carry = s/10;
25 |     
26 |     // cout<<s;
27 |     // if(carry ==1){
28 |         for(int i = n-2;i>=0;i--)
29 |         {
30 |             if(carry==1){
31 |                 s = A[i]+carry;
32 |                 A[i] = s%10;
33 |                 carry = s/10;
34 |             }
35 |         }
36 |         vector<int> ans;
37 |     if(carry == 1)
38 |         {
39 |             ans.push_back(carry);
40 |             for(int i=0;i<n;i++)
41 |             ans.push_back(A[i]);
42 |             return ans;
43 |             
44 |         }
45 |      else{
46 |         bool done = false;
47 |         for(int i=0;i<n;i++){
48 |             if(A[i]!=0)
49 |             done = true;
50 |             if(done)
51 |             ans.push_back(A[i]);
52 |         }
53 |         return ans;
54 |      }
55 |     
56 |     
57 |     
58 |     
59 |     
60 | }
61 | 


--------------------------------------------------------------------------------
/Interview Bit/Largest Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Interview Bit */
 2 | /* Title - Largest Number */
 3 | 
 4 | // Given a list of non negative integers, arrange them such that they form the largest number.
 5 | 
 6 | // For example:
 7 | 
 8 | // Given [3, 30, 34, 5, 9], the largest formed number is 9534330.
 9 | 
10 | // Note: The result may be very large, so you need to return a string instead of an integer.
11 | 
12 | int compare(int,int);
13 | string Solution::largestNumber(const vector<int> &A) {
14 |     
15 |     vector<int> B;
16 |     bool allZero = true;
17 |     for(int i=0;i<A.size();i++){
18 |     if(A[i]!=0)
19 |     allZero=false;
20 |     B.push_back(A[i]);
21 |     }
22 |     if(allZero)
23 |     return "0";
24 |     sort(B.begin(),B.end(),compare);
25 |     string s="";
26 |     int i;
27 |     for( i=0;i<B.size();i++){
28 |         s.append(to_string(B[i]));
29 |     }
30 |     
31 |     return s;
32 | }
33 | int compare(int x,int y){
34 |     string X = to_string(x);
35 |     string Y = to_string(y);
36 |     string xy = X.append(Y);
37 |     string yx = Y.append(X);
38 |     return xy.compare(yx)>0?1:0;
39 | }


--------------------------------------------------------------------------------
/Interview Bit/Longest Common Prefix.cpp:
--------------------------------------------------------------------------------
 1 | /* Interview Bit */
 2 | /* Title - Longest Common Prefix */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/09/2020 */
 5 | 
 6 | // Given the array of strings A,
 7 | // you need to find the longest string S which is the prefix of ALL the strings in the array.
 8 | 
 9 | // Longest common prefix for a pair of strings S1 and S2 is the longest string S which is the prefix of both S1
10 | // and S2.
11 | 
12 | // For Example, longest common prefix of "abcdefgh" and "abcefgh" is "abc".
13 | 
14 | 
15 | 
16 | // Input Format
17 | 
18 | // The only argument given is an array of strings A.
19 | // Output Format
20 | 
21 | // Return longest common prefix of all strings in A.
22 | // For Example
23 | 
24 | // Input 1:
25 | //     A = ["abcdefgh", "aefghijk", "abcefgh"]
26 | // Output 1:
27 | //     "a"
28 | //     Explanation 1:
29 | //         Longest common prefix of all the strings is "a".
30 | 
31 | // Input 2:
32 | //     A = ["abab", "ab", "abcd"];
33 | // Output 2:
34 | //     "ab"
35 | //     Explanation 2:
36 | //         Longest common prefix of all the strings is "ab".
37 | 
38 | string Solution::longestCommonPrefix(vector<string> &A) {
39 |     sort(A.begin(),A.end());
40 |     int n = A.size();
41 |     int minval = min(A[0].length(),A[n-1].length());
42 |     int i=0;
43 |     string first = A[0], last = A[n-1];
44 |     while(i<minval and first[i]==last[i])
45 |     i++;
46 |     
47 |     string ans = first.substr(0,i);
48 |     return ans;
49 | }
50 | 


--------------------------------------------------------------------------------
/Interview Bit/Max Sum Contiguous Subarray.cpp:
--------------------------------------------------------------------------------
 1 | /* Interview Bit */
 2 | /* Title - Max Sum Contiguous Subarray */
 3 | 
 4 | // Find the contiguous subarray within an array, A of length N which has the largest sum.
 5 | 
 6 | // Input Format:
 7 | 
 8 | // The first and the only argument contains an integer array, A.
 9 | // Output Format:
10 | 
11 | // Return an integer representing the maximum possible sum of the contiguous subarray.
12 | // Constraints:
13 | 
14 | // 1 <= N <= 1e6
15 | // -1000 <= A[i] <= 1000
16 | // For example:
17 | 
18 | // Input 1:
19 | //     A = [1, 2, 3, 4, -10]
20 | 
21 | // Output 1:
22 | //     10
23 | 
24 | // Explanation 1:
25 | //     The subarray [1, 2, 3, 4] has the maximum possible sum of 10.
26 | 
27 | // Input 2:
28 | //     A = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
29 | 
30 | // Output 2:
31 | //     6
32 | 
33 | // Explanation 2:
34 | //     The subarray [4,-1,2,1] has the maximum possible sum of 6.
35 | 
36 | int Solution::maxSubArray(const vector<int> &A) {
37 |     int n = A.size();
38 |     int sum = INT_MIN;
39 |     int currentSum = 0;
40 |     for(int i=0;i<n;i++){
41 |         currentSum += A[i];
42 |         sum = max(sum,currentSum);
43 |         if(currentSum < 0)
44 |         currentSum = 0;
45 |     }
46 |     return sum;
47 | }
48 | 


--------------------------------------------------------------------------------
/Interview Bit/Min Steps In Infinite Grid.cpp:
--------------------------------------------------------------------------------
 1 | /* Interview Bit */
 2 | /* Title - Min Steps In Infinite Grid */
 3 | // You are in an infinite 2D grid where you can move in any of the 8 directions :
 4 | 
 5 | //  (x,y) to 
 6 | //     (x+1, y), 
 7 | //     (x - 1, y), 
 8 | //     (x, y+1), 
 9 | //     (x, y-1), 
10 | //     (x-1, y-1), 
11 | //     (x+1,y+1), 
12 | //     (x-1,y+1), 
13 | //     (x+1,y-1) 
14 | // You are given a sequence of points and the order in which you need to cover the points. Give the minimum number of steps in which you can achieve it. You start from the first point.
15 | 
16 | // Input :
17 | 
18 | // Given two integer arrays A and B, where A[i] is x coordinate and B[i] is y coordinate of ith point respectively.
19 | // Output :
20 | 
21 | // Return an Integer, i.e minimum number of steps.
22 | // Example :
23 | 
24 | // Input : [(0, 0), (1, 1), (1, 2)]
25 | // Output : 2
26 | // It takes 1 step to move from (0, 0) to (1, 1). It takes one more step to move from (1, 1) to (1, 2).
27 | 
28 | int Solution::coverPoints(vector<int> &A, vector<int> &B) {
29 |      int count = 0;
30 |     int a = 0; int b = 0;
31 |     for (int i=0; i < (A.size()-1); ++i) {
32 |         a = abs((A[i+1]-A[i]));
33 |         b = abs((B[i+1]-B[i]));
34 |         count += max(a,b);
35 |     }
36 |     return count;
37 | }
38 | 


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


--------------------------------------------------------------------------------
/Leet Code/Add Digits.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Add Digits */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/7/2020 */
 5 | 
 6 | // Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
 7 | 
 8 | // Example:
 9 | 
10 | // Input: 38
11 | // Output: 2 
12 | // Explanation: The process is like: 3 + 8 = 11, 1 + 1 = 2. 
13 | //              Since 2 has only one digit, return it.
14 | // Follow up:
15 | // Could you do it without any loop/recursion in O(1) runtime?
16 | 
17 | class Solution {
18 | public:
19 |     int addDigits(int num) {
20 |         if(num==0)
21 |             return 0;
22 |         else if(num%9==0)
23 |             return 9;
24 |         else
25 |             return num%9;
26 |     }
27 | };


--------------------------------------------------------------------------------
/Leet Code/All Paths From Source to Target.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - All Paths From Source to Target */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/7/2020 */
 5 | 
 6 | // Given a directed, acyclic graph of N nodes.  Find all possible paths from node 0 to node N-1, and return them in any order.
 7 | 
 8 | // The graph is given as follows:  the nodes are 0, 1, ..., graph.length - 1.  graph[i] is a list of all nodes j for which the edge (i, j) exists.
 9 | 
10 | // Example:
11 | // Input: [[1,2], [3], [3], []] 
12 | // Output: [[0,1,3],[0,2,3]] 
13 | // Explanation: The graph looks like this:
14 | // 0--->1
15 | // |    |
16 | // v    v
17 | // 2--->3
18 | // There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.
19 | // Note:
20 | 
21 | // The number of nodes in the graph will be in the range [2, 15].
22 | // You can print different paths in any order, but you should keep the order of nodes inside one path.
23 | 
24 | class Solution {
25 | public:
26 |     void dfs(vector<vector<int>> graph,int target,int i,vector<int>& t,vector<vector<int>>& ans){
27 |         if(i==target)
28 |             ans.push_back(t);
29 |         for(auto x:graph[i]){
30 |             t.push_back(x);
31 |             dfs(graph,target,x,t,ans);
32 |             t.pop_back();
33 |         }            
34 |     }
35 |     vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
36 |         vector<vector<int>> res;
37 |         int target = graph.size()-1;
38 |         vector<int> t;
39 |         t.push_back(0);
40 |         dfs(graph,target,0,t,res);
41 |         return res;
42 |     }
43 | };


--------------------------------------------------------------------------------
/Leet Code/Angle Between Hands of a Clock.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Angle Between Hands of a Clock */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/07/2020 */
 5 | 
 6 | // Given two numbers, hour and minutes. Return the smaller angle (in degrees) formed between the hour and the minute hand.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | 
13 | 
14 | // Input: hour = 12, minutes = 30
15 | // Output: 165
16 | // Example 2:
17 | 
18 | 
19 | 
20 | // Input: hour = 3, minutes = 30
21 | // Output: 75
22 | // Example 3:
23 | 
24 | 
25 | 
26 | // Input: hour = 3, minutes = 15
27 | // Output: 7.5
28 | // Example 4:
29 | 
30 | // Input: hour = 4, minutes = 50
31 | // Output: 155
32 | // Example 5:
33 | 
34 | // Input: hour = 12, minutes = 0
35 | // Output: 0
36 |  
37 | 
38 | // Constraints:
39 | 
40 | // 1 <= hour <= 12
41 | // 0 <= minutes <= 59
42 | // Answers within 10^-5 of the actual value will be accepted as correct.
43 | 
44 | class Solution {
45 | public:
46 |     double angleClock(int hour, int minutes) {
47 |         double hourAngle = (hour%12)*30+minutes*0.5;
48 |         double minAngle = minutes*6;
49 |         double diffAngle = abs(hourAngle-minAngle);
50 |         return min(diffAngle,360-diffAngle);
51 |     }
52 | };


--------------------------------------------------------------------------------
/Leet Code/Best Time to Buy and Sell Stock.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Best Time to Buy and Sell Stock */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/09/2020 */
 5 | 
 6 | // Say you have an array for which the ith element is the price of a given stock on day i.
 7 | 
 8 | // If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.
 9 | 
10 | // Note that you cannot sell a stock before you buy one.
11 | 
12 | // Example 1:
13 | 
14 | // Input: [7,1,5,3,6,4]
15 | // Output: 5
16 | // Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
17 | //              Not 7-1 = 6, as selling price needs to be larger than buying price.
18 | // Example 2:
19 | 
20 | // Input: [7,6,4,3,1]
21 | // Output: 0
22 | // Explanation: In this case, no transaction is done, i.e. max profit = 0.
23 | 
24 | class Solution {
25 | public:
26 |     int maxProfit(vector<int>& prices) {
27 |         int n = prices.size();
28 |         if(n<=1)
29 |             return 0;
30 |         if(n==2 and prices[1]>prices[0])
31 |             return prices[1]-prices[0];
32 |         int minp = INT_MAX;
33 |         int maxp =0;
34 |         for(int i=0;i<n;i++){
35 |             if(prices[i]<minp){
36 |                 minp = prices[i];
37 |             }
38 |             else if(prices[i]-minp>maxp)
39 |                 maxp = prices[i]-minp;
40 |         }
41 |         return maxp;
42 |     }
43 | };


--------------------------------------------------------------------------------
/Leet Code/Binary Tree Inorder Traversal.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Binary Tree Inorder Traversal */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/09/2020 */
 5 | 
 6 | // Given the root of a binary tree, return the inorder traversal of its nodes' values.
 7 | 
 8 | 
 9 | /**
10 |  * Definition for a binary tree node.
11 |  * struct TreeNode {
12 |  *     int val;
13 |  *     TreeNode *left;
14 |  *     TreeNode *right;
15 |  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
16 |  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
17 |  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
18 |  * };
19 |  */
20 | class Solution {
21 | public:
22 |     vector<int> v;
23 |     vector<int> inorderTraversal(TreeNode* root) {
24 |         if(root==NULL)
25 |             return v;
26 |         
27 |         inorderTraversal(root->left);
28 |         v.push_back(root->val);
29 |         inorderTraversal(root->right);
30 |         
31 |         return v;
32 |     }
33 | };


--------------------------------------------------------------------------------
/Leet Code/Binary Tree Postorder Traversal.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Binary Tree Postorder Traversal */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/09/2020 */
 5 | 
 6 | // Given the root of a binary tree, return the postorder traversal of its nodes' values.
 7 | 
 8 | // Follow up: Recursive solution is trivial, could you do it iteratively?
 9 | 
10 | 
11 | /**
12 |  * Definition for a binary tree node.
13 |  * struct TreeNode {
14 |  *     int val;
15 |  *     TreeNode *left;
16 |  *     TreeNode *right;
17 |  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
18 |  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
19 |  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
20 |  * };
21 |  */
22 | class Solution {
23 | public:
24 |     vector<int> v;
25 |     vector<int> postorderTraversal(TreeNode* root) {
26 |         if(root==NULL)
27 |             return v;
28 |         
29 |         postorderTraversal(root->left);
30 |         postorderTraversal(root->right);
31 |         v.push_back(root->val);
32 |         
33 |         return v;
34 |     }
35 | };  
36 | 
37 | 


--------------------------------------------------------------------------------
/Leet Code/Binary Tree Preorder Traversal.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Binary Tree Preorder Traversal */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/09/2020 */
 5 | 
 6 | // Given a binary tree, return the preorder traversal of its nodes' values.
 7 | 
 8 | // Example:
 9 | 
10 | // Input: [1,null,2,3]
11 | //    1
12 | //     \
13 | //      2
14 | //     /
15 | //    3
16 | 
17 | // Output: [1,2,3]
18 | // Follow up: Recursive solution is trivial, could you do it iteratively?
19 | 
20 | /**
21 |  * Definition for a binary tree node.
22 |  * struct TreeNode {
23 |  *     int val;
24 |  *     TreeNode *left;
25 |  *     TreeNode *right;
26 |  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
27 |  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
28 |  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
29 |  * };
30 |  */
31 | class Solution {
32 | public:
33 |     vector<int> v;
34 |     vector<int> preorderTraversal(TreeNode* root) {
35 |         if(root==NULL)
36 |             return v;
37 |         
38 |         v.push_back(root->val);
39 |         preorderTraversal(root->left);
40 |         preorderTraversal(root->right);
41 |         return v;
42 |     }
43 | };


--------------------------------------------------------------------------------
/Leet Code/Bitwise AND of Numbers Range.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Bitwise AND of Numbers Range */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 17/10/2020 */
 5 | 
 6 | // Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: [5,7]
11 | // Output: 4
12 | // Example 2:
13 | 
14 | // Input: [0,1]
15 | // Output: 0
16 | 
17 | class Solution {
18 | public:
19 |     int rangeBitwiseAnd(int m, int n) {
20 |         if(m==0 or n==0)
21 |             return 0;
22 |         if(m==n)
23 |             return m;
24 |         int num1 = log2(m)+1;
25 |         int num2 = log2(n)+1;
26 |      
27 |         if(num1==num2){
28 |             if(m+1==n)
29 |                 return m&n;
30 |             int x = m^n;
31 |             int count = 0;
32 |             while(num1--){
33 |                 if(x&1)
34 |                     count = 0;
35 |                 else
36 |                     count++;
37 |                 x = x>>1;
38 |             }
39 |             int ans = 0;
40 |             int diff = num2 - count;
41 |             while(count--){
42 |                 ans = ans<<1;
43 |                 ans = ans | 1;
44 |             }
45 |             ans = ans<<diff;
46 |             return m&ans;
47 |         }
48 |         else
49 |             return 0;
50 |         
51 |     }
52 | };


--------------------------------------------------------------------------------
/Leet Code/Boats to Save People.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Boats to Save People */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 09/06/2023 */
 5 | 
 6 | // You are given an array people where people[i] is the weight of the ith person, and an infinite number of boats where each boat can carry a maximum weight of limit. Each boat carries at most two people at the same time, provided the sum of the weight of those people is at most limit.
 7 | 
 8 | // Return the minimum number of boats to carry every given person.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: people = [1,2], limit = 3
15 | // Output: 1
16 | // Explanation: 1 boat (1, 2)
17 | // Example 2:
18 | 
19 | // Input: people = [3,2,2,1], limit = 3
20 | // Output: 3
21 | // Explanation: 3 boats (1, 2), (2) and (3)
22 | // Example 3:
23 | 
24 | // Input: people = [3,5,3,4], limit = 5
25 | // Output: 4
26 | // Explanation: 4 boats (3), (3), (4), (5)
27 |   
28 | class Solution {
29 | public:
30 |     int numRescueBoats(vector<int>& people, int limit) {
31 |         sort(people.begin(), people.end());
32 |         int i=0,j=people.size()-1,count=0;
33 |         while(i<=j){
34 |             if(people[i]+people[j]<=limit)
35 |                 i++;
36 |             j--;
37 |             count++;
38 |         }
39 |         return count;
40 |     }
41 | };
42 | 


--------------------------------------------------------------------------------
/Leet Code/Climbing Stairs.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Climbing stairs */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 31/7/2020 */
 5 | 
 6 | // You are climbing a stair case. It takes n steps to reach to the top.
 7 | 
 8 | // Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
 9 | 
10 | // Example 1:
11 | 
12 | // Input: 2
13 | // Output: 2
14 | // Explanation: There are two ways to climb to the top.
15 | // 1. 1 step + 1 step
16 | // 2. 2 steps
17 | // Example 2:
18 | 
19 | // Input: 3
20 | // Output: 3
21 | // Explanation: There are three ways to climb to the top.
22 | // 1. 1 step + 1 step + 1 step
23 | // 2. 1 step + 2 steps
24 | // 3. 2 steps + 1 step
25 |  
26 | 
27 | // Constraints:
28 | 
29 | // 1 <= n <= 45
30 | 
31 | class Solution{
32 | public:
33 | 	int climbingStairs(int n){
34 | 		if(n==1)
35 | 			return 1;
36 | 		int a=1;
37 | 		int b=2;
38 | 		for(int i=3;i<=n;i++){
39 | 			int c = a+b;
40 | 			a=b;
41 | 			b=c;
42 | 		}
43 | 		return b;
44 | 	}
45 | };


--------------------------------------------------------------------------------
/Leet Code/Combinations.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Combinations */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 06/06/2023 */
 5 | 
 6 | // Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n].
 7 | 
 8 | // You may return the answer in any order.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: n = 4, k = 2
15 | // Output: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
16 | // Explanation: There are 4 choose 2 = 6 total combinations.
17 | // Note that combinations are unordered, i.e., [1,2] and [2,1] are considered to be the same combination.
18 | // Example 2:
19 | 
20 | // Input: n = 1, k = 1
21 | // Output: [[1]]
22 | // Explanation: There is 1 choose 1 = 1 total combination.
23 | 
24 | class Solution {
25 | public:
26 |     void backtrack(int i, int j, int k, int n, vector<int> &temp, vector<vector<int>> & res){
27 |         if(i==k){
28 |             res.push_back(temp);
29 |             return;
30 |         }
31 |         for(int l=j;l<=n;l++){
32 |             temp.push_back(l);
33 |             j++;
34 |             backtrack(i+1,j,k,n,temp,res);
35 |             temp.pop_back();
36 |         }
37 | 
38 |     }
39 |     vector<vector<int>> combine(int n, int k) {
40 |         vector<int> temp;
41 |         vector<vector<int>> res;
42 |         backtrack(0,1,k,n,temp,res);
43 |         return res;
44 |     }
45 | };
46 | 


--------------------------------------------------------------------------------
/Leet Code/Concatenation of Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Concatenation of Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 05/08/2021 */
 5 | 
 6 | // Given an integer array nums of length n, you want to create an array ans of length 2n where ans[i] == nums[i] and ans[i + n] == nums[i] for 0 <= i < n (0-indexed).
 7 | 
 8 | // Specifically, ans is the concatenation of two nums arrays.
 9 | 
10 | // Return the array ans.
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: nums = [1,2,1]
17 | // Output: [1,2,1,1,2,1]
18 | // Explanation: The array ans is formed as follows:
19 | // - ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
20 | // - ans = [1,2,1,1,2,1]
21 | // Example 2:
22 | 
23 | // Input: nums = [1,3,2,1]
24 | // Output: [1,3,2,1,1,3,2,1]
25 | // Explanation: The array ans is formed as follows:
26 | // - ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
27 | // - ans = [1,3,2,1,1,3,2,1]
28 | 
29 | 
30 | class Solution {
31 | public:
32 |     vector<int> getConcatenation(vector<int>& nums) {
33 |         vector<int> ans(2*nums.size());
34 |         
35 |         for(int i=0;i<nums.size();i++){
36 |             ans[i] = nums[i];
37 |             ans[i+nums.size()] = nums[i];
38 |         }
39 |         
40 |         return ans;
41 |     }
42 | };


--------------------------------------------------------------------------------
/Leet Code/Container With Most Water.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Codde */
 2 | /* Title - Container With Most Water */
 3 | 
 4 | // Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
 5 | 
 6 | // Note: You may not slant the container and n is at least 2.
 7 | // Example:
 8 | 
 9 | // Input: [1,8,6,2,5,4,8,3,7]
10 | // Output: 49
11 | 
12 | class Solution {
13 | public:
14 |     int maxArea(vector<int>& height) {
15 |         int sum = 0;
16 |         int i = 0;
17 |         int j = height.size() - 1;
18 |         int current = 0;
19 |         while(i<j){
20 |             current = min(height[i],height[j])*(j-i);
21 |             sum = max(sum,current);
22 |             if(height[i]<height[j])
23 |                 i++;
24 |             else 
25 |                 j--;
26 |            
27 |         }
28 |         return sum;
29 |         
30 |     }
31 | };


--------------------------------------------------------------------------------
/Leet Code/Contains Duplicate II.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Contains Duplicate II */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 28/12/2020 */
 5 | 
 6 | // Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: nums = [1,2,3,1], k = 3
11 | // Output: true
12 | // Example 2:
13 | 
14 | // Input: nums = [1,0,1,1], k = 1
15 | // Output: true
16 | // Example 3:
17 | 
18 | // Input: nums = [1,2,3,1,2,3], k = 2
19 | // Output: false
20 | 
21 | class Solution {
22 | public:
23 |     bool containsNearbyDuplicate(vector<int>& nums, int k) {
24 |         unordered_map<int,vector<int>> m;
25 |         for(int i=0;i<nums.size();i++){
26 |             if(m[nums[i]].size()>0){
27 |                 for(auto x: m[nums[i]]){
28 |                     if(abs(x-i)<=k)
29 |                         return true;
30 |                 }
31 |             }
32 |             m[nums[i]].push_back(i);
33 |         }
34 |         return false;
35 |     }
36 | };


--------------------------------------------------------------------------------
/Leet Code/Contains Duplicate.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Contains Duplicate */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/08/2020 */
 5 | 
 6 | // Given an array of integers, find if the array contains any duplicates.
 7 | 
 8 | // Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
 9 | 
10 | // Example 1:
11 | 
12 | // Input: [1,2,3,1]
13 | // Output: true
14 | // Example 2:
15 | 
16 | // Input: [1,2,3,4]
17 | // Output: false
18 | // Example 3:
19 | 
20 | // Input: [1,1,1,3,3,4,3,2,4,2]
21 | // Output: true
22 | 
23 | class Solution {
24 | public:
25 |     bool containsDuplicate(vector<int>& nums) {
26 |         unordered_map<int,int> m;
27 |         for(auto x: nums){
28 |             m[x]++;
29 |             if(m[x]>1)
30 |                 return true;
31 |             
32 |         }
33 |         return false;
34 |     }
35 | };


--------------------------------------------------------------------------------
/Leet Code/Count Primes.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Count Primes */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/12/2020 */
 5 | 
 6 | // Count the number of prime numbers less than a non-negative number, n.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: n = 10
13 | // Output: 4
14 | // Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7.
15 | // Example 2:
16 | 
17 | // Input: n = 0
18 | // Output: 0
19 | // Example 3:
20 | 
21 | // Input: n = 1
22 | // Output: 0
23 | 
24 | class Solution {
25 | public:
26 |     int countPrimes(int n) {
27 |         if(n==0 || n==1 || n==2){
28 |             return 0;
29 |         }
30 |         vector<int> prime(n+1,1);
31 |         prime[0] = 0;
32 |         prime[1] = 0;
33 |         // prime[2] = 0;
34 |         for(long long int i=2;i<=n;i++){
35 |             if(prime[i]==1){
36 |                 for(long long int j=i*i;j<=n;j+=i)
37 |                     prime[j] = 0;
38 |             }
39 |         }
40 |         int count = 0;
41 |         for(int i=2;i<n;i++){
42 |             if(prime[i])
43 |                 count++;
44 |         }
45 |         return count;
46 |     }
47 | };


--------------------------------------------------------------------------------
/Leet Code/Count the Number of Consistent Strings.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Count the Number of Consistent Strings */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 06/05/2023 */
 5 | 
 6 | // You are given a string allowed consisting of distinct characters and an array of strings words. A string is consistent if all characters in the string appear in the string allowed.
 7 | 
 8 | // Return the number of consistent strings in the array words.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
15 | // Output: 2
16 | // Explanation: Strings "aaab" and "baa" are consistent since they only contain characters 'a' and 'b'.
17 | // Example 2:
18 | 
19 | // Input: allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]
20 | // Output: 7
21 | // Explanation: All strings are consistent.
22 | // Example 3:
23 | 
24 | // Input: allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]
25 | // Output: 4
26 | // Explanation: Strings "cc", "acd", "ac", and "d" are consistent.
27 | 
28 | class Solution {
29 | public:
30 |     int countConsistentStrings(string allowed, vector<string>& words) {
31 |         bool arr[26] = {};
32 |         bool flag = false;
33 |         int count=0;
34 |         for(int i=0;i<allowed.length();i++) arr[allowed[i]-'a']=true;
35 |         for(int i=0;i<words.size();i++) {
36 |             flag=true;
37 |             for(char j:words[i]) if(!arr[j-'a']) {flag=false;break;}
38 |             if(flag) count++;
39 |         }
40 |         return count;
41 |     }
42 | };
43 | 


--------------------------------------------------------------------------------
/Leet Code/Counting Bits.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Counting Bits */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 30/09/2020 */
 5 | 
 6 | // Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1's in their binary representation and return them as an array.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: 2
11 | // Output: [0,1,1]
12 | // Example 2:
13 | 
14 | // Input: 5
15 | // Output: [0,1,1,2,1,2]
16 | // Follow up:
17 | 
18 | // It is very easy to come up with a solution with run time O(n*sizeof(integer)). But can you do it in linear time O(n) /possibly in a single pass?
19 | // Space complexity should be O(n).
20 | // Can you do it like a boss? Do it without using any builtin function like __builtin_popcount in c++ or in any other language.
21 | 
22 | class Solution {
23 | public:
24 |     vector<int> countBits(int num) {
25 |         vector<int> dp(num+1);
26 |         dp[0] = 0;
27 |         if(num==0)
28 |             return dp;
29 |         dp[1] = 1;
30 |         for(int i=2;i<=num;i++){
31 |             if(i%2==0)
32 |                 dp[i] = dp[i/2];
33 |             else
34 |                 dp[i] = dp[i-1] + 1;
35 |         }
36 |         return dp;
37 |     }
38 | };


--------------------------------------------------------------------------------
/Leet Code/DI String Match.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - DI String Match */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 02/05/2023 */
 5 | 
 6 | // A permutation perm of n + 1 integers of all the integers in the range [0, n] can be represented as a string s of length n where:
 7 | 
 8 | // s[i] == 'I' if perm[i] < perm[i + 1], and
 9 | // s[i] == 'D' if perm[i] > perm[i + 1].
10 | // Given a string s, reconstruct the permutation perm and return it. If there are multiple valid permutations perm, return any of them.
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: s = "IDID"
17 | // Output: [0,4,1,3,2]
18 | // Example 2:
19 | 
20 | // Input: s = "III"
21 | // Output: [0,1,2,3]
22 | // Example 3:
23 | 
24 | // Input: s = "DDI"
25 | // Output: [3,2,0,1]
26 | 
27 | class Solution {
28 | public:
29 |     vector<int> diStringMatch(string s) {
30 |         int low = 0, high = s.length();
31 |         vector<int> res;
32 |         
33 |         for(int i=0;i<s.length();i++) {
34 |             if(s[i]=='I') {
35 |                 res.push_back(low++);
36 |             }else {
37 |                 res.push_back(high--);
38 |             }
39 |         }
40 |         res.push_back(low);
41 |         return res;
42 |     }
43 | };
44 | 


--------------------------------------------------------------------------------
/Leet Code/Daily Temperatures.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Daily Temperatures */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 09/05/2023 */
 5 | 
 6 | // Given an array of integers temperatures represents the daily temperatures, 
 7 | // return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. 
 8 | // If there is no future day for which this is possible, keep answer[i] == 0 instead.
 9 | 
10 | // Example 1:
11 | 
12 | // Input: temperatures = [73,74,75,71,69,72,76,73]
13 | // Output: [1,1,4,2,1,1,0,0]
14 | // Example 2:
15 | 
16 | // Input: temperatures = [30,40,50,60]
17 | // Output: [1,1,1,0]
18 | // Example 3:
19 | 
20 | // Input: temperatures = [30,60,90]
21 | // Output: [1,1,0]
22 | 
23 | class Solution {
24 | public:
25 |     vector<int> dailyTemperatures(vector<int>& temperatures) {
26 |         vector<int> res(temperatures.size());
27 |         stack<int> s;
28 |         for(int i=0;i<temperatures.size();i++){
29 |             while(!s.empty() && temperatures[s.top()]<temperatures[i]){
30 |                 int top=s.top();
31 |                 res[top]=i-top;
32 |                 s.pop();
33 |             }
34 |             s.push(i);
35 |         }
36 |         return res;
37 |     }
38 | };
39 | 


--------------------------------------------------------------------------------
/Leet Code/Destination City.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Destination City */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 06/05/2023 */
 5 | 
 6 | // You are given the array paths, where paths[i] = [cityAi, cityBi] means there exists a direct path going from cityAi to cityBi. Return the destination city, that is, the city without any path outgoing to another city.
 7 | 
 8 | // It is guaranteed that the graph of paths forms a line without any loop, therefore, there will be exactly one destination city.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
15 | // Output: "Sao Paulo" 
16 | // Explanation: Starting at "London" city you will reach "Sao Paulo" city which is the destination city. Your trip consist of: "London" -> "New York" -> "Lima" -> "Sao Paulo".
17 | // Example 2:
18 | 
19 | // Input: paths = [["B","C"],["D","B"],["C","A"]]
20 | // Output: "A"
21 | // Explanation: All possible trips are: 
22 | // "D" -> "B" -> "C" -> "A". 
23 | // "B" -> "C" -> "A". 
24 | // "C" -> "A". 
25 | // "A". 
26 | // Clearly the destination city is "A".
27 | // Example 3:
28 | 
29 | // Input: paths = [["A","Z"]]
30 | // Output: "Z"
31 | 
32 | class Solution {
33 | public:
34 |     string destCity(vector<vector<string>>& paths) {
35 |         unordered_set<string> mp;
36 |         for(int i=0;i<paths.size();i++) mp.insert(paths[i][0]);
37 |         for(int i=0;i<paths.size();i++) {
38 |             if(mp.find(paths[i][1]) == mp.end()) return paths[i][1];
39 |         }
40 |         return paths[0][1];
41 |     }
42 | };
43 | 


--------------------------------------------------------------------------------
/Leet Code/Detect Capital.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Detect Capital */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 1/8/2020 */
 5 | 
 6 | // Given a word, you need to judge whether the usage of capitals in it is right or not.
 7 | 
 8 | // We define the usage of capitals in a word to be right when one of the following cases holds:
 9 | 
10 | // All letters in this word are capitals, like "USA".
11 | // All letters in this word are not capitals, like "leetcode".
12 | // Only the first letter in this word is capital, like "Google".
13 | // Otherwise, we define that this word doesn't use capitals in a right way.
14 |  
15 | 
16 | // Example 1:
17 | 
18 | // Input: "USA"
19 | // Output: True
20 |  
21 | 
22 | // Example 2:
23 | 
24 | // Input: "FlaG"
25 | // Output: False
26 |  
27 | 
28 | // Note: The input will be a non-empty word consisting of uppercase and lowercase latin letters.
29 | 
30 | 
31 | class Solution {
32 | public:
33 |     bool detectCapitalUse(string word) {
34 |         int count =0;
35 |         for(int i=0;i<word.length();i++)
36 |             if(isupper(word[i]))
37 |                 count++;
38 |         if(count==1 and isupper(word[0]))
39 |             return true;
40 |         else if(count == word.length())
41 |             return true;
42 |         else if(count==0)
43 |             return true;
44 |         else
45 |             return false;
46 |     }
47 | };


--------------------------------------------------------------------------------
/Leet Code/Element Appearing More Than 25% In Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Element Appearing More Than 25% In Sorted Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 30/09/2020 */
 5 | 
 6 | // Given an integer array sorted in non-decreasing order, there is exactly one integer in the array that occurs more than 25% of the time.
 7 | 
 8 | // Return that integer.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: arr = [1,2,2,6,6,6,6,7,10]
15 | // Output: 6
16 |  
17 | 
18 | // Constraints:
19 | 
20 | // 1 <= arr.length <= 10^4
21 | // 0 <= arr[i] <= 10^5
22 | 
23 | class Solution {
24 | public:
25 |     int findSpecialInteger(vector<int>& arr) {
26 |         unordered_map<int,int> m;
27 |         if(arr.size()==0)
28 |             return 0;
29 |         float avg = arr.size()/4;
30 |         int ans = 0;
31 |         for(int i=0;i<arr.size();i++){
32 |             m[arr[i]]++;
33 |             if(m[arr[i]]>avg)
34 |                 return ans = arr[i];
35 |         }
36 |         return ans;
37 |     }
38 | };


--------------------------------------------------------------------------------
/Leet Code/Excel Sheet Column Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Excel Sheet Column Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 10/8/2020 */
 5 | 
 6 | // Given a column title as appear in an Excel sheet, return its corresponding column number.
 7 | 
 8 | // For example:
 9 | 
10 | //     A -> 1
11 | //     B -> 2
12 | //     C -> 3
13 | //     ...
14 | //     Z -> 26
15 | //     AA -> 27
16 | //     AB -> 28 
17 | //     ...
18 | // Example 1:
19 | 
20 | // Input: "A"
21 | // Output: 1
22 | // Example 2:
23 | 
24 | // Input: "AB"
25 | // Output: 28
26 | // Example 3:
27 | 
28 | // Input: "ZY"
29 | // Output: 701
30 |  
31 | 
32 | // Constraints:
33 | 
34 | // 1 <= s.length <= 7
35 | // s consists only of uppercase English letters.
36 | // s is between "A" and "FXSHRXW".
37 | 
38 | class Solution {
39 | public:
40 |     int titleToNumber(string s) {
41 |         
42 |         int cell = 0;
43 |         int n = s.length()-1;
44 |         for(int i=0;s[i]!='\0';i++){
45 |             int temp = s[i] - 'A' + 1;
46 |             cell += pow(26,n) * temp;
47 |             n--;
48 |         }
49 |         return cell;
50 |     }
51 | };


--------------------------------------------------------------------------------
/Leet Code/Fibonacci Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Fibonacci Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 29/05/2023 */
 5 | 
 6 | // The Fibonacci numbers, commonly denoted F(n) form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. That is,
 7 | 
 8 | // F(0) = 0, F(1) = 1
 9 | // F(n) = F(n - 1) + F(n - 2), for n > 1.
10 | // Given n, calculate F(n).
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: n = 2
17 | // Output: 1
18 | // Explanation: F(2) = F(1) + F(0) = 1 + 0 = 1.
19 | // Example 2:
20 | 
21 | // Input: n = 3
22 | // Output: 2
23 | // Explanation: F(3) = F(2) + F(1) = 1 + 1 = 2.
24 | // Example 3:
25 | 
26 | // Input: n = 4
27 | // Output: 3
28 | // Explanation: F(4) = F(3) + F(2) = 2 + 1 = 3.
29 | 
30 | class Solution {
31 | public:
32 |     int topDown(int n, vector<int> &dp){
33 |         if(n==0 || n==1) return n;
34 |         if(n<0) return 0;
35 |         if(dp[n]) return dp[n];
36 |         return dp[n]=topDown(n-1,dp)+topDown(n-2,dp);
37 |     }
38 |     int fib(int n) {
39 |         vector<int> dp(n+1);
40 |         return topDown(n,dp);
41 |     }
42 | };
43 | 


--------------------------------------------------------------------------------
/Leet Code/Find All Duplicates in an Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Find All Duplicates in an Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 6/8/2020 */
 5 | 
 6 | // Given an array of integers, 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.
 7 | 
 8 | // Find all the elements that appear twice in this array.
 9 | 
10 | // Could you do it without extra space and in O(n) runtime?
11 | 
12 | // Example:
13 | // Input:
14 | // [4,3,2,7,8,2,3,1]
15 | 
16 | // Output:
17 | // [2,3]
18 | 
19 | class Solution {
20 | public:
21 |     vector<int> findDuplicates(vector<int>& nums) {
22 |         map<int,int> m;
23 |         for(auto x: nums){
24 |             m[x]++;
25 |         }
26 |         vector<int> v;
27 |         for(auto x: m){
28 |             if(x.second==2)
29 |                 v.push_back(x.first);
30 |         }
31 |         return v;
32 |     }
33 | };


--------------------------------------------------------------------------------
/Leet Code/Find Minimum In Rotated Sorted Array II.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Find Minimum In Rotated Sprted Array II */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/7/2020 */
 5 | 
 6 | // Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
 7 | 
 8 | // (i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).
 9 | 
10 | // Find the minimum element.
11 | 
12 | // The array may contain duplicates.
13 | 
14 | // Example 1:
15 | 
16 | // Input: [1,3,5]
17 | // Output: 1
18 | // Example 2:
19 | 
20 | // Input: [2,2,2,0,1]
21 | // Output: 0
22 | // Note:
23 | 
24 | // This is a follow up problem to Find Minimum in Rotated Sorted Array.
25 | // Would allow duplicates affect the run-time complexity? How and why?
26 | 
27 | class Solution {
28 | public:
29 | 
30 |     int findMin(vector<int>& nums) {
31 |         // int ans = findArr(nums,0,nums.size()-1);
32 |         int low=0;
33 |         int high = nums.size()-1;
34 |         while(low<high){
35 |             // cout<<low<<endl;
36 |             int mid=low+(high-low)/2;
37 |             // cout<<mid<<endl;
38 |             if(nums[mid]==nums[high])
39 |                 high--;
40 |             else if(nums[mid]<=nums[high])
41 |                 high=mid;
42 |             else{
43 |                 low=mid+1;
44 |             }
45 |         }
46 |         return nums[high];
47 |     }
48 | };


--------------------------------------------------------------------------------
/Leet Code/Find Minimum In Rotated Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Find Minimum In Rotated Sprted Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/7/2020 */
 5 | 
 6 | // Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
 7 | 
 8 | // (i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).
 9 | 
10 | // Find the minimum element.
11 | 
12 | // You may assume no duplicate exists in the array.
13 | 
14 | // Example 1:
15 | 
16 | // Input: [3,4,5,1,2] 
17 | // Output: 1
18 | // Example 2:
19 | 
20 | // Input: [4,5,6,7,0,1,2]
21 | // Output: 0
22 | 
23 | class Solution {
24 | public:
25 |     int findArr(vector<int> nums,int low, int high){
26 |         if(low>high)
27 |             return nums[0];
28 |         if(high==low)
29 |             return nums[low];
30 |         
31 |         int mid = low +(high-low)/2;
32 |         if(mid<high and nums[mid+1]<nums[mid])
33 |             return nums[mid+1];
34 |         if(mid>low && nums[mid]<nums[mid-1])
35 |             return nums[mid];
36 |         if(nums[mid]<nums[high])
37 |             return findArr(nums,low,mid-1);
38 |         return findArr(nums,mid+1,high);
39 |     }
40 |     int findMin(vector<int>& nums) {
41 |         int ans = findArr(nums,0,nums.size()-1);
42 |         return ans;
43 |     }
44 | };


--------------------------------------------------------------------------------
/Leet Code/Find The Duplicate Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Find The Duplicate Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 22/8/2020 */
 5 | 
 6 | // Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: [1,3,4,2,2]
11 | // Output: 2
12 | // Example 2:
13 | 
14 | // Input: [3,1,3,4,2]
15 | // Output: 3
16 | // Note:
17 | 
18 | // You must not modify the array (assume the array is read only).
19 | // You must use only constant, O(1) extra space.
20 | // Your runtime complexity should be less than O(n2).
21 | // There is only one duplicate number in the array, but it could be repeated more than once.
22 | 
23 | class Solution {
24 | public:
25 |     int findDuplicate(vector<int>& nums) {
26 |         sort(nums.begin(),nums.end());
27 |         int i;
28 |         for(i=0;i<nums.size()-1;i++){
29 |             if(nums[i]==nums[i+1])
30 |                 break;
31 |         }
32 |         return nums[i];
33 |     }
34 | };


--------------------------------------------------------------------------------
/Leet Code/Find the Pivot Integer.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Find the Pivot Integer */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 03/06/2023 */
 5 | 
 6 | // Given a positive integer n, find the pivot integer x such that:
 7 | 
 8 | // The sum of all elements between 1 and x inclusively equals the sum of all elements between x and n inclusively.
 9 | // Return the pivot integer x. If no such integer exists, return -1. It is guaranteed that there will be at most one pivot index for the given input.
10 | 
11 |  
12 | 
13 | // Example 1:
14 | 
15 | // Input: n = 8
16 | // Output: 6
17 | // Explanation: 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21.
18 | // Example 2:
19 | 
20 | // Input: n = 1
21 | // Output: 1
22 | // Explanation: 1 is the pivot integer since: 1 = 1.
23 | // Example 3:
24 | 
25 | // Input: n = 4
26 | // Output: -1
27 | // Explanation: It can be proved that no such integer exist.
28 | 
29 | 
30 | class Solution {
31 | public:
32 |     int pivotInteger(int n) {
33 |         vector<int> v(n+1);
34 |         v[1]=1;
35 |         for(int i=2;i<=n;i++)
36 |             v[i]=v[i-1]+i;
37 |         for(int i=1;i<=n;i++)
38 |             if(v[i]==(v[n]-v[i]+i)) return i;
39 |         return -1;
40 |     }
41 | };
42 | 


--------------------------------------------------------------------------------
/Leet Code/First Missing Positive.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - First Missing Positive */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 16/07/2021 */
 5 | 
 6 | // Given an unsorted integer array nums, find the smallest missing positive integer.
 7 | 
 8 | // You must implement an algorithm that runs in O(n) time and uses constant extra space.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: nums = [1,2,0]
15 | // Output: 3
16 | // Example 2:
17 | 
18 | // Input: nums = [3,4,-1,1]
19 | // Output: 2
20 | // Example 3:
21 | 
22 | // Input: nums = [7,8,9,11,12]
23 | // Output: 1
24 | 
25 | 
26 | class Solution {
27 | public:
28 |     int firstMissingPositive(vector<int>& nums) {
29 |         if(nums.size()==0)
30 |             return 1;
31 |         int n = nums.size();
32 |         int count = 0;
33 |         for(int i=0;i<nums.size();i++){
34 |             if(nums[i]>0){
35 |                 nums[count++] = nums[i];
36 |             }
37 |         }
38 |     
39 |         for(int i=0;i<count;i++){
40 |             if(abs(nums[i])-1<n && nums[abs(nums[i])-1]>0){
41 |                 nums[abs(nums[i])-1] = -nums[abs(nums[i])-1];
42 |             }
43 |         }
44 |         
45 |         for(int i=0;i<count;i++){
46 |             if(nums[i]>0)
47 |                 return i+1;
48 |         }
49 |         return count+1;
50 |     }
51 | };


--------------------------------------------------------------------------------
/Leet Code/First Unique Character in a String.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - First Unique Character in a String */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/09/2020 */
 5 | 
 6 | // Given a string, find the first non-repeating character in it and return its index. If it doesn't exist, return -1.
 7 | 
 8 | // Examples:
 9 | 
10 | // s = "leetcode"
11 | // return 0.
12 | 
13 | // s = "loveleetcode"
14 | // return 2.
15 |  
16 | 
17 | // Note: You may assume the string contains only lowercase English letters.
18 | 
19 | class Solution {
20 | public:
21 |     int firstUniqChar(string s) {
22 |         vector<int> v(256,0);
23 |         
24 |         for(int i=0;i<s.length();i++){
25 |             v[s[i]]++;
26 |         }
27 |         for(int i=0;i<s.length();i++){
28 |             if(v[s[i]]==1)
29 |                 return i;
30 |         }
31 |         return -1;
32 |     }
33 | };


--------------------------------------------------------------------------------
/Leet Code/FizzBuzz.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Chef And Work */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/08/2020 */
 5 | 
 6 | // Write a program that outputs the string representation of numbers from 1 to n.
 7 | 
 8 | // But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.
 9 | 
10 | // Example:
11 | 
12 | // n = 15,
13 | 
14 | // Return:
15 | // [
16 | //     "1",
17 | //     "2",
18 | //     "Fizz",
19 | //     "4",
20 | //     "Buzz",
21 | //     "Fizz",
22 | //     "7",
23 | //     "8",
24 | //     "Fizz",
25 | //     "Buzz",
26 | //     "11",
27 | //     "Fizz",
28 | //     "13",
29 | //     "14",
30 | //     "FizzBuzz"
31 | // ]
32 | 
33 | class Solution {
34 | public:
35 |     vector<string> fizzBuzz(int n) {
36 |         vector<string> s;
37 |         for(int i=1;i<=n;i++){
38 |             if(i%3==0 && i%5==0){
39 |                 s.push_back("FizzBuzz");
40 |             }
41 |             else if(i%3==0)
42 |                 s.push_back("Fizz");
43 |             else if(i%5==0)
44 |                 s.push_back("Buzz");
45 |             else
46 |                 s.push_back(to_string(i));
47 |         }
48 |         return s;
49 |     }
50 | };


--------------------------------------------------------------------------------
/Leet Code/Generate Parentheses.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Generate Parentheses */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/09/2020 */
 5 | 
 6 | // Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
 7 | 
 8 | // For example, given n = 3, a solution set is:
 9 | 
10 | // [
11 | //   "((()))",
12 | //   "(()())",
13 | //   "(())()",
14 | //   "()(())",
15 | //   "()()()"
16 | // ]
17 | 
18 | 
19 | class Solution {
20 | public:
21 |     vector<string> s;
22 |     void generate(char *str,int idx,int n,int open, int close){
23 |         if(idx==2*n){
24 |             str[idx]='\0';
25 |             s.push_back(str);
26 |             return ;
27 |         }
28 |         if(open<n){
29 |             str[idx]='(';
30 |             
31 |             generate(str,idx+1,n,open+1,close);
32 |         }
33 |         if(close<open){
34 |             str[idx] = ')';
35 |             generate(str,idx+1,n,open,close+1);
36 |         }
37 |     }
38 |     vector<string> generateParenthesis(int n) {
39 |         if(n==0){
40 |             return s;
41 |         }
42 |         char str[10000000];
43 |         generate(str,0,n,0,0);
44 |         return s;
45 |     }
46 | };


--------------------------------------------------------------------------------
/Leet Code/Gray Code.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Gray Code */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 01/07/2021 */
 5 | 
 6 | // An n-bit gray code sequence is a sequence of 2n integers where:
 7 | 
 8 | // Every integer is in the inclusive range [0, 2n - 1],
 9 | // The first integer is 0,
10 | // An integer appears no more than once in the sequence,
11 | // The binary representation of every pair of adjacent integers differs by exactly one bit, and
12 | // The binary representation of the first and last integers differs by exactly one bit.
13 | // Given an integer n, return any valid n-bit gray code sequence.
14 | 
15 |  
16 | 
17 | // Example 1:
18 | 
19 | // Input: n = 2
20 | // Output: [0,1,3,2]
21 | // Explanation:
22 | // The binary representation of [0,1,3,2] is [00,01,11,10].
23 | // - 00 and 01 differ by one bit
24 | // - 01 and 11 differ by one bit
25 | // - 11 and 10 differ by one bit
26 | // - 10 and 00 differ by one bit
27 | // [0,2,3,1] is also a valid gray code sequence, whose binary representation is [00,10,11,01].
28 | // - 00 and 10 differ by one bit
29 | // - 10 and 11 differ by one bit
30 | // - 11 and 01 differ by one bit
31 | // - 01 and 00 differ by one bit
32 | // Example 2:
33 | 
34 | // Input: n = 1
35 | // Output: [0,1]
36 |  
37 | 
38 | // Constraints:
39 | 
40 | // 1 <= n <= 16
41 | 
42 | class Solution {
43 | public:
44 |     vector<int> grayCode(int n) {
45 |         vector<int> res(1<<n);
46 |         for(int i=0;i< 1<<n ; i++)
47 |             res[i] = i ^ (i>>1);
48 |         
49 |         return res;
50 |     }
51 | };


--------------------------------------------------------------------------------
/Leet Code/Hamming Distance.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Hamming Distance */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 05/07/2020 */
 5 | 
 6 | // The Hamming distance between two integers is the number of positions at which the corresponding bits are different.
 7 | 
 8 | // Given two integers x and y, calculate the Hamming distance.
 9 | 
10 | // Note:
11 | // 0 ≤ x, y < 231.
12 | 
13 | // Example:
14 | 
15 | // Input: x = 1, y = 4
16 | 
17 | // Output: 2
18 | 
19 | // Explanation:
20 | // 1   (0 0 0 1)
21 | // 4   (0 1 0 0)
22 | //        ↑   ↑
23 | 
24 | // The above arrows point to positions where the corresponding bits are different.
25 | 
26 | class Solution {
27 | public:
28 |     int hammingDistance(int x, int y) {
29 |         int count = 0;
30 |         while(x!=0 || y!=0){
31 |             int x1 = x&1;
32 |             int y1 = y&1;
33 |             if(x1^y1){
34 |                 count++;
35 |             }
36 |             x=x>>1;
37 |             y=y>>1;
38 |         }
39 |         return count;
40 |     }
41 | };


--------------------------------------------------------------------------------
/Leet Code/Happy Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Happy Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/12/2020 */
 5 | 
 6 | // Write an algorithm to determine if a number n is happy.
 7 | 
 8 | // A happy number is a number defined by the following process:
 9 | 
10 | // Starting with any positive integer, replace the number by the sum of the squares of its digits.
11 | // Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.
12 | // Those numbers for which this process ends in 1 are happy.
13 | // Return true if n is a happy number, and false if not.
14 | 
15 | class Solution {
16 | public:
17 |     bool isHappy(int n) {
18 |         if(n<1)
19 |             return false;
20 |         set<int> s;
21 |         int num = n;
22 |         while(s.find(num)==s.end()){
23 |             s.insert(num);
24 |             num = digitSquaredSum(num);
25 |         }
26 |         return num==1;
27 |     }
28 |     int digitSquaredSum(int n){
29 |         int sum = 0;
30 |         while(n>0){
31 |             int t = n%10;
32 |             sum += (t*t);
33 |             n/=10;
34 |         }
35 |         return sum;
36 |     }
37 | };


--------------------------------------------------------------------------------
/Leet Code/Invert Binary Tree.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Invert Binary Tree */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/09/2020 */
 5 | 
 6 | // Invert a binary tree.
 7 | 
 8 | // Example:
 9 | 
10 | // Input:
11 | 
12 | //      4
13 | //    /   \
14 | //   2     7
15 | //  / \   / \
16 | // 1   3 6   9
17 | // Output:
18 | 
19 | //      4
20 | //    /   \
21 | //   7     2
22 | //  / \   / \
23 | // 9   6 3   1
24 | // Trivia:
25 | // This problem was inspired by this original tweet by Max Howell:
26 | 
27 | // Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so f*** off.
28 | 
29 | /**
30 |  * Definition for a binary tree node.
31 |  * struct TreeNode {
32 |  *     int val;
33 |  *     TreeNode *left;
34 |  *     TreeNode *right;
35 |  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
36 |  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
37 |  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
38 |  * };
39 |  */
40 | class Solution {
41 | public:
42 |     TreeNode* invertTree(TreeNode* root) {
43 |         if(root==NULL)
44 |             return root;
45 |         TreeNode* leftTree = invertTree(root->left);
46 |         TreeNode* rightTree = invertTree(root->right);
47 |         
48 |         root->left = rightTree;
49 |         root-> right = leftTree;
50 |         return root;
51 |     }
52 | };


--------------------------------------------------------------------------------
/Leet Code/Is Subsequence.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Is Subsequence */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 22/05/2023 */
 5 | 
 6 | // Given two strings s and t, return true if s is a subsequence of t, or false otherwise.
 7 | 
 8 | // A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: s = "abc", t = "ahbgdc"
15 | // Output: true
16 | // Example 2:
17 | 
18 | // Input: s = "axc", t = "ahbgdc"
19 | // Output: false
20 | 
21 | class Solution {
22 | public:
23 |     bool isSubsequence(string s, string t) {
24 |         int j=0;
25 |         for(int i=0;i<t.length();i++){
26 |             if(t[i]==s[j]) j++;
27 |             if(j==s.length()) return true;
28 |         }
29 |         if(j==s.length()) return true;
30 |         return false;
31 |     }
32 | };
33 | 


--------------------------------------------------------------------------------
/Leet Code/Jump Game II.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Jump Game II */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 28/05/2023 */
 5 | 
 6 | // You are given a 0-indexed array of integers nums of length n. You are initially positioned at nums[0].
 7 | 
 8 | // Each element nums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can jump to any nums[i + j] where:
 9 | 
10 | // 0 <= j <= nums[i] and
11 | // i + j < n
12 | // Return the minimum number of jumps to reach nums[n - 1]. The test cases are generated such that you can reach nums[n - 1].
13 | 
14 |  
15 | 
16 | // Example 1:
17 | 
18 | // Input: nums = [2,3,1,1,4]
19 | // Output: 2
20 | // Explanation: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
21 | // Example 2:
22 | 
23 | // Input: nums = [2,3,0,1,4]
24 | // Output: 2
25 |   
26 | class Solution {
27 | public:
28 |     int jump(vector<int>& nums) {
29 |         vector<int> dp(nums.size(),0);
30 |         int dist=0;
31 |         dp[0]=nums[0];
32 |         for(int i=1;i<nums.size();i++){
33 |             dp[i]=max(dp[i-1], i+nums[i]);
34 |         }
35 |         int i=0;
36 |         while(i<nums.size()-1) dist++,i=dp[i];
37 |         return dist;
38 |     }
39 | };
40 | 


--------------------------------------------------------------------------------
/Leet Code/Jump Game.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Jump Game */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 28/05/2023 */
 5 | 
 6 | // You are given an integer array nums. You are initially positioned at the array's first index, and each element in the array represents your maximum jump length at that position.
 7 | 
 8 | // Return true if you can reach the last index, or false otherwise.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: nums = [2,3,1,1,4]
15 | // Output: true
16 | // Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
17 | // Example 2:
18 | 
19 | // Input: nums = [3,2,1,0,4]
20 | // Output: false
21 | // Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
22 | 
23 | class Solution {
24 | public:
25 |     bool canJump(vector<int>& nums) {
26 |         int n = nums.size();
27 |         vector<int> dp(n,0);
28 |         dp[0]=nums[0];
29 |         if(nums[0]==0 and nums.size()>1) return false;
30 |         for(int i=1;i<nums.size();i++){
31 |             if(dp[i-1]==i and nums[i]==0 and i!=nums.size()-1) return false;
32 |             dp[i]=max(dp[i-1],i+nums[i]);
33 |         }
34 |         return true;
35 |     }
36 | };
37 | 


--------------------------------------------------------------------------------
/Leet Code/Kth Largest Element in an Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Kth Largest Element in an Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 10/08/2021 */
 5 | 
 6 | // Given an integer array nums and an integer k, return the kth largest element in the array.
 7 | 
 8 | // Note that it is the kth largest element in the sorted order, not the kth distinct element.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: nums = [3,2,1,5,6,4], k = 2
15 | // Output: 5
16 | // Example 2:
17 | 
18 | // Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
19 | // Output: 4
20 | 
21 | 
22 | class Solution {
23 | public:
24 |     int findKthLargest(vector<int>& nums, int k) {
25 |         sort(nums.begin(), nums.end(), greater<int>());
26 |         return nums[k-1];
27 |     }
28 | };


--------------------------------------------------------------------------------
/Leet Code/Length of Last Word.cpp:
--------------------------------------------------------------------------------
 1 | /* Leetcode */
 2 | /* Title - Length of Last Word */
 3 | /* Created by - Akash Modak */
 4 | /* Date - 17/04/2021 */
 5 | 
 6 | // Given a string s consists of some words separated by spaces, return the length of the last word in the string. If the last word does not exist, return 0.
 7 | 
 8 | // A word is a maximal substring consisting of non-space characters only.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: s = "Hello World"
15 | // Output: 5
16 | // Example 2:
17 | 
18 | // Input: s = " "
19 | // Output: 0
20 | 
21 | class Solution {
22 | public:
23 |     int lengthOfLastWord(string s) {
24 |         int length = s.length();
25 |         int len = 0;
26 |         if(length==1 and isalpha(s[0]))
27 |             return 1;
28 |         for(int i=length-1; i>=0;i--){
29 |             if(isalpha(s[i])){
30 |                 for(int j=i; j>=0;j--){
31 |                     if(!isalpha(s[j])){
32 |                         return len;
33 |                     }
34 |                     len++;
35 |                 }
36 |                 return len;
37 |             }
38 |         }
39 |         return 0;
40 |     }
41 | };


--------------------------------------------------------------------------------
/Leet Code/Length of the Longest Alphabetical Continuous Substring.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Length of the Longest Alphabetical Continuous Substring */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/05/2023 */
 5 | 
 6 | // An alphabetical continuous string is a string consisting of consecutive letters in the alphabet. In other words, it is any substring of the string "abcdefghijklmnopqrstuvwxyz".
 7 | 
 8 | // For example, "abc" is an alphabetical continuous string, while "acb" and "za" are not.
 9 | // Given a string s consisting of lowercase letters only, return the length of the longest alphabetical continuous substring.
10 | 
11 |  
12 | 
13 | // Example 1:
14 | 
15 | // Input: s = "abacaba"
16 | // Output: 2
17 | // Explanation: There are 4 distinct continuous substrings: "a", "b", "c" and "ab".
18 | // "ab" is the longest continuous substring.
19 | // Example 2:
20 | 
21 | // Input: s = "abcde"
22 | // Output: 5
23 | // Explanation: "abcde" is the longest continuous substring.
24 | 
25 |   
26 | class Solution {
27 | public:
28 |     int longestContinuousSubstring(string s) {
29 |         int i=0,count=1, total=1;
30 |         for(i=1;i<s.length();i++){
31 |             if(s[i]==s[i-1]+1)
32 |                 count++;
33 |             else
34 |               count=1;
35 |             total=max(total,count);
36 |         }
37 |         return total;
38 |     }
39 | };
40 | 


--------------------------------------------------------------------------------
/Leet Code/Letter Case Permutation.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Letter Case Permutation */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 07/06/2023 */
 5 | 
 6 | // Given a string s, you can transform every letter individually to be lowercase or uppercase to create another string.
 7 | 
 8 | // Return a list of all possible strings we could create. Return the output in any order.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: s = "a1b2"
15 | // Output: ["a1b2","a1B2","A1b2","A1B2"]
16 | // Example 2:
17 | 
18 | // Input: s = "3z4"
19 | // Output: ["3z4","3Z4"]
20 | 
21 | class Solution {
22 | public:
23 |     void perm(vector<string> &res, string s, int i){
24 |         if(i==s.length()){
25 |             res.push_back(s);
26 |             return;
27 |         }else if(isalpha(s[i])){
28 |             s[i]=tolower(s[i]);
29 |             perm(res,s,i+1);
30 |             s[i]=toupper(s[i]);
31 |             perm(res,s,i+1);
32 |         }else{
33 |             perm(res,s,i+1);
34 |         }
35 | 
36 |     }
37 |     vector<string> letterCasePermutation(string s) {
38 |         vector<string> res;
39 |         perm(res,s,0);
40 |         return res;
41 |     }
42 | };
43 | 


--------------------------------------------------------------------------------
/Leet Code/Letter Combinations of a Phone Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Letter Combinations of a Phone Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/09/2020 */
 5 | 
 6 | // Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent.
 7 | 
 8 | // A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
 9 | 
10 | 
11 | 
12 | // Example:
13 | 
14 | // Input: "23"
15 | // Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
16 | // Note:
17 | 
18 | // Although the above answer is in lexicographical order, your answer could be in any order you want.
19 | 
20 | class Solution {
21 | public:
22 |     string table[20] = {"","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
23 |     vector<string> s;
24 |     void generate(string inp,int i,char *out,int j){
25 |         if(inp[i]=='\0'){
26 |             out[j] = '\0';
27 |             s.push_back(out);
28 |             return ;
29 |         }
30 |         
31 |         int key = inp[i]-'0';
32 |         key--;
33 |         for(int t=0;table[key][t]!='\0';t++){
34 |             out[j] = table[key][t];
35 |             generate(inp,i+1,out,j+1);
36 |         }
37 |     }
38 |     vector<string> letterCombinations(string digits) {
39 |         if(digits.length()==0)
40 |             return s;
41 |         char out[10000000];
42 |         generate(digits,0,out,0);
43 |         return s;
44 |     }
45 | };


--------------------------------------------------------------------------------
/Leet Code/Longest Common Prefix.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Longest Common Prefix */
 3 | 
 4 | // Write a function to find the longest common prefix string amongst an array of strings.
 5 | 
 6 | // If there is no common prefix, return an empty string "".
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: ["flower","flow","flight"]
11 | // Output: "fl"
12 | // Example 2:
13 | 
14 | // Input: ["dog","racecar","car"]
15 | // Output: ""
16 | // Explanation: There is no common prefix among the input strings.
17 | // Note:
18 | 
19 | // All given inputs are in lowercase letters a-z.
20 | 
21 | class Solution {
22 | public:
23 |     string longestCommonPrefix(vector<string>& strs) {
24 |         string s = "";
25 |         int n = strs.size();
26 |         if(n==0)
27 |             return s;
28 |         if(n==1)
29 |             return strs[0];
30 |         
31 |         sort(strs.begin(),strs.end());
32 |         int minimumLength = min(strs[0].length(),strs[n-1].length());
33 |         string first = strs[0], last = strs[n-1];
34 |         int i=0;
35 |         while(i<minimumLength && last[i]==first[i])
36 |             i++;
37 |         s = first.substr(0,i);
38 |         return s;
39 |     }
40 | };


--------------------------------------------------------------------------------
/Leet Code/Longest Consecutive Sequence.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Longest Consecutive Sequence */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 22/05/2023 */
 5 | 
 6 | // Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.
 7 | 
 8 | // You must write an algorithm that runs in O(n) time.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: nums = [100,4,200,1,3,2]
15 | // Output: 4
16 | // Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
17 | // Example 2:
18 | 
19 | // Input: nums = [0,3,7,2,5,8,4,6,0,1]
20 | // Output: 9
21 | 
22 | class Solution {
23 | public:
24 |     int longestConsecutive(vector<int>& nums) {
25 |         unordered_set<int> s;
26 |         int maxCount=0;
27 |         for(int i=0;i<nums.size();i++) s.insert(nums[i]);
28 |         for(int n: nums){
29 |             if(s.find(n-1)==s.end()){
30 |                 int num=n;
31 |                 int count=1;
32 |                 while(s.find(num+1)!=s.end()){
33 |                     num++;
34 |                     count++;
35 |                 }
36 |                 maxCount=max(maxCount,count);
37 |             }
38 |         }
39 |         return maxCount;
40 |     }
41 | };
42 | 


--------------------------------------------------------------------------------
/Leet Code/Longest Increasing Subsequence.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Longest Increasing Subsequence */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/09/2020 */
 5 | 
 6 | // Given an unsorted array of integers, find the length of longest increasing subsequence.
 7 | 
 8 | // Example:
 9 | 
10 | // Input: [10,9,2,5,3,7,101,18]
11 | // Output: 4 
12 | // Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4. 
13 | // Note:
14 | 
15 | // There may be more than one LIS combination, it is only necessary for you to return the length.
16 | // Your algorithm should run in O(n^2) complexity.
17 | 
18 | class Solution {
19 | public:
20 |     int lengthOfLIS(vector<int>& nums) {
21 |         if(nums.size()==0)
22 |             return 0;
23 |         int n = nums.size();
24 |         int lis[n];
25 |         for(int i=0;i<n;i++)
26 |             lis[i]=1;
27 |         for(int i=0;i<n;i++){
28 |             for(int j=0;j<i;j++){
29 |                 if(nums[i]>nums[j] and lis[i]<lis[j]+1){
30 |                     lis[i] = lis[j]+1;
31 |                 }
32 |             }
33 |         }
34 |         int max = 0;
35 |         for(int i=0;i<n;i++){
36 |             if(max<lis[i])
37 |                 max=lis[i];
38 |         }
39 |         return max;
40 |     }
41 | };


--------------------------------------------------------------------------------
/Leet Code/Longest Palindrome.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Longest Palindrome */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/8/2020 */
 5 | 
 6 | // Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.
 7 | 
 8 | // This is case sensitive, for example "Aa" is not considered a palindrome here.
 9 | 
10 | // Note:
11 | // Assume the length of given string will not exceed 1,010.
12 | 
13 | // Example:
14 | 
15 | // Input:
16 | // "abccccdd"
17 | 
18 | // Output:
19 | // 7
20 | 
21 | // Explanation:
22 | // One longest palindrome that can be built is "dccaccd", whose length is 7.
23 | 
24 | class Solution {
25 | public:
26 |     int longestPalindrome(string s) {
27 |         map<char,int> m;
28 |         int ans =0;
29 |         for(int i=0;i<s.length();i++){
30 |             m[s[i]]++;
31 |             if(m[s[i]]%2==0)
32 |                 ans+=2;
33 |         }
34 |         return s.length()>ans?ans+1:ans;
35 |     }
36 | };


--------------------------------------------------------------------------------
/Leet Code/Longest Substring Without Repeating Characters.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Longest Substring Without Repeating Characters */
 3 | // Given a string, find the length of the longest substring without repeating characters.
 4 | 
 5 | // Example 1:
 6 | 
 7 | // Input: "abcabcbb"
 8 | // Output: 3 
 9 | // Explanation: The answer is "abc", with the length of 3. 
10 | // Example 2:
11 | 
12 | // Input: "bbbbb"
13 | // Output: 1
14 | // Explanation: The answer is "b", with the length of 1.
15 | // Example 3:
16 | 
17 | // Input: "pwwkew"
18 | // Output: 3
19 | // Explanation: The answer is "wke", with the length of 3. 
20 | //              Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
21 | 
22 | class Solution {
23 | public:
24 |     int lengthOfLongestSubstring(string s) {
25 |         vector<int> lastIndex(256,-1);
26 |         int i = 0;
27 |         int j;
28 |         int res = 0;
29 |         int n = s.length();
30 |         for(j=0;j<n;j++){
31 |             i = max(i,lastIndex[s[j]]+1);
32 |             res = max(res,j-i+1);
33 |             lastIndex[s[j]] = j;
34 |         }
35 |         return res;
36 |         
37 |     }
38 | };


--------------------------------------------------------------------------------
/Leet Code/Majority Element II.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Majority Element II */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/06/2020 */
 5 | 
 6 | // Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times.
 7 | 
 8 | // Follow-up: Could you solve the problem in linear time and in O(1) space?
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: nums = [3,2,3]
15 | // Output: [3]
16 | // Example 2:
17 | 
18 | // Input: nums = [1]
19 | // Output: [1]
20 | // Example 3:
21 | 
22 | // Input: nums = [1,2]
23 | // Output: [1,2]
24 | 
25 | class Solution {
26 | public:
27 |     vector<int> majorityElement(vector<int>& nums) {
28 |         if(nums.size()==1){
29 |             return vector<int>(1,nums[0]);
30 |         }
31 |         vector<int> res;
32 |         int length = nums.size();
33 |         int oneThird = length/3;
34 |         int count = 1;
35 |         sort(nums.begin(), nums.end());
36 |         int currentElement = nums[0];
37 |         for(int i=1;i<length;i++){
38 |             if(currentElement != nums[i]){
39 |                 if(count > oneThird)
40 |                 {
41 |                     res.push_back(currentElement);
42 |                 }
43 |                 count = 0;
44 |             }
45 |             currentElement = nums[i];
46 |             count++;
47 |         }
48 |         if(count > oneThird)
49 |         {
50 |             res.push_back(currentElement); 
51 |         }
52 |         return res;
53 |     }
54 | };


--------------------------------------------------------------------------------
/Leet Code/Majority Element.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Majority Element */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/06/2021 */
 5 | 
 6 | // Given an array nums of size n, return the majority element.
 7 | 
 8 | // The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.
 9 | // Example 1:
10 | 
11 | // Input: nums = [3,2,3]
12 | // Output: 3
13 | // Example 2:
14 | 
15 | // Input: nums = [2,2,1,1,1,2,2]
16 | // Output: 2
17 | 
18 | class Solution {
19 | public:
20 |     int majorityElement(vector<int>& nums) {
21 |         if(nums.size() == 1)
22 |             return nums[0];
23 |         sort(nums.begin(), nums.end());
24 |         int middleElement = nums.size()/2;
25 |         return nums[middleElement];
26 |         
27 |     }
28 | };


--------------------------------------------------------------------------------
/Leet Code/Maximum Depth of Binary Tree.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Maximum Depth of Binary Tree */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/09/2020 */
 5 | 
 6 | // Given a binary tree, find its maximum depth.
 7 | 
 8 | // The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
 9 | 
10 | // Note: A leaf is a node with no children.
11 | 
12 | // Example:
13 | 
14 | // Given binary tree [3,9,20,null,null,15,7],
15 | 
16 | //     3
17 | //    / \
18 | //   9  20
19 | //     /  \
20 | //    15   7
21 | // return its depth = 3.
22 | 
23 | /**
24 |  * Definition for a binary tree node.
25 |  * struct TreeNode {
26 |  *     int val;
27 |  *     TreeNode *left;
28 |  *     TreeNode *right;
29 |  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
30 |  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
31 |  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
32 |  * };
33 |  */
34 | class Solution {
35 | public:
36 |     int depth = 0;
37 |     int maxDepth(TreeNode* root) {
38 |         if(root==NULL)
39 |             return 0;
40 |         int h1 = maxDepth(root->left)+1;
41 |         int h2 = maxDepth(root->right)+1;
42 |         
43 |         depth = max(h1,h2);
44 |         return depth;
45 |     }
46 | };


--------------------------------------------------------------------------------
/Leet Code/Maximum Erasure Value.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Maximum Erasure Value */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/06/2023 */
 5 | 
 6 | // You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.
 7 | 
 8 | // Return the maximum score you can get by erasing exactly one subarray.
 9 | 
10 | // An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: nums = [4,2,4,5,6]
17 | // Output: 17
18 | // Explanation: The optimal subarray here is [2,4,5,6].
19 | // Example 2:
20 | 
21 | // Input: nums = [5,2,1,2,5,2,1,2,5]
22 | // Output: 8
23 | // Explanation: The optimal subarray here is [5,2,1] or [1,2,5].
24 | 
25 | class Solution {
26 | public:
27 |     int maximumUniqueSubarray(vector<int>& nums) {
28 |         unordered_set<int> s;
29 |         int sum=0, maxSum=INT_MIN,start=0;
30 |         for(int i=0;i<nums.size();i++){
31 |             if(s.find(nums[i])!=s.end()){
32 |                 maxSum=max(sum,maxSum);
33 |                 while(start<i) {
34 |                     sum-=nums[start];
35 |                     s.erase(nums[start]);
36 |                     start++;
37 |                     if(nums[start-1]==nums[i]) break;   
38 |                 }
39 |             }
40 |             s.insert(nums[i]);
41 |             sum+=nums[i];
42 |         }
43 |         return maxSum<sum?sum:maxSum;
44 |     }
45 | };
46 | 


--------------------------------------------------------------------------------
/Leet Code/Maximum Number of Balloons.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Maximum Number of Balloons */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 13/09/2021 */
 5 | 
 6 | 
 7 | // Given a string text, you want to use the characters of text to form as many instances of the word "balloon" as possible.
 8 | 
 9 | // You can use each character in text at most once. Return the maximum number of instances that can be formed.
10 | 
11 |  
12 | 
13 | // Example 1:
14 | 
15 | 
16 | 
17 | // Input: text = "nlaebolko"
18 | // Output: 1
19 | // Example 2:
20 | 
21 | 
22 | 
23 | // Input: text = "loonbalxballpoon"
24 | // Output: 2
25 | // Example 3:
26 | 
27 | // Input: text = "leetcode"
28 | // Output: 0
29 | 
30 | 
31 | class Solution {
32 | public:
33 |     int maxNumberOfBalloons(string text) {
34 |         unordered_map<char,int> m;
35 |         
36 |         int num = 0;
37 |         
38 |         for(int i=0;i<text.length();i++){
39 |             if(text[i] == 'b' || text[i] == 'a' || text[i] == 'l' || text[i] == 'o' || text[i] == 'n'){
40 |                 m[text[i]]++;
41 |             }
42 |         }
43 |         num = m['b'];
44 |         num = min(num, m['a']);
45 |         num = min(num, m['l']/2);
46 |         num = min(num, m['o']/2);
47 |         num = min(num, m['n']);
48 |         
49 |         return num; 
50 |     }
51 | };


--------------------------------------------------------------------------------
/Leet Code/Maximum Number of Vowels in a Substring of Given Length.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Maximum Number of Vowels in a Substring of Given Length */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/04/2023 */
 5 | 
 6 | // Given a string s and an integer k, return the maximum number of vowel letters in any substring of s with length k.
 7 | 
 8 | // Vowel letters in English are 'a', 'e', 'i', 'o', and 'u'.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: s = "abciiidef", k = 3
15 | // Output: 3
16 | // Explanation: The substring "iii" contains 3 vowel letters.
17 | // Example 2:
18 | 
19 | // Input: s = "aeiou", k = 2
20 | // Output: 2
21 | // Explanation: Any substring of length 2 contains 2 vowels.
22 | // Example 3:
23 | 
24 | // Input: s = "leetcode", k = 3
25 | // Output: 2
26 | // Explanation: "lee", "eet" and "ode" contain 2 vowels.
27 | 
28 | class Solution {
29 | public:
30 |     int maxVowels(string s, int k) {
31 |         unordered_set<char> ch;
32 |         ch.insert('a');
33 |         ch.insert('e');
34 |         ch.insert('i');
35 |         ch.insert('o');
36 |         ch.insert('u');
37 |         int count=0, maxCount=0;
38 |         for(int i=0;i<k;i++)
39 |             if(ch.find(s[i])!=ch.end())
40 |                 count++;
41 |         maxCount=count;
42 |         for(int i=k;i<s.length();i++){
43 |             if(ch.find(s[i-k])!=ch.end()) count--;
44 |             if(ch.find(s[i])!=ch.end()) count++;
45 |             maxCount=max(count,maxCount);
46 |         }
47 |         return maxCount;
48 |     }
49 | };
50 | 


--------------------------------------------------------------------------------
/Leet Code/Maximum Sub Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Maximum Sub Array */
 3 | 
 4 | //Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
 5 | 
 6 | //Example:
 7 | //
 8 | //Input: [-2,1,-3,4,-1,2,1,-5,4],
 9 | //Output: 6
10 | //Explanation: [4,-1,2,1] has the largest sum = 6.
11 | class Solution {
12 | public:
13 |     int maxSubArray(vector<int>& nums) {
14 |        
15 |         int maxSum=INT_MIN;
16 |         int currSum=0;
17 |         for(int i=0;i<nums.size();i++)
18 |         {
19 |             currSum = currSum + nums[i];
20 |             if( maxSum < currSum)
21 |                 maxSum = currSum;
22 |             if( currSum < 0 )
23 |                 currSum = 0;
24 |         }
25 |         return maxSum;
26 |     }
27 | };
28 | 


--------------------------------------------------------------------------------
/Leet Code/Merge Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code*/
 2 | /* Title - Merge Sorted Array */
 3 | //Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
 4 | //
 5 | //Note:
 6 | //
 7 | //The number of elements initialized in nums1 and nums2 are m and n respectively.
 8 | //You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.
 9 | //Example:
10 | //
11 | //Input:
12 | //nums1 = [1,2,3,0,0,0], m = 3
13 | //nums2 = [2,5,6],       n = 3
14 | //
15 | //Output: [1,2,2,3,5,6]
16 | 
17 | class Solution {
18 | public:
19 |     void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
20 |         int i=m-1;
21 |         int j=n-1;
22 |         int k=m+n-1;
23 |         while(i>=0 && j>=0)
24 |         {
25 |             nums1[k--]=nums1[i]>nums2[j]?nums1[i--]:nums2[j--];
26 |         }
27 |         while(i>=0)
28 |             nums1[k--]=nums1[i--];
29 |         while(j>=0)
30 |             nums1[k--]=nums2[j--];
31 |         
32 |     }
33 | };
34 | 


--------------------------------------------------------------------------------
/Leet Code/Minimum Add to Make Parentheses Valid.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Minimum Add to Make Parentheses Valid */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 01/06/2023 */
 5 | 
 6 | // A parentheses string is valid if and only if:
 7 | 
 8 | // It is the empty string,
 9 | // It can be written as AB (A concatenated with B), where A and B are valid strings, or
10 | // It can be written as (A), where A is a valid string.
11 | // You are given a parentheses string s. In one move, you can insert a parenthesis at any position of the string.
12 | 
13 | // For example, if s = "()))", you can insert an opening parenthesis to be "(()))" or a closing parenthesis to be "())))".
14 | // Return the minimum number of moves required to make s valid.
15 | 
16 |  
17 | 
18 | // Example 1:
19 | 
20 | // Input: s = "())"
21 | // Output: 1
22 | // Example 2:
23 | 
24 | // Input: s = "((("
25 | // Output: 3
26 | 
27 | class Solution {
28 | public:
29 |     int minAddToMakeValid(string s) {
30 |         int open=0,add=0,close=0;
31 |         for(int i=0;i<s.length();i++){
32 |             if(s[i]=='(') open++;
33 |             else if(open>0) open--;
34 |             else add++;
35 |         }
36 |         return add+open;
37 |     }
38 | };
39 | 


--------------------------------------------------------------------------------
/Leet Code/Minimum Flips to Make a OR b Equal to c.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Minimum Flips to Make a OR b Equal to c */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 07/06/2023 */
 5 | 
 6 | // Given 3 positives numbers a, b and c. Return the minimum flips required in some bits of a and b to make ( a OR b == c ). (bitwise OR operation).
 7 | // Flip operation consists of change any single bit 1 to 0 or change the bit 0 to 1 in their binary representation.
 8 | 
 9 | // Example 1:
10 | 
11 | // Input: a = 2, b = 6, c = 5
12 | // Output: 3
13 | // Explanation: After flips a = 1 , b = 4 , c = 5 such that (a OR b == c)
14 | // Example 2:
15 | 
16 | // Input: a = 4, b = 2, c = 7
17 | // Output: 1
18 | // Example 3:
19 | 
20 | // Input: a = 1, b = 2, c = 3
21 | // Output: 0
22 | 
23 | class Solution {
24 | public:
25 |     int minFlips(int a, int b, int c) {
26 |         int at, bt, ct,count=0;
27 |         while(c!=0 || b!=0 || a!=0){
28 |             at=a&1;
29 |             bt=b&1;
30 |             ct=c&1;
31 |             a=a>>1;
32 |             b=b>>1;
33 |             c=c>>1;
34 |             if(ct==1 and at!=bt) continue;
35 |             else if(ct==0 and at!=bt) count++;        
36 |             else if(ct==1 and at==0) count++;
37 |             else if(ct==0 and at==1) count+=2;     
38 |         }
39 |         return count;
40 |     }
41 | };
42 | 


--------------------------------------------------------------------------------
/Leet Code/Minimum Path Sum.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Minimum Path Sum */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/09/2020 */
 5 | 
 6 | // Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.
 7 | 
 8 | // Note: You can only move either down or right at any point in time.
 9 | 
10 | // Example:
11 | 
12 | // Input:
13 | // [
14 | //   [1,3,1],
15 | //   [1,5,1],
16 | //   [4,2,1]
17 | // ]
18 | // Output: 7
19 | // Explanation: Because the path 1→3→1→1→1 minimizes the sum.
20 | 
21 | class Solution {
22 | public:
23 |     
24 |  
25 |     int minPathSum(vector<vector<int>>& grid) {
26 |         if(grid.size()==0)
27 |             return 0;
28 |         int m = grid.size();
29 |         int n = grid[0].size();
30 |         
31 |         if(m==0 and n==0)
32 |             return 0;
33 |     
34 |         int dp[m][n];
35 |         dp[0][0] = grid[0][0];
36 |         for(int i=1;i<m;i++)
37 |             dp[i][0] = dp[i-1][0] + grid[i][0];
38 |         for(int j=1;j<n;j++)
39 |             dp[0][j] = dp[0][j-1] + grid[0][j];
40 |         
41 |         for(int i=1;i<m;i++){
42 |             for(int j=1;j<n;j++){
43 |                 int sum1 = dp[i-1][j] + grid[i][j];
44 |                 int sum2 = dp[i][j-1] + grid[i][j];
45 |                 dp[i][j] = min(sum1,sum2);
46 |             }
47 |         }
48 |         return dp[m-1][n-1];
49 |         
50 |     }
51 | };


--------------------------------------------------------------------------------
/Leet Code/Minimum Size Subarray Sum.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Minimum Size Subarray Sum */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/09/2020 */
 5 | 
 6 | // Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn't one, return 0 instead.
 7 | 
 8 | // Example: 
 9 | 
10 | // Input: s = 7, nums = [2,3,1,2,4,3]
11 | // Output: 2
12 | // Explanation: the subarray [4,3] has the minimal length under the problem constraint.
13 | // Follow up:
14 | // If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n). 
15 | 
16 | class Solution {
17 | public:
18 |     int minSubArrayLen(int s, vector<int>& nums) {
19 |         int ans = INT_MAX;
20 |         int start = 0;
21 |         int sum = 0;
22 |         for(int i=0;i<nums.size();i++){
23 |             sum+=nums[i];
24 |             // cout<<sum<<endl;
25 |             if(sum>=s){
26 |                 while(sum-nums[start]>=s){
27 |                  sum-=nums[start];
28 |                     start++;
29 |                 }
30 |                 int len = i-start+1;
31 |                 ans = min(ans,len);
32 |                 
33 |             }
34 |         }
35 |         if(ans==INT_MAX)
36 |             return 0;
37 |         return ans;
38 | 
39 |     }
40 | };


--------------------------------------------------------------------------------
/Leet Code/Missing Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Missing Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 22/8/2020 */
 5 | 
 6 | // Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: [3,0,1]
11 | // Output: 2
12 | // Example 2:
13 | 
14 | // Input: [9,6,4,2,3,5,7,0,1]
15 | // Output: 8
16 | 
17 | 
18 | class Solution {
19 | public:
20 |     int missingNumber(vector<int>& nums) {
21 |         int n = nums.size();
22 |         int sumn = (n*(n+1))/2;
23 |         int sum = 0;
24 |         for(int i=0;i<n;i++){
25 |             sum+=nums[i];
26 |         }
27 |         return sumn-sum;
28 |     }
29 | };


--------------------------------------------------------------------------------
/Leet Code/Move Zeroes.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Move Zeroes */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/08/2020 */
 5 | 
 6 | // Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.
 7 | 
 8 | // Example:
 9 | 
10 | // Input: [0,1,0,3,12]
11 | // Output: [1,3,12,0,0]
12 | // Note:
13 | 
14 | // You must do this in-place without making a copy of the array.
15 | // Minimize the total number of operations.
16 | 
17 | class Solution {
18 | public:
19 |     void moveZeroes(vector<int>& nums) {
20 |         int count = 0;
21 |         int i,j=0;
22 |         if(nums.empty())
23 |             return;
24 |         for(i=0;i<nums.size();i++){
25 |             if(nums[i]!=0){
26 |                 nums[j] = nums[i];
27 |                 j++;
28 |             }else{
29 |                 count++;
30 |             }
31 |         }
32 |         for(i=nums.size()-count;i<nums.size();i++){
33 |             nums[i]=0;
34 |         }
35 |     }
36 | };


--------------------------------------------------------------------------------
/Leet Code/Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/06/2023 */
 5 | 
 6 | // Given an array of integers arr and two integers k and threshold, return the number of sub-arrays of size k and average greater than or equal to threshold.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: arr = [2,2,2,2,5,5,5,8], k = 3, threshold = 4
13 | // Output: 3
14 | // Explanation: Sub-arrays [2,5,5],[5,5,5] and [5,5,8] have averages 4, 5 and 6 respectively. All other sub-arrays of size 3 have averages less than 4 (the threshold).
15 | // Example 2:
16 | 
17 | // Input: arr = [11,13,17,23,29,31,7,5,2,3], k = 3, threshold = 5
18 | // Output: 6
19 | // Explanation: The first 6 sub-arrays of size 3 have averages greater than 5. Note that averages are not integers.
20 | 
21 | class Solution {
22 | public:
23 |     int numOfSubarrays(vector<int>& arr, int k, int threshold) {
24 |         int count=0,sum=0;
25 |         for(int i=0;i<arr.size();i++){
26 |             sum+=arr[i];
27 |             if(i>=k){
28 |                 sum-=arr[i-k];
29 |             }
30 |             if(i>=k-1 and sum/k>=threshold) count++;
31 |         }
32 |         return count;
33 |     }
34 | };
35 | 


--------------------------------------------------------------------------------
/Leet Code/Optimal Partition of String.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Optimal Partition of String */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 18/05/2023 */
 5 | 
 6 | // Given a string s, partition the string into one or more substrings such that the characters in each substring are unique. That is, no letter appears in a single substring more than once.
 7 | 
 8 | // Return the minimum number of substrings in such a partition.
 9 | 
10 | // Note that each character should belong to exactly one substring in a partition.
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: s = "abacaba"
17 | // Output: 4
18 | // Explanation:
19 | // Two possible partitions are ("a","ba","cab","a") and ("ab","a","ca","ba").
20 | // It can be shown that 4 is the minimum number of substrings needed.
21 | // Example 2:
22 | 
23 | // Input: s = "ssssss"
24 | // Output: 6
25 | // Explanation:
26 | // The only valid partition is ("s","s","s","s","s","s").
27 | 
28 | class Solution {
29 | public:
30 |     int partitionString(string s) {
31 |         int maxVal=1;
32 |         int letters[26]={0};  
33 |         for(int i=0;i<s.length();i++) {  
34 |               if(letters[s[i]-'a']==1){
35 |                   maxVal++;
36 |                   memset(letters,0,sizeof(letters));
37 |               }
38 |               letters[s[i]-'a']++;
39 |         }
40 |         return maxVal;
41 |     }
42 | };
43 | 


--------------------------------------------------------------------------------
/Leet Code/Pallindrome Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Pallindrome Number */
 3 | 
 4 | //Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.
 5 | //
 6 | //Example 1:
 7 | //
 8 | //Input: 121
 9 | //Output: true
10 | //Example 2:
11 | //
12 | //Input: -121
13 | //Output: false
14 | //Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
15 | class Solution {
16 | public:
17 |     bool isPalindrome(int x) {
18 |         int rev = 0,s;
19 |         
20 |         s = x;
21 |         while(x>0)
22 |         {
23 |             int pop = x % 10;
24 |              x /= 10;
25 |             if( rev > INT_MAX / 10 || ( rev == INT_MAX / 10 && pop > 7 ) )
26 |                 return false;
27 |             if( rev < INT_MIN / 10 || ( rev == INT_MIN/10 && pop < -8 ) )
28 |                 return false;
29 |             rev = ( rev * 10 ) + pop;
30 |            
31 |          }
32 |         if( rev == s )
33 |             return true;
34 |         else 
35 |             return false;
36 |     }
37 | };
38 |   
39 | 


--------------------------------------------------------------------------------
/Leet Code/Permutations II.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Permutations II */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 03/06/2023 */
 5 | 
 6 | // Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: nums = [1,1,2]
13 | // Output:
14 | // [[1,1,2],
15 | //  [1,2,1],
16 | //  [2,1,1]]
17 | // Example 2:
18 | 
19 | // Input: nums = [1,2,3]
20 | // Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
21 | 
22 | class Solution {
23 | public:
24 |     void swap(vector<int> &nums, int i, int j) {
25 |         int t=nums[i];
26 |         nums[i]=nums[j];
27 |         nums[j]=t;
28 |     }
29 |     void perm(vector<int> nums, int i, set<vector<int>> &s){
30 |         if(i==nums.size()){
31 |             s.insert(nums);
32 |             return;
33 |         }
34 | 
35 |         for(int j=i;j<nums.size();j++){
36 |             swap(nums, i,j);
37 |             perm(nums, i+1,s);
38 |             swap(nums,i,j);
39 |         }
40 |     }
41 |     vector<vector<int>> permuteUnique(vector<int>& nums) {
42 |         set<vector<int>> st;
43 |         perm(nums,0,st);
44 |         vector<vector<int>> res(st.begin(),st.end());
45 |         return res;
46 |     }
47 | };
48 | 


--------------------------------------------------------------------------------
/Leet Code/Plus One.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Plus One */
 3 | 
 4 | // Given a non-empty array of digits representing a non-negative integer, plus one to the integer.
 5 | 
 6 | // The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.
 7 | 
 8 | // You may assume the integer does not contain any leading zero, except the number 0 itself.
 9 | 
10 | // Example 1:
11 | 
12 | // Input: [1,2,3]
13 | // Output: [1,2,4]
14 | // Explanation: The array represents the integer 123.
15 | // Example 2:
16 | 
17 | // Input: [4,3,2,1]
18 | // Output: [4,3,2,2]
19 | // Explanation: The array represents the integer 4321.
20 | 
21 | class Solution {
22 | public:
23 |     vector<int> plusOne(vector<int>& digits) {
24 |         int n = digits.size();
25 |         int carry = 0;
26 |         int temp = digits[n-1]+1;
27 |         digits[n-1] = temp%10;
28 |         carry = temp/10;
29 |         for(int i=n-2;i>=0;i--){
30 |             int temp = digits[i]+carry;
31 |             digits[i] = temp%10;
32 |             carry = temp/10;
33 |         }
34 |         if(carry)
35 |             digits.insert(digits.begin(),carry);
36 |         return digits;
37 |     }
38 | };


--------------------------------------------------------------------------------
/Leet Code/PowXN.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Pow(x,n)  */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 16/7/2020 */
 5 | 
 6 | // Implement pow(x, n), which calculates x raised to the power n (xn).
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: 2.00000, 10
11 | // Output: 1024.00000
12 | // Example 2:
13 | 
14 | // Input: 2.10000, 3
15 | // Output: 9.26100
16 | // Example 3:
17 | 
18 | // Input: 2.00000, -2
19 | // Output: 0.25000
20 | // Explanation: 2-2 = 1/2^2 = 1/4 = 0.25
21 | // Note:
22 | 
23 | // -100.0 < x < 100.0
24 | // n is a 32-bit signed integer, within the range [−2^31, 2^31 − 1]
25 | 
26 | class Solution {
27 | public:
28 |     double power(double x, long long n){
29 |         if(n==0)
30 |             return 1.0;
31 |         if(n%2==0)
32 |         {
33 |             double ans = power(x,n/2);
34 |             return ans*ans;
35 |         }
36 |         else
37 |             return x*power(x,n-1);
38 |     }
39 |     double myPow(double x, int n) {
40 |         
41 |         if(n<0)
42 |             return 1/power(x,-1*(long long)n);
43 |         return power(x,(long long)n);
44 |     }
45 | };


--------------------------------------------------------------------------------
/Leet Code/Power Of Four.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Power of Four */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 4/8/2020 */
 5 | 
 6 | // Given an integer (signed 32 bits), write a function to check whether it is a power of 4.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: 16
11 | // Output: true
12 | // Example 2:
13 | 
14 | // Input: 5
15 | // Output: false
16 | // Follow up: Could you solve it without loops/recursion?
17 | 
18 | class Solution {
19 | public:
20 |     bool isPowerOfFour(long long int num) {
21 |         if(num==1)
22 |             return true;
23 |         if(num<=0)
24 |             return false;
25 |         int setBits = __builtin_popcount(num);
26 |         int numOfDigits = floor(log2(num))+1;
27 |         // cout<<numOfDigits<<" "<<setBits;
28 |         int numOfZeros = numOfDigits - setBits;
29 |         if(setBits==1 && numOfZeros%2==0){
30 |             return true;
31 |         }
32 |         else 
33 |             return false;
34 |     }
35 | };


--------------------------------------------------------------------------------
/Leet Code/Power of Two.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Power of Two */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 17/10/2020 */
 5 | 
 6 | // Given an integer n, write a function to determine if it is a power of two.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: n = 1
13 | // Output: true
14 | // Explanation: 2^0 = 1
15 | // Example 2:
16 | 
17 | // Input: n = 16
18 | // Output: true
19 | // Explanation: 2^4 = 16
20 | // Example 3:
21 | 
22 | // Input: n = 3
23 | // Output: false
24 | // Example 4:
25 | 
26 | // Input: n = 4
27 | // Output: true
28 | // Example 5:
29 | 
30 | // Input: n = 5
31 | // Output: false
32 | 
33 | 
34 | class Solution {
35 | public:
36 |     bool isPowerOfTwo(int n) {
37 |         
38 |         if(n<0)
39 |             return false;
40 |         int x = __builtin_popcount(n);
41 |         if(x==1)
42 |             return true;
43 |         else
44 |             return false;
45 |     }
46 | };


--------------------------------------------------------------------------------
/Leet Code/Product of Array Except Self.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Product of Array Except Self */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 24/09/2020 */
 5 | 
 6 | // Given an array nums of n integers where n > 1,  return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].
 7 | 
 8 | // Example:
 9 | 
10 | // Input:  [1,2,3,4]
11 | // Output: [24,12,8,6]
12 | // Constraint: It's guaranteed that the product of the elements of any prefix or suffix of the array (including the whole array) fits in a 32 bit integer.
13 | 
14 | // Note: Please solve it without division and in O(n).
15 | 
16 | // Follow up:
17 | // Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of space complexity analysis.)
18 | 
19 | class Solution {
20 | public:
21 |     vector<int> productExceptSelf(vector<int>& nums) {
22 |         if(nums.size()==0 || nums.size()==1)
23 |             return nums;
24 |         
25 |         int left=1,right=1;
26 |         vector<int> res(nums.size(),1);
27 |         for(int i=0;i<nums.size();i++){
28 |             res[i]*=left;
29 |             left*=nums[i];
30 |             res[nums.size()-i-1]*=right;
31 |             right*=nums[nums.size()-i-1];
32 |         }
33 |         return res;
34 |         
35 |     }
36 | };


--------------------------------------------------------------------------------
/Leet Code/Ransom Note.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Ransom Note */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/09/2021 */
 5 | 
 6 | // Given two stings ransomNote and magazine, return true if ransomNote can be constructed from magazine and false otherwise.
 7 | 
 8 | // Each letter in magazine can only be used once in ransomNote.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: ransomNote = "a", magazine = "b"
15 | // Output: false
16 | // Example 2:
17 | 
18 | // Input: ransomNote = "aa", magazine = "ab"
19 | // Output: false
20 | // Example 3:
21 | 
22 | // Input: ransomNote = "aa", magazine = "aab"
23 | // Output: true
24 | 
25 | class Solution {
26 | public:
27 |     bool canConstruct(string ransomNote, string magazine) {
28 |         unordered_map<char, int> m;
29 |         for(int i=0;i<magazine.length();i++){
30 |             m[magazine[i]]++;
31 |         }
32 |         
33 |         for(int i=0;i<ransomNote.length();i++){
34 |             if(m.find(ransomNote[i]) == m.end()){
35 |                 return false;
36 |             }
37 |             else if(m[ransomNote[i]] == 0){
38 |                 return false;
39 |             }
40 |             m[ransomNote[i]]--;
41 |         }
42 |         
43 |         return true;
44 |     }
45 | };


--------------------------------------------------------------------------------
/Leet Code/Remove All Adjacent Duplicates In String.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Remove All Adjacent Duplicates In String */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 12/05/2023 */
 5 | 
 6 | // You are given a string s consisting of lowercase English letters. A duplicate removal consists of choosing two adjacent and equal letters and removing them.
 7 | 
 8 | // We repeatedly make duplicate removals on s until we no longer can.
 9 | 
10 | // Return the final string after all such duplicate removals have been made. It can be proven that the answer is unique.
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: s = "abbaca"
17 | // Output: "ca"
18 | // Explanation: 
19 | // For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move.  The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
20 | // Example 2:
21 | 
22 | // Input: s = "azxxzy"
23 | // Output: "ay"
24 | 
25 | class Solution {
26 | public:
27 |     string removeDuplicates(string s) {
28 |         string res="";
29 |         for(int i=0;i<s.length();i++){
30 |             if(res.length()>0 && res[res.length()-1]==s[i])
31 |                 res.pop_back();
32 |             else
33 |                 res.push_back(s[i]);
34 |         }
35 |         return res;
36 |     }
37 | };
38 | 


--------------------------------------------------------------------------------
/Leet Code/Remove Duplicates From A Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Remove Duplicates From A Sorted Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 22/8/2020 */
 5 | 
 6 | // Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.
 7 | 
 8 | // Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
 9 | 
10 | // Example 1:
11 | 
12 | // Given nums = [1,1,2],
13 | 
14 | // Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
15 | 
16 | // It doesn't matter what you leave beyond the returned length.
17 | // Example 2:
18 | 
19 | // Given nums = [0,0,1,1,1,2,2,3,3,4],
20 | 
21 | // Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.
22 | 
23 | // It doesn't matter what values are set beyond the returned length.
24 | 
25 | class Solution {
26 | public:
27 |     int removeDuplicates(vector<int>& nums) {
28 |         if(nums.size()==0)
29 |             return 0;
30 |         int i=0,j;
31 |         for(j=1;j<nums.size();j++)
32 |         {
33 |             if(nums[j] != nums[i])
34 |             {
35 |                 i++;
36 |                 nums[i] = nums[j];
37 |             }
38 |         }
39 |         // nums.pop_back();
40 |         return i+1;
41 |     }
42 | };


--------------------------------------------------------------------------------
/Leet Code/Remove Duplicates From Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Remove Duplicates From Sorted Array */
 3 | 
 4 | // Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.
 5 | 
 6 | // Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Given nums = [1,1,2],
11 | 
12 | // Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
13 | 
14 | // It doesn't matter what you leave beyond the returned length.
15 | // Example 2:
16 | 
17 | // Given nums = [0,0,1,1,1,2,2,3,3,4],
18 | 
19 | // Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.
20 | 
21 | // It doesn't matter what values are set beyond the returned length.
22 | 
23 | class Solution {
24 | public:
25 |     int removeDuplicates(vector<int>& nums) {
26 |         int n = nums.size();
27 |         if(n==0)
28 |             return 0;
29 |         int i=0;
30 |         int j=1;
31 |         while(j<n){
32 |             if(nums[i]!=nums[j]){
33 |                 nums[++i]=nums[j++];
34 |             }
35 |             else{
36 |                 j++;
37 |             }
38 |         }
39 |         return i+1;
40 |     }
41 | };


--------------------------------------------------------------------------------
/Leet Code/Remove Duplicates from Sorted List.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Remove Duplicates from Sorted List */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 04/08/2021 */
 5 | 
 6 | 
 7 | // Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.
 8 | 
 9 | // Input: head = [1,1,2]
10 | // Output: [1,2]
11 | 
12 | 
13 | /**
14 |  * Definition for singly-linked list.
15 |  * struct ListNode {
16 |  *     int val;
17 |  *     ListNode *next;
18 |  *     ListNode() : val(0), next(nullptr) {}
19 |  *     ListNode(int x) : val(x), next(nullptr) {}
20 |  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
21 |  * };
22 |  */
23 | class Solution {
24 | public:
25 |     ListNode* deleteDuplicates(ListNode* head) {
26 |         if(head == NULL)
27 |             return head;
28 |         
29 |         int current = head->val;
30 |         ListNode* node = new ListNode(head->val);
31 |         ListNode* temp = node;
32 |         ListNode* output = temp;
33 |         while(head != NULL){
34 |             
35 |             if(head->val != current){
36 |                 node = new ListNode(head->val);
37 |                 temp->next = node;
38 |                 temp = temp->next;
39 |                 current = head->val;
40 |             }
41 |             
42 |             head = head->next;
43 |         }
44 |         
45 |         return output;
46 |     }
47 | };


--------------------------------------------------------------------------------
/Leet Code/Remove Element.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Remove Element */
 3 | 
 4 | // Given an array nums and a value val, remove all instances of that value in-place and return the new length.
 5 | 
 6 | // Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
 7 | 
 8 | // The order of elements can be changed. It doesn't matter what you leave beyond the new length.
 9 | 
10 | // Example 1:
11 | 
12 | // Given nums = [3,2,2,3], val = 3,
13 | 
14 | // Your function should return length = 2, with the first two elements of nums being 2.
15 | 
16 | // It doesn't matter what you leave beyond the returned length.
17 | // Example 2:
18 | 
19 | // Given nums = [0,1,2,2,3,0,4,2], val = 2,
20 | 
21 | // Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4.
22 | 
23 | // Note that the order of those five elements can be arbitrary.
24 | 
25 | // It doesn't matter what values are set beyond the returned length.
26 | 
27 | class Solution {
28 | public:
29 |     int removeElement(vector<int>& nums, int val) {
30 |         int n = nums.size();
31 |         int i=0,j=0;
32 |         while(j<n){
33 |             if(nums[j]!=val)
34 |                 nums[i++]=nums[j++];
35 |             else
36 |                 j++;
37 |         }
38 |         return i;
39 |     }
40 | };


--------------------------------------------------------------------------------
/Leet Code/Remove Linked LIst Elements.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Remove Linked List Elements */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 20/7/2020 */
 5 | 
 6 | Remove all elements from a linked list of integers that have value val.
 7 | 
 8 | Example:
 9 | 
10 | Input:  1->2->6->3->4->5->6, val = 6
11 | Output: 1->2->3->4->5
12 | 
13 | /**
14 |  * Definition for singly-linked list.
15 |  * struct ListNode {
16 |  *     int val;
17 |  *     ListNode *next;
18 |  *     ListNode() : val(0), next(nullptr) {}
19 |  *     ListNode(int x) : val(x), next(nullptr) {}
20 |  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
21 |  * };
22 |  */
23 | class Solution {
24 | public:
25 |     ListNode* removeElements(ListNode* head, int val) {
26 |         if(head==NULL or head->next==NULL){
27 |             if(head==NULL)
28 |                 return head;
29 |             else if(head->next==NULL and head->val==val){
30 |                 head= head->next;
31 |                 return head;
32 |             }
33 |             return head;
34 |             
35 |         }
36 |         if(head->val==val)
37 |             head = removeElements(head->next,val);
38 |         else
39 |             head->next = removeElements(head->next,val);
40 |         return head;
41 |     }
42 | };


--------------------------------------------------------------------------------
/Leet Code/Removing Stars From a String.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Removing Stars From a String */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 08/05/2023 */
 5 | 
 6 | // You are given a string s, which contains stars *.
 7 | 
 8 | // In one operation, you can:
 9 | 
10 | // Choose a star in s.
11 | // Remove the closest non-star character to its left, as well as remove the star itself.
12 | // Return the string after all stars have been removed.
13 | 
14 | // Note:
15 | 
16 | // The input will be generated such that the operation is always possible.
17 | // It can be shown that the resulting string will always be unique.
18 |  
19 | 
20 | // Example 1:
21 | 
22 | // Input: s = "leet**cod*e"
23 | // Output: "lecoe"
24 | // Explanation: Performing the removals from left to right:
25 | // - The closest character to the 1st star is 't' in "leet**cod*e". s becomes "lee*cod*e".
26 | // - The closest character to the 2nd star is 'e' in "lee*cod*e". s becomes "lecod*e".
27 | // - The closest character to the 3rd star is 'd' in "lecod*e". s becomes "lecoe".
28 | // There are no more stars, so we return "lecoe".
29 | // Example 2:
30 | 
31 | // Input: s = "erase*****"
32 | // Output: ""
33 | // Explanation: The entire string is removed, so we return an empty string.
34 | 
35 | class Solution {
36 | public:
37 |     string removeStars(string s) {
38 |         int j=0;
39 |         for(int i=0;i<s.length();i++){
40 |             if(s[i]!='*') s[j++]=s[i];
41 |             else j--;
42 |         }
43 |         return s.substr(0,j);
44 |     }
45 | };
46 | 


--------------------------------------------------------------------------------
/Leet Code/Reverse Bits.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Reverse Bits */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 12/07/2020 */
 5 | 
 6 | // Reverse bits of a given 32 bits unsigned integer.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: 00000010100101000001111010011100
13 | // Output: 00111001011110000010100101000000
14 | // Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.
15 | // Example 2:
16 | 
17 | // Input: 11111111111111111111111111111101
18 | // Output: 10111111111111111111111111111111
19 | // Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.
20 | //  
21 | 
22 | #define R2(n)     n,     n + 2*64,     n + 1*64,     n + 3*64 
23 | #define R4(n) R2(n), R2(n + 2*16), R2(n + 1*16), R2(n + 3*16) 
24 | #define R6(n) R4(n), R4(n + 2*4 ), R4(n + 1*4 ), R4(n + 3*4 ) 
25 | class Solution {
26 | public:
27 |     uint32_t reverseBits(uint32_t n) {
28 |         uint32_t rev = 0;
29 |         uint32_t lookuptable[256]={R6(0),R6(2),R6(1),R6(3)};
30 |         
31 |         rev = lookuptable[ n & 0xff ]<<24 |    
32 |               lookuptable[ (n >> 8) & 0xff ]<<16 |  
33 |               lookuptable[ (n >> 16 )& 0xff ]<< 8 | 
34 |               lookuptable[ (n >>24 ) & 0xff ] ; 
35 |         return rev;
36 |     
37 |     }
38 | };


--------------------------------------------------------------------------------
/Leet Code/Reverse Integer.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Reverse Number */
 3 | //Given a 32-bit signed integer, reverse digits of an integer.
 4 | //
 5 | //Example 1:
 6 | //
 7 | //Input: 123
 8 | //Output: 321
 9 | //Example 2:
10 | //
11 | //Input: -123
12 | //Output: -321
13 | //Example 3:
14 | //
15 | //Input: 120
16 | //Output: 21
17 | //Note:
18 | //Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [-231,  231 - 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
19 | 
20 | 
21 | 
22 | class Solution {
23 | public:
24 |     int reverse(int x) {
25 |         int sum=0;
26 |        
27 |         while(x!=0) {
28 |             int pop = (x%10);
29 |              x/=10;
30 |             if(sum >  INT_MAX/10 || (sum == INT_MAX / 10 && pop > 7))
31 |                 return 0;
32 |             if(sum < INT_MIN /10 || (sum == INT_MIN/10 && pop < -8))
33 |                 return 0;
34 |             sum = (sum*10)+pop;
35 |            
36 |         }
37 |          
38 |         cout<<sum;
39 |         return sum;
40 |     }
41 | };
42 | 
43 | 


--------------------------------------------------------------------------------
/Leet Code/Reverse Linked List.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Reverse Linked List */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/09/2020 */
 5 | 
 6 | // Reverse a singly linked list.
 7 | 
 8 | // Example:
 9 | 
10 | // Input: 1->2->3->4->5->NULL
11 | // Output: 5->4->3->2->1->NULL
12 | // Follow up:
13 | 
14 | // A linked list can be reversed either iteratively or recursively. Could you implement both?
15 | 
16 | /**
17 |  * Definition for singly-linked list.
18 |  * struct ListNode {
19 |  *     int val;
20 |  *     ListNode *next;
21 |  *     ListNode() : val(0), next(nullptr) {}
22 |  *     ListNode(int x) : val(x), next(nullptr) {}
23 |  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
24 |  * };
25 |  */
26 | class Solution {
27 | public:
28 |     ListNode* reverseList(ListNode* head) {
29 |         if(head==NULL)
30 |             return head;
31 |         ListNode* current = head ;
32 |         ListNode* prev = NULL;
33 |         ListNode* nextNode = NULL;
34 |         while(current!=NULL){
35 |             nextNode = current->next;
36 |             current->next = prev;
37 |             prev = current;
38 |             current = nextNode;
39 |         }
40 |         return prev;
41 |     }
42 | };


--------------------------------------------------------------------------------
/Leet Code/Reverse String.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Reverse String */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/09/2020 */
 5 | 
 6 | // Write a function that reverses a string. The input string is given as an array of characters char[].
 7 | 
 8 | // Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
 9 | 
10 | // You may assume all the characters consist of printable ascii characters.
11 | 
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: ["h","e","l","l","o"]
17 | // Output: ["o","l","l","e","h"]
18 | // Example 2:
19 | 
20 | // Input: ["H","a","n","n","a","h"]
21 | // Output: ["h","a","n","n","a","H"]
22 | 
23 | class Solution {
24 | public:
25 |     void reverseString(vector<char>& s) {
26 |         int i,j,n = s.size();
27 |         if(n==0 ||n==1)
28 |             return ;
29 |         for(i=0,j=n-1;i<j;i++,j--){
30 |             char temp = s[i];
31 |             s[i] = s[j];
32 |             s[j] = temp;
33 |         }
34 |     }
35 | };


--------------------------------------------------------------------------------
/Leet Code/Reverse Words In A String.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Reverse Words In A String  */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 15/7/2020 */
 5 | 
 6 | // Given an input string, reverse the string word by word.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: "the sky is blue"
13 | // Output: "blue is sky the"
14 | // Example 2:
15 | 
16 | // Input: "  hello world!  "
17 | // Output: "world! hello"
18 | // Explanation: Your reversed string should not contain leading or trailing spaces.
19 | // Example 3:
20 | 
21 | // Input: "a good   example"
22 | // Output: "example good a"
23 | // Explanation: You need to reduce multiple spaces between two words to a single space in the reversed string.
24 |  
25 | 
26 | // Note:
27 | 
28 | // A word is defined as a sequence of non-space characters.
29 | // Input string may contain leading or trailing spaces. However, your reversed string should not contain leading or trailing spaces.
30 | // You need to reduce multiple spaces between two words to a single space in the reversed string.
31 | 
32 | class Solution {
33 | public:
34 |     string reverseWords(string s) {
35 |         stringstream a(s);
36 |         string word,ans="";
37 |         while(a>>word)
38 |             ans = word+" "+ans;
39 |         return ans.substr(0,ans.length()-1);
40 |     }
41 | };


--------------------------------------------------------------------------------
/Leet Code/Rotate Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Rotate Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/08/2020 */
 5 | 
 6 | // Given an array, rotate the array to the right by k steps, where k is non-negative.
 7 | 
 8 | // Follow up:
 9 | 
10 | // Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
11 | // Could you do it in-place with O(1) extra space?
12 |  
13 | 
14 | // Example 1:
15 | 
16 | // Input: nums = [1,2,3,4,5,6,7], k = 3
17 | // Output: [5,6,7,1,2,3,4]
18 | // Explanation:
19 | // rotate 1 steps to the right: [7,1,2,3,4,5,6]
20 | // rotate 2 steps to the right: [6,7,1,2,3,4,5]
21 | // rotate 3 steps to the right: [5,6,7,1,2,3,4]
22 | // Example 2:
23 | 
24 | // Input: nums = [-1,-100,3,99], k = 2
25 | // Output: [3,99,-1,-100]
26 | // Explanation: 
27 | // rotate 1 steps to the right: [99,-1,-100,3]
28 | // rotate 2 steps to the right: [3,99,-1,-100]
29 |  
30 | 
31 | // Constraints:
32 | 
33 | // 1 <= nums.length <= 2 * 10^4
34 | // It's guaranteed that nums[i] fits in a 32 bit-signed integer.
35 | // k >= 0
36 | 
37 | class Solution {
38 | public:
39 |     void rotate(vector<int>& nums, int k) {
40 |         int n = nums.size();
41 |         while(k-- && n){
42 |             int temp = nums[n-1];
43 |             nums.pop_back();
44 |             nums.insert(nums.begin(),temp);
45 |         }
46 |     }
47 | };


--------------------------------------------------------------------------------
/Leet Code/Search Insert Position.cpp:
--------------------------------------------------------------------------------
 1 | /*Leet Code*/
 2 | /*Title - Search Insert Position*/
 3 | //Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
 4 | //
 5 | //You may assume no duplicates in the array.
 6 | //
 7 | //Example 1:
 8 | //
 9 | //Input: [1,3,5,6], 5
10 | //Output: 2
11 | //Example 2:
12 | //
13 | //Input: [1,3,5,6], 2
14 | //Output: 1
15 | 
16 | 
17 | // class Solution {
18 | // public:
19 | //     int searchInsert(vector<int>& nums, int target) {
20 | //         int pos=0,i=0;
21 | //         while(i<nums.size())
22 | //         {
23 | //             if(target>nums[i])
24 | //                 pos++;
25 | //             else if(target==nums[i])
26 | //                 return pos;
27 | //             i++;
28 | //         }
29 | //         return pos;
30 | //     }
31 | // };
32 | 
33 | // optimized solution 
34 | class Solution {
35 | public:
36 |     int searchInsert(vector<int>& nums, int target) {
37 |         int low = 0, high = nums.size()-1, mid = low;
38 | 
39 |         while(low<=high) {
40 |             mid = low + (high-low)/2;
41 |             if(nums[mid]==target )
42 |                 return mid;
43 |             else if(target < nums[mid]) {
44 |                 high = mid-1;
45 |             }else {
46 |                 low = mid+1;
47 |             }
48 |         }
49 |         return low;
50 |     }
51 | };
52 | 


--------------------------------------------------------------------------------
/Leet Code/Single Number III.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Single Number III */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 23/7/2020 */
 5 | 
 6 | // Given an array of numbers nums, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once.
 7 | 
 8 | // Example:
 9 | 
10 | // Input:  [1,2,1,3,2,5]
11 | // Output: [3,5]
12 | // Note:
13 | 
14 | // The order of the result is not important. So in the above example, [5, 3] is also correct.
15 | // Your algorithm should run in linear runtime complexity. Could you implement it using only constant space complexity?
16 | 
17 | class Solution {
18 | public:
19 |     vector<int> singleNumber(vector<int>& nums) {
20 |         int x=0;
21 |         int n = nums.size();
22 |         for(int i=0;i<n;i++)
23 |             x=x^nums[i];
24 |         int temp=x;
25 |         int pos=0;
26 |         while((temp&1)==0){
27 |             pos++;
28 |             temp=temp>>1;
29 |         }
30 |         int mask = (1<<pos);
31 |         int m=0;
32 |         // cout<<mask;
33 |         for(int i=0;i<n;i++){
34 |             if((mask&nums[i])>0)
35 |                 m^=nums[i];
36 |         }
37 |         // cout<<m;
38 |         vector<int> v;
39 |         // cout<<x;
40 |         v.push_back(m);
41 |         v.push_back(x^m);
42 |         return v;
43 |     }
44 | };


--------------------------------------------------------------------------------
/Leet Code/Single Number.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Single Number */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/7/2020 */
 5 | 
 6 | // Given a non-empty array of integers, every element appears twice except for one. Find that single one.
 7 | 
 8 | // Note:
 9 | 
10 | // Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
11 | 
12 | // Example 1:
13 | 
14 | // Input: [2,2,1]
15 | // Output: 1
16 | // Example 2:
17 | 
18 | // Input: [4,1,2,1,2]
19 | // Output: 4
20 | 
21 | class Solution {
22 | public:
23 |     int singleNumber(vector<int>& nums) {
24 |         int x = 0;
25 |         for(auto i:nums){
26 |             x^=i;
27 |         }
28 |         return x;
29 |     }
30 | };


--------------------------------------------------------------------------------
/Leet Code/Sort Array By Parity.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Sort Array By Parity */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/8/2020 */
 5 | 
 6 | // Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.
 7 | 
 8 | // You may return any answer array that satisfies this condition.
 9 | 
10 |  
11 | 
12 | // Example 1:
13 | 
14 | // Input: [3,1,2,4]
15 | // Output: [2,4,3,1]
16 | // The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
17 |  
18 | 
19 | class Solution {
20 | public:
21 |     vector<int> sortArrayByParity(vector<int>& A) {
22 |         if(A.empty()){
23 |             return vector<int>{};
24 |         }
25 |         vector<int> v;
26 |         for(int i=0;i<A.size();i++){
27 |             if(A[i]%2==0)
28 |             v.push_back(A[i]);
29 |         }
30 |         for(int i=0;i<A.size();i++){
31 |             if(A[i]%2)
32 |             v.push_back(A[i]);
33 |         }
34 |         
35 |             return v;
36 |     }
37 | };
38 | 


--------------------------------------------------------------------------------
/Leet Code/Subarray Product Less Than K.cpp:
--------------------------------------------------------------------------------
 1 | /* Leetcode */
 2 | /* Title - Subarray Product Less Than K */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 01/12/2020 */
 5 | 
 6 | // Your are given an array of positive integers nums.
 7 | 
 8 | // Count and print the number of (contiguous) subarrays where the product of all the elements in the subarray is less than k.
 9 | 
10 | // Example 1:
11 | // Input: nums = [10, 5, 2, 6], k = 100
12 | // Output: 8
13 | // Explanation: The 8 subarrays that have product less than 100 are: [10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6].
14 | // Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
15 | 
16 | class Solution {
17 | public:
18 |     int numSubarrayProductLessThanK(vector<int>& nums, int k) {
19 |         if(nums.empty())
20 |             return 0;
21 |         else if(nums.size()==1){
22 |             if(nums[0]<k)
23 |                 return 1;
24 |             else 
25 |                 return 0;
26 |         }
27 |         
28 |         int count = 0,start=0,i,mult=1;
29 |         for(i=0;i<nums.size();i++){
30 |             mult*=nums[i];
31 |            
32 |             if(mult>=k){
33 |                 while(mult>=k and start<nums.size()) {
34 |                     mult/=nums[start++];
35 |                 }
36 |                 if(start==nums.size())
37 |                     break;
38 |             }
39 |             count+=i-start+1;
40 |         }
41 |         return count;
42 |             
43 |     }
44 | };


--------------------------------------------------------------------------------
/Leet Code/Subarray Sum Equals K.cpp:
--------------------------------------------------------------------------------
 1 | /* Leetcode */
 2 | /* Title - Subarray Sum Equals K */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 25/11/2020 */
 5 | 
 6 | // Given an array of integers nums and an integer k, return the total number of continuous subarrays whose sum equals to k.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: nums = [1,1,1], k = 2
13 | // Output: 2
14 | // Example 2:
15 | 
16 | // Input: nums = [1,2,3], k = 3
17 | // Output: 2
18 | 
19 | class Solution {
20 | public:
21 |     int subarraySum(vector<int>& nums, int k) {
22 |         int count = 0;
23 |         if(nums.empty())
24 |             return count;
25 |         int sum = 0;
26 |         unordered_map<int,int> m;
27 |         m[0] = 1;
28 |         for(int i=0;i<nums.size();i++){
29 |             sum+=nums[i];
30 |             if(m.find(sum-k)!=m.end())
31 |                 count+=m[sum-k];
32 |             m[sum]++;
33 |         }
34 |         return count;
35 |     }
36 | };


--------------------------------------------------------------------------------
/Leet Code/Subsets.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Subsets */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 11/07/2020 */
 5 | 
 6 | // Given a set of distinct integers, nums, return all possible subsets (the power set).
 7 | 
 8 | // Note: The solution set must not contain duplicate subsets.
 9 | 
10 | // Example:
11 | 
12 | // Input: nums = [1,2,3]
13 | // Output:
14 | // [
15 | //   [3],
16 | //   [1],
17 | //   [2],
18 | //   [1,2,3],
19 | //   [1,3],
20 | //   [2,3],
21 | //   [1,2],
22 | //   []
23 | // ]
24 | 
25 | class Solution {
26 | public:
27 |     void fillPowerSet(vector<int>& nums,int i,int n,vector<vector<int>>& ans){
28 |         if(i==n) return;  //n is end of nums array if we reach there return
29 |         int v = nums[i];  // The current element we are looking at
30 |         vector<vector<int>>t = ans;  // temp array to store the arrays for current element
31 |         for(auto x: t){
32 |             x.push_back(v);   // add the current element
33 |             ans.push_back(x);  // insert it to ans array
34 |         }
35 |         fillPowerSet(nums,i+1,n,ans);  // go for the next element (i = i+1)
36 |     }
37 |     
38 |     vector<vector<int>> subsets(vector<int>& nums) {
39 |         int i = 0, n=nums.size();
40 |         if(n==0) return {};  // if empty array
41 |         vector<vector<int>>ans;
42 |         ans.push_back({});
43 |         fillPowerSet(nums,i,n,ans);
44 |         return ans;
45 |     }
46 | };


--------------------------------------------------------------------------------
/Leet Code/Substrings of Size Three with Distinct Characters.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Substrings of Size Three with Distinct Characters */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 11/05/2023 */
 5 | 
 6 | // A string is good if there are no repeated characters.
 7 | 
 8 | // Given a string s, return the number of good substrings of length three in s,
 9 | 
10 | // Note that if there are multiple occurrences of the same substring, every occurrence should be counted.
11 | 
12 | // A substring is a contiguous sequence of characters in a string.
13 | 
14 |  
15 | 
16 | // Example 1:
17 | 
18 | // Input: s = "xyzzaz"
19 | // Output: 1
20 | // Explanation: There are 4 substrings of size 3: "xyz", "yzz", "zza", and "zaz". 
21 | // The only good substring of length 3 is "xyz".
22 | // Example 2:
23 | 
24 | // Input: s = "aababcabc"
25 | // Output: 4
26 | // Explanation: There are 7 substrings of size 3: "aab", "aba", "bab", "abc", "bca", "cab", and "abc".
27 | // The good substrings are "abc", "bca", "cab", and "abc".
28 | 
29 | class Solution {
30 | public:
31 |     int countGoodSubstrings(string s) {
32 |         int count=0;
33 |         for(int i=1;i<s.length()-1;i++){
34 |             if(s[i-1]!=s[i] and s[i+1]!=s[i] and s[i-1]!=s[i+1]) count++;
35 |         }
36 |         return count;
37 |     }
38 | };
39 | 


--------------------------------------------------------------------------------
/Leet Code/Swap Nodes in Pairs.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Swap Nodes in Pairs */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 27/09/2020 */
 5 | 
 6 | // Given a linked list, swap every two adjacent nodes and return its head.
 7 | 
 8 | // You may not modify the values in the list's nodes, only nodes itself may be changed.
 9 | 
10 |  
11 | 
12 | // Example:
13 | 
14 | // Given 1->2->3->4, you should return the list as 2->1->4->3.
15 | 
16 | /**
17 |  * Definition for singly-linked list.
18 |  * struct ListNode {
19 |  *     int val;
20 |  *     ListNode *next;
21 |  *     ListNode() : val(0), next(nullptr) {}
22 |  *     ListNode(int x) : val(x), next(nullptr) {}
23 |  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
24 |  * };
25 |  */
26 | class Solution {
27 | public:
28 |     ListNode* swapPairs(ListNode* head) {
29 |         int k = 2;
30 |         ListNode* current = head;
31 |         ListNode* prev = NULL;
32 |         ListNode* nextNode = NULL;
33 |         
34 |         while(current!=NULL and k>0){
35 |             nextNode = current->next;
36 |             current->next = prev;
37 |             prev = current;
38 |             current = nextNode;
39 |             k--;
40 |         }
41 |         if(current!=NULL)
42 |             head->next = swapPairs(current);
43 |         return prev;
44 |     }
45 | };


--------------------------------------------------------------------------------
/Leet Code/Top K Frequent Elements.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Top K Frequent Elements */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 17/7/2020 */
 5 | 
 6 | // Given a non-empty array of integers, return the k most frequent elements.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: nums = [1,1,1,2,2,3], k = 2
11 | // Output: [1,2]
12 | // Example 2:
13 | 
14 | // Input: nums = [1], k = 1
15 | // Output: [1]
16 | // Note:
17 | 
18 | // You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
19 | // Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
20 | // It's guaranteed that the answer is unique, in other words the set of the top k frequent elements is unique.
21 | // You can return the answer in any order.
22 | 
23 | class Solution {
24 | public:
25 |     vector<int> topKFrequent(vector<int>& nums, int k) {
26 |         map<int,int> m,n;
27 |         for(auto x: nums){
28 |             m[x]++;
29 |         }
30 |         vector<int> v;
31 |         priority_queue<pair<int,int>> j;
32 |         
33 |         for(auto x: m){
34 |             j.push({x.second,x.first});
35 |         }
36 |         while(k--){
37 |             v.push_back(j.top().second);
38 |             j.pop();
39 |         }
40 |         return v;
41 |     }
42 | };


--------------------------------------------------------------------------------
/Leet Code/Trapping Rain Water.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code*/
 2 | /* Title - Trapping Rain Water */
 3 | //Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.
 4 | 
 5 | class Solution {
 6 | public:
 7 |     int trap(vector<int>& height) {
 8 |         if(height.empty())
 9 |             return 0;
10 |         int sum = 0;
11 |         vector<int> left(height.size());
12 |         vector<int> right(height.size());
13 |         left[0] = height[0];
14 |         right[height.size()-1] = height[height.size()-1];
15 |         for(int i=1;i<height.size();i++)
16 |         {
17 |             if(left[i-1]>height[i])
18 |                 left[i] = left[i-1];
19 |             else
20 |                 left[i] = height[i];
21 |         }
22 |         for(int i=height.size()-2;i>=0;i--)
23 |         {
24 |             if(right[i+1]>height[i])
25 |                 right[i] = right[i+1];
26 |             else
27 |                 right[i] = height[i];
28 |         }
29 |         for(int i=0;i<height.size();i++)
30 |             sum += min(left[i],right[i]) - height[i];
31 |         return sum;
32 |     }
33 | };
34 | 


--------------------------------------------------------------------------------
/Leet Code/Two Sum.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code*/
 2 | /* Title - Two Sum */
 3 | //Given an array of integers, return indices of the two numbers such that they add up to a specific target.
 4 | //
 5 | //You may assume that each input would have exactly one solution, and you may not use the same element twice.
 6 | //
 7 | //Example:
 8 | //
 9 | //Given nums = [2, 7, 11, 15], target = 9,
10 | //
11 | //Because nums[0] + nums[1] = 2 + 7 = 9,
12 | //return [0, 1].
13 | 
14 | class Solution {
15 | public:
16 |     vector<int> twoSum(vector<int>& nums, int target) {
17 |         map <int,int> hashmap;
18 |         vector<int> output;
19 |         for( int i=0;i<nums.size();i++ )
20 |         {
21 |             int secondEle = target - nums[i];
22 |             hashmap.insert(pair<int,int>(nums[i],i));
23 | 
24 |             if(hashmap.find(secondEle)!=hashmap.end() && hashmap.find(secondEle)->second!=i)
25 |             {
26 |                 output.push_back(hashmap.find(secondEle)->second);
27 |                 
28 |                 output.push_back(i);
29 |                 return output;
30 |             }
31 |         }
32 |         return output;
33 |     }
34 | };
35 | 


--------------------------------------------------------------------------------
/Leet Code/Ugly Number II.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Ugly Number II */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 4/7/2020 */
 5 | 
 6 | // Write a program to find the n-th ugly number.
 7 | 
 8 | // Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. 
 9 | 
10 | // Example:
11 | 
12 | // Input: n = 10
13 | // Output: 12
14 | // Explanation: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.
15 | // Note:  
16 | 
17 | // 1 is typically treated as an ugly number.
18 | // n does not exceed 1690.
19 | 
20 | 
21 | class Solution {
22 | public:
23 |     int nthUglyNumber(int n) {
24 |         int mul2=2,mul3=3,mul5=5,next=1;
25 |         int i2=0,i3=0,i5=0;
26 |         int a[n];
27 |         a[0]=1;
28 |         for(int i=1;i<n;i++){
29 |             next=min(mul2,min(mul3,mul5));
30 |             a[i]=next;
31 |             // cout<<mul2<<" "<<mul3<<" "<<mul5<<endl;
32 |             if(next==mul2){
33 |                 i2++;
34 |                 mul2 = a[i2]*2;
35 |             }
36 |             if(next==mul3){
37 |                 i3++;
38 |                 mul3=a[i3]*3;
39 |             }
40 |             if(next==mul5){
41 |                 i5++;
42 |                 mul5=a[i5]*5;
43 |                 
44 |             }
45 |                
46 |         }
47 |         return next;        
48 |     }
49 | };


--------------------------------------------------------------------------------
/Leet Code/Valid Anagrams.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Valid Anagram */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 21/09/2020 */
 5 | 
 6 | // Given two strings s and t , write a function to determine if t is an anagram of s.
 7 | 
 8 | // Example 1:
 9 | 
10 | // Input: s = "anagram", t = "nagaram"
11 | // Output: true
12 | // Example 2:
13 | 
14 | // Input: s = "rat", t = "car"
15 | // Output: false
16 | // Note:
17 | // You may assume the string contains only lowercase alphabets.
18 | 
19 | class Solution {
20 | public:
21 |     bool isAnagram(string s, string t) {
22 |         unordered_map<char,int> m1,m2;
23 |         if(s.length()!= t.length())
24 |             return false;
25 |         for(int i=0;i<s.length();i++){
26 |             m1[s[i]]++;
27 |             m2[t[i]]++;
28 |         }
29 |         if(m1==m2)
30 |             return true;
31 |         else 
32 |             return false;
33 |         
34 |     }
35 | };


--------------------------------------------------------------------------------
/Leet Code/Valid Mountain Array.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Valid Mountain Array */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 14/08/2021 */
 5 | 
 6 | // Given an array of integers arr, return true if and only if it is a valid mountain array.
 7 | 
 8 | // Recall that arr is a mountain array if and only if:
 9 | 
10 | // arr.length >= 3
11 | // There exists some i with 0 < i < arr.length - 1 such that:
12 | // arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
13 | // arr[i] > arr[i + 1] > ... > arr[arr.length - 1]
14 | 
15 |  
16 | 
17 | // Example 1:
18 | 
19 | // Input: arr = [2,1]
20 | // Output: false
21 | // Example 2:
22 | 
23 | // Input: arr = [3,5,5]
24 | // Output: false
25 | // Example 3:
26 | 
27 | // Input: arr = [0,3,2,1]
28 | // Output: true
29 | 
30 | class Solution {
31 | public:
32 |     bool validMountainArray(vector<int>& arr) {
33 |         bool increasing = false;
34 |         bool decreasing = false;
35 |         if(arr.size()<3)
36 |             return false;
37 |         int i=0;
38 |         bool flag = false;
39 |         while(i<arr.size()-1 and arr[i]<arr[i+1]){
40 |             flag = true;
41 |             i++;
42 |         }
43 |         
44 |         if(i==arr.size()-1)
45 |             return false;
46 |         
47 |         while(i<arr.size()-1 and arr[i]>arr[i+1] and flag){
48 |             i++;
49 |         }
50 |         
51 |         if(i!=arr.size()-1)
52 |             return false;
53 |         
54 |         return true;
55 |     }
56 | };


--------------------------------------------------------------------------------
/Leet Code/Valid_Palindrome.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Valid Palindrome */
 3 | /* Date - 02/10/2020 */
 4 | 
 5 | // Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
 6 | 
 7 | 
 8 | 
 9 | //Example 1:
10 | 
11 | //Input: "A man, a plan, a canal: Panama"
12 | //Output: true
13 | 
14 | //Example 2:
15 | 
16 | //Input: "race a car"
17 | //Output: false
18 | 
19 | //Note: For the purpose of this problem, we define empty string as valid palindrome.
20 | 
21 | 
22 | class Solution {
23 | public:
24 |     bool isPalindrome(string s) {
25 |         int i=0, j=s.length()-1;
26 |         while (i<j) {
27 |             while (i<j && !isalnum(s[i]))   i++;
28 |             while (i<j && !isalnum(s[j]))   j--;
29 |             if (tolower(s[i])!=tolower(s[j])) return false;
30 |             i++;
31 |             j--;
32 |         }
33 |         return true;
34 |     }
35 | };


--------------------------------------------------------------------------------
/Leet Code/Validate Stack Sequences.cpp:
--------------------------------------------------------------------------------
 1 | /* Leet Code */
 2 | /* Title - Validate Stack Sequences */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 09/05/2023 */
 5 | 
 6 | // Given two integer arrays pushed and popped each with distinct values, return true if this could have been the result of a sequence of push and pop operations on an initially empty stack, or false otherwise.
 7 | 
 8 |  
 9 | 
10 | // Example 1:
11 | 
12 | // Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
13 | // Output: true
14 | // Explanation: We might do the following sequence:
15 | // push(1), push(2), push(3), push(4),
16 | // pop() -> 4,
17 | // push(5),
18 | // pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
19 | // Example 2:
20 | 
21 | // Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
22 | // Output: false
23 | // Explanation: 1 cannot be popped before 2.
24 | 
25 | class Solution {
26 | public:
27 |     bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
28 |         int i=0,j=0;
29 |         stack<int> s;
30 |         for(;i<pushed.size();i++){
31 |             s.push(pushed[i]);       
32 |             while(!s.empty() && s.top()==popped[j]){
33 |                 j++;
34 |                 s.pop();
35 |             }
36 |         }
37 |         while(!s.empty() && j<popped.size()){
38 |             if(s.top()!=popped[j++]) return false;
39 |             s.pop();
40 |         }
41 |         return true;
42 |     }
43 | };
44 | 


--------------------------------------------------------------------------------
/SPOJ/Defense of a Kingdom.cpp:
--------------------------------------------------------------------------------
 1 | /* SPOJ */
 2 | /* Title - Defense Of A Kingdom */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 29/08/2020 */
 5 | 
 6 | 
 7 | // Problem Link - https://www.spoj.com/problems/DEFKIN/
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | using namespace std;
12 | 
13 | int main(){
14 | 	int t;
15 | 	cin>>t;
16 | 	while(t--){
17 | 		int n,w,h;
18 | 		int x[40010],y[40010];
19 | 		cin>>w>>h>>n;
20 | 		if(n==0){
21 | 			cout<<w*h<<endl;
22 | 			continue;
23 | 		}
24 | 		for(int i=0;i<n;i++){
25 | 			cin>>x[i]>>y[i];
26 | 		}
27 | 		sort(x,x+n);
28 | 		sort(y,y+n);
29 | 
30 | 		int dx = x[0]-1;
31 | 		int dy = y[0]-1;
32 | 
33 | 		for(int i=1;i<n;i++){
34 | 			dx = max(dx,x[i]-x[i-1]-1);
35 | 			dy = max(dy,y[i]-y[i-1]-1);
36 | 		}
37 | 
38 | 		dx = max(dx,w-x[n-1]);
39 | 		dy = max(dy,h-y[n-1]);
40 | 
41 | 		cout<<dx*dy<<endl;
42 | 	}
43 | 	return 0;
44 | }


--------------------------------------------------------------------------------
/SPOJ/I Am Busy Man.cpp:
--------------------------------------------------------------------------------
 1 | /* SPOJ / Hacker Blocks */
 2 | /* Title - I Am Very Busy Man */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 26/8/2020 */
 5 | 
 6 | //Problem link - https://www.spoj.com/problems/BUSYMAN/
 7 | 
 8 | #include<bits/stdc++.h>
 9 | using namespace std;
10 | 
11 | bool compare(pair<int,int> a,pair<int,int> b){
12 | 	return a.second<b.second;
13 | }
14 | 
15 | int main(){
16 | 	int t;
17 | 	cin>>t;
18 | 	while(t--){
19 | 		int n,s,e;
20 | 		cin>>n;
21 | 
22 | 		vector<pair<int,int> > v;
23 | 		for(int i=0;i<n;i++){
24 | 			cin>>s>>e;
25 | 			v.push_back(make_pair(s,e));
26 | 		}
27 | 		sort(v.begin(),v.end(),compare);
28 | 		int activity=1;
29 | 		int taken_activity = v[0].second;
30 | 		for(int i=1;i<v.size();i++){
31 | 			if(v[i].first>=taken_activity){
32 | 				activity++;
33 | 				taken_activity = v[i].second;
34 | 			}
35 | 		}
36 | 		cout<<activity<<endl;
37 | 	}
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/SPOJ/TEST.cpp:
--------------------------------------------------------------------------------
 1 | /* SPOJ */
 2 | /* Title - TEST - Life, the Universe, and Everything */
 3 | /* Created By - Akash Modak */
 4 | /* Date - 04/09/2020 */
 5 | 
 6 | 
 7 | // Your program is to use the brute-force approach in order to find the Answer to Life, the Universe, and Everything. More precisely... rewrite small numbers from input to output. Stop processing input after reading in the number 42. All numbers at input are integers of one or two digits.
 8 | 
 9 | 
10 | // Example
11 | // Input:
12 | // 1
13 | // 2
14 | // 88
15 | // 42
16 | // 99
17 | 
18 | // Output:
19 | // 1
20 | // 2
21 | // 88
22 | 
23 | #include <iostream>
24 | using namespace std;
25 | 
26 | int main() {
27 | 	// your code goes here
28 | 	int n;
29 | 	cin>>n;
30 | 	while(n!=42){
31 | 		cout<<n<<"\n";
32 | 		cin>>n;
33 | 	}
34 | 	return 0;
35 | }


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