├── 0 - 1 Knapsack Problem ├── Absolute difference divisible by K ├── Add 1 to a Linked List Number ├── Add Minimum Characters ├── Add two numbers represented by linked lists ├── Adding Ones ├── Additive Sequence ├── Aggressive Cows ├── Akku and Binary Numbers ├── All Unique Permutations of An Array ├── Allocate Minimum Pages ├── Alternate positive and negative numbers ├── Alternative Sorting ├── Anagram ├── Ancestors in Binary Tree ├── Another Coin Change Problem ├── Anti Diagonal Traversal of Matrix ├── Apple Sequences ├── Armstrong Numbers ├── Arrange Consonants and Vowels ├── Arranging the array ├── Array Operations ├── Array Pair Sum Divisibility Problem ├── Asteroid Collision ├── Avoid Explosion ├── BST Downward Traversal ├── BST Maximum Difference ├── Balloon Everywhere ├── Best Node ├── Bheem Wants Ladoos ├── Binary Modulo ├── Binary Tree to DLL ├── Binary matrix having maximum number of 1s ├── Binary representation of next number ├── Bit Magic ├── Bottom View of Binary Tree ├── Brackets in Matrix Chain Multiplication ├── Burst Balloons ├── Bus Conductor ├── Buy Maximum Stocks if i stocks can be bought on i-th day ├── Cake Distribution Problem ├── CamelCase Pattern Matching ├── Candy ├── Carpet into Box ├── Case-specific Sorting of Strings ├── Check if a String is Repetition of its Substring of K-Length ├── Check if a number is divisible by 8 ├── Check if frequencies can be equal ├── Circle of strings ├── Clone a linked list with next and random pointer ├── Clone an Undirected Graph ├── Closest Neighbour in BST ├── Closest Three Sum ├── Combination Sum II ├── Compare two fractions ├── Connect Nodes at Same Level ├── Construct Binary Tree from Parent Array ├── Construct a Full Binary Tree ├── Construct list using given q XOR queries ├── Container With Most Water ├── Convert an array to reduced form ├── Convert array into Zig-Zag fashion ├── Count Cyclic Paths ├── Count Even Length ├── Count Linked List Nodes ├── Count Lucky Permutations ├── Count More than Z Occurences ├── Count Smaller elements ├── Count Special Numbers ├── Count Subarrays with given XOR ├── Count Total Setbits ├── Count all Possible Path ├── Count digit groupings of a number ├── Count distinct elements in every window ├── Count number of free cell ├── Count numbers containing 4 ├── Count pairs Sum in matrices ├── Count pairs with given sum ├── Count the Substring ├── Count the Substrings ├── Count the elements ├── Count the number of possible triangles ├── Count ways to N'th Stair ├── Course Schedule ├── Cutting Binary String ├── Cutting Rectangles ├── DFS of Graph ├── Decimal Equivalent of Binary Linked List ├── Delete Alternate Nodes ├── Delete Middle of Linked List ├── Delete middle element of a stack ├── Delete node in Doubly Linked List ├── Delete without head pointer ├── Deletion and Reverse in Circular Linked List ├── Determinant of a Matrix ├── Distinct Coloring ├── Distinct Difference ├── Distinct occurrences ├── Distribute Candies in a Binary Tree ├── Divide in Incremental Groups ├── Divisibility tree ├── Divisor Game ├── Does array represent Heap ├── Dominant Pairs ├── Duplicate Subtrees ├── Easy Task ├── Edit Distance ├── Equal Left and Right Subarray Sum ├── Equilibrium Point ├── Exit Point in a Matrix ├── Express as sum of power of natural numbers ├── Expression Add Operators ├── Extract the Number from the String ├── Facing the Sun ├── Fill the Matrix ├── Find All Triplets with Zero Sum ├── Find Kth permutation ├── Find Maximum Equal sum of Three Stacks ├── Find Number ├── Find Total Time Taken ├── Find all Critical Connections in the Graph ├── Find anagrams in linked list ├── Find duplicate rows in a binary matrix ├── Find k-th smallest element in given n ranges ├── Find kth element of spiral matrix ├── Find length of Loop ├── Find minimum number of leptops ├── Find number of closed islands ├── Find shortest safe route in a matrix ├── Find the Closest Element in BST ├── Find the Highest number ├── Find the N-th character ├── Find the Sum of Last N nodes of the Linked List ├── Find the closest number ├── Find the first node of loop in linked list ├── Find the longest string ├── Find the maximum GCD of the siblings of a Binary Tree ├── Find triplets with zero sum ├── First element to occur k times ├── First non-repeating character in a stream ├── Fixing Two swapped nodes of a BST ├── Flatten BST to sorted list ├── Flattening a Linked List ├── Fractional Knapsack ├── Frequency Game ├── Frogs and Jumps ├── GCD Array ├── Game of Subsets ├── Game of XOR ├── Game with String ├── Geek And The String ├── Geek hates too many 1s ├── Geek's Village and Wells ├── Geeks Island ├── Generalised Fibonacci numbers ├── Given a linked list of 0s, 1s and 2s, sort it ├── Good Stones ├── Good Subtrees ├── Gray to Binary Equivalent ├── Grinding Geek ├── Hackwithinfy + Bridge Program ├── Hands of Straights ├── Identical Linked Lists ├── Implement Atoi ├── Implement two stacks in an array ├── Indexes of Subarray Sum ├── Insert Interval ├── Insert an Element at the Bottom of a Stack ├── Insert and Search in a Trie ├── Insertion Sort for Singly Linked List ├── Intersection Point in Y Shaped Linked Lists ├── Intersection of Two arrays with Duplicate Elements ├── Is it Fibonacci ├── Is it a tree ├── Job Sequencing Problem ├── Juggler Sequence ├── K Sized Subarray Maximum ├── K closest elements ├── K-Palindrome ├── Kadane's Algorithm ├── Kth Ancestor in a Tree ├── Kth Smallest ├── Kth common ancestor in BST ├── LCS of three strings ├── Largest BST ├── Largest Number formed from an Array ├── Largest Pair Sum ├── Largest Subtree Sum in a Tree ├── Largest Sum Cycle ├── Largest Sum Subarray of Size at Least K ├── Largest rectangular sub-matrix whose sum is 0 ├── Largest subarray of 0's and 1's ├── Largest subsquare surrounded by X ├── Last cell in a Matrix ├── Last modified ball ├── Least Prime Factor ├── Left View of Binary Tree ├── Lemonade Change ├── Length of the longest subarray with positive product ├── Level order traversal ├── Level order traversal in spiral form ├── Linked List Matrix ├── Linked List that is Sorted Alternatingly ├── Longest Common Prefix of Strings ├── Longest Consecutive Subsequence ├── Longest Palindrome in a String ├── Longest Prefix Suffix ├── Longest Repeating Subsequence ├── Longest Subarray with Sum Divisible by K ├── Longest Subarray with Sum K ├── Longest alternating subsequence ├── Longest subsequence-1 ├── Longest valid Parentheses ├── Lowest Common Ancestor in a BST ├── Majority Element ll ├── Make Palindrom ├── Make array elements unique ├── Make the array beautiful ├── Matchsticks game ├── Max Circular Subarray Sum ├── Max Coins ├── Max Level Sum in Binary Tree ├── Max Sum without Adjacents ├── Max min Height ├── Max sum path in two arrays ├── Maximize The Cut Segments ├── Maximize dot product ├── Maximum Bipartite Matching ├── Maximum Diamonds ├── Maximum Difference ├── Maximum Identical Bowls ├── Maximum Index ├── Maximum Intersecting Lines ├── Maximum Length ├── Maximum Meetings in One Room ├── Maximum Number of Toys ├── Maximum Number of coins ├── Maximum Possible Value ├── Maximum Product Subarray ├── Maximum Profit By Choosing A Subset Of Intervals ├── Maximum Tip Calculator ├── Maximum Weight Node ├── Maximum product subset of an array ├── Maximum subset sum ├── Maximum sum of hour glass ├── Maximum value at each level of tree ├── Median of BST ├── Median of the Subarrays ├── Median of two sorted arrays ├── Meeting Rooms ├── Merge 2 sorted linked list in reverse order ├── Merge Without Extra Space ├── Merge two BST 's ├── Merge two sorted linked lists ├── Middle of a Linked List ├── Min Chars to Add for Palindrome ├── Min Time ├── Min distance between two given nodes of a Binary Tree ├── Min operations ├── Minimal Cost ├── Minimize Max Distance to Gas Station ├── Minimize number of Students to be Removed ├── Minimize the Difference ├── Minimize the Heights II ├── Minimize the sum ├── Minimum Absolute Difference In BST ├── Minimum BST Sum Subtree ├── Minimum Cost Path ├── Minimum Cost To Make Two Strings Identical ├── Minimum Cost of Ropes ├── Minimum Days ├── Minimum Integer ├── Minimum Jumps ├── Minimum Number ├── Minimum Points To Reach Destination ├── Minimum X (xor) A ├── Minimum cost to fill given weight in a bag ├── Minimum number of deletions and insertions ├── Minimum repeat to make substring ├── Minimum steps Required ├── Minimum steps to destination ├── Minimum sum ├── Mirror Tree ├── Missing And Repeating ├── Missing number in matrix ├── Mobile numeric keypad ├── Modified Game of Nim ├── Modify Linked List-1 ├── Modify the Array ├── Modular Exponentiation for large numbers ├── Move All Zeroes to End ├── Multiply two linked lists ├── N meetings in one room ├── N-Queen Problem ├── Nearest multiple of 10 ├── Nearest smaller tower ├── Nearly Sorted ├── New Year Resolution ├── Next Greater Element ├── Next Permutation ├── Node at Distance ├── Non Repeating Character ├── Non Repeating Numbers ├── Non-overlapping Intervals ├── Not a subset sum ├── Nth node from end of linked list ├── Number of 1 Bits ├── Number of Good Components ├── Number of Subarrays of 0's ├── Number of occurrence ├── Number of pairs ├── Nuts and Bolts Problem ├── Odd Even Problem ├── Optimal Array ├── Optimal Strategy For A Game ├── Padovan Sequence ├── Pair with given sum in a sorted array ├── Pairs violating the BST property ├── Pairs with difference k ├── Palindrome Linked List ├── Palindrome with minimum sum ├── Panagram Checking ├── Parenthesis Checker ├── Partition the Array ├── Partitions with Given Difference ├── Party of Couples ├── Path With Minimum Effort ├── Paths from root with a specified sum ├── Paths to reach origin ├── Peak element ├── Permutations of a given string ├── Play With OR ├── Populate Inorder Successor for all nodes ├── Power Of Numbers ├── Power Set ├── Powerfull Integer ├── Predecessor and Successor ├── Prefix Suffix String ├── Prefix match with other strings ├── Prime Pair with Target Sum ├── Print Anagrams Together ├── Print Bracket Number ├── Print N-bit binary numbers having more 1s than 0s ├── Print all nodes that don't have sibling ├── Print matrix in diagonal pattern ├── Product array puzzle ├── Queue Operations ├── Queue Reversal ├── Quick Sort on Linked List ├── Rat in a Maze Problem - I ├── Recamans sequence ├── Recursive Sequence ├── Remainder on dividing by 11 ├── Remaining String ├── Remove Duplicates ├── Remove Half Nodes ├── Remove all duplicates from a given string ├── Remove all occurences of duplicates in a linked list ├── Remove and Reverse ├── Remove duplicates in array ├── Remove every kth node ├── Remove the balls ├── Reverse Bits ├── Reverse Coding ├── Reverse First K Elements of Queue ├── Reverse Level Order Traversal ├── Reverse Words ├── Reverse a Linked List in groups of given size ├── Reverse a linked list ├── Reverse both parts ├── Reversing the Equation ├── Right View of Binary Tree ├── Rightmost different bit ├── Rod Cutting ├── Rohan's Love for Matrix ├── Roof Top ├── Root to Leaf Paths ├── Root to leaf paths sum ├── Rotate Array ├── Rotate and delete ├── Rotate by 90 degree ├── Row with max 1s ├── Row with minimum number of 1's ├── Santa Banta ├── Scrambled String ├── Search in Rotated Sorted Array ├── Search in a Row-Column sorted matrix ├── Search in a row-wise sorted matrix ├── Search in a sorted Matrix ├── Seating Arrangement ├── Second Largest ├── Second smallest number ├── Segregate 0s and 1s ├── Select Nodes ├── Sequence of Sequence ├── Shortest Path Using Atmost One Curved Edge ├── Shortest Prime Path ├── Shortest Source to Destination Path ├── Shortest XY distance in Grid ├── Shortest path in Directed Acyclic Graph ├── Shy Geek ├── Single Number ├── Single valued subtree ├── Smaller Sum ├── Smallest Positive missing number ├── Smallest number ├── Smallest window Containing 0, 1 and 2 ├── Smallest window in a string containing all the characters of another string ├── Sort 0s, 1s and 2s ├── Sorted and Rotated Minimum ├── Sorted insert for circular linked list ├── Sorted subsequence of size 3 ├── Sorting Elements of an Array by Frequency ├── Special Digits ├── Special Palindrome Substrings ├── Spirally traversing a matrix ├── Split Array Largest Sum ├── Split Linked List Alternatingly ├── Split an array into two equal Sum subarrays ├── Split array in three equal sum subarrays ├── Square root of a number ├── Stock Buy and Sell – Max one Transaction Allowed ├── Stock Buy and Sell – Multiple Transaction Allowed ├── Strictly Increasing Array ├── String Mirror ├── String Subsequence ├── String rp and pr ├── String's Count ├── Strings Rotations of Each Other ├── Subarray range with given sum ├── Subarrays with sum K ├── Subtraction in Linked List ├── Subtree In N-ary Tree ├── Sum Pair closest to target ├── Sum of Products ├── Sum of all substrings of a number ├── Sum of bit differences ├── Sum of nodes on the longest path from root to leaf node ├── Swap the array elements ├── Swap two nibbles in a byte ├── Taxi Booking ├── The Celebrity Problem ├── Three way partitioning ├── Ticket Counter ├── Top k numbers in a stream ├── Topological Sort ├── Total Cuts ├── Total Decoding Messages ├── Total count ├── Trace Path ├── Trail of ones ├── Transform to Sum Tree ├── Transpose of Matrix ├── Tree Transformation ├── Triplet Family ├── Two Sum - Pair with Given Sum ├── Two Swaps ├── Type it! ├── Unequal Arrays ├── Union of Arrays with Duplicates ├── Union of Two Sorted Arrays with Distinct Elements ├── Unique Number of Occurrences ├── Unique Paths in a Grid ├── Unique rows in boolean matrix ├── Update Queries ├── Valid Compressed String ├── Validate an IP Address ├── Vertex Cover ├── Vertical Sum ├── Vertical Width of a Binary Tree ├── Walls Coloring II ├── Water the Plants ├── Wifi Range ├── Wildcard Pattern Matching ├── Wildcard String Matching ├── Wine Buying and Selling ├── Winner of An Election ├── Word Break ├── Word Search ├── XOR Linked List ├── Xoring and Clearing ├── Yet another query problem ├── You and your books ├── Zero Sum Subarrays ├── k largest elements ├── linked list of strings forms a palindrome └── nCr /Absolute difference divisible by K: -------------------------------------------------------------------------------- 1 | Brute Force:- 2 | 3 | long long countPairs(int n, int arr[], int k) { 4 | // code here 5 | long long ans=0; 6 | for(int i=0;i mm; 21 | for(int i=0;i alternateSort(vector& arr) { 4 | // Your code goes here 5 | int n = arr.size(); 6 | vector ans(n); 7 | sort(arr.begin(),arr.end()); 8 | int i=0,j=n-1; 9 | for(int k=0;k alternateSort(int[] arr) { 20 | // Your code goes here 21 | int n = arr.length; 22 | ArrayList ans = new ArrayList<>(); 23 | Arrays.sort(arr); 24 | int i=0,j=n-1; 25 | for(int k=0;k freq(26,0); 6 | for(auto x:s1)freq[x-'a']++; 7 | for(auto x:s2)freq[x-'a']--; 8 | for(int x:freq)if(x!=0)return false; 9 | return true; 10 | } 11 | 12 | 13 | // JAVA CODE 14 | 15 | public static boolean areAnagrams(String s1, String s2) { 16 | 17 | // Your code here 18 | int freq[]=new int[26]; 19 | Arrays.fill(freq,0); 20 | for(int i=0;i &coins) { 22 | // code here 23 | vector> dp(K+1,vector(target+1,false)); 24 | dp[0][0]=true; 25 | for(int i=0;im){ 7 | if(arr[j]=='O')orange--; 8 | j++; 9 | } 10 | ans=max(ans,i-j+1); 11 | } 12 | return ans; 13 | } 14 | -------------------------------------------------------------------------------- /Armstrong Numbers: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | string armstrongNumber(int n){ 4 | // code here 5 | int ans=0,temp=n; 6 | while(temp){ 7 | int digit=temp%10; 8 | ans+=digit*digit*digit; 9 | temp/=10; 10 | } 11 | return ans==n?"Yes":"No"; 12 | } 13 | 14 | // JAVA CODE 15 | 16 | static String armstrongNumber(int n){ 17 | // code here 18 | int num=0,temp=n; 19 | while(temp!=0){ 20 | int digit=temp%10; 21 | num+=digit*digit*digit; 22 | temp/=10; 23 | } 24 | return num==n?"Yes":"No"; 25 | } 26 | 27 | // Time Complexity:- O(1) 28 | // Space Complexity:- O(1) 29 | -------------------------------------------------------------------------------- /Array Operations: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static int arrayOperations(int n, int[] arr) { 4 | // code here 5 | int ans=0,len=0; 6 | for(int i=0;i &arr) { 22 | // code here 23 | int ans=0,len=0; 24 | for(int i=0;i nums, int k) { 4 | // Code here. 5 | if(nums.size()%2)return false; 6 | unordered_map mm; 7 | for(auto x:nums){ 8 | mm[x%k]++; 9 | } 10 | for(auto x:mm){ 11 | if(x.first==0 and x.second%2)return false; 12 | if(x.first!=0){ 13 | if(x.second!=mm[k-x.first])return false; 14 | } 15 | } 16 | return true 17 | } 18 | 19 | 20 | // JAVA CODE 21 | 22 | public boolean canPair(int[] nums, int k) { 23 | // Code here 24 | if(nums.length%2==1)return false; 25 | HashMap mm = new HashMap<>(); 26 | for(int i=0;i x:mm.entrySet()){ 31 | if(x.getKey()==0 && x.getValue()%2==1)return false; 32 | if(x.getKey()!=0){ 33 | if(x.getValue()!=mm.get(k-x.getKey()))return false; 34 | } 35 | } 36 | return true; 37 | } 38 | -------------------------------------------------------------------------------- /Asteroid Collision: -------------------------------------------------------------------------------- 1 | vector asteroidCollision(int N, vector &asteroids) { 2 | // code here 3 | stack st; 4 | for(int i=0;i0){ 6 | st.push(asteroids[i]); 7 | } 8 | else{ 9 | bool a=true; 10 | while(st.size() and st.top()<=abs(asteroids[i]) and st.top()>0){ 11 | if(st.top()==abs(asteroids[i])){ 12 | st.pop(); 13 | a=false; 14 | break; 15 | } 16 | st.pop(); 17 | } 18 | if((st.empty() or st.top()<0) and a)st.push(asteroids[i]); 19 | } 20 | } 21 | vector ans; 22 | while(st.size()){ 23 | int temp = st.top(); 24 | st.pop(); 25 | ans.push_back(temp); 26 | } 27 | reverse(ans.begin(),ans.end()); 28 | return ans; 29 | } 30 | -------------------------------------------------------------------------------- /BST Downward Traversal: -------------------------------------------------------------------------------- 1 | void help(Node* root,int khapadihai,long long int &ans){ 2 | if(!root)return; 3 | if(khapadihai==0)ans+=root->data; 4 | help(root->left,khapadihai-1,ans); 5 | help(root->right,khapadihai+1,ans); 6 | } 7 | void getTarget(Node* root,int target,Node* &temp){ 8 | if(!root)return; 9 | if(root->data==target)temp=root; 10 | if(root->dataright,target,temp); 11 | else getTarget(root->left,target,temp); 12 | } 13 | long long int verticallyDownBST(Node *root,int target){ 14 | // Code here 15 | Node *temp=NULL; 16 | getTarget(root,target,temp); 17 | if(!temp)return -1; 18 | long long int ans=0; 19 | help(temp,0,ans); 20 | ans-=target; 21 | return ans; 22 | } 23 | -------------------------------------------------------------------------------- /Balloon Everywhere: -------------------------------------------------------------------------------- 1 | int maxInstance(string s){ 2 | int arr[26]={0}; 3 | for(int i=0;i1) and (arr['o'-'a']>1) and arr['n'-'a']){ 7 | ans++; 8 | arr[1]--; 9 | arr[0]--; 10 | arr['l'-'a']-=2; 11 | arr['o'-'a']-=2; 12 | arr['n'-'a']--; 13 | } 14 | else return ans; 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Binary Modulo: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int modulo(string s,int m) 4 | { 5 | //code here 6 | int ans=0,temp=1; 7 | for(int i=s.length()-1;i>=0;i--){ 8 | if(s[i]=='1'){ 9 | ans+=temp; 10 | ans%=m; 11 | } 12 | temp*=2; 13 | temp%=m; 14 | } 15 | return ans; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | int modulo(String s, int m) { 22 | //Write your code here 23 | int ans=0,temp=1; 24 | for(int i=s.length()-1;i>=0;i--){ 25 | if(s.charAt(i)=='1'){ 26 | ans+=temp; 27 | ans%=m; 28 | } 29 | temp*=2; 30 | temp%=m; 31 | } 32 | return ans; 33 | } 34 | -------------------------------------------------------------------------------- /Binary Tree to DLL: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | Node *head = NULL, *lastNode = NULL; 4 | void help(Node *root){ 5 | if(!root)return; 6 | help(root->left); 7 | if(!head)head=root; 8 | if(lastNode)lastNode->right=root; 9 | root->left=lastNode; 10 | lastNode=root; 11 | help(root->right); 12 | } 13 | Node* bToDLL(Node* root) { 14 | // code here 15 | help(root); 16 | return head; 17 | } 18 | 19 | 20 | // JAVA CODE 21 | 22 | Node head = null, lastNode = null; 23 | void help(Node root){ 24 | if(root==null)return; 25 | help(root.left); 26 | if(head==null)head=root; 27 | if(lastNode!=null)lastNode.right=root; 28 | root.left=lastNode; 29 | lastNode=root; 30 | help(root.right); 31 | } 32 | //Function to convert binary tree to doubly linked list and return it. 33 | Node bToDLL(Node root) 34 | { 35 | // Your code here 36 | help(root); 37 | return head; 38 | } 39 | 40 | 41 | // Time Complexity:- O(N) 42 | // Space Complexity:- O(H) 43 | -------------------------------------------------------------------------------- /Binary matrix having maximum number of 1s: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | vector findMaxRow(vector> mat, int N) { 4 | //code here 5 | int one=0,row=0,j=N-1; 6 | for(int i=0;i=0 and mat[i][j]){ 8 | j--; 9 | one++; 10 | row=i; 11 | } 12 | } 13 | return {row,one}; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | public int[] findMaxRow(int mat[][], int N) { 20 | // code here 21 | int one=0,row=0,j=N-1; 22 | for(int i=0;i=0 && (mat[i][j]==1)){ 24 | j--; 25 | one++; 26 | row=i; 27 | } 28 | } 29 | int ans[] = new int[2]; 30 | ans[0]=row; 31 | ans[1]=one; 32 | return ans; 33 | } 34 | -------------------------------------------------------------------------------- /Bit Magic: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static int bitMagic(int n, int[] arr) { 4 | // code here 5 | int ans=0,i=0,j=n-1; 6 | while(i &arr) { 18 | // code here 19 | int ans=0,i=0,j=n-1; 20 | while(i &arr,int start,int end,vector> &dp){ 2 | if(start>end)return 0; 3 | if(dp[start][end]!=-1)return dp[start][end]; 4 | int temp = 1; 5 | if(start!=0){ 6 | temp*=arr[start-1]; 7 | } 8 | if(end!=N-1){ 9 | temp*=arr[end+1]; 10 | } 11 | for(int i=start;i<=end;i++){ 12 | int t = arr[i]*temp; 13 | dp[start][end]=max(dp[start][end],t+help(N,arr,start,i-1,dp)+help(N,arr,i+1,end,dp)); 14 | } 15 | return dp[start][end]; 16 | } 17 | int maxCoins(int N, vector &arr) { 18 | vector> dp(N,vector(N,-1)); 19 | return help(N,arr,0,N-1,dp); 20 | } 21 | -------------------------------------------------------------------------------- /Bus Conductor: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static int findMoves(int n, int[] chairs, int[] passengers) { 4 | // code here 5 | Arrays.sort(chairs); 6 | Arrays.sort(passengers); 7 | int ans=0; 8 | for(int i=0;i chairs, vector passengers) { 18 | sort(chairs.begin(),chairs.end()); 19 | sort(passengers.begin(),passengers.end()); 20 | int ans=0; 21 | for(int i=0;i mm; 8 | for(int i=0;i mm = new HashMap<>(); 23 | for(int i=0;i=0?s.length()-3:0; 7 | while(i=0?s.length()-3:0; 20 | while(ikey==n)return n; 8 | else if(root->keykey); 10 | root=root->right; 11 | } 12 | else root=root->left; 13 | } 14 | return ans==INT_MIN?-1:ans; 15 | } 16 | 17 | // JAVA CODE 18 | 19 | public static int findMaxForN(Node root, int n) { 20 | // Add your code here. 21 | int ans = Integer.MIN_VALUE; 22 | while(root!=null){ 23 | if(root.key==n)return n; 24 | else if(root.key q; 5 | q.push(root); 6 | while(q.size()){ 7 | int s= q.size(); 8 | vector arr; 9 | for(int i=0;ileft)q.push(temp->left); 14 | if(temp->right)q.push(temp->right); 15 | } 16 | arr.push_back(NULL); 17 | for(int i=0;inextRight=arr[i+1]; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Construct list using given q XOR queries: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | vector constructList(int q, vector> &queries) { 4 | // code here 5 | int x=0; 6 | vector ans; 7 | for(int i=q-1;i>=0;i--){ 8 | if(queries[i][0])x^=queries[i][1]; 9 | else ans.push_back(queries[i][1]^x); 10 | } 11 | ans.push_back(x); 12 | sort(ans.begin(),ans.end()); 13 | return ans; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | public static ArrayList constructList(int q, int[][] queries) { 20 | // code here 21 | int x=0; 22 | ArrayList ans = new ArrayList<>(); 23 | for(int i=q-1;i>=0;i--){ 24 | if(queries[i][0]==1)x^=queries[i][1]; 25 | else ans.add(queries[i][1]^x); 26 | } 27 | ans.add(x); 28 | Collections.sort(ans); 29 | return ans; 30 | } 31 | 32 | 33 | // Time Complexity:- O(Q*Log(Q)) 34 | // Space Complexity:- O(Q) 35 | -------------------------------------------------------------------------------- /Container With Most Water: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int maxWater(vector &arr) { 4 | // code here 5 | int n=arr.size(),i=0,j=n-1, ans=0; 6 | while(i> vec; 4 | for(int i=0;i &arr) { 4 | // code here 5 | for(int i=0;iarr[i+1])swap(arr[i],arr[i+1]); 7 | else if(i%2==1 and arr[i]arr[i+1]){ 18 | int temp = arr[i]; 19 | arr[i]=arr[i+1]; 20 | arr[i+1]=temp; 21 | } 22 | else if(i%2==1 && arr[i] 1) { 10 | // q is quotient 11 | int q = A / M; 12 | int t = M; 13 | 14 | // m is remainder now, process same as 15 | // Euclid's algo 16 | M = A % M, A = t; 17 | t = y; 18 | 19 | // Update y and x 20 | y = x - q * y; 21 | x = t; 22 | } 23 | 24 | // Make x positive 25 | if (x < 0) 26 | x += m0; 27 | 28 | return x; 29 | } 30 | int compute_value(long long n) 31 | { 32 | // Code here 33 | int mod = 1e9+7; 34 | int ans=2; 35 | long long prev = 1; 36 | for(int i=1;inext; 9 | } 10 | return ans; 11 | } 12 | 13 | 14 | // JAVA CODE 15 | 16 | public int getCount(Node head) { 17 | // code here 18 | int ans = 0; 19 | while(head!=null){ 20 | ans++; 21 | head=head.next; 22 | } 23 | return ans; 24 | } 25 | 26 | 27 | // Time Complexity:- O(N) 28 | // Space Complexity:- O(1) 29 | -------------------------------------------------------------------------------- /Count Lucky Permutations: -------------------------------------------------------------------------------- 1 | long long int luckyPermutations(int N, int M, vector arr, 2 | vector> graph) { 3 | // Code here 4 | vector> adj(N,vector(N,0)); 5 | for(auto x:graph){ 6 | adj[x[0]-1][x[1]-1]=1; 7 | adj[x[1]-1][x[0]-1]=1; 8 | } 9 | vector> dp(N,vector(pow(2,N),0)); 10 | for(int i=0;i>i)) 17 | for(int j=0;j>j)) and arr[i]!=arr[j] and adj[arr[i]-1][arr[j]-1]){ 19 | dp[i][bit]+=dp[j][bit^(1< mm; 8 | for(int i=0;in/k)ans++; 12 | } 13 | return ans; 14 | } 15 | 16 | // JAVA CODE 17 | 18 | public int countOccurence(int[] arr, int n, int k) 19 | { 20 | // your code here,return the answer 21 | HashMap mm = new HashMap<>(); 22 | for(int i=0;i x:mm.entrySet()){ 28 | if(x.getValue()>n/k){ 29 | ans++; 30 | } 31 | } 32 | return ans; 33 | } 34 | -------------------------------------------------------------------------------- /Count Special Numbers: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public int countSpecialNumbers(int N, int arr[]) { 4 | // Code here 5 | int mx = arr[0]; 6 | for(int i=1;i1)ans++; 16 | return ans; 17 | } 18 | 19 | 20 | //C++ CODE 21 | 22 | int countSpecialNumbers(int N, vector arr) { 23 | // Code here 24 | int mx = *max_element(arr.begin(),arr.end()); 25 | int special[mx+1]; 26 | memset(special,0,sizeof(special)); 27 | for(int i=0;i1)ans++; 34 | return ans; 35 | } 36 | -------------------------------------------------------------------------------- /Count Subarrays with given XOR: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long subarrayXor(vector &arr, int k) { 4 | // code here 5 | int xor_=0,ans=0; 6 | unordered_map mm; 7 | for(int x:arr){ 8 | xor_^=x; 9 | if(xor_==k)ans++; 10 | ans+=mm[xor_^k]; 11 | mm[xor_]++; 12 | } 13 | return ans; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | public long subarrayXor(int arr[], int k) { 20 | // code here 21 | int xor_=0,ans=0; 22 | HashMap mm = new HashMap<>(); 23 | for(int x:arr){ 24 | xor_^=x; 25 | if(xor_==k)ans++; 26 | ans+=mm.getOrDefault(xor_^k,0); 27 | mm.put(xor_,mm.getOrDefault(xor_,0)+1); 28 | } 29 | return ans; 30 | } 31 | 32 | 33 | // Time Complexity:- O(N) 34 | // Space Complexity:- O(N) 35 | -------------------------------------------------------------------------------- /Count Total Setbits: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static long countBits(long N) { 4 | // code here 5 | long ans = 0,i=1,n=N; 6 | while(n!=0){ 7 | long temp = (N+1)/(i*2); 8 | ans+=temp*i; 9 | temp = (N+1)/i; 10 | if(temp%2==1)ans+=(N+1)%i; 11 | i*=2; 12 | n>>=1; 13 | } 14 | return ans; 15 | } 16 | 17 | 18 | // C++ CODE 19 | 20 | long long countBits(long long N) { 21 | // code here 22 | long long ans = 0,i=1,n=N; 23 | while(n!=0){ 24 | long long temp = (N+1)/(i*2); 25 | ans+=temp*i; 26 | temp = (N+1)/i; 27 | if(temp%2==1)ans+=(N+1)%i; 28 | i*=2; 29 | n>>=1; 30 | } 31 | return ans; 32 | } 33 | -------------------------------------------------------------------------------- /Count all Possible Path: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int isPossible(vector>paths){ 4 | // Code here 5 | for(int i=0;i countZero(int n, int k, vector>& arr){ 2 | //Code Here 3 | vector ans; 4 | long long int freecell=n*n; 5 | int count1=0,count2=0; 6 | vector r(n,0),c(n,0); 7 | for(int i=0;i0) 28 | { 29 | if(j%10==4){ 30 | ans++; 31 | break; 32 | } 33 | j/=10; 34 | } 35 | } 36 | return ans; 37 | } 38 | 39 | 40 | // Time Complexity:- O(N*M) 41 | // Space Complexity:- O(1) 42 | -------------------------------------------------------------------------------- /Count pairs with given sum: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int countPairs(vector &arr, int target) { 4 | // Code here 5 | int ans=0; 6 | unordered_map mm; 7 | for(int x:arr){ 8 | if(mm[target-x])ans+=mm[target-x]; 9 | mm[x]++; 10 | } 11 | return ans; 12 | } 13 | 14 | // JAVA CODE 15 | 16 | int countPairs(int arr[], int target) { 17 | // Your code here 18 | int ans=0; 19 | HashMap mm = new HashMap<>(); 20 | for(int x:arr){ 21 | if(mm.get(target-x)!=null)ans+=mm.get(target-x); 22 | mm.put(x,mm.getOrDefault(x,0)+1); 23 | } 24 | return ans; 25 | } 26 | 27 | 28 | // Time Complexity:- O(N) 29 | // Space Complexity:- O(N) 30 | -------------------------------------------------------------------------------- /Count the Substring: -------------------------------------------------------------------------------- 1 | long long countSubstring(string S){ 2 | int n = S.length(); 3 | long long ans=0; 4 | int sum=0,onesekam=0; 5 | unordered_map mm; 6 | for(auto x:S){ 7 | if(x=='1')sum++; 8 | else sum--; 9 | if(sum<=0)onesekam++; 10 | mm[sum]++; 11 | } 12 | sum=0; 13 | for(int i=0;i mm = new HashMap<>(); 8 | for(int i=0;i='A' && S.charAt(i)<='Z')sum++; 10 | else sum--; 11 | if(sum==0)ans++; 12 | if(mm.get(sum)!=null){ 13 | ans+=mm.get(sum); 14 | mm.put(sum,mm.get(sum)+1); 15 | } 16 | else mm.put(sum,1); 17 | } 18 | return ans; 19 | } 20 | 21 | 22 | //C++ CODE 23 | 24 | int countSubstring(string S) 25 | { 26 | // code here 27 | int ans = 0,sum=0; 28 | unordered_map mm; 29 | for(int i=0;i& arr) { 4 | // code here 5 | sort(arr.begin(),arr.end()); 6 | int n=arr.size(),ans=0; 7 | for(int i=n-1;i>=2;i--){ 8 | int j=0,k=i-1; 9 | while(jarr[i]){ 12 | ans+=k-j; 13 | k--; 14 | } 15 | else j++; 16 | } 17 | } 18 | return ans; 19 | } 20 | 21 | 22 | // JAVA CODE 23 | 24 | static int countTriangles(int arr[]) { 25 | // code here 26 | Arrays.sort(arr); 27 | int n=arr.length,ans=0; 28 | for(int i=n-1;i>=2;i--){ 29 | int j=0,k=i-1; 30 | while(jarr[i]){ 33 | ans+=k-j; 34 | k--; 35 | } 36 | else j++; 37 | } 38 | } 39 | return ans; 40 | } 41 | 42 | 43 | // Time Complexity:- O(N^2) 44 | // Space Complexity:- O(1) 45 | -------------------------------------------------------------------------------- /Count ways to N'th Stair: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long long countWays(int n) { 4 | // your code here 5 | return n/2+1; 6 | } 7 | 8 | // JAVA CODE 9 | 10 | Long countWays(int n) { 11 | // your code here 12 | return (long)n/2+1; 13 | } 14 | 15 | 16 | // Time Complexity:- O(1) 17 | // Space Complexity:- O(1) 18 | -------------------------------------------------------------------------------- /Cutting Rectangles: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | static long __gcd(long a,long b){ 4 | if(a==0)return b; 5 | return __gcd(b%a,a); 6 | } 7 | static List minimumSquares(long L, long B) 8 | { 9 | // code here 10 | List ans = new ArrayList<>(); 11 | long a = __gcd(L,B); 12 | long b = (L*B)/(a*a); 13 | ans.add(b); 14 | ans.add(a); 15 | return ans; 16 | } 17 | 18 | 19 | // C++ CODE 20 | 21 | vector minimumSquares(long long int L, long long int B) 22 | { 23 | // code here 24 | long long int a = __gcd(L,B); 25 | long long int b = (L*B)/(a*a); 26 | return {b,a}; 27 | } 28 | -------------------------------------------------------------------------------- /Decimal Equivalent of Binary Linked List: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long long unsigned int decimalValue(Node *head) 4 | { 5 | // Your Code Here 6 | long long int ans =0; 7 | int mod = 1e9+7; 8 | while(head){ 9 | ans = (ans*2+head->data)%mod; 10 | head=head->next; 11 | } 12 | return ans; 13 | } 14 | 15 | // JAVA CODE 16 | 17 | long DecimalValue(Node head) 18 | { 19 | int mod = 1000000007; 20 | long ans = 0; 21 | while(head!=null){ 22 | ans = (ans*2+head.data)%mod; 23 | head=head.next; 24 | } 25 | return ans; 26 | } 27 | -------------------------------------------------------------------------------- /Delete Alternate Nodes: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void deleteAlt(struct Node *head) { 4 | // Code here 5 | while(head and head->next){ 6 | head->next = head->next->next; 7 | head=head->next; 8 | } 9 | } 10 | 11 | 12 | // JAVA CODE 13 | 14 | public void deleteAlt(Node head) { 15 | // Code Here 16 | while(head!=null && head.next!=null){ 17 | head.next = head.next.next; 18 | head=head.next; 19 | } 20 | } 21 | 22 | 23 | // Time Complexity:- O(N) 24 | // Space Complexity:- O(1) 25 | -------------------------------------------------------------------------------- /Delete Middle of Linked List: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | Node* deleteMid(Node* head) 4 | { 5 | // Your Code Here 6 | if(head->next==NULL)return NULL; 7 | Node *slow=head,*fast=head,*temp=NULL; 8 | while(fast && fast->next){ 9 | temp=slow; 10 | slow=slow->next; 11 | fast=fast->next->next; 12 | } 13 | temp->next=slow->next; 14 | return head; 15 | } 16 | 17 | // JAVA CODE 18 | 19 | Node deleteMid(Node head) { 20 | // This is method only submission. 21 | // You only need to complete the method. 22 | if(head.next==null)return null; 23 | Node slow=head,fast=head,temp=null; 24 | while(fast!=null && fast.next!=null){ 25 | temp=slow; 26 | slow=slow.next; 27 | fast=fast.next.next; 28 | } 29 | temp.next=slow.next; 30 | return head; 31 | } 32 | 33 | 34 | // Time Complexity:- O(N) 35 | // Space Complexity:- O(1) 36 | -------------------------------------------------------------------------------- /Delete middle element of a stack: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public void deleteMid(Stacks,int sizeOfStack){ 4 | // code here 5 | if(s.size()==(sizeOfStack+1)/2){ 6 | s.pop(); 7 | return; 8 | } 9 | int x = s.peek(); 10 | s.pop(); 11 | deleteMid(s,sizeOfStack); 12 | s.push(x); 13 | } 14 | 15 | // C++ CODE 16 | 17 | void deleteMid(stack&s, int sizeOfStack) 18 | { 19 | // code here.. 20 | if(s.size()==(sizeOfStack+1)/2){ 21 | s.pop(); 22 | return; 23 | } 24 | int x = s.top(); 25 | s.pop(); 26 | deleteMid(s,sizeOfStack); 27 | s.push(x); 28 | } 29 | -------------------------------------------------------------------------------- /Delete node in Doubly Linked List: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | Node* deleteNode(Node* head, int x) { 4 | // Your code here 5 | if(x==1)return head->next; 6 | Node *temp=head; 7 | int count=1; 8 | while(countnext; 10 | count++; 11 | } 12 | temp->prev->next=temp->next; 13 | if(temp->next)temp->next->prev=temp->prev; 14 | return head; 15 | } 16 | 17 | 18 | // JAVA CODE 19 | 20 | public Node deleteNode(Node head, int x) { 21 | if(x==1)return head.next; 22 | int count=1; 23 | Node temp=head; 24 | while(countdata = del_node->next->data; 7 | del_node->next = del_node->next->next; 8 | } 9 | 10 | // JAVA CODE 11 | 12 | void deleteNode(Node del_node) 13 | { 14 | // Your code here 15 | del_node.data = del_node.next.data; 16 | del_node.next = del_node.next.next; 17 | } 18 | 19 | // Time Complexity:- O(1) 20 | // Space Complexity:- O(1) 21 | -------------------------------------------------------------------------------- /Distinct Coloring: -------------------------------------------------------------------------------- 1 | long long int distinctColoring(int N, int r[], int g[], int b[]){ 2 | // code here 3 | vector> dp(N,vector(3,0)); 4 | dp[0][0]=r[0]; 5 | dp[0][1]=g[0]; 6 | dp[0][2]=b[0]; 7 | for(int i=1;ileft,ans); 6 | int r = help(root->right,ans); 7 | ans+=abs(l)+abs(r); 8 | return root->key-1+l+r; 9 | } 10 | int distributeCandy(Node* root) 11 | { 12 | //code here 13 | int ans = 0; 14 | help(root,ans); 15 | return ans; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | static int ans = 0; 22 | static int help(Node root){ 23 | if(root==null)return 0; 24 | int l=help(root.left); 25 | int r=help(root.right); 26 | ans+=Math.abs(l)+Math.abs(r); 27 | return root.data-1+l+r; 28 | } 29 | public static int distributeCandy(Node root) 30 | { 31 | //code here 32 | ans=0; 33 | help(root); 34 | return ans; 35 | } 36 | -------------------------------------------------------------------------------- /Divide in Incremental Groups: -------------------------------------------------------------------------------- 1 | //Java CODE 2 | 3 | public int countWaystoDivide(int N, int K) { 4 | // Code here 5 | int dp[][] = new int[N+1][K+1]; 6 | for(int i=1;i<=N;i++)dp[i][1]=1; 7 | for(int i=1;i<=N;i++){ 8 | for(int j=2;j<=K;j++){ 9 | if(i>=j)dp[i][j]=dp[i-1][j-1]+dp[i-j][j]; 10 | } 11 | } 12 | return dp[N][K]; 13 | } 14 | 15 | 16 | 17 | // C++ CODE 18 | 19 | int countWaystoDivide(int N, int K) { 20 | // Code here 21 | vector> dp(N+1,vector(K+1,0)); 22 | for(int i=1;i<=N;i++)dp[i][1]=1; 23 | for(int i=1;i<=N;i++){ 24 | for(int j=2;j<=K;j++){ 25 | if(i>=j)dp[i][j]=dp[i-1][j-1]+dp[i-j][j]; 26 | } 27 | } 28 | return dp[N][K]; 29 | } 30 | -------------------------------------------------------------------------------- /Divisor Game: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | bool divisorGame(int n) { 4 | // code here 5 | return n%2==0; 6 | } 7 | 8 | // JAVA CODE 9 | 10 | public static boolean divisorGame(int n) { 11 | // code here 12 | return n%2==0; 13 | } 14 | 15 | 16 | // Time Complexity:- O(1) 17 | // Space Complexity:- O(1) 18 | -------------------------------------------------------------------------------- /Does array represent Heap: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | bool isMaxHeap(int arr[], int n) 4 | { 5 | // Your code goes here 6 | int j = 1; 7 | for(int i=0;iarr[i])return false; 9 | if(j+1arr[i])return false; 10 | j+=2; 11 | } 12 | return true; 13 | } 14 | 15 | // JAVA CODE 16 | 17 | public boolean countSub(long arr[], long n) 18 | { 19 | // Your code goes here 20 | int j = 1; 21 | for(int i=0;iarr[i])return false; 23 | if(j+1arr[i])return false; 24 | j+=2; 25 | } 26 | return true; 27 | } 28 | 29 | Time Complexity:- O(N) 30 | Space Complexity:- O(1) 31 | -------------------------------------------------------------------------------- /Equal Left and Right Subarray Sum: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | int equalSum(int [] A, int N) { 4 | //Write your code here 5 | int right=0,left=0; 6 | for(int i=0;i &A) { 19 | // code here 20 | int right=0,left=0; 21 | for(int i=0;i &arr) { 4 | // code here 5 | int n=arr.size(),right=0,left=0; 6 | for(int x:arr)right+=x; 7 | for(int i=0;in || n<0)return 0; 7 | if(dp[n][num]!=-1)return dp[n][num]; 8 | int temp = (int)Math.pow(num,x); 9 | return dp[n][num]=(help(n-temp,x,num+1,dp)+help(n,x,num+1,dp))%mod; 10 | } 11 | static int numOfWays(int n, int x) 12 | { 13 | // code here 14 | int dp[][] = new int[n+1][n+1]; 15 | for(int temp[]:dp)Arrays.fill(temp,-1); 16 | return help(n,x,1,dp); 17 | } 18 | 19 | // C++ CODE 20 | 21 | int mod = 1e9+7; 22 | int help(int n,int x,int num,vector> &dp){ 23 | if(n==0)return 1; 24 | if(num>n or n<0)return 0; 25 | if(dp[n][num]!=-1)return dp[n][num]; 26 | int temp = pow(num,x); 27 | return dp[n][num]=(help(n-temp,x,num+1,dp)+help(n,x,num+1,dp))%mod; 28 | } 29 | int numOfWays(int n, int x) 30 | { 31 | // code here 32 | vector> dp(n+1,vector(n+1,-1)); 33 | return help(n,x,1,dp); 34 | } 35 | -------------------------------------------------------------------------------- /Facing the Sun: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int countBuildings(vector &height) { 4 | // code here 5 | int ans = 1, mx = height[0]; 6 | for(auto x:height){ 7 | if(x>mx){ 8 | mx=x; 9 | ans++; 10 | } 11 | } 12 | return ans; 13 | } 14 | 15 | 16 | // JAVA CODE 17 | 18 | public int countBuildings(int[] height) { 19 | // code here 20 | int ans = 1, mx = height[0]; 21 | for(int x:height){ 22 | if(x>mx){ 23 | mx=x; 24 | ans++; 25 | } 26 | } 27 | return ans; 28 | } 29 | 30 | 31 | // Time Complexity:- O(N) 32 | // Space Complexity:- O(1) 33 | -------------------------------------------------------------------------------- /Fill the Matrix: -------------------------------------------------------------------------------- 1 | int minIteration(int N, int M, int x, int y){ 2 | // code here 3 | vector> arr(N,vector(M,0)); 4 | arr[x-1][y-1]=1; 5 | queue>> q; 6 | q.push({0,{x-1,y-1}}); 7 | int ans=0; 8 | while(q.size()){ 9 | auto temp = q.front(); 10 | q.pop(); 11 | ans = temp.first; 12 | x = temp.second.first; 13 | y = temp.second.second; 14 | if(x+1=0 and arr[x-1][y]==0){ 19 | arr[x-1][y]=1; 20 | q.push({ans+1,{x-1,y}}); 21 | } 22 | if(y+1=0 and arr[x][y-1]==0){ 27 | arr[x][y-1]=1; 28 | q.push({ans+1,{x,y-1}}); 29 | } 30 | } 31 | return ans; 32 | } 33 | -------------------------------------------------------------------------------- /Find Total Time Taken: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static long totalTime(int n,int arr[],int time[]) 4 | { 5 | HashMap mm = new HashMap<>(); 6 | long ans=-1; 7 | for(int i=0;i &arr, vector &time) { 22 | // code here 23 | unordered_map mm; 24 | int ans = -1; 25 | for(int i=0;i=end[j]){ 8 | occu--; 9 | j++; 10 | 11 | } 12 | else{ 13 | occu++; 14 | i++; 15 | } 16 | ans=max(ans,occu); 17 | } 18 | return ans; 19 | } 20 | -------------------------------------------------------------------------------- /Find the Closest Element in BST: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | static int ans=Integer.MAX_VALUE; 4 | static void help(Node root,int K){ 5 | if(root==null)return; 6 | ans=Math.min(ans,Math.abs(root.data-K)); 7 | if(root.data>K)help(root.left,K); 8 | else help(root.right,K); 9 | } 10 | static int minDiff(Node root, int K) 11 | { 12 | // Write your code here 13 | ans=Integer.MAX_VALUE; 14 | help(root,K); 15 | return ans; 16 | } 17 | 18 | 19 | // C++ CODE 20 | 21 | void help(Node *root,int &ans,int K){ 22 | if(!root)return; 23 | ans=min(ans,abs(root->data-K)); 24 | if(root->data>K)help(root->left,ans,K); 25 | else help(root->right,ans,K); 26 | } 27 | int minDiff(Node *root, int K) 28 | { 29 | //Your code here 30 | int ans=INT_MAX; 31 | help(root,ans,K); 32 | return ans; 33 | } 34 | -------------------------------------------------------------------------------- /Find the N-th character: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | char nthCharacter(string s, int r, int n) { 4 | //code here 5 | string temp=""; 6 | while(r--){ 7 | for(auto x:s){ 8 | if(x=='1')temp+="10"; 9 | else temp+="01"; 10 | if(temp.length()>n)break; 11 | } 12 | s=temp; 13 | temp=""; 14 | } 15 | return s[n]; 16 | } 17 | 18 | // JAVA CODE 19 | 20 | public char nthCharacter(String s, int r, int n) 21 | { 22 | //code here 23 | StringBuilder temp = new StringBuilder(); 24 | while(r!=0){ 25 | for(int i=0;in)break; 29 | } 30 | s=temp.toString(); 31 | temp.setLength(0); 32 | r--; 33 | } 34 | return s.charAt(n); 35 | } 36 | 37 | // Time Complexity:- O(r*|s|) 38 | // Space Complexity:- O(|s|) 39 | -------------------------------------------------------------------------------- /Find the Sum of Last N nodes of the Linked List: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int sumOfLastN_Nodes(struct Node* head, int n) { 4 | // Code here 5 | Node *temp = head; 6 | int count=0,sum=0; 7 | while(temp){ 8 | count++; 9 | temp=temp->next; 10 | } 11 | count-=n; 12 | temp=head; 13 | while(temp){ 14 | if(!count)sum+=temp->data; 15 | else count--; 16 | temp=temp->next; 17 | } 18 | return sum; 19 | } 20 | 21 | 22 | // JAVA CODE 23 | 24 | public int sumOfLastN_Nodes(Node head, int n) { 25 | // write code here 26 | Node temp = head; 27 | int count=0,sum=0; 28 | while(temp!=null){ 29 | count++; 30 | temp=temp.next; 31 | } 32 | count-=n; 33 | temp=head; 34 | while(temp!=null){ 35 | if(count==0)sum+=temp.data; 36 | else count--; 37 | temp=temp.next; 38 | } 39 | return sum; 40 | } 41 | 42 | 43 | // Time Complexity:- O(N) 44 | // Space Complexity:- O(1) 45 | -------------------------------------------------------------------------------- /Find the first node of loop in linked list: -------------------------------------------------------------------------------- 1 | Node* ispresent(Node* head){ 2 | Node* slow=head,*fast=head; 3 | while(fast and fast->next){ 4 | slow=slow->next; 5 | fast=fast->next->next; 6 | if(slow==fast)return slow; 7 | } 8 | return NULL; 9 | } 10 | int findFirstNode(Node* head) 11 | { 12 | // your code here 13 | Node* loophai = ispresent(head); 14 | if(loophai){ 15 | Node* temp=head; 16 | while(temp!=loophai){ 17 | temp=temp->next; 18 | loophai=loophai->next; 19 | } 20 | return loophai->data; 21 | } 22 | return -1; 23 | } 24 | -------------------------------------------------------------------------------- /Find the longest string: -------------------------------------------------------------------------------- 1 | bool IsPresent(string str,unordered_map&mm){ 2 | string temp=""; 3 | for(int i=0;i &words) 10 | { 11 | // code here 12 | string ans=""; 13 | unordered_map mm; 14 | for(string x:words)mm[x]++; 15 | for(string x:words){ 16 | if(IsPresent(x,mm)){ 17 | if(x.length()>ans.length())ans=x; 18 | else if(x.length()==ans.length())ans=min(ans,x); 19 | } 20 | } 21 | return ans; 22 | } 23 | -------------------------------------------------------------------------------- /Find the maximum GCD of the siblings of a Binary Tree: -------------------------------------------------------------------------------- 1 | void help(Node* root,int &gcd,int &ans){ 2 | if(!root)return; 3 | if(root->left and root->right){ 4 | int temp = __gcd(root->left->data,root->right->data); 5 | if(temp>gcd){ 6 | gcd=temp; 7 | ans=root->data; 8 | } 9 | else if(temp==gcd){ 10 | ans=max(ans,root->data); 11 | } 12 | } 13 | help(root->left,gcd,ans); 14 | help(root->right,gcd,ans); 15 | } 16 | int maxGCD( Node* root) 17 | { 18 | //code here 19 | int gcd=0,ans=0; 20 | help(root,gcd,ans); 21 | return ans; 22 | } 23 | -------------------------------------------------------------------------------- /Find triplets with zero sum: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public boolean findTriplets(int arr[] , int n) 4 | { 5 | //add code here. 6 | Arrays.sort(arr); 7 | for(int i=0;i mm; 6 | for(int i=0;i mm = new HashMap<>(); 17 | for(int i=0;ileft,pehli,dusri,pichli); 4 | if(pichli and root->datadata){ 5 | if(!pehli)pehli=pichli; 6 | dusri=root; 7 | } 8 | pichli=root; 9 | inorder(root->right,pehli,dusri,pichli); 10 | } 11 | struct Node *correctBST(struct Node *root) { 12 | // code here 13 | Node *pehli=NULL,*dusri=NULL,*pichli=NULL; 14 | inorder(root,pehli,dusri,pichli); 15 | swap(pehli->data,dusri->data); 16 | return root; 17 | } 18 | -------------------------------------------------------------------------------- /Flatten BST to sorted list: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | Node *ans=NULL,*prev=NULL; 4 | void help(Node *root){ 5 | if(!root)return; 6 | help(root->left); 7 | if(prev){ 8 | prev->left=NULL; 9 | prev->right=root; 10 | } 11 | else ans=root; 12 | prev=root; 13 | help(root->right); 14 | prev->left=NULL; 15 | } 16 | Node *flattenBST(Node *root) 17 | { 18 | // code here; 19 | help(root); 20 | return ans; 21 | } 22 | 23 | // JAVA CODE 24 | 25 | static Node prev=null,ans=null; 26 | void help(Node root){ 27 | if(root==null)return; 28 | help(root.left); 29 | if(prev!=null){ 30 | prev.right=root; 31 | prev.left=null; 32 | } 33 | else ans=root; 34 | prev=root; 35 | help(root.right); 36 | prev.left=null; 37 | } 38 | public Node flattenBST(Node root) { 39 | // Code here 40 | ans=null; 41 | prev=null; 42 | help(root); 43 | return ans; 44 | } 45 | -------------------------------------------------------------------------------- /Flattening a Linked List: -------------------------------------------------------------------------------- 1 | Node* merge(Node* one, Node* two){ 2 | if(!one)return two; 3 | if(!two)return one; 4 | Node* temp; 5 | if(one->datadata){ 6 | temp = one; 7 | temp->bottom=merge(one->bottom,two); 8 | } 9 | else{ 10 | temp = two; 11 | temp->bottom=merge(one,two->bottom); 12 | } 13 | return temp; 14 | } 15 | Node *flatten(Node *root) 16 | { 17 | // Your code here 18 | if(!root)return root; 19 | return merge(root,flatten(root->next)); 20 | } 21 | -------------------------------------------------------------------------------- /GCD Array: -------------------------------------------------------------------------------- 1 | int solve(int N, int K, vector &arr) { 2 | // code here 3 | vector factors; 4 | int sum = 0; 5 | sum=accumulate(arr.begin(),arr.end(),sum); 6 | for(int i=1; i<=sqrt(sum); i++){ 7 | if(sum % i == 0){ 8 | factors.push_back(i); 9 | factors.push_back(sum / i); 10 | } 11 | } 12 | int ans = 1; 13 | for(int x:factors){ 14 | int temp = 0; 15 | sum=0; 16 | for(auto y:arr){ 17 | sum+=y; 18 | if(sum%x==0){ 19 | temp++; 20 | } 21 | } 22 | if(temp>= K){ 23 | ans = max(x,ans); 24 | } 25 | } 26 | return ans; 27 | } 28 | -------------------------------------------------------------------------------- /Game of XOR: -------------------------------------------------------------------------------- 1 | // CPP CODE 2 | 3 | int gameOfXor(int N , int A[]) { 4 | // code here 5 | if(N%2==0)return 0; 6 | int ans=0; 7 | for(int i=0;i st; 4 | for(int i=0;i> &arr,vector> &mat,int N,int M){ 2 | if(arr[i][j])return; 3 | arr[i][j]=1; 4 | if(i+1=mat[i][j])dfs(i+1,j,arr,mat,N,M); 5 | if(i-1>=0 and mat[i-1][j]>=mat[i][j])dfs(i-1,j,arr,mat,N,M); 6 | if(j+1=mat[i][j])dfs(i,j+1,arr,mat,N,M); 7 | if(j-1=mat[i][j])dfs(i,j-1,arr,mat,N,M); 8 | } 9 | int water_flow(vector> &mat,int N,int M){ 10 | // Write your code here. 11 | vector> Indian(N,vector(M,false)); 12 | vector> Arabian(N,vector(M,false)); 13 | for(int i=0;i &arr,vector &vis,vector &dfs){ 2 | if(index>=n or index<0){ 3 | return 1; 4 | } 5 | if(dfs[index])return 2; 6 | if(vis[index])return vis[index]; 7 | vis[index]=1; 8 | dfs[index]=1; 9 | int next = index+arr[index]; 10 | int temp = help(n,next,arr,vis,dfs); 11 | if(temp==2)vis[index]=2; 12 | dfs[index]=0; 13 | return vis[index]; 14 | } 15 | int goodStones(int n,vector &arr){ 16 | // Code here 17 | vector vis(n,0),dfs(n,0); 18 | int ans=0; 19 | for(int i=0;idata!=head2->data)return false; 7 | head1=head1->next; 8 | head2=head2->next; 9 | } 10 | if(head1 or head2)return false; 11 | return true; 12 | } 13 | 14 | 15 | 16 | // JAVA CODE 17 | 18 | class Solution { 19 | // Function to check whether two linked lists are identical or not. 20 | public boolean areIdentical(Node head1, Node head2) { 21 | // write your code here 22 | while(head1!=null && head2!=null){ 23 | if(head1.data!=head2.data)return false; 24 | head1=head1.next; 25 | head2=head2.next; 26 | } 27 | if(head1!=null || head2!=null)return false; 28 | return true; 29 | } 30 | } 31 | 32 | 33 | // Time Complexity:- O(N) 34 | // Space Complexity:- O(1) 35 | -------------------------------------------------------------------------------- /Implement Atoi: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int atoi(string s) { 4 | //Your code here 5 | int num = 0; 6 | for(int i=0;i='0' and s[i]<='9'){ 9 | num=num*10+(s[i]-'0'); 10 | } 11 | else return -1; 12 | } 13 | if(s[0]=='-')num*=-1; 14 | return num; 15 | } 16 | 17 | // JAVA CODE 18 | 19 | int atoi(String s) { 20 | // Your code here 21 | int num=0; 22 | for(int i=0;i=0 && s.charAt(i)-'0'<=9){ 26 | num = num*10 + (s.charAt(i)-'0'); 27 | } 28 | else 29 | return -1; 30 | } 31 | if(s.charAt(0)=='-') 32 | num*=-1; 33 | return num; 34 | } 35 | -------------------------------------------------------------------------------- /Indexes of Subarray Sum: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | vector subarraySum(vector &arr, int target) { 4 | // code here 5 | int n=arr.size(),j=0,sum=0; 6 | for(int i=0;itarget and j subarraySum(int[] arr, int target) { 18 | // code here 19 | ArrayList ans = new ArrayList<>(); 20 | int n=arr.length,j=0,sum=0; 21 | for(int i=0;itarget && j insertAtBottom(stack st,int x){ 4 | stack temp; 5 | while(st.size()){ 6 | temp.push(st.top()); 7 | st.pop(); 8 | } 9 | st.push(x); 10 | while(temp.size()){ 11 | st.push(temp.top()); 12 | temp.pop(); 13 | } 14 | return st; 15 | } 16 | 17 | // JAVA CODE 18 | 19 | public Stack insertAtBottom(Stack st, int x) { 20 | Stack temp = new Stack<>(); 21 | while(!st.isEmpty()){ 22 | temp.push(st.peek()); 23 | st.pop(); 24 | } 25 | st.push(x); 26 | while(!temp.isEmpty()){ 27 | st.push(temp.peek()); 28 | temp.pop(); 29 | } 30 | return st; 31 | } 32 | 33 | 34 | // Time Complexity:- O(N) 35 | // Space Complexity:- O(N) 36 | -------------------------------------------------------------------------------- /Intersection of Two arrays with Duplicate Elements: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | vector intersectionWithDuplicates(vector& a, vector& b) { 4 | // code here 5 | vector ans; 6 | unordered_map mm; 7 | for(int x:a)mm[x]=1; 8 | for(int x:b){ 9 | if(mm[x]){ 10 | ans.push_back(x); 11 | mm[x]=0; 12 | } 13 | } 14 | return ans; 15 | } 16 | 17 | // JAVA CODE 18 | 19 | public ArrayList intersectionWithDuplicates(int[] a, int[] b) { 20 | // code here 21 | ArrayList ans = new ArrayList<>(); 22 | HashMap mm = new HashMap<>(); 23 | for(int x:a)mm.put(x,1); 24 | for(int x:b){ 25 | if(mm.get(x)!=null && mm.get(x)!=0){ 26 | ans.add(x); 27 | mm.put(x,0); 28 | } 29 | } 30 | return ans; 31 | } 32 | 33 | 34 | // Time Complexity:- O(N+M) 35 | // Space Complexity:- O(N) 36 | -------------------------------------------------------------------------------- /Is it Fibonacci: -------------------------------------------------------------------------------- 1 | long long solve(int N, int K, vector GeekNum) { 2 | // code here 3 | long long sum=0; 4 | sum=accumulate(GeekNum.begin(),GeekNum.end(),sum); 5 | int j=0; 6 | for(int i=K;i jugglerSequence(long long n) { 4 | // code here 5 | vector ans; 6 | while(n!=1){ 7 | ans.push_back(n); 8 | if(n%2){ 9 | n=pow(sqrt(n),3); 10 | } 11 | else{ 12 | n=sqrt(n); 13 | } 14 | } 15 | ans.push_back(1); 16 | return ans; 17 | } 18 | 19 | // JAVA CODE 20 | 21 | static List jugglerSequence(long n) { 22 | // code here 23 | List ans = new ArrayList(); 24 | while(n!=1){ 25 | ans.add(n); 26 | if(n%2==1){ 27 | n=(long)Math.pow(Math.sqrt(n),3); 28 | } 29 | else{ 30 | n=(long)Math.sqrt(n); 31 | } 32 | } 33 | ans.add(1L); 34 | return ans; 35 | } 36 | 37 | // Time Complexity:- O(NLogN) 38 | // Space Complexity:- O(N) 39 | -------------------------------------------------------------------------------- /K Sized Subarray Maximum: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | vector max_of_subarrays(int k, vector &arr) { 4 | // your code here 5 | vector ans; 6 | deque dq; 7 | for(int i=0;i=k-1)ans.push_back(arr[dq.front()]); 12 | } 13 | return ans; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | public ArrayList max_of_subarrays(int k, int arr[]) { 20 | // Your code here 21 | ArrayList ans = new ArrayList<>(); 22 | Deque dq = new ArrayDeque<>(); 23 | for(int i=0;i=k-1)ans.add(arr[dq.getFirst()]); 28 | } 29 | return ans; 30 | } 31 | 32 | 33 | // Time Complexity:- O(N) 34 | // Space Complexity:- O(K) 35 | -------------------------------------------------------------------------------- /K-Palindrome: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int kPalindrome(string str, int n, int k) 4 | { 5 | // code here 6 | int dp[n][n]; 7 | memset(dp,0,sizeof dp); 8 | for(int i=2;i<=n;i++){ 9 | for(int row=0;row<=n-i;row++){ 10 | int col = row+i-1; 11 | if(str[row]==str[col])dp[row][col]=dp[row+1][col-1]; 12 | else dp[row][col]=min(dp[row+1][col],dp[row][col-1])+1; 13 | } 14 | } 15 | return dp[0][n-1]<=k?1:0; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | public int kPalindrome(String str, int n, int k) { 22 | // code here 23 | int dp[][] = new int[n][n]; 24 | for(int i=2;i<=n;i++){ 25 | for(int row=0;row<=n-i;row++){ 26 | int col=row+i-1; 27 | if(str.charAt(row)==str.charAt(col))dp[row][col]=dp[row+1][col-1]; 28 | else dp[row][col]=Math.min(dp[row][col-1],dp[row+1][col])+1; 29 | } 30 | } 31 | return dp[0][n-1]<=k?1:0; 32 | } 33 | 34 | 35 | // Time Complexity:- O(N*N) 36 | // Space Complexity:- O(N*N) 37 | -------------------------------------------------------------------------------- /Kadane's Algorithm: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int maxSubarraySum(vector &arr) { 4 | // code here... 5 | int sum=0,ans=INT_MIN,n=arr.size(); 6 | for(int i=0;i &arr, int k) { 4 | // code here 5 | int mx = INT_MIN; 6 | for(auto x:arr)mx=max(x,mx); 7 | int hash[mx+1]; 8 | memset(hash,0,sizeof hash); 9 | for(auto x:arr)hash[x]=1; 10 | for(int i=1;i<=mx;i++){ 11 | k-=hash[i]; 12 | if(!k)return i; 13 | } 14 | return 0; 15 | } 16 | 17 | 18 | // JAVA CODE 19 | 20 | public static int kthSmallest(int[] arr, int k) { 21 | // Your code here 22 | int mx = Integer.MIN_VALUE; 23 | for(int x:arr)mx=Math.max(x,mx); 24 | int hash[] = new int[mx+1]; 25 | Arrays.fill(hash,0); 26 | for(int x:arr)hash[x]=1; 27 | for(int i=1;i<=mx;i++){ 28 | k-=hash[i]; 29 | if(k==0)return i; 30 | } 31 | return 0; 32 | } 33 | 34 | 35 | // Time Complexity:- O(N+Max_Element) 36 | // Space Complexity:- O(Max_Element) 37 | -------------------------------------------------------------------------------- /Largest Number formed from an Array: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | static bool func(string a,string b){ 4 | return a+b>b+a; 5 | } 6 | string printLargest(int n, vector &arr) { 7 | // code here 8 | sort(arr.begin(),arr.end(),func); 9 | string ans=""; 10 | for(auto x:arr)ans+=x; 11 | return ans; 12 | } 13 | 14 | // JAVA CODE 15 | 16 | String printLargest(int n, String[] arr) { 17 | // code here 18 | StringBuilder temp = new StringBuilder(); 19 | Arrays.sort(arr,new Comparator(){ 20 | @Override 21 | public int compare(String x, String y){ 22 | String a = x+y; 23 | String b = y+x; 24 | return b.compareTo(a); 25 | } 26 | }); 27 | for(String x:arr)temp.append(x); 28 | return temp.toString(); 29 | } 30 | 31 | 32 | // Time Complexity:- O(NLogN) 33 | // Space Complexity:- O(M) 34 | -------------------------------------------------------------------------------- /Largest Pair Sum: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int pairsum(vector &arr) { 4 | // code here 5 | int largest = INT_MIN, secondLargest = INT_MIN; 6 | for(int x:arr){ 7 | if(x>largest){ 8 | secondLargest=largest; 9 | largest=x; 10 | } 11 | else if(x>secondLargest)secondLargest=x; 12 | } 13 | return largest+secondLargest; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | public static int pairsum(int[] arr) { 20 | // code here 21 | int largest = Integer.MIN_VALUE, secondLargest = Integer.MIN_VALUE; 22 | for(int x:arr){ 23 | if(x>largest){ 24 | secondLargest=largest; 25 | largest=x; 26 | } 27 | else if(x>secondLargest)secondLargest=x; 28 | } 29 | return largest+secondLargest; 30 | } 31 | 32 | 33 | // Time Complexity:- O(N) 34 | // Space Complexity:- O(1) 35 | -------------------------------------------------------------------------------- /Largest Subtree Sum in a Tree: -------------------------------------------------------------------------------- 1 | int help(Node* root,int &ans){ 2 | if(!root)return 0; 3 | int l = help(root->left,ans); 4 | int r = help(root->right,ans); 5 | ans = max(ans,root->data+l+r); 6 | return root->data+l+r; 7 | } 8 | int findLargestSubtreeSum(Node* root) 9 | { 10 | //Write your code here 11 | int ans=INT_MIN; 12 | int t = help(root,ans); 13 | return ans; 14 | } 15 | -------------------------------------------------------------------------------- /Last modified ball: -------------------------------------------------------------------------------- 1 | int solve(int N, vector A) { 2 | // code here 3 | for(int i=N-1;i>=0;i--)if(A[i]!=9)return i+1; 4 | } 5 | -------------------------------------------------------------------------------- /Least Prime Factor: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public int[] leastPrimeFactor(int n) 4 | { 5 | // code here 6 | int ans[] = new int[n+1]; 7 | Arrays.fill(ans,0); 8 | ans[1]=1; 9 | for(int i=2;i<=n;i++){ 10 | if(ans[i]==0){ 11 | ans[i]=i; 12 | for(int j=2*i;j<=n;j+=i){ 13 | if(ans[j]==0){ 14 | ans[j]=i; 15 | } 16 | } 17 | } 18 | } 19 | return ans; 20 | } 21 | 22 | 23 | // C++ CODE 24 | 25 | vector leastPrimeFactor(int n) { 26 | // code here 27 | vector ans(n+1,0); 28 | ans[1]=1; 29 | for(int i=2;i<=n;i++){ 30 | if(ans[i]==0){ 31 | ans[i]=i; 32 | for(int j=2*i;j<=n;j+=i){ 33 | if(ans[j]==0){ 34 | ans[j]=i; 35 | } 36 | } 37 | } 38 | } 39 | return ans; 40 | } 41 | -------------------------------------------------------------------------------- /Length of the longest subarray with positive product: -------------------------------------------------------------------------------- 1 | int maxLength(vector &arr,int n){ 2 | //code here 3 | int ans=0,c=0,negative=-1,start=0; 4 | for(int i=0;i levelOrder(Node* root) 4 | { 5 | //Your code here 6 | vector ans; 7 | queue q; 8 | q.push(root); 9 | while(!q.empty()){ 10 | Node *temp = q.front(); 11 | q.pop(); 12 | ans.push_back(temp->data); 13 | if(temp->left)q.push(temp->left); 14 | if(temp->right)q.push(temp->right); 15 | } 16 | return ans; 17 | } 18 | 19 | // JAVA CODE 20 | 21 | static ArrayList levelOrder(Node root) 22 | { 23 | // Your code here 24 | ArrayList ans = new ArrayList<>(); 25 | Queue q = new LinkedList<>(); 26 | q.add(root); 27 | while(!q.isEmpty()) 28 | { 29 | Node n=q.remove(); 30 | if(n.left!=null)q.add(n.left); 31 | if(n.right!=null)q.add(n.right); 32 | ans.add(n.data); 33 | } 34 | return ans; 35 | } 36 | -------------------------------------------------------------------------------- /Longest Common Prefix of Strings: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | string longestCommonPrefix(vector arr) { 4 | // your code here 5 | string temp = arr[0]; 6 | int i=0,j=0; 7 | while(i storeLength(n,0); 7 | while(i0)j=storeLength[j-1]; 11 | else i++; 12 | } 13 | } 14 | return storeLength[n-1]; 15 | } 16 | 17 | 18 | // JAVA CODE 19 | 20 | int lps(String str) { 21 | // code here 22 | int i=1,j=0,n=str.length(); 23 | int storeLength[] = new int[n]; 24 | while(i0)j=storeLength[j-1]; 28 | else i++; 29 | } 30 | } 31 | return storeLength[n-1]; 32 | } 33 | 34 | 35 | // Time Complexity:- O(|Str|) 36 | // Space Complexity:- O(|Str|) 37 | -------------------------------------------------------------------------------- /Longest Subarray with Sum Divisible by K: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int longSubarrWthSumDivByK(int arr[], int n, int k) 4 | { 5 | // Complete the function 6 | int ans=0,sum=0; 7 | unordered_map mm; 8 | for(int i=0;i mm = new HashMap<>(); 30 | for(int i=0;i& arr) { 4 | // Code here 5 | int des=1,inc=1; 6 | for(int i=1;iarr[i-1])inc=des+1; 8 | else if(arr[i]arr[i-1])inc=dec+1; 22 | } 23 | return Math.max(inc,dec); 24 | } 25 | 26 | 27 | // Time Complexity:- O(N) 28 | // Space Complexity:- O(1) 29 | -------------------------------------------------------------------------------- /Longest subsequence-1: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int longestSubseq(int n, vector &a) { 4 | // code here 5 | int ans=0; 6 | unordered_map mm; 7 | for(int i=0;i mm = new HashMap<>(); 19 | int ans=0; 20 | for(int i=0;in1 && root.data>n2){ 8 | root=root.left; 9 | } 10 | else if(root.datadata>n1 and root->data>n2){ 24 | root=root->left; 25 | } 26 | else if(root->datadataright; 28 | } 29 | else return root; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /Make array elements unique: -------------------------------------------------------------------------------- 1 | long long int minIncrements(vector arr, int N) { 2 | // Code here 3 | sort(arr.begin(),arr.end()); 4 | long long int ans=0; 5 | for(int i=1;i &arr) { 4 | 5 | // your code here 6 | int n = arr.size(),mn=INT_MAX,mx=INT_MIN,sum1=0,sum2=0,total=0; 7 | for(int i=0;i> &G,int banda,vector &vis,vector &job){ 2 | for(int i=0;i>&G){ 18 | // Code here 19 | int M = G.size(); 20 | int N = G[0].size(); 21 | vector job(N,-1); 22 | int ans=0; 23 | for(int i=0;i vis(N,0); 25 | if(desktehai(G,i,vis,job))ans++; 26 | } 27 | return ans; 28 | } 29 | -------------------------------------------------------------------------------- /Maximum Diamonds: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | static long maxDiamonds(int[] A, int N, int K) { 4 | // code here 5 | long ans=0; 6 | PriorityQueue pq=new PriorityQueue<>(Collections.reverseOrder()); 7 | for(int i=0;i pq; 25 | for(int i=0;i &arr) { 4 | // code here 5 | long long int sum=0; 6 | sum=accumulate(arr.begin(),arr.end(),sum); 7 | for(int i=N;i>=1;i--){ 8 | if(sum%i==0)return i; 9 | } 10 | } 11 | 12 | // JAVA CODE 13 | 14 | public static int getMaximum(int N, int[] arr) { 15 | // code here 16 | long sum=0; 17 | for(int i=0;i=0;i--){ 19 | if(sum%i==0)return i; 20 | } 21 | return 1; 22 | } 23 | -------------------------------------------------------------------------------- /Maximum Index: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int maxIndexDiff(int a[], int n) 4 | { 5 | // Your code here 6 | vector right(n); 7 | right[n-1]=a[n-1]; 8 | for(int i=n-2;i>=0;i--)right[i]=max(a[i],right[i+1]); 9 | int i=0,j=0,ans=INT_MIN; 10 | while(i=0;i--)right[i]=Math.max(a[i],right[i+1]); 28 | int i=0,j=0,ans=Integer.MIN_VALUE; 29 | while(i mm = new TreeMap<>(); 6 | for(int[] x:lines){ 7 | mm.putIfAbsent(x[0],0); 8 | mm.putIfAbsent(x[1]+1,0); 9 | mm.put(x[0],mm.get(x[0])+1); 10 | mm.put(x[1]+1,mm.get(x[1]+1)-1); 11 | } 12 | int ans = 1; 13 | int total=0; 14 | for(int x:mm.keySet()){ 15 | total+=mm.get(x); 16 | ans=Math.max(ans,total); 17 | } 18 | return ans; 19 | } 20 | 21 | 22 | // C++ CODE 23 | 24 | int maxIntersections(vector> lines, int N) { 25 | // Code here 26 | map mm; 27 | for(auto x:lines){ 28 | mm[x[0]]++; 29 | mm[x[1]+1]--; 30 | } 31 | int ans = 1,total=0; 32 | for(auto x:mm){ 33 | total+=x.second; 34 | ans=max(ans,total); 35 | } 36 | return ans; 37 | } 38 | -------------------------------------------------------------------------------- /Maximum Length: -------------------------------------------------------------------------------- 1 | // JAVA and C++ CODE 2 | 3 | int solve(int a, int b, int c) { 4 | // code here 5 | if((a>2*(b+c)+2) || (b>2*(a+c)+2) || (c>2*(a+b)+2))return -1; 6 | return a+b+c; 7 | } 8 | -------------------------------------------------------------------------------- /Maximum Possible Value: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | long maxPossibleValue(int N, int A[] ,int B[]) { 4 | // code here 5 | long sum=0; 6 | int mn=Integer.MAX_VALUE,total=0; 7 | for(int i=0;i A, vector B) { 24 | // code here 25 | long long sum=0; 26 | int mn=INT_MAX,total=0; 27 | for(int i=0;i &arr) { 4 | // Your Code Here 5 | int ans=INT_MIN,productStart=1,productEnd=1,n=arr.size(); 6 | for(int i=0;i Edge) 2 | { 3 | // code here 4 | vector arr(N,0); 5 | for(int i=0;i> mat) { 4 | // code here 5 | if(n<3 or m<3)return -1; 6 | int ans = INT_MIN; 7 | for(int i=2;i> &arr) { 4 | // Your Code Here 5 | int n = arr.size(); 6 | sort(arr.begin(),arr.end()); 7 | for(int i=1;iarr[i][0])return false; 9 | } 10 | return true; 11 | } 12 | 13 | 14 | // JAVA CODE 15 | 16 | static boolean canAttend(int[][] arr) { 17 | // Your code here 18 | int n = arr.length; 19 | Arrays.sort(arr, (a,b)->Integer.compare(a[0],b[0])); 20 | for(int i=1;iarr[i][0])return false; 22 | } 23 | return true; 24 | } 25 | 26 | 27 | // Time Complexity:- O(NLogN) 28 | // Space Complexity:- O(1) 29 | -------------------------------------------------------------------------------- /Merge Without Extra Space: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void mergeArrays(vector& a, vector& b) { 4 | // code here 5 | int n=a.size(),m=b.size(),i=n-1,j=0; 6 | while(i>=0 && j=0 && jnext; 6 | while(fast and fast->next){ 7 | slow=slow->next; 8 | fast=fast->next->next; 9 | } 10 | return fast!=NULL?slow->next->data:slow->data; 11 | } 12 | 13 | 14 | // JAVA CODE 15 | 16 | int getMiddle(Node head) { 17 | // Your code here. 18 | Node slow = head, fast = head.next; 19 | while(fast!=null && fast.next!=null){ 20 | slow=slow.next; 21 | fast=fast.next.next; 22 | } 23 | return fast!=null?slow.next.data:slow.data; 24 | } 25 | 26 | 27 | 28 | // Time Complexity:- O(N) 29 | // Space Complexity:- O(1) 30 | -------------------------------------------------------------------------------- /Min operations: -------------------------------------------------------------------------------- 1 | int solve(int a, int b) { 2 | // code here 3 | if(a==b)return 0; 4 | if((a&b)==a or (a&b)==b)return 1; 5 | return 2; 6 | } 7 | -------------------------------------------------------------------------------- /Minimize number of Students to be Removed: -------------------------------------------------------------------------------- 1 | int binarySearch(vector &temp,int key,int s){ 2 | int start=0,end=s-1,mid,index; 3 | while(start<=end){ 4 | mid = (start+end)/2; 5 | if(temp[mid]==key)return mid; 6 | else if(temp[mid]>key){ 7 | index=mid; 8 | end=mid-1; 9 | } 10 | else{ 11 | start=mid+1; 12 | } 13 | } 14 | return index; 15 | } 16 | int removeStudents(int H[], int N) { 17 | // code here 18 | vector temp; 19 | temp.push_back(H[0]); 20 | int s =1; 21 | for(int i=1;itemp[s-1]){ 23 | temp.push_back(H[i]); 24 | s++; 25 | } 26 | else{ 27 | int index = binarySearch(temp,H[i],s); 28 | temp[index]=H[i]; 29 | } 30 | } 31 | return N-s; 32 | 33 | } 34 | -------------------------------------------------------------------------------- /Minimize the Heights II: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int getMinDiff(vector &arr, int k) { 4 | // code here 5 | int n = arr.size(); 6 | if(n==1)return 0; 7 | sort(arr.begin(),arr.end()); 8 | int ans = arr[n-1]-arr[0], mn=0, mx=0; 9 | for(int i=1;i arr) { 2 | // code here 3 | priority_queue,greater> pq; 4 | for(int i=0;ileft,ans,previous); 6 | if(previous!=-1)ans=min(ans,abs(root->data-previous)); 7 | previous=root->data; 8 | help(root->right,ans,previous); 9 | } 10 | int absolute_diff(Node *root) 11 | { 12 | //Your code here 13 | int ans = INT_MAX,previous=-1; 14 | help(root,ans,previous); 15 | return ans; 16 | } 17 | 18 | // JAVA CODE 19 | 20 | static int ans = Integer.MAX_VALUE,previous=-1; 21 | static void help(Node root){ 22 | if(root==null)return; 23 | help(root.left); 24 | if(previous!=-1)ans=Math.min(ans,Math.abs(root.data-previous)); 25 | previous=root.data; 26 | help(root.right); 27 | } 28 | int absolute_diff(Node root) 29 | { 30 | //Your code here 31 | ans = Integer.MAX_VALUE; 32 | previous=-1; 33 | help(root); 34 | return ans; 35 | } 36 | 37 | 38 | // Time Complexity:- O(N) 39 | // Space Complexity:- O(H) 40 | -------------------------------------------------------------------------------- /Minimum Cost of Ropes: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long long minCost(vector& arr) { 4 | // Your code here 5 | long long ans = 0; 6 | priority_queue, greater> pq; 7 | for(auto x:arr)pq.push(x); 8 | while(pq.size()!=1){ 9 | long long first = pq.top(); 10 | pq.pop(); 11 | long long second = pq.top(); 12 | pq.pop(); 13 | long long total = first+second; 14 | pq.push(total); 15 | ans+=total; 16 | } 17 | return ans; 18 | } 19 | 20 | 21 | // JAVA CODE 22 | 23 | public long minCost(long[] arr) { 24 | // code here 25 | long ans = 0; 26 | PriorityQueue pq = new PriorityQueue<>(); 27 | for(Long x:arr)pq.add(x); 28 | while(pq.size()!=1){ 29 | long first = pq.poll(); 30 | long second = pq.poll(); 31 | long total = first+second; 32 | pq.add(total); 33 | ans+=total; 34 | } 35 | return ans; 36 | } 37 | 38 | 39 | // Time Complexity:- O(NLogN) 40 | // Space Complexity:- O(N) 41 | -------------------------------------------------------------------------------- /Minimum Days: -------------------------------------------------------------------------------- 1 | int getMinimumDays(int N,string S, vector &P) { 2 | // code here 3 | if(N==1)return 0; 4 | int count=0; 5 | for(int i=0;i &A) { 18 | // code here 19 | long long int sum=0; 20 | int ans = INT_MAX; 21 | sum = accumulate(A.begin(),A.end(),sum); 22 | for(int i=0;i& arr) { 4 | // Your code here 5 | if(!arr[0])return -1; 6 | int ans = 1, jump = arr[0], mx = 0; 7 | for(int i=1;i0 && b>0){ 11 | if(a &arr){ 24 | // Code here 25 | int mn = INT_MAX; 26 | for(int i=0;i0 && b>0){ 31 | if(a>=1; 7 | } 8 | while(b){ 9 | if(b&1)setB++; 10 | b>>=1; 11 | } 12 | int faltu=0,kam=0; 13 | if(setB>setA)faltu=setB-setA; 14 | else kam = setA-setB; 15 | int ans=0; 16 | int i=0; 17 | while(a){ 18 | if(faltu){ 19 | ans+=pow(2,i); 20 | if((a&1)==0)faltu--; 21 | } 22 | else{ 23 | if(kam>0 and a&1)kam--; 24 | else if(kam==0 and a&1){ 25 | ans+=pow(2,i); 26 | } 27 | } 28 | i++; 29 | a>>=1; 30 | } 31 | return ans; 32 | } 33 | -------------------------------------------------------------------------------- /Minimum cost to fill given weight in a bag: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int minimumCost(int n, int w, vector &cost) { 4 | // code here 5 | vector dp(w+1,INT_MAX); 6 | dp[0]=0; 7 | for(int i=0;ileft); 7 | mirror(node->right); 8 | swap(node->left,node->right); 9 | } 10 | 11 | 12 | // JAVA CODE 13 | 14 | void mirror(Node node) { 15 | // Your code here 16 | if(node==null)return; 17 | mirror(node.left); 18 | mirror(node.right); 19 | Node temp = node.left; 20 | node.left=node.right; 21 | node.right=temp; 22 | } 23 | 24 | 25 | // Time Complexity:- O(N) 26 | // Space Complexity:- O(H) 27 | -------------------------------------------------------------------------------- /Missing And Repeating: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | vector findTwoElement(vector& arr) { 4 | // code here 5 | int n=arr.size(); 6 | vector ans; 7 | for(int i=0;i0)ans.push_back(i+1); 14 | } 15 | return ans; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | int[] findTwoElement(int arr[]) { 22 | // code here 23 | int n = arr.length; 24 | int ans[] = new int[2]; 25 | for(int i=0;i0)ans[1]=i+1; 32 | } 33 | return ans; 34 | } 35 | 36 | 37 | // Time Complexity:- O(N) 38 | // Space Complexity:- O(1) 39 | -------------------------------------------------------------------------------- /Modified Game of Nim: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int findWinner(int n, int A[]){ 4 | // code here 5 | int x=0; 6 | for(int i=0;i0){ 22 | if(n%2==1)ans=(ans*x)%m; 23 | x=(x*x)%m; 24 | n/=2; 25 | } 26 | return ans; 27 | } 28 | 29 | 30 | // Time Complexity:- O(Log(N)) 31 | // Space Complexity:- O(1) 32 | -------------------------------------------------------------------------------- /Move All Zeroes to End: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void pushZerosToEnd(vector& arr) { 4 | // code here 5 | int j=0,n=arr.size(); 6 | for(int i=0;idata)%mod; 7 | node=node->next; 8 | } 9 | return num; 10 | } 11 | long long multiplyTwoLists(Node *first, Node *second) { 12 | // code here 13 | long long num1 = listToNum(first); 14 | long long num2 = listToNum(second); 15 | return (num1*num2)%1000000007; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | public static long listToNum(Node node){ 22 | long num = 0,mod=1000000007; 23 | while(node!=null){ 24 | num = (num*10+node.data)%mod; 25 | node=node.next; 26 | } 27 | return num; 28 | } 29 | public long multiplyTwoLists(Node first, Node second) { 30 | // Code here 31 | long num1 = listToNum(first); 32 | long num2 = listToNum(second); 33 | return (num1*num2)%1000000007; 34 | } 35 | 36 | 37 | // Time Complexity:- O(Max(N,M)) 38 | // Space Complexity:- O(1) 39 | -------------------------------------------------------------------------------- /Nearest multiple of 10: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | string roundToNearest(string str) { 4 | // Complete the function 5 | int n = str.length()-1; 6 | if(str[n]<='5'){ 7 | str[n]='0'; 8 | return str; 9 | } 10 | str[n]='0'; 11 | n--; 12 | while(n>=0 and str[n]=='9'){ 13 | str[n]='0'; 14 | n--; 15 | } 16 | if(n==-1)return '1'+str; 17 | str[n]++; 18 | return str; 19 | } 20 | 21 | 22 | // JAVA CODE 23 | 24 | String roundToNearest(String str) { 25 | // Complete the function 26 | int n = str.length()-1; 27 | char temp[] = str.toCharArray(); 28 | if(temp[n]<='5'){ 29 | temp[n]='0'; 30 | return new String(temp); 31 | } 32 | temp[n]='0'; 33 | n--; 34 | while(n>=0 && temp[n]=='9'){ 35 | temp[n]='0'; 36 | n--; 37 | } 38 | if(n==-1)return '1' + new String(temp); 39 | temp[n]+=1; 40 | return new String(temp); 41 | } 42 | 43 | 44 | // Time Complexity:- O(N) 45 | // Space Complexity:- O(1) 46 | -------------------------------------------------------------------------------- /Nearly Sorted: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void nearlySorted(vector& arr, int k) { 4 | // code 5 | int j=0,n=arr.size(); 6 | priority_queue,greater> pq; 7 | for(int i=0;i=k){ 10 | arr[j++]=pq.top(); 11 | pq.pop(); 12 | } 13 | } 14 | while(!pq.empty()){ 15 | arr[j++]=pq.top(); 16 | pq.pop(); 17 | } 18 | } 19 | 20 | 21 | // JAVA CODE 22 | 23 | public void nearlySorted(int[] arr, int k) { 24 | // code 25 | PriorityQueue pq = new PriorityQueue<>(); 26 | int j=0,n=arr.length; 27 | for(int i=0;i=k)arr[j++]=pq.poll(); 31 | } 32 | while(!pq.isEmpty())arr[j++]=pq.poll(); 33 | } 34 | 35 | // Time Complexity:- O(NLogK) 36 | // Space Complexity:- O(K) 37 | -------------------------------------------------------------------------------- /Next Greater Element: -------------------------------------------------------------------------------- 1 | vector nextLargerElement(vector &arr, int n){ 2 | // Your code here 3 | vector ans; 4 | stack st; 5 | for(int i=n-1;i>=0;i--){ 6 | if(st.empty()){ 7 | ans.push_back(-1); 8 | } 9 | else{ 10 | while(st.size() and st.top()<=arr[i])st.pop(); 11 | if(st.empty())ans.push_back(-1); 12 | else ans.push_back(st.top()); 13 | } 14 | st.push(arr[i]); 15 | } 16 | reverse(ans.begin(),ans.end()); 17 | return ans; 18 | } 19 | -------------------------------------------------------------------------------- /Non Repeating Character: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | static char nonrepeatingCharacter(String S) 4 | { 5 | //Your code here 6 | HashMap mm = new HashMap<>(); 7 | for(int i=0;i mm; 24 | for(auto x:S)mm[x]++; 25 | for(auto x:S)if(mm[x]==1)return x; 26 | return '$'; 27 | } 28 | -------------------------------------------------------------------------------- /Non-overlapping Intervals: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | static bool func(vector &a,vector &b){ 4 | if(a[1]b[1])return false; 6 | return a[0]<=b[0]; 7 | } 8 | int minRemoval(vector> &intervals) { 9 | // code here 10 | sort(intervals.begin(),intervals.end(),func); 11 | int last=0,ans=0,n=intervals.size(); 12 | for(int i=1;iInteger.compare(a[1],b[1])); 25 | int last = 0,ans=0,n=intervals.length; 26 | for(int i=1;i &arr) { 4 | // Your code goes here. 5 | long long ans = 1; 6 | for(int x:arr){ 7 | if(x>ans)return ans; 8 | ans+=x; 9 | } 10 | return ans; 11 | } 12 | 13 | 14 | // JAVA CODE 15 | 16 | public long findSmallest(int[] arr) { 17 | // Your code goes here 18 | long ans = 1; 19 | for(int x:arr){ 20 | if(x>ans)return ans; 21 | ans+=x; 22 | } 23 | return ans; 24 | } 25 | 26 | 27 | // Time Complexity:- O(N) 28 | // Space Complexity:- O(1) 29 | -------------------------------------------------------------------------------- /Nth node from end of linked list: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | int getNthFromLast(Node head, int n) 4 | { 5 | // Your code here 6 | Node first=head,second=head; 7 | int c=0; 8 | while(first!=null){ 9 | first=first.next; 10 | c++; 11 | if(c>n)second=second.next; 12 | } 13 | if(cnext; 27 | c++; 28 | if(c>n){ 29 | second=second->next; 30 | } 31 | } 32 | if(cdata; 34 | } 35 | -------------------------------------------------------------------------------- /Number of 1 Bits: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int setBits(int N) { 4 | // Write Your Code here 5 | int ans=0; 6 | while(N){ 7 | if(N&1)ans++; 8 | N>>=1; 9 | } 10 | return ans; 11 | } 12 | 13 | // JAVA CODE 14 | 15 | static int setBits(int N) { 16 | // code here 17 | int ans=0; 18 | while(N!=0){ 19 | if((N&1)==1)ans++; 20 | N>>=1; 21 | } 22 | return ans; 23 | } 24 | -------------------------------------------------------------------------------- /Number of Good Components: -------------------------------------------------------------------------------- 1 | void dfs(int i,int s,vector> &adj,vector &vis,bool &a,int &node){ 2 | vis[i]=1; 3 | node++; 4 | if(s!=adj[i].size()){ 5 | a=false; 6 | } 7 | for(auto x:adj[i]){ 8 | if(!vis[x])dfs(x,s,adj,vis,a,node); 9 | } 10 | } 11 | int findNumberOfGoodComponent(int e, int v, vector> &edges) { 12 | // code here 13 | vector> adj(v+1); 14 | for(auto x:edges){ 15 | adj[x[0]].push_back(x[1]); 16 | adj[x[1]].push_back(x[0]); 17 | } 18 | int ans=0; 19 | vector vis(v+1,0); 20 | for(int i=1;i<=v;i++){ 21 | if(!vis[i]){ 22 | int node=0; 23 | bool a=true; 24 | dfs(i,adj[i].size(),adj,vis,a,node); 25 | if(a and node-1==adj[i].size())ans++; 26 | } 27 | } 28 | return ans; 29 | } 30 | -------------------------------------------------------------------------------- /Number of Subarrays of 0's: -------------------------------------------------------------------------------- 1 | //Java CODE 2 | 3 | long no_of_subarrays(int N, int [] arr) { 4 | //Write your code here 5 | long ans=0,c=0; 6 | for(int i=0;i &arr) { 22 | // Write your code here. 23 | long long int ans=0,c=0; 24 | for(int i=0;i mm; 7 | int j=0; 8 | for(int i=0;i mm = new HashMap<>(); 24 | for(int i=0;i optimalArray(int n,vector &a){ 2 | // Code here 3 | vector ans; 4 | ans.push_back(0); 5 | for(int i=1;i& arr, int k) { 4 | // code here 5 | int ans = 0; 6 | unordered_map mm; 7 | for(int x:arr)mm[x]++; 8 | for(int x:arr)ans+=mm[x+k]; 9 | return ans; 10 | } 11 | 12 | 13 | // JAVA CODE 14 | 15 | int countPairsWithDiffK(int[] arr, int k) { 16 | // code here 17 | int ans = 0; 18 | Map mm = new HashMap<>(); 19 | for(int x:arr)mm.put(x,mm.getOrDefault(x,0)+1); 20 | for(int x:arr)ans+=mm.getOrDefault(x+k,0); 21 | return ans; 22 | } 23 | 24 | 25 | // Time Complexity:- O(N) 26 | // Space Complexity:- O(N) 27 | -------------------------------------------------------------------------------- /Panagram Checking: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | bool checkPangram (string s) { 4 | // your code here 5 | if(s.length()<26)return false; 6 | unordered_map mm; 7 | for(auto x:s){ 8 | if(x>='A' and x<='Z'){ 9 | mm[x-'A']++; 10 | } 11 | else if(x>='a' and x<='z'){ 12 | mm[x-'a']++; 13 | } 14 | } 15 | return mm.size()==26; 16 | } 17 | 18 | // JAVA CODE 19 | 20 | public static boolean checkPangram (String s) { 21 | // your code here 22 | if(s.length()<26)return false; 23 | Map mm = new HashMap<>(); 24 | for(int i=0;i='A' && x<='Z'){ 27 | mm.putIfAbsent(x-'A',1); 28 | } 29 | else if(x>='a' && x<='z'){ 30 | mm.putIfAbsent(x-'a',1); 31 | } 32 | } 33 | return mm.size()==26; 34 | } 35 | -------------------------------------------------------------------------------- /Party of Couples: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int findSingle(int n, int arr[]){ 4 | // code here 5 | int x=0; 6 | for(int i=0;i> &dp){ 5 | if(x==0 and y==0)return 1; 6 | if(x<0 or y<0)return 0; 7 | if(dp[x][y]!=-1)return dp[x][y]; 8 | int a = help(x-1,y,dp); 9 | int b = help(x,y-1,dp); 10 | return dp[x][y] = (a+b)%mod; 11 | } 12 | int ways(int x, int y) 13 | { 14 | //code here. 15 | vector> dp(x+1,vector(y+1,-1)); 16 | return help(x,y,dp); 17 | } 18 | 19 | // JAVA CODE 20 | 21 | static int mod = 1000000007; 22 | static int help(int x,int y,int dp[][]){ 23 | if(x==0 && y==0)return 1; 24 | if(x<0 || y<0)return 0; 25 | if(dp[x][y]!=-1)return dp[x][y]; 26 | int a = help(x-1,y,dp); 27 | int b = help(x,y-1,dp); 28 | return dp[x][y] = (a+b)%mod; 29 | } 30 | public static int ways(int n, int m) 31 | { 32 | // complete the function 33 | int dp[][] = new int[n+1][m+1]; 34 | for(int temp[]:dp)Arrays.fill(temp,-1); 35 | return help(n,m,dp); 36 | } 37 | 38 | // Time Complexity:- O(x*y) 39 | // Space Complexity:- O(x*y) 40 | -------------------------------------------------------------------------------- /Peak element: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int peakElement(int arr[], int n) 4 | { 5 | // Your code here 6 | int start=0,end=n-1,mid; 7 | while(start<=end){ 8 | mid=(start+end)/2; 9 | int prev = mid-1>=0?mid-1:0; 10 | int next = mid+1=arr[prev] and arr[mid]>=arr[next])return mid; 12 | else if(arr[mid]=0?mid-1:0; 28 | int next=mid+1=arr[prev] && arr[mid]>=arr[next])return mid; 30 | else if(arr[mid]right); 8 | root->next=nxt; 9 | nxt=root; 10 | populateNext(root->left); 11 | } 12 | 13 | 14 | // JAVA CODE 15 | 16 | Node nxt=null; 17 | public void populateNext(Node root) { 18 | // code here 19 | if(root==null)return; 20 | populateNext(root.right); 21 | root.next=nxt; 22 | nxt=root; 23 | populateNext(root.left); 24 | } 25 | 26 | 27 | // Time Complexity:- O(N) 28 | // Space Complexity:- O(H) 29 | -------------------------------------------------------------------------------- /Power Of Numbers: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | static int mod = 1000000007; 4 | static long power(int N,int R) 5 | { 6 | //Your code here 7 | if(R==1)return N%mod; 8 | long half = power(N,R/2); 9 | half = (half*half)%mod; 10 | if(R%2==1)half = (half*N)%mod; 11 | return half; 12 | } 13 | 14 | // C++ CODE 15 | 16 | long long power(int N,int R) 17 | { 18 | //Your code here 19 | if(R==1)return N%mod; 20 | long long half = power(N,R/2); 21 | half = (half*half)%mod; 22 | if(R%2==1)half = (half*N)%mod; 23 | return half; 24 | } 25 | -------------------------------------------------------------------------------- /Predecessor and Successor: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static void findPreSuc(Node root, int key) 4 | { 5 | // code here. 6 | Node temp=root; 7 | while(temp!=null){ 8 | if(temp.data>=key)temp=temp.left; 9 | else{ 10 | pre=temp; 11 | temp=temp.right; 12 | } 13 | } 14 | temp=root; 15 | while(temp!=null){ 16 | if(temp.data<=key)temp=temp.right; 17 | else{ 18 | suc=temp; 19 | temp=temp.left; 20 | } 21 | } 22 | } 23 | 24 | 25 | // C++ CODE 26 | 27 | void findPreSuc(Node* root, Node*& pre, Node*& suc, int key) 28 | { 29 | // Your code goes here 30 | Node *temp=root; 31 | while(temp){ 32 | if(temp->key>=key)temp=temp->left; 33 | else{ 34 | pre=temp; 35 | temp=temp->right; 36 | } 37 | } 38 | temp=root; 39 | while(temp){ 40 | if(temp->key<=key)temp=temp->right; 41 | else{ 42 | suc=temp; 43 | temp=temp->left; 44 | } 45 | } 46 | } 47 | 48 | -------------------------------------------------------------------------------- /Prefix match with other strings: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public int klengthpref(String[] arr, int n, int k, String str) 4 | { 5 | // code here 6 | if(k>str.length())return 0; 7 | int ans=0; 8 | for(int i=0;istr.length())return 0; 25 | int ans=0; 26 | for(int i=0;i rev(Queue q){ 4 | //add code here. 5 | Stack st = new Stack<>(); 6 | while(q.size()!=0){ 7 | st.push(q.remove()); 8 | } 9 | while(st.size()!=0){ 10 | q.add(st.peek()); 11 | st.pop(); 12 | } 13 | return q; 14 | } 15 | 16 | // C++ CODE 17 | 18 | queue rev(queue q) 19 | { 20 | // add code here. 21 | stack st; 22 | while(q.size()){ 23 | st.push(q.front()); 24 | q.pop(); 25 | } 26 | while(st.size()){ 27 | q.push(st.top()); 28 | st.pop(); 29 | } 30 | return q; 31 | } 32 | -------------------------------------------------------------------------------- /Recursive Sequence: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long long sequence(int n){ 4 | // code here 5 | long long ans = 1,temp=2,mod=1e9+7; 6 | int i = 2; 7 | while(i<=n){ 8 | int j = i; 9 | long long temp2 = 1; 10 | while(j--){ 11 | temp2*=temp; 12 | temp2%=mod; 13 | temp++; 14 | } 15 | ans+=temp2; 16 | ans%=mod; 17 | i++; 18 | } 19 | return ans; 20 | } 21 | 22 | // JAVA CODE 23 | 24 | static long sequence(int n){ 25 | // code here 26 | long ans = 1,mod = 1000000007,temp=2; 27 | int i=2; 28 | while(i<=n){ 29 | int j = i; 30 | long temp2 = 1; 31 | while(j!=0){ 32 | temp2*=temp; 33 | temp2%=mod; 34 | temp++; 35 | j--; 36 | } 37 | i++; 38 | ans+=temp2; 39 | ans%=mod; 40 | } 41 | return ans; 42 | } 43 | -------------------------------------------------------------------------------- /Remainder on dividing by 11: -------------------------------------------------------------------------------- 1 | //JAVA CODE 2 | 3 | static int xmod11(String x) 4 | { 5 | // code here 6 | int ans = 0; 7 | for(int i=0;i=s.length()-1)return ""; 11 | s=s.substr(i+1); 12 | return s; 13 | } 14 | 15 | 16 | // JAVA CODE 17 | 18 | public String printString(String s, char ch, int count) { 19 | // code here 20 | int i=0; 21 | for(i=0;i=s.length()-1)return ""; 26 | s=s.substring(i+1); 27 | return s; 28 | } 29 | 30 | 31 | // Time Complexity:- O(|S|) 32 | // Space Complexity:- O(1) 33 | -------------------------------------------------------------------------------- /Remove Duplicates: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | string removeDups(string str) { 4 | // Your code goes here 5 | string ans=""; 6 | bool temp[26]; 7 | for(auto x:str){ 8 | if(!temp[x-'a']){ 9 | ans+=x; 10 | temp[x-'a']=true; 11 | } 12 | } 13 | return ans; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | String removeDups(String str) { 20 | // code here 21 | StringBuilder ans = new StringBuilder(); 22 | boolean temp[]=new boolean[26]; 23 | for(int i=0;ileft = RemoveHalfNodes(root->left); 7 | root->right = RemoveHalfNodes(root->right); 8 | if(!root->left and root->right)return root->right; 9 | if(root->left and !root->right)return root->left; 10 | return root; 11 | } 12 | 13 | 14 | // JAVA CODE 15 | 16 | public Node RemoveHalfNodes(Node root) { 17 | // Code Here 18 | if(root==null)return null; 19 | root.left = RemoveHalfNodes(root.left); 20 | root.right = RemoveHalfNodes(root.right); 21 | if(root.left==null && root.right!=null)return root.right; 22 | if(root.left!=null && root.right==null)return root.left; 23 | return root; 24 | } 25 | 26 | 27 | // Time Complexity:- O(N) 28 | // Space Complexity:- (H) 29 | -------------------------------------------------------------------------------- /Remove all duplicates from a given string: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | string removeDuplicates(string str) { 4 | // code here 5 | string ans = ""; 6 | unordered_map mm; 7 | for(auto x:str){ 8 | if(!mm[x])ans+=x; 9 | mm[x]++; 10 | } 11 | return ans; 12 | } 13 | 14 | // JAVA CODE 15 | 16 | String removeDuplicates(String str) { 17 | StringBuilder ans = new StringBuilder(); 18 | HashMap mm = new HashMap<>(); 19 | for(int i=0;i removeDuplicate(vector& arr) { 4 | // code here 5 | int mm[101]={0}; 6 | vector ans; 7 | for(int x:arr){ 8 | if(!mm[x]){ 9 | ans.push_back(x); 10 | mm[x]=1; 11 | } 12 | } 13 | return ans; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | ArrayList removeDuplicate(int arr[]) { 20 | // code here 21 | int mm[] = new int[101]; 22 | Arrays.fill(mm,0); 23 | ArrayList ans = new ArrayList<>(); 24 | for(int x:arr){ 25 | if(mm[x]==0){ 26 | ans.add(x); 27 | mm[x]=1; 28 | } 29 | } 30 | return ans; 31 | } 32 | 33 | 34 | // Time Complexity:- O(N) 35 | // Space Complexity:- O(1) 36 | -------------------------------------------------------------------------------- /Remove every kth node: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | Node* deleteK(Node *head,int K){ 4 | //Your code here 5 | if(K==1)return NULL; 6 | Node *temp=head,*prev=NULL; 7 | int c=1; 8 | while(temp){ 9 | if(c==K){ 10 | prev->next=temp->next; 11 | c=0; 12 | } 13 | else prev=temp; 14 | c++; 15 | temp=temp->next; 16 | } 17 | return head; 18 | } 19 | 20 | // JAVA CODE 21 | 22 | Node delete(Node head, int k) 23 | { 24 | // Your code here 25 | if(k==1)return null; 26 | Node temp=head,prev=null; 27 | int c=1; 28 | while(temp!=null){ 29 | if(c==k){ 30 | c=0; 31 | prev.next=temp.next; 32 | } 33 | else prev=temp; 34 | c++; 35 | temp=temp.next; 36 | } 37 | return head; 38 | } 39 | 40 | // Time Complexity:- O(N) 41 | // Space Complexity:- O(1) 42 | -------------------------------------------------------------------------------- /Remove the balls: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static int finLength(int N, int[] color, int[] radius) { 4 | // code here 5 | Stack st = new Stack<>(); 6 | for(int i=0;i color, vector radius) { 21 | stack st; 22 | for(int i=0;i>=1; 10 | } 11 | return ans; 12 | } 13 | 14 | // JAVA CODE 15 | 16 | static Long reversedBits(Long x) { 17 | // code here 18 | long ans = 0,i=31; 19 | while(x!=0){ 20 | ans+=(long)Math.pow(2,i)*(x&1); 21 | x>>=1; 22 | i--; 23 | } 24 | return ans; 25 | } 26 | 27 | // Time Complexity:- O(log(N)) 28 | // Space Complexity:- O(1) 29 | -------------------------------------------------------------------------------- /Reverse Coding: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | static int sumOfNaturals(int n) { 3 | // code here 4 | int mod = 1000000007; 5 | long ans=(((long)n*(n+1))/2)%mod; 6 | return (int)ans; 7 | } 8 | 9 | // C++ CODE 10 | 11 | int sumOfNaturals(int n) { 12 | // code here 13 | int mod = 1e9+7; 14 | return (((long long)n*(n+1))/2)%mod; 15 | } 16 | -------------------------------------------------------------------------------- /Reverse First K Elements of Queue: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | queue modifyQueue(queue q, int k) { 4 | // add code here. 5 | stack st; 6 | for(int i=0;i modifyQueue(Queue q, int k) { 26 | // add code here. 27 | Stack st = new Stack<>(); 28 | for(int i=0;i reverseLevelOrder(Node *root) 4 | { 5 | // code here 6 | queue q; 7 | vector ans; 8 | q.push(root); 9 | while(q.size()){ 10 | Node *temp = q.front(); 11 | q.pop(); 12 | ans.push_back(temp->data); 13 | if(temp->right)q.push(temp->right); 14 | if(temp->left)q.push(temp->left); 15 | } 16 | reverse(ans.begin(),ans.end()); 17 | return ans; 18 | } 19 | 20 | // JAVA CODE 21 | 22 | public ArrayList reverseLevelOrder(Node node) 23 | { 24 | // code here 25 | ArrayList ans = new ArrayList<>(); 26 | Queue q = new LinkedList<>(); 27 | q.add(node); 28 | while(q.size()!=0){ 29 | Node temp=q.remove(); 30 | ans.add(temp.data); 31 | if(temp.right!=null)q.add(temp.right); 32 | if(temp.left!=null)q.add(temp.left); 33 | } 34 | Collections.reverse(ans); 35 | return ans; 36 | } 37 | 38 | // Time Complexity:- O(N) 39 | // Space Complexity:- O(N) 40 | -------------------------------------------------------------------------------- /Reverse a linked list: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | Node* reverseList(struct Node* head) { 4 | // code here 5 | Node *prev=NULL,*nxt=NULL,*cur=head; 6 | while(cur){ 7 | nxt=cur->next; 8 | cur->next=prev; 9 | prev=cur; 10 | cur=nxt; 11 | } 12 | return prev; 13 | } 14 | 15 | 16 | // JAVA CODE 17 | 18 | Node reverseList(Node head) { 19 | // code here 20 | Node nxt=null,prev=null,cur=head; 21 | while(cur!=null) 22 | { 23 | nxt=cur.next; 24 | cur.next=prev; 25 | prev=cur; 26 | cur=nxt; 27 | } 28 | return prev; 29 | } 30 | 31 | 32 | // Time Complexity:- O(N) 33 | // Space Complexity:- O(1) 34 | -------------------------------------------------------------------------------- /Reverse both parts: -------------------------------------------------------------------------------- 1 | Node *reverse(Node *head, int k) 2 | { 3 | // code here 4 | Node *curr=head,*prev=NULL,*agli; 5 | int node=0; 6 | while(curr){ 7 | node++; 8 | agli = curr->next; 9 | curr->next = prev; 10 | prev = curr; 11 | curr=agli; 12 | } 13 | node=node-k-1; 14 | Node *temp = prev; 15 | while(node--){ 16 | temp=temp->next; 17 | } 18 | head->next=prev; 19 | head=temp->next; 20 | temp->next=NULL; 21 | return head; 22 | } 23 | -------------------------------------------------------------------------------- /Right View of Binary Tree: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | int taken=0; 4 | void help(Node node,int cur,ArrayList ans){ 5 | if(node==null)return; 6 | if(taken rightView(Node node) { 15 | //add code here. 16 | ArrayList ans = new ArrayList<>(); 17 | int cur=1; 18 | help(node,cur,ans); 19 | return ans; 20 | } 21 | 22 | // C++ CODE 23 | 24 | void help(Node* root,int cur,int &taken,vector &ans){ 25 | if(!root)return; 26 | if(takendata); 28 | taken++; 29 | } 30 | cur++; 31 | help(root->right,cur,taken,ans); 32 | help(root->left,cur,taken,ans); 33 | } 34 | vector rightView(Node *root) 35 | { 36 | // Your Code here 37 | vector ans; 38 | int cur=1,taken=0; 39 | help(root,cur,taken,ans); 40 | return ans; 41 | } 42 | -------------------------------------------------------------------------------- /Rightmost different bit: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int posOfRightMostDiffBit(int m, int n) 4 | { 5 | // Your code here 6 | int a=0,b=0,pos=0; 7 | while(m || n){ 8 | pos++; 9 | if(m){ 10 | a=m&1; 11 | m>>=1; 12 | } 13 | if(n){ 14 | b=n&1; 15 | n>>=1; 16 | } 17 | if(a!=b)return pos; 18 | a=0; 19 | b=0; 20 | } 21 | return -1; 22 | } 23 | 24 | // JAVA CODE 25 | 26 | public static int posOfRightMostDiffBit(int m, int n) 27 | { 28 | // Your code here 29 | int a=0,b=0,pos=0; 30 | while(m!=0 || n!=0){ 31 | pos++; 32 | if(m!=0){ 33 | a=m&1; 34 | m>>=1; 35 | } 36 | if(n!=0){ 37 | b=n&1; 38 | n>>=1; 39 | } 40 | if(a!=b)return pos; 41 | a=0; 42 | b=0; 43 | } 44 | return -1; 45 | } 46 | -------------------------------------------------------------------------------- /Rohan's Love for Matrix: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int firstElement(int n) { 4 | // code here 5 | if(n==1 or n==2)return 1; 6 | int a=1,b=1,ans=0,mod=1e9+7; 7 | for(int i=3;i<=n;i++){ 8 | ans=(a+b)%mod; 9 | a=b; 10 | b=ans; 11 | } 12 | return ans; 13 | } 14 | 15 | 16 | // JAVA CODE 17 | 18 | static int firstElement(int n) { 19 | // code here 20 | if(n==1 || n==2)return 1; 21 | int a=1,b=1,ans=0,mod=1000000007; 22 | for(int i=3;i<=n;i++){ 23 | ans=(a+b)%mod; 24 | a=b; 25 | b=ans; 26 | } 27 | return ans; 28 | } 29 | 30 | 31 | // Time Complexity:- O(N) 32 | // Space Complexity:- O(1) 33 | -------------------------------------------------------------------------------- /Roof Top: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int maxStep(vector& arr) { 4 | // Your code here 5 | int ans = 0, increaseCount = 0; 6 | for(int i=1;iarr[i-1])increaseCount++; 8 | else{ 9 | ans=max(ans,increaseCount); 10 | increaseCount=0; 11 | } 12 | } 13 | ans=max(ans,increaseCount); 14 | return ans; 15 | } 16 | 17 | 18 | // JAVA CODE 19 | 20 | public int maxStep(int arr[]) { 21 | // Your code here 22 | int ans = 0,increaseCount = 0; 23 | for(int i=1;iarr[i-1])increaseCount++; 25 | else{ 26 | ans=Math.max(ans,increaseCount); 27 | increaseCount=0; 28 | } 29 | } 30 | ans=Math.max(ans,increaseCount); 31 | return ans; 32 | } 33 | 34 | // Time Complexity:- O(N) 35 | // Space Complexity:- O(1) 36 | -------------------------------------------------------------------------------- /Root to leaf paths sum: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int help(Node *root,int num){ 4 | if(!root)return 0; 5 | num = num*10+root->data; 6 | if(!root->left && !root->right)return num; 7 | return help(root->left,num)+help(root->right,num); 8 | } 9 | int treePathsSum(Node *root) { 10 | // code here. 11 | return help(root,0); 12 | } 13 | 14 | 15 | // JAVA CODE 16 | 17 | public static int help(Node root,int num){ 18 | if(root==null)return 0; 19 | num = num*10+root.data; 20 | if(root.left==null && root.right==null)return num; 21 | return help(root.left,num)+help(root.right,num); 22 | } 23 | public static int treePathsSum(Node root) { 24 | // add code here. 25 | return help(root,0); 26 | } 27 | 28 | 29 | // Time Complexity:- O(N) 30 | // Space Complexity:- O(H) 31 | -------------------------------------------------------------------------------- /Rotate Array: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void rev(vector &arr,int i,int j){ 4 | while(i& arr, int d) { 12 | // code here 13 | int n = arr.size(); 14 | d=d%n; 15 | rev(arr,0,d-1); 16 | rev(arr,d,n-1); 17 | rev(arr,0,n-1); 18 | } 19 | 20 | 21 | // JAVA CODE 22 | 23 | static void rev(int arr[],int i,int j){ 24 | while(i &arr) { 4 | // Your code here 5 | int n = arr.size(), temp = n/2; 6 | int i = 3*(temp/2); 7 | if(temp%2)i++; 8 | return arr[n-i]; 9 | } 10 | 11 | 12 | // JAVA CODE 13 | 14 | public static int rotateDelete(ArrayList arr) { 15 | // code here 16 | int n = arr.size(), temp = n/2; 17 | int i = 3*(temp/2); 18 | if(temp%2==1)i++; 19 | return arr.get(n-i); 20 | } 21 | 22 | 23 | // Time Complexity:- O(1) 24 | // Space Complexity:- O(1) 25 | -------------------------------------------------------------------------------- /Rotate by 90 degree: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void rotate(vector >& matrix) { 4 | // Your code goes here 5 | int n = matrix[0].size(); 6 | for(int i=0;i > &arr) { 4 | // code here 5 | int i=0,j=arr[0].size()-1,ans=-1; 6 | while(i=0){ 7 | if(!arr[i][j]){ 8 | i++; 9 | } 10 | else{ 11 | ans=i; 12 | j--; 13 | } 14 | } 15 | return ans; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | public int rowWithMax1s(int arr[][]) { 22 | // code here 23 | int i=0,j=arr[0].length-1,ans=-1; 24 | while(i=0){ 25 | if(arr[i][j]==0){ 26 | i++; 27 | } 28 | else{ 29 | ans=i; 30 | j--; 31 | } 32 | } 33 | return ans; 34 | } 35 | 36 | 37 | // Time Complexity:- O(N+M) 38 | // Space Complexity:- O(1) 39 | -------------------------------------------------------------------------------- /Row with minimum number of 1's: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int minRow(int n, int m, vector> a) { 4 | // code here 5 | int ans=-1,mn=INT_MAX,one=0; 6 | for(int i=0;i mm; 2 | bool isScramble(string S1, string S2){ 3 | //code here 4 | if(S1==S2)return true; 5 | if(mm.find(S1+S2)!=mm.end())return mm[S1+S2]; 6 | int n = S1.length(); 7 | string temp =""; 8 | for(int i=0;i> &mat, int x) { 4 | // your code here 5 | int i=0,j=mat[0].size()-1,n=mat.size(); 6 | while(i=0){ 7 | int temp = mat[i][j]; 8 | if(temp==x)return true; 9 | else if(temp=0){ 22 | int temp=mat[i][j]; 23 | if(temp==x)return true; 24 | else if(temp> &mat, int x) { 4 | // code here 5 | int n=mat.size(),m=mat[0].size(),low=0,high=n*m-1,mid=0; 6 | while(low<=high){ 7 | mid=(low+high)/2; 8 | int temp=mat[mid/m][mid%m]; 9 | if(temp==x)return true; 10 | else if(temp &arr) { 4 | // Code Here 5 | int mx1=INT_MIN,mx2=INT_MIN; 6 | for(int x:arr){ 7 | if(x>mx1){ 8 | mx2=mx1; 9 | mx1=x; 10 | } 11 | else if(x>mx2 && x!=mx1)mx2=x; 12 | } 13 | return mx2!=INT_MIN?mx2:-1; 14 | } 15 | 16 | // JAVA CODE 17 | 18 | public int getSecondLargest(int[] arr) { 19 | // Code Here 20 | int mx1=Integer.MIN_VALUE,mx2=Integer.MIN_VALUE; 21 | for(int x:arr){ 22 | if(x>mx1){ 23 | mx2=mx1; 24 | mx1=x; 25 | } 26 | else if(x>mx2 && x!=mx1)mx2=x; 27 | } 28 | return mx2!=Integer.MIN_VALUE?mx2:-1; 29 | } 30 | 31 | 32 | // Time Complexity:- O(N) 33 | // Space Complexity:- O(1) 34 | -------------------------------------------------------------------------------- /Segregate 0s and 1s: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void segregate0and1(vector &arr) { 4 | // code here 5 | int zero=0,one=arr.size()-1; 6 | while(zero adj[],int node,vector &vis,int &ans){ 2 | if(vis[node])return 0; 3 | vis[node]=1; 4 | int kamkarnahai=0; 5 | for(auto x:adj[node]){ 6 | if(!vis[x]){ 7 | int temp = dfs(adj,x,vis,ans); 8 | if(temp==0){ 9 | kamkarnahai=1; 10 | } 11 | } 12 | } 13 | if(kamkarnahai)ans++; 14 | return kamkarnahai; 15 | } 16 | int countVertex(int N, vector>edges){ 17 | // code here 18 | vector adj[N+1]; 19 | vector vis(N+1,0); 20 | for(auto x:edges){ 21 | adj[x[0]].push_back(x[1]); 22 | adj[x[1]].push_back(x[0]); 23 | } 24 | int ans=0; 25 | dfs(adj,1,vis,ans); 26 | return ans; 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Sequence of Sequence: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int numberSequence(int m, int n){ 4 | // code here 5 | if(m==0 || n==1)return m; 6 | int ans = 0; 7 | for(int i=m;i>=1;i--){ 8 | ans+=numberSequence(i/2,n-1); 9 | } 10 | return ans; 11 | } 12 | 13 | // JAVA CODE 14 | 15 | static int numberSequence(int m, int n) 16 | { 17 | // code here 18 | if(m==0 || n==1)return m; 19 | int ans=0; 20 | for(int i=m;i>=1;i--){ 21 | ans+=numberSequence(i/2,n-1); 22 | } 23 | return ans; 24 | } 25 | -------------------------------------------------------------------------------- /Single Number: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int getSingle(vector& arr) { 4 | // code here 5 | int ans = 0; 6 | for(int x:arr)ans^=x; 7 | return ans; 8 | } 9 | 10 | 11 | // JAVA CODE 12 | 13 | int getSingle(int arr[]) { 14 | // code here 15 | int ans = 0; 16 | for(int x:arr)ans^=x; 17 | return ans; 18 | } 19 | 20 | 21 | // Time Complexity:- O(N) 22 | // Space Complexity:- o(1) 23 | -------------------------------------------------------------------------------- /Single valued subtree: -------------------------------------------------------------------------------- 1 | int help(Node* root,int &ans){ 2 | if(!root)return -1; 3 | int l = help(root->left,ans); 4 | int r = help(root->right,ans); 5 | if((l==-1 and r==-1) or (root->data==l and r==-1) or (root->data==r and l==-1) 6 | or (root->data==l and root->data==r)){ 7 | ans++; 8 | return root->data; 9 | } 10 | return -2; 11 | } 12 | int singlevalued(Node *root) 13 | { 14 | //code here 15 | int ans =0; 16 | int t = help(root,ans); 17 | return ans; 18 | } 19 | -------------------------------------------------------------------------------- /Smallest Positive missing number: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | static int missingNumber(int arr[], int size) 4 | { 5 | // Your code here 6 | int i=0,temp=0; 7 | while(i0 && arr[i]<=size && arr[i]!=arr[arr[i]-1]){ 9 | temp = arr[i]; 10 | arr[i]=arr[arr[i]-1]; 11 | arr[temp-1]=temp; 12 | } 13 | else i++; 14 | } 15 | for(i=0;i0 and arr[i]<=n and arr[i]!=arr[arr[i]-1]){ 29 | swap(arr[i],arr[arr[i]-1]); 30 | } 31 | else i++; 32 | } 33 | for(int i=0;i9)return "-1"; 11 | ans+=(num+'0'); 12 | i++; 13 | s-=num; 14 | } 15 | return ans; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | public String smallestNumber(int s, int d) { 22 | // code here 23 | StringBuilder ans = new StringBuilder(); 24 | int i=1; 25 | while(i<=d){ 26 | int num = s-(d-i)*9<=0?0:s-(d-i)*9; 27 | if(num>9)return "-1"; 28 | if(i==1 && num==0)num=1; 29 | ans.append((char)(num+'0')); 30 | s-=num; 31 | i++; 32 | } 33 | return ans.toString(); 34 | } 35 | 36 | 37 | // Time Complexity:- O(d) 38 | // Space Complexity:- O(d) 39 | -------------------------------------------------------------------------------- /Sorted and Rotated Minimum: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int findMin(vector& arr) { 4 | // complete the function here 5 | int n=arr.size(),low=0,high=n-1,mid=0; 6 | while(low& arr) { 4 | // code here 5 | int sum = 0, firstSum = 0; 6 | for(auto x:arr)sum+=x; 7 | for(auto x:arr){ 8 | sum-=x; 9 | firstSum+=x; 10 | if(sum==firstSum)return true; 11 | } 12 | return false; 13 | } 14 | 15 | 16 | // JAVA CODE 17 | 18 | public boolean canSplit(int arr[]) { 19 | // code here 20 | int sum = 0,firstSum=0; 21 | for(int x:arr)sum+=x; 22 | for(int x:arr){ 23 | sum-=x; 24 | firstSum+=x; 25 | if(firstSum==sum)return true; 26 | } 27 | return false; 28 | } 29 | 30 | 31 | // Time Complexity:- O(N) 32 | // Space Complexity:- O(1) 33 | -------------------------------------------------------------------------------- /Square root of a number: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long long int floorSqrt(long long int n) { 4 | // Your code goes here 5 | long long int low=1,high=n,mid=0,ans=1; 6 | while(low<=high){ 7 | mid=(low+high)/2; 8 | if(mid*mid==n)return mid; 9 | else if(mid*mid &prices) { 4 | // code here 5 | int n=prices.size(),buy=prices[0],profit=0; 6 | for(int i=1;i &prices) { 4 | // code here 5 | int ans=0,n=prices.size(); 6 | for(int i=1;iprices[i-1]){ 8 | ans+=prices[i]-prices[i-1]; 9 | } 10 | } 11 | return ans; 12 | } 13 | 14 | 15 | // JAVA CODE 16 | 17 | public int maximumProfit(int prices[]) { 18 | // code here 19 | int ans=0,n=prices.length; 20 | for(int i=1;iprices[i-1]){ 22 | ans+=prices[i]-prices[i-1]; 23 | } 24 | } 25 | return ans; 26 | } 27 | 28 | 29 | // Time Complexity:- O(N) 30 | // Space Complexity:- O(1) 31 | -------------------------------------------------------------------------------- /Strictly Increasing Array: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int min_operations(vector& nums) { 4 | // Code here 5 | int n = nums.size(),temp=1; 6 | vector dp(n,1); 7 | for(int i=0;i=i-j){ 10 | dp[i]=max(dp[i],dp[j]+1); 11 | temp=max(dp[i],temp); 12 | } 13 | } 14 | } 15 | return n-temp; 16 | } 17 | 18 | // JAVA CODE 19 | 20 | public int min_operations(int []nums) 21 | { 22 | // Code here 23 | int n=nums.length,temp=1; 24 | int dp[]=new int[n]; 25 | Arrays.fill(dp,1); 26 | for(int i=0;i=i-j){ 29 | dp[i]=Math.max(dp[i],dp[j]+1); 30 | temp=Math.max(dp[i],temp); 31 | } 32 | } 33 | } 34 | return n-temp; 35 | } 36 | 37 | // Time Complexity:- O(N^2) 38 | // Space Complexity:- O(N) 39 | -------------------------------------------------------------------------------- /String Mirror: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | string stringMirror(string str){ 4 | // Code here 5 | string temp=""; 6 | temp+=str[0]; 7 | for(int i=1;i& arr, int tar) { 4 | // Your code here 5 | unordered_map mm; 6 | int ans=0,sum=0; 7 | for(int x:arr){ 8 | sum+=x; 9 | if(sum==tar)ans++; 10 | if(mm.find(sum - tar) != mm.end())ans+=mm[sum-tar]; 11 | mm[sum]++; 12 | } 13 | return ans; 14 | } 15 | 16 | 17 | // JAVA CODE 18 | 19 | static int subArraySum(int arr[], int tar) { 20 | // add your code here 21 | Map mm = new HashMap<>(); 22 | int ans=0,sum=0; 23 | for(int x:arr){ 24 | sum+=x; 25 | if(sum==tar)ans++; 26 | if(mm.get(sum-tar)!=null)ans+=mm.get(sum-tar); 27 | mm.put(sum,mm.getOrDefault(sum,0)+1); 28 | } 29 | return ans; 30 | } 31 | 32 | // Time Complexity:- O(N) 33 | // Space Complexity:- O(N) 34 | -------------------------------------------------------------------------------- /Subarrays with sum K: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int countSubarrays(vector &arr, int k) { 4 | // code here 5 | int sum=0,ans=0; 6 | unordered_map mm; 7 | for(int x:arr){ 8 | sum+=x; 9 | if(sum==k)ans++; 10 | ans+=mm[sum-k]; 11 | mm[sum]++; 12 | } 13 | return ans; 14 | } 15 | 16 | // JAVA CODE 17 | 18 | public int countSubarrays(int arr[], int k) { 19 | // code here 20 | int sum=0,ans=0; 21 | HashMap mm = new HashMap<>(); 22 | for(int x:arr){ 23 | sum+=x; 24 | if(sum==k)ans++; 25 | ans+=mm.getOrDefault(sum-k,0); 26 | mm.put(sum,mm.getOrDefault(sum,0)+1); 27 | } 28 | return ans; 29 | } 30 | 31 | 32 | // Time Complexity:- O(N) 33 | // Space Complexity:- O(N) 34 | -------------------------------------------------------------------------------- /Sum of all substrings of a number: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | long long sumSubstrings(string s){ 4 | 5 | // your code here 6 | long long ans = 0,previous=0,mod=1e9+7; 7 | for(int i=0;i>4); 6 | } 7 | 8 | // JAVA CODE 9 | 10 | static int swapNibbles(int n) { 11 | // code here 12 | return (n&0x0F)<<4|(n>>4); 13 | } 14 | 15 | // Time Complexity:- O(1) 16 | // Space Complexity:- O(1) 17 | -------------------------------------------------------------------------------- /Taxi Booking: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int minimumTime(int N,int cur,vector &pos,vector &time){ 4 | int ans = INT_MAX; 5 | for(int i=0;i=0;i--){ 13 | right[i]=Math.min(right[i+1],A[i]); 14 | } 15 | int ans=0; 16 | for(int i=1;i=K)ans++; 18 | } 19 | return ans; 20 | } 21 | 22 | //C++ CODE 23 | 24 | int totalCuts(int N,int K,vector &A){ 25 | // Code here 26 | int left[N],right[N]; 27 | left[0]=A[0]; 28 | for(int i=1;i=0;i--){ 33 | right[i]=min(right[i+1],A[i]); 34 | } 35 | int ans=0; 36 | for(int i=1;i=K)ans++; 38 | } 39 | return ans; 40 | } 41 | -------------------------------------------------------------------------------- /Total Decoding Messages: -------------------------------------------------------------------------------- 1 | const long mod = 1e9+7; 2 | class Solution { 3 | public: 4 | int help(string str,int i,int n,vector &dp){ 5 | if(i>=n)return 1; 6 | if(dp[i]!=-1)return dp[i]%mod; 7 | if(str[i]=='0')return 0; 8 | int a = 0,b=0; 9 | a = help(str,i+1,n,dp); 10 | if(i!=n-1 and ((str[i]=='1') or (str[i]=='2' and str[i+1]<='6'))) 11 | b = help(str,i+2,n,dp); 12 | return dp[i] = (a+b)%mod; 13 | } 14 | int CountWays(string str){ 15 | // Code here 16 | int n = str.length(); 17 | vector dp(n,-1); 18 | return help(str,0,n,dp); 19 | } 20 | 21 | }; 22 | -------------------------------------------------------------------------------- /Total count: -------------------------------------------------------------------------------- 1 | //C++ CODE 2 | 3 | int totalCount(int k, vector& arr) { 4 | // code here 5 | int ans = 0; 6 | for(auto x : arr) { 7 | ans += (x + k - 1) / k; 8 | } 9 | return ans; 10 | } 11 | 12 | 13 | // JAVA CODE 14 | 15 | int totalCount(int k, int[] arr) { 16 | // code here 17 | int ans = 0; 18 | for(int x : arr) { 19 | ans += (x + k - 1) / k; 20 | } 21 | return ans; 22 | } 23 | 24 | 25 | // Time Complexity:- O(N) 26 | // Space Complexity:- O(1) 27 | -------------------------------------------------------------------------------- /Trail of ones: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | int numberOfConsecutiveOnes(int n) { 4 | // code here 5 | if(n==2)return 1; 6 | int a=0,b=1,ans=1,mod=1e9+7; 7 | for(int i=3;i<=n;i++){ 8 | int c = (a+b)%mod; 9 | a=b; 10 | b=c; 11 | ans=((ans*2)%mod+c)%mod; 12 | } 13 | return ans; 14 | } 15 | 16 | // JAVA CODE 17 | 18 | static int numberOfConsecutiveOnes(int n) { 19 | // code here \ 20 | if(n==2)return 1; 21 | int ans=1,a=0,b=1,mod=1000000007; 22 | for(int i=3;i<=n;i++){ 23 | int c=(a+b)%mod; 24 | a=b; 25 | b=c; 26 | ans=((ans*2)%mod+c)%mod; 27 | } 28 | return ans; 29 | } 30 | 31 | 32 | // Time Complexity:- O(N) 33 | // Space Complexity:- O(1) 34 | -------------------------------------------------------------------------------- /Transform to Sum Tree: -------------------------------------------------------------------------------- 1 | int help(Node *node){ 2 | if(!node)return 0; 3 | int l = help(node->left); 4 | int r = help(node->right); 5 | int temp=node->data; 6 | node->data=l+r; 7 | return temp+l+r; 8 | 9 | } 10 | void toSumTree(Node *node) 11 | { 12 | // Your code here 13 | int t = help(node); 14 | } 15 | -------------------------------------------------------------------------------- /Transpose of Matrix: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public void transpose(int n,int a[][]) 4 | { 5 | int temp=0; 6 | for(int i=0;i >& matrix, int n) 18 | { 19 | // code here 20 | for(int i=0;i p){ 21 | // code here 22 | vector temp(N,0); 23 | for(int i=1;i& arr) { 4 | // Your code 5 | sort(arr.begin(),arr.end()); 6 | int n=arr.size(); 7 | if (n < 3) return false; 8 | for(int i=n-1;i>=2;i--){ 9 | int j=i-1,k=0; 10 | while(karr[i])j--; 14 | else k++; 15 | } 16 | } 17 | return false; 18 | } 19 | 20 | 21 | // JAVA CODE 22 | 23 | public boolean findTriplet(int[] arr) { 24 | int n = arr.length; 25 | if(n<3)return false; 26 | Arrays.sort(arr); 27 | for(int i=n-1;i>=2;i--){ 28 | int j=i-1,k=0; 29 | while(k& arr, int target) { 4 | // code here 5 | unordered_map mm; 6 | for(int x:arr){ 7 | if(mm[target-x])return true; 8 | mm[x]=1; 9 | } 10 | return false; 11 | } 12 | 13 | // JAVA CODE 14 | 15 | boolean twoSum(int arr[], int target) { 16 | // code here 17 | HashMap mm = new HashMap<>(); 18 | for(int x:arr){ 19 | if(mm.get(target-x)!=null)return true; 20 | mm.put(x,1); 21 | } 22 | return false; 23 | } 24 | 25 | 26 | // Time Complexity:- O(N) 27 | // Space Complexity:- O(N) 28 | -------------------------------------------------------------------------------- /Two Swaps: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | bool checkSorted(vector &arr) { 4 | // code here. 5 | int count=0; 6 | for(int i=0;i2)return false; 13 | } 14 | return count==2|count==0; 15 | } 16 | 17 | 18 | // JAVA CODE 19 | 20 | public boolean checkSorted(List arr) { 21 | // code here 22 | int count=0; 23 | for(int i=0;i2)return false; 32 | } 33 | return count==2|count==0; 34 | } 35 | 36 | 37 | // Time Complexity:- O(N) 38 | // Space Complexity:- O(1) 39 | -------------------------------------------------------------------------------- /Type it!: -------------------------------------------------------------------------------- 1 | int minOperation(string s) { 2 | // code here 3 | int mx=0,ans=s.length(); 4 | for(int i=0;i& a, vector& b) { 4 | // code here 5 | int ans=0; 6 | unordered_map mm; 7 | for(int x:a){ 8 | if(!mm[x])ans++; 9 | mm[x]=1; 10 | } 11 | for(int x:b){ 12 | if(!mm[x])ans++; 13 | mm[x]=1; 14 | } 15 | return ans; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | public static int findUnion(int a[], int b[]) { 22 | // code here 23 | int ans=0; 24 | HashMap mm = new HashMap<>(); 25 | for(int x:a){ 26 | if(mm.get(x)==null)ans++; 27 | mm.put(x,1); 28 | } 29 | for(int x:b){ 30 | if(mm.get(x)==null)ans++; 31 | mm.put(x,1); 32 | } 33 | return ans; 34 | } 35 | 36 | 37 | // Time Complexity:- O(N+M) 38 | // Space Complexity:- O(N+M) 39 | -------------------------------------------------------------------------------- /Unique Number of Occurrences: -------------------------------------------------------------------------------- 1 | // JAVA CODE 2 | 3 | public static boolean isFrequencyUnique(int n, int[] arr) { 4 | // code here 5 | HashMap mm = new HashMap<>(); 6 | HashMap mm2 = new HashMap<>(); 7 | for(int x:arr){ 8 | mm.putIfAbsent(x,0); 9 | mm.put(x,mm.get(x)+1); 10 | } 11 | for(Map.Entry x:mm.entrySet()){ 12 | if(mm2.get(x.getValue())!=null)return false; 13 | mm2.put(x.getValue(),1); 14 | } 15 | return true; 16 | } 17 | 18 | // C++ CODE 19 | 20 | bool isFrequencyUnique(int n, int arr[]) 21 | { 22 | unordered_map mm,mm2; 23 | for(int i=0;i> &grid) { 2 | // code here 3 | if(!grid[0][0])return 0; 4 | int mod = 1e9+7; 5 | vector> ans(n+1,vector(m+1,0)); 6 | ans[1][1]=1; 7 | for(int i=1;i<=n;i++){ 8 | for(int j=1;j<=m;j++){ 9 | if(i==1 and j==1)continue; 10 | if(grid[i-1][j-1]){ 11 | ans[i][j]=(ans[i-1][j]+ans[i][j-1])%mod; 12 | } 13 | } 14 | } 15 | return ans[n][m]; 16 | } 17 | -------------------------------------------------------------------------------- /Valid Compressed String: -------------------------------------------------------------------------------- 1 | int checkCompressed(string S, string T) { 2 | // code here 3 | int num=0,j=0; 4 | for(int i=0;i=S.length() or S[j]!=T[i])return 0; 14 | j++; 15 | } 16 | } 17 | j+=num; 18 | if(j!=S.length())return 0; 19 | return 1; 20 | } 21 | -------------------------------------------------------------------------------- /Vertical Width of a Binary Tree: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void help(Node *root,int &mn,int &mx,int pos){ 4 | if(!root)return; 5 | mn=min(mn,pos); 6 | mx=max(mx,pos); 7 | help(root->left,mn,mx,pos-1); 8 | help(root->right,mn,mx,pos+1); 9 | } 10 | int verticalWidth(Node* root) { 11 | // code here 12 | if(!root)return 0; 13 | int mn=0,mx=0; 14 | help(root,mn,mx,0); 15 | return mx+abs(mn)+1; 16 | } 17 | 18 | 19 | // JAVA CODE 20 | 21 | static int mn=0,mx=0; 22 | void help(Node root,int pos){ 23 | if(root==null)return; 24 | mn=Math.min(mn,pos); 25 | mx=Math.max(mx,pos); 26 | help(root.left,pos-1); 27 | help(root.right,pos+1); 28 | } 29 | public int verticalWidth(Node root) { 30 | // code here. 31 | if(root==null)return 0; 32 | mn=0; 33 | mx=0; 34 | help(root,0); 35 | return mx+Math.abs(mn)+1; 36 | } 37 | 38 | 39 | // Time Complexity:- O(N) 40 | // Space Complexity:- O(H) 41 | -------------------------------------------------------------------------------- /Wine Buying and Selling: -------------------------------------------------------------------------------- 1 | long long int wineSelling(vector& Arr, int N){ 2 | //Code here. 3 | long long int sum=0,ans=0; 4 | for(int i=0;inpx = head; 7 | if(head)head->npx = XOR(temp,head->npx); 8 | return temp; 9 | } 10 | 11 | vector getList(struct Node *head) { 12 | // Code here 13 | vector ans; 14 | Node *curr=head,*prev=NULL,*nxt=NULL; 15 | while(curr){ 16 | ans.push_back(curr->data); 17 | nxt = XOR(prev,curr->npx); 18 | prev=curr; 19 | curr=nxt; 20 | } 21 | return ans; 22 | } 23 | 24 | 25 | // Time Complexity:- O(N) 26 | // Space Complexity:- O(1) 27 | -------------------------------------------------------------------------------- /Xoring and Clearing: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | void printArr(int n, int arr[]) { 4 | // Your code for printing array here 5 | for(int i=0;i &arr, int n ) { 5 | //code here 6 | long long int ans =0; 7 | long long int sum = 0; 8 | unordered_map mm; 9 | for(int i=0;i pq=new PriorityQueue<>(); 6 | for(int i=0;i kLargest(int arr[], int n, int k) { 28 | // code here 29 | priority_queue,greater> pq; 30 | for(int i=0;ipq.top()){ 33 | pq.pop(); 34 | pq.push(arr[i]); 35 | } 36 | } 37 | vector ans(k,0); 38 | int i=k-1; 39 | while(pq.size()){ 40 | ans[i--]=pq.top(); 41 | pq.pop(); 42 | } 43 | return ans; 44 | } 45 | -------------------------------------------------------------------------------- /linked list of strings forms a palindrome: -------------------------------------------------------------------------------- 1 | // C++ CODE 2 | 3 | bool compute(Node* head) { 4 | // Your code goes here 5 | string temp=""; 6 | while(head){ 7 | temp+=head->data; 8 | head=head->next; 9 | } 10 | int i=0,j=temp.size()-1; 11 | while(in)return 0; 7 | if(r==n || r==0)return 1; 8 | int dp[]=new int[r+1]; 9 | dp[0]=1; 10 | int mod=1000000007; 11 | for(int i=1;i<=n;i++){ 12 | for(int j=Math.min(i,r);j>0;j--){ 13 | dp[j]=(dp[j]+dp[j-1])%mod; 14 | } 15 | } 16 | return dp[r]; 17 | } 18 | 19 | // C++ CODE 20 | 21 | int nCr(int n, int r){ 22 | // code here 23 | if(r>n)return 0; 24 | if(r==n or r==0)return 1; 25 | int dp[r+1]={0}; 26 | dp[0]=1; 27 | int mod=1e9+7; 28 | for(int i=1;i<=n;i++){ 29 | for(int j=min(i,r);j>0;j--){ 30 | dp[j]=(dp[j]+dp[j-1])%mod; 31 | } 32 | } 33 | return dp[r]; 34 | } 35 | --------------------------------------------------------------------------------