text
stringlengths 17
4.49k
| code
stringlengths 49
5.46k
|
|---|---|
Count quadruplets with sum K from given array | C ++ program for the above approach ; Function to return the number of quadruplets having given sum ; Initialize variables ; Initialize answer ; All possible first elements ; All possible second element ; Use map to find the fourth element ; All possible third elements ; Calculate number of valid 4 th elements ; Update the twice_count ; Unordered pairs ; Return answer ; Driver Code ; Given array arr [ ] ; Given sum S ; Function Call | #include <iostream> NEW_LINE #include <unordered_map> NEW_LINE using namespace std ; int countSum ( int a [ ] , int n , int sum ) { int i , j , k , l ; int count = 0 ; for ( i = 0 ; i < n - 3 ; i ++ ) { for ( j = i + 1 ; j < n - 2 ; j ++ ) { int req = sum - a [ i ] - a [ j ] ; unordered_map < int , int > m ; for ( k = j + 1 ; k < n ; k ++ ) m [ a [ k ] ] ++ ; int twice_count = 0 ; for ( k = j + 1 ; k < n ; k ++ ) { twice_count += m [ req - a [ k ] ] ; if ( req - a [ k ] == a [ k ] ) twice_count -- ; } count += twice_count / 2 ; } } return count ; } int main ( ) { int arr [ ] = { 4 , 5 , 3 , 1 , 2 , 4 } ; int S = 13 ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countSum ( arr , N , S ) ; return 0 ; } |
Find four elements a , b , c and d in an array such that a + b = c + d | Find four different elements a , b , c and d of array such that a + b = c + d ; function to find a , b , c , d such that ( a + b ) = ( c + d ) ; Create an empty Hash to store mapping from sum to pair indexes ; Traverse through all possible pairs of arr [ ] ; If sum of current pair is not in hash , then store it and continue to next pair ; Driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool findPairs ( int arr [ ] , int n ) { map < int , pair < int , int > > Hash ; for ( int i = 0 ; i < n ; ++ i ) { for ( int j = i + 1 ; j < n ; ++ j ) { int sum = arr [ i ] + arr [ j ] ; if ( Hash . find ( sum ) == Hash . end ( ) ) Hash [ sum ] = make_pair ( i , j ) ; else { pair < int , int > pp = Hash [ sum ] ; cout << " ( " << arr [ pp . first ] << " , ▁ " << arr [ pp . second ] << " ) ▁ and ▁ ( " << arr [ i ] << " , ▁ " << arr [ j ] << " ) n " ; return true ; } } } cout << " No ▁ pairs ▁ found " ; return false ; } int main ( ) { int arr [ ] = { 3 , 4 , 7 , 1 , 2 , 9 , 8 } ; int n = sizeof arr / sizeof arr [ 0 ] ; findPairs ( arr , n ) ; return 0 ; } |
Check if all subarrays contains at least one unique element | C ++ program for the above approach ; Function to check if all subarrays have at least one unique element ; Generate all subarray ; Store frequency of subarray 's elements ; Traverse the array over the range [ i , N ] ; Update frequency of current subarray in map ; Increment count ; Decrement count ; If all subarrays have at least 1 unique element ; Driver Code ; Given array arr [ ] ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; string check ( int arr [ ] , int n ) { for ( int i = 0 ; i < n ; i ++ ) { map < int , int > hm ; int count = 0 ; for ( int j = i ; j < n ; j ++ ) { hm [ arr [ j ] ] ++ ; if ( hm [ arr [ j ] ] == 1 ) count ++ ; if ( hm [ arr [ j ] ] == 2 ) count -- ; if ( count == 0 ) return " No " ; } } return " Yes " ; } int main ( ) { int arr [ ] = { 1 , 2 , 1 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << check ( arr , N ) ; } |
Count all disjoint pairs having absolute difference at least K from a given array | C ++ program for the above approach ; Function to count distinct pairs with absolute difference atleast K ; Track the element that have been paired ; Stores count of distinct pairs ; Pick all elements one by one ; If already visited ; If already visited ; If difference is at least K ; Mark element as visited and increment the count ; Print the final count ; Driver Code ; Given arr [ ] ; Size of array ; Given difference K ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; void countPairsWithDiffK ( int arr [ ] , int N , int K ) { int vis [ N ] ; memset ( vis , 0 , sizeof ( vis ) ) ; int count = 0 ; for ( int i = 0 ; i < N ; i ++ ) { if ( vis [ i ] == 1 ) continue ; for ( int j = i + 1 ; j < N ; j ++ ) { if ( vis [ j ] == 1 ) continue ; if ( abs ( arr [ i ] - arr [ j ] ) >= K ) { count ++ ; vis [ i ] = 1 ; vis [ j ] = 1 ; break ; } } } cout << count << ' ▁ ' ; } int main ( ) { int arr [ ] = { 1 , 3 , 3 , 5 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int K = 2 ; countPairsWithDiffK ( arr , N , K ) ; return 0 ; } |
Check if two trees are Mirror | C ++ program to check if two trees are mirror of each other ; A binary tree node has data , pointer to left child and a pointer to right child ; Given two trees , return true if they are mirror of each other ; Base case : Both empty ; If only one is empty ; Both non - empty , compare them recursively Note that in recursive calls , we pass left of one tree and right of other tree ; Helper function that allocates a new node ; Driver program to test areMirror ( ) | #include <bits/stdc++.h> NEW_LINE using namespace std ; struct Node { int data ; Node * left , * right ; } ; int areMirror ( Node * a , Node * b ) { if ( a == NULL && b == NULL ) return true ; if ( a == NULL b == NULL ) return false ; return a -> data == b -> data && areMirror ( a -> left , b -> right ) && areMirror ( a -> right , b -> left ) ; } Node * newNode ( int data ) { Node * node = new Node ; node -> data = data ; node -> left = node -> right = NULL ; return ( node ) ; } int main ( ) { Node * a = newNode ( 1 ) ; Node * b = newNode ( 1 ) ; a -> left = newNode ( 2 ) ; a -> right = newNode ( 3 ) ; a -> left -> left = newNode ( 4 ) ; a -> left -> right = newNode ( 5 ) ; b -> left = newNode ( 3 ) ; b -> right = newNode ( 2 ) ; b -> right -> left = newNode ( 5 ) ; b -> right -> right = newNode ( 4 ) ; areMirror ( a , b ) ? cout << " Yes " : cout << " No " ; return 0 ; } |
Find the length of largest subarray with 0 sum | C ++ program to find the length of largest subarray with 0 sum ; Returns Length of the required subarray ; Map to store the previous sums ; Initialize the sum of elements ; Initialize result ; Traverse through the given array ; Add current element to sum ; Look for this sum in Hash table ; Else insert this sum with index in hash table ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxLen ( int arr [ ] , int n ) { unordered_map < int , int > presum ; int sum = 0 ; int max_len = 0 ; for ( int i = 0 ; i < n ; i ++ ) { sum += arr [ i ] ; if ( arr [ i ] == 0 && max_len == 0 ) max_len = 1 ; if ( sum == 0 ) max_len = i + 1 ; if ( presum . find ( sum ) != presum . end ( ) ) { max_len = max ( max_len , i - presum [ sum ] ) ; } else { presum [ sum ] = i ; } } return max_len ; } int main ( ) { int arr [ ] = { 15 , -2 , 2 , -8 , 1 , 7 , 10 , 23 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Length ▁ of ▁ the ▁ longest ▁ 0 ▁ sum ▁ subarray ▁ is ▁ " << maxLen ( arr , n ) ; return 0 ; } |
Print alternate elements of an array | C ++ program to implement the above approach ; Function to print Alternate elements of the given array ; Print elements at odd positions ; Print elements of array ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printAlter ( int arr [ ] , int N ) { for ( int currIndex = 0 ; currIndex < N ; currIndex += 2 ) { cout << arr [ currIndex ] << " ▁ " ; } } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 4 , 5 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; printAlter ( arr , N ) ; } |
Longest Increasing consecutive subsequence | CPP program to find length of the longest increasing subsequence whose adjacent element differ by 1 ; function that returns the length of the longest increasing subsequence whose adjacent element differ by 1 ; stores the index of elements ; stores the length of the longest subsequence that ends with a [ i ] ; iterate for all element ; if a [ i ] - 1 is present before i - th index ; last index of a [ i ] - 1 ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int longestSubsequence ( int a [ ] , int n ) { unordered_map < int , int > mp ; int dp [ n ] ; memset ( dp , 0 , sizeof ( dp ) ) ; int maximum = INT_MIN ; for ( int i = 0 ; i < n ; i ++ ) { if ( mp . find ( a [ i ] - 1 ) != mp . end ( ) ) { int lastIndex = mp [ a [ i ] - 1 ] - 1 ; dp [ i ] = 1 + dp [ lastIndex ] ; } else dp [ i ] = 1 ; mp [ a [ i ] ] = i + 1 ; maximum = max ( maximum , dp [ i ] ) ; } return maximum ; } int main ( ) { int a [ ] = { 3 , 10 , 3 , 11 , 4 , 5 , 6 , 7 , 8 , 12 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << longestSubsequence ( a , n ) ; return 0 ; } |
Longest subsequence such that difference between adjacents is one | Set 2 | C ++ implementation to find longest subsequence such that difference between adjacents is one ; function to find longest subsequence such that difference between adjacents is one ; hash table to map the array element with the length of the longest subsequence of which it is a part of and is the last element of that subsequence ; to store the longest length subsequence ; traverse the array elements ; initialize current length for element arr [ i ] as 0 ; if ' arr [ i ] -1' is in ' um ' and its length of subsequence is greater than ' len ' ; if ' arr [ i ] + 1' is in ' um ' and its length of subsequence is greater than ' len ' ; update arr [ i ] subsequence length in ' um ' ; update longest length ; required longest length subsequence ; Driver program to test above | #include <bits/stdc++.h> NEW_LINE using namespace std ; int longLenSub ( int arr [ ] , int n ) { unordered_map < int , int > um ; int longLen = 0 ; for ( int i = 0 ; i < n ; i ++ ) { int len = 0 ; if ( um . find ( arr [ i ] - 1 ) != um . end ( ) && len < um [ arr [ i ] - 1 ] ) len = um [ arr [ i ] - 1 ] ; if ( um . find ( arr [ i ] + 1 ) != um . end ( ) && len < um [ arr [ i ] + 1 ] ) len = um [ arr [ i ] + 1 ] ; um [ arr [ i ] ] = len + 1 ; if ( longLen < um [ arr [ i ] ] ) longLen = um [ arr [ i ] ] ; } return longLen ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 4 , 5 , 3 , 2 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Longest ▁ length ▁ subsequence ▁ = ▁ " << longLenSub ( arr , n ) ; return 0 ; } |
Count nodes having highest value in the path from root to itself in a Binary Tree | C ++ 14 program for the above approach ; Stores the ct of nodes which are maximum in the path from root to the current node ; Binary Tree Node ; Function that performs Inorder Traversal on the Binary Tree ; If root does not exist ; Check if the node satisfies the condition ; Update the maximum value and recursively traverse left and right subtree ; Function that counts the good nodes in the given Binary Tree ; Perform inorder Traversal ; Return the final count ; Driver code ; A Binary Tree 3 / \ 2 5 / \ 4 6 ; Function call ; Print the count of good nodes | #include <bits/stdc++.h> NEW_LINE using namespace std ; int ct = 0 ; struct Node { int val ; Node * left , * right ; Node ( int x ) { val = x ; left = right = NULL ; } } ; void find ( Node * root , int mx ) { if ( root == NULL ) return ; if ( root -> val >= mx ) ct ++ ; find ( root -> left , max ( mx , root -> val ) ) ; find ( root -> right , max ( mx , root -> val ) ) ; } int NodesMaxInPath ( Node * root ) { find ( root , INT_MIN ) ; return ct ; } int main ( ) { Node * root = new Node ( 3 ) ; root -> left = new Node ( 2 ) ; root -> right = new Node ( 5 ) ; root -> left -> left = new Node ( 4 ) ; root -> right -> right = new Node ( 7 ) ; int answer = NodesMaxInPath ( root ) ; cout << ( answer ) ; return 0 ; } |
Longest Consecutive Subsequence | C ++ program to find longest contiguous subsequence ; Returns length of the longest contiguous subsequence ; sort the array ; insert repeated elements only once in the vector ; find the maximum length by traversing the array ; Check if the current element is equal to previous element + 1 ; update the maximum ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findLongestConseqSubseq ( int arr [ ] , int n ) { int ans = 0 , count = 0 ; sort ( arr , arr + n ) ; vector < int > v ; v . push_back ( arr [ 0 ] ) ; for ( int i = 1 ; i < n ; i ++ ) { if ( arr [ i ] != arr [ i - 1 ] ) v . push_back ( arr [ i ] ) ; } for ( int i = 0 ; i < v . size ( ) ; i ++ ) { if ( i > 0 && v [ i ] == v [ i - 1 ] + 1 ) count ++ ; else count = 1 ; ans = max ( ans , count ) ; } return ans ; } int main ( ) { int arr [ ] = { 1 , 2 , 2 , 3 } ; int n = sizeof arr / sizeof arr [ 0 ] ; cout << " Length ▁ of ▁ the ▁ Longest ▁ contiguous ▁ subsequence ▁ " " is ▁ " << findLongestConseqSubseq ( arr , n ) ; return 0 ; } |
Count smaller primes on the right of each array element | C ++ Program for the above approach ; Function to check if a number is prime or not ; Function to update a Binary Tree ; Function to find the sum of all the elements which are less than or equal to index ; Function to find the number of smaller primes on the right for every array element ; Iterate the array in backwards ; Calculating the required number of primes ; If current array element is prime ; Update the Fenwick tree ; Driver Code ; Function call | #include " bits / stdc + + . h " NEW_LINE using namespace std ; const int maxn = 1e6 + 5 ; int BITree [ maxn ] ; bool is_prime ( int n ) { if ( n <= 1 ) return 0 ; for ( int i = 2 ; i * i <= n ; i ++ ) if ( n % i == 0 ) return 0 ; return 1 ; } void update_bitree ( int BITree [ ] , int index , int value ) { while ( index <= maxn ) { BITree [ index ] += value ; index += ( index & ( - index ) ) ; } } int sum_bitree ( int BITree [ ] , int index ) { int s = 0 ; while ( index > 0 ) { s += BITree [ index ] ; index -= ( index & ( - index ) ) ; } return s ; } void countSmallerPrimes ( int BITree [ ] , int ar [ ] , int N ) { int ans [ N ] ; for ( int i = N - 1 ; i >= 0 ; i -- ) { ans [ i ] = sum_bitree ( BITree , ar [ i ] ) ; if ( is_prime ( ar [ i ] ) ) update_bitree ( BITree , ar [ i ] , 1 ) ; } for ( int i = 0 ; i < N ; i ++ ) cout << ans [ i ] << " ▁ " ; } int main ( ) { int ar [ ] = { 5 , 5 , 17 , 9 , 12 , 15 , 11 , 7 , 39 , 3 } ; int N = sizeof ar / sizeof ar [ 0 ] ; countSmallerPrimes ( BITree , ar , N ) ; return 0 ; } |
Longest Consecutive Subsequence | C ++ program to find longest contiguous subsequence ; Returns length of the longest contiguous subsequence ; Hash all the array elements ; check each possible sequence from the start then update optimal length ; if current element is the starting element of a sequence ; Then check for next elements in the sequence ; update optimal length if this length is more ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findLongestConseqSubseq ( int arr [ ] , int n ) { unordered_set < int > S ; int ans = 0 ; for ( int i = 0 ; i < n ; i ++ ) S . insert ( arr [ i ] ) ; for ( int i = 0 ; i < n ; i ++ ) { if ( S . find ( arr [ i ] - 1 ) == S . end ( ) ) { int j = arr [ i ] ; while ( S . find ( j ) != S . end ( ) ) j ++ ; ans = max ( ans , j - arr [ i ] ) ; } } return ans ; } int main ( ) { int arr [ ] = { 1 , 9 , 3 , 10 , 4 , 20 , 2 } ; int n = sizeof arr / sizeof arr [ 0 ] ; cout << " Length ▁ of ▁ the ▁ Longest ▁ contiguous ▁ subsequence ▁ " " is ▁ " << findLongestConseqSubseq ( arr , n ) ; return 0 ; } |
Longest Consecutive Subsequence | CPP program for the above approach ; return the length of the longest subsequence of consecutive integers ; adding element from array to PriorityQueue ; Storing the first element of the Priority Queue This first element is also the smallest element ; Taking a counter variable with value 1 ; Storing value of max as 1 as there will always be one element ; check if current peek element minus previous element is greater then 1 This is done because if it ' s ▁ greater ▁ than ▁ 1 ▁ ▁ then ▁ the ▁ sequence ▁ ▁ doesn ' t start or is broken here ; Store the value of counter to 1 As new sequence may begin ; Update the previous position with the current peek And remove it ; Check if the previous element and peek are same ; Update the previous position with the current peek And remove it ; If the difference between previous element and peek is 1 ; Update the counter These are consecutive elements ; Update the previous position with the current peek And remove it ; Check if current longest subsequence is the greatest ; Store the current subsequence count as max ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findLongestConseqSubseq ( int arr [ ] , int N ) { priority_queue < int , vector < int > , greater < int > > pq ; for ( int i = 0 ; i < N ; i ++ ) { pq . push ( arr [ i ] ) ; } int prev = pq . top ( ) ; pq . pop ( ) ; int c = 1 ; int max = 1 ; while ( ! pq . empty ( ) ) { if ( pq . top ( ) - prev > 1 ) { c = 1 ; prev = pq . top ( ) ; pq . pop ( ) ; } else if ( pq . top ( ) - prev == 0 ) { prev = pq . top ( ) ; pq . pop ( ) ; } else { c ++ ; prev = pq . top ( ) ; pq . pop ( ) ; } if ( max < c ) { max = c ; } } return max ; } int main ( ) { int arr [ ] = { 1 , 9 , 3 , 10 , 4 , 20 , 2 } ; int n = 7 ; cout << " Length ▁ of ▁ the ▁ Longest ▁ consecutive ▁ subsequence ▁ " " is ▁ " << findLongestConseqSubseq ( arr , n ) ; return 0 ; } |
Kth space | C ++ program of the above approach ; Function to extract integer at key position in the given string ; strtok ( ) : Extracts the number at key c_str ( ) : Type cast string to char * ; Driver Code ; Given string ; Given K ; Function call | #include <cstring> NEW_LINE #include <iostream> NEW_LINE using namespace std ; void print_kth_string ( string str , int K ) { char * s = strtok ( ( char * ) str . c_str ( ) , " ▁ " ) ; while ( K > 1 ) { s = strtok ( NULL , " ▁ " ) ; K -- ; } cout << string ( s ) << " ▁ " ; } int main ( ) { string s ( "10 ▁ 20 ▁ 30 ▁ 40" ) ; int K = 2 ; print_kth_string ( s , K ) ; return 0 ; } |
Largest increasing subsequence of consecutive integers | C ++ implementation of longest continuous increasing subsequence ; Function for LIS ; Initialize result ; iterate through array and find end index of LIS and its Size ; print LIS size ; print LIS after setting start element ; driver | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findLIS ( int A [ ] , int n ) { unordered_map < int , int > hash ; int LIS_size = 1 ; int LIS_index = 0 ; hash [ A [ 0 ] ] = 1 ; for ( int i = 1 ; i < n ; i ++ ) { hash [ A [ i ] ] = hash [ A [ i ] - 1 ] + 1 ; if ( LIS_size < hash [ A [ i ] ] ) { LIS_size = hash [ A [ i ] ] ; LIS_index = A [ i ] ; } } cout << " LIS _ size ▁ = ▁ " << LIS_size << " STRNEWLINE " ; cout << " LIS ▁ : ▁ " ; int start = LIS_index - LIS_size + 1 ; while ( start <= LIS_index ) { cout << start << " ▁ " ; start ++ ; } } int main ( ) { int A [ ] = { 2 , 5 , 3 , 7 , 4 , 8 , 5 , 13 , 6 } ; int n = sizeof ( A ) / sizeof ( A [ 0 ] ) ; findLIS ( A , n ) ; return 0 ; } |
Count subsets having distinct even numbers | C ++ implementation to count subsets having even numbers only and all are distinct ; function to count the required subsets ; inserting even numbers in the set ' us ' single copy of each number is retained ; distinct even numbers ; total count of required subsets ; Driver program to test above | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countSubsets ( int arr [ ] , int n ) { unordered_set < int > us ; int even_count = 0 ; for ( int i = 0 ; i < n ; i ++ ) if ( arr [ i ] % 2 == 0 ) us . insert ( arr [ i ] ) ; unordered_set < int > :: iterator itr ; even_count = us . size ( ) ; return ( pow ( 2 , even_count ) - 1 ) ; } int main ( ) { int arr [ ] = { 4 , 2 , 1 , 9 , 2 , 6 , 5 , 3 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Number ▁ of ▁ subsets ▁ = ▁ " << countSubsets ( arr , n ) ; return 0 ; } |
Count distinct elements in every window of size k | Simple C ++ program to count distinct elements in every window of size k ; Counts distinct elements in window of size k ; Traverse the window ; Check if element arr [ i ] exists in arr [ 0. . i - 1 ] ; Counts distinct elements in all windows of size k ; Traverse through every window ; Driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countWindowDistinct ( int win [ ] , int k ) { int dist_count = 0 ; for ( int i = 0 ; i < k ; i ++ ) { int j ; for ( j = 0 ; j < i ; j ++ ) if ( win [ i ] == win [ j ] ) break ; if ( j == i ) dist_count ++ ; } return dist_count ; } void countDistinct ( int arr [ ] , int n , int k ) { for ( int i = 0 ; i <= n - k ; i ++ ) cout << countWindowDistinct ( arr + i , k ) << endl ; } int main ( ) { int arr [ ] = { 1 , 2 , 1 , 3 , 4 , 2 , 3 } , k = 4 ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; countDistinct ( arr , n , k ) ; return 0 ; } |
Iterative method to check if two trees are mirror of each other | C ++ implementation to check whether the two binary tress are mirrors of each other or not ; structure of a node in binary tree ; Utility function to create and return a new node for a binary tree ; function to check whether the two binary trees are mirrors of each other or not ; iterative inorder traversal of 1 st tree and reverse inoder traversal of 2 nd tree ; if the corresponding nodes in the two traversal have different data values , then they are not mirrors of each other . ; if at any point one root becomes null and the other root is not null , then they are not mirrors . This condition verifies that structures of tree are mirrors of each other . ; we have visited the node and its left subtree . Now , it ' s ▁ right ▁ subtree ' s turn ; we have visited the node and its right subtree . Now , it ' s ▁ left ▁ subtree ' s turn ; both the trees have been completely traversed ; tress are mirrors of each other ; Driver program to test above ; 1 st binary tree formation ; 1 ; / \ ; 3 2 ; / \ ; 2 nd binary tree formation ; 1 ; / \ ; 2 3 ; / \ ; 4 5 | #include <bits/stdc++.h> NEW_LINE using namespace std ; struct Node { int data ; struct Node * left , * right ; } ; struct Node * newNode ( int data ) { struct Node * temp = new Node ( ) ; temp -> data = data ; temp -> left = temp -> right = NULL ; return temp ; } string areMirrors ( Node * root1 , Node * root2 ) { stack < Node * > st1 , st2 ; while ( 1 ) { while ( root1 && root2 ) { if ( root1 -> data != root2 -> data ) return " No " ; st1 . push ( root1 ) ; st2 . push ( root2 ) ; root1 = root1 -> left ; root2 = root2 -> right ; } if ( ! ( root1 == NULL && root2 == NULL ) ) return " No " ; if ( ! st1 . empty ( ) && ! st2 . empty ( ) ) { root1 = st1 . top ( ) ; root2 = st2 . top ( ) ; st1 . pop ( ) ; st2 . pop ( ) ; root1 = root1 -> right ; root2 = root2 -> left ; } else break ; } return " Yes " ; } int main ( ) { Node * root1 = newNode ( 1 ) ; root1 -> left = newNode ( 3 ) ; root1 -> right = newNode ( 2 ) ; root1 -> right -> left = newNode ( 5 ) ; root1 -> right -> right = newNode ( 4 ) ; Node * root2 = newNode ( 1 ) ; root2 -> left = newNode ( 2 ) ; root2 -> right = newNode ( 3 ) ; root2 -> left -> left = newNode ( 4 ) ; root2 -> left -> right = newNode ( 5 ) ; cout << areMirrors ( root1 , root2 ) ; return 0 ; } |
Maximum score assigned to a subsequence of numerically consecutive and distinct array elements | C ++ program for the above approach ; Function to find the maximum score possible ; Base Case ; If previously occurred subproblem occurred ; Check if lastpicked element differs by 1 from the current element ; Calculate score by including the current element ; Calculate score by excluding the current element ; Return maximum score from the two possibilities ; Function to print maximum score ; DP array to store results Initialise dp with - 1 ; Function call ; Driver code ; Given arrays ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maximumSum ( int a [ ] , int b [ ] , int n , int index , int lastpicked , vector < vector < int > > dp ) { if ( index == n ) return 0 ; if ( dp [ index ] [ lastpicked + 1 ] != -1 ) return dp [ index ] [ lastpicked + 1 ] ; int option1 = 0 , option2 = 0 ; if ( lastpicked == -1 a [ lastpicked ] != a [ index ] ) { option1 = b [ index ] + maximumSum ( a , b , n , index + 1 , index , dp ) ; } option2 = maximumSum ( a , b , n , index + 1 , lastpicked , dp ) ; return dp [ index ] [ lastpicked + 1 ] = max ( option1 , option2 ) ; } void maximumPoints ( int arr [ ] , int brr [ ] , int n ) { int index = 0 , lastPicked = -1 ; vector < vector < int > > dp ( n + 5 , vector < int > ( n + 5 , -1 ) ) ; cout << maximumSum ( arr , brr , n , index , lastPicked , dp ) << endl ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 3 , 3 , 1 } ; int brr [ ] = { -1 , 2 , 10 , 20 , -10 , -9 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; maximumPoints ( arr , brr , N ) ; return 0 ; } |
Maximum possible sum of a window in an array such that elements of same window in other array are unique | C ++ program to find the maximum possible sum of a window in one array such that elements in same window of other array are unique . ; Function to return maximum sum of window in B [ ] according to given constraints . ; Map is used to store elements and their counts . ; Initialize result ; calculating the maximum possible sum for each subarray containing unique elements . ; Remove all duplicate instances of A [ i ] in current window . ; Add current instance of A [ i ] to map and to current sum . ; Update result if current sum is more . ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int returnMaxSum ( int A [ ] , int B [ ] , int n ) { unordered_set < int > mp ; int result = 0 ; int curr_sum = 0 , curr_begin = 0 ; for ( int i = 0 ; i < n ; ++ i ) { while ( mp . find ( A [ i ] ) != mp . end ( ) ) { mp . erase ( A [ curr_begin ] ) ; curr_sum -= B [ curr_begin ] ; curr_begin ++ ; } mp . insert ( A [ i ] ) ; curr_sum += B [ i ] ; result = max ( result , curr_sum ) ; } return result ; } int main ( ) { int A [ ] = { 0 , 1 , 2 , 3 , 0 , 1 , 4 } ; int B [ ] = { 9 , 8 , 1 , 2 , 3 , 4 , 5 } ; int n = sizeof ( A ) / sizeof ( A [ 0 ] ) ; cout << returnMaxSum ( A , B , n ) ; return 0 ; } |
Length of second longest sequence of consecutive 1 s in a binary array | C ++ implementation of the above approach ; Function to find maximum and second maximum length ; Initialise maximum length ; Initialise second maximum length ; Initialise count ; Iterate over the array ; If sequence ends ; Reset count ; Otherwise ; Increase length of current sequence ; Update maximum ; Traverse the given array ; If sequence continues ; Increase length of current sequence ; Update second max ; Reset count when 0 is found ; Print the result ; Driver Code ; Given array ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; void FindMax ( int arr [ ] , int N ) { int maxi = -1 ; int maxi2 = -1 ; int count = 0 ; for ( int i = 0 ; i < N ; ++ i ) { if ( arr [ i ] == 0 ) count = 0 ; else { count ++ ; maxi = max ( maxi , count ) ; } } for ( int i = 0 ; i < N ; i ++ ) { if ( arr [ i ] == 1 ) { count ++ ; if ( count > maxi2 && count < maxi ) { maxi2 = count ; } } if ( arr [ i ] == 0 ) count = 0 ; } maxi = max ( maxi , 0 ) ; maxi2 = max ( maxi2 , 0 ) ; cout << maxi2 ; } int main ( ) { int arr [ ] = { 1 , 1 , 1 , 0 , 0 , 1 , 1 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; FindMax ( arr , N ) ; return 0 ; } |
Minimum distance between any special pair in the given array | C ++ program for the above approach ; Function that finds the minimum difference between two vectors ; Find lower bound of the index ; Find two adjacent indices to take difference ; Return the result ; Function to find the minimum distance between index of special pairs ; Stores the index of each element in the array arr [ ] ; Store the indexes ; Get the unique values in list ; Take adjacent difference of same values ; Left index array ; Right index array ; Find the minimum gap between the two adjacent different values ; Driver Code ; Given array ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int mindist ( vector < int > & left , vector < int > & right ) { int res = INT_MAX ; for ( int i = 0 ; i < left . size ( ) ; ++ i ) { int num = left [ i ] ; int index = lower_bound ( right . begin ( ) , right . end ( ) , num ) - right . begin ( ) ; if ( index == 0 ) res = min ( res , abs ( num - right [ index ] ) ) ; else if ( index == right . size ( ) ) res = min ( res , abs ( num - right [ index - 1 ] ) ) ; else res = min ( res , min ( abs ( num - right [ index - 1 ] ) , abs ( num - right [ index ] ) ) ) ; } return res ; } int specialPairs ( vector < int > & nums ) { map < int , set < int > > m ; vector < int > vals ; for ( int i = 0 ; i < nums . size ( ) ; ++ i ) { m [ nums [ i ] ] . insert ( i ) ; } for ( auto p : m ) { vals . push_back ( p . first ) ; } int res = INT_MAX ; for ( int i = 0 ; i < vals . size ( ) ; ++ i ) { vector < int > vec ( m [ vals [ i ] ] . begin ( ) , m [ vals [ i ] ] . end ( ) ) ; for ( int i = 1 ; i < vec . size ( ) ; ++ i ) res = min ( res , abs ( vec [ i ] - vec [ i - 1 ] ) ) ; if ( i ) { int a = vals [ i ] ; vector < int > left ( m [ a ] . begin ( ) , m [ a ] . end ( ) ) ; int b = vals [ i - 1 ] ; vector < int > right ( m [ b ] . begin ( ) , m [ b ] . end ( ) ) ; res = min ( res , mindist ( left , right ) ) ; } } return res ; } int main ( ) { vector < int > arr { 0 , -10 , 5 , -5 , 1 } ; cout << specialPairs ( arr ) ; return 0 ; } |
Substring of length K having maximum frequency in the given string | C ++ program for the above approach ; Function that generates substring of length K that occurs maximum times ; Store the frequency of substrings ; Deque to maintain substrings window size K ; Update the frequency of the first substring in the Map ; Remove the first character of the previous K length substring ; Traverse the string ; Insert the current character as last character of current substring ; Pop the first character of previous K length substring ; Find the substring that occurs maximum number of times ; Print the substring ; Driver Code ; Given string ; Given K size of substring ; Function Call | #include <bits/stdc++.h> NEW_LINE using ll = long long int ; using namespace std ; void maximumOccurringString ( string s , ll K ) { map < deque < char > , ll > M ; ll i ; deque < char > D ; for ( i = 0 ; i < K ; i ++ ) { D . push_back ( s [ i ] ) ; } M [ D ] ++ ; D . pop_front ( ) ; for ( ll j = i ; j < s . size ( ) ; j ++ ) { D . push_back ( s [ j ] ) ; M [ D ] ++ ; D . pop_front ( ) ; } ll maxi = INT_MIN ; deque < char > ans ; for ( auto it : M ) { if ( it . second > maxi ) { maxi = it . second ; ans = it . first ; } } for ( ll i = 0 ; i < ans . size ( ) ; i ++ ) { cout << ans [ i ] ; } } int main ( ) { string s = " bbbbbaaaaabbabababa " ; ll K = 5 ; maximumOccurringString ( s , K ) ; return 0 ; } |
Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree | C ++ program of the above approach ; Stores the nodes to be deleted ; Structure of a Tree node ; Function to create a new node ; Function to find the min value of node for each level ; Count is used to diffentiate each level of the tree ; Function to check whether the nodes in the level below it are smaller by performing post order traversal ; Traverse the left subtree ; Traverse right subtree ; Check from minimum values computed at each level ; Function to print count of nodes from all lower levels having values less than the the nodes in the current level ; Stores the number of levels ; Stores the required count of nodes for each level ; Driver Code ; 4 / \ 3 5 / \ / \ 10 2 3 1 | #include <bits/stdc++.h> NEW_LINE using namespace std ; unordered_map < int , bool > mp ; struct Node { int key ; struct Node * left , * right ; } ; Node * newNode ( int key ) { Node * temp = new Node ; temp -> key = key ; temp -> left = temp -> right = NULL ; return ( temp ) ; } void calculateMin ( Node * root , vector < int > & levelMin ) { queue < Node * > qt ; qt . push ( root ) ; int count = 1 ; int min_v = INT_MAX ; while ( ! qt . empty ( ) ) { Node * temp = qt . front ( ) ; min_v = min ( min_v , temp -> key ) ; qt . pop ( ) ; if ( temp -> left ) { qt . push ( temp -> left ) ; } if ( temp -> right ) { qt . push ( temp -> right ) ; } count -- ; if ( count == 0 ) { levelMin . push_back ( min_v ) ; min_v = INT_MAX ; count = qt . size ( ) ; } } } void findNodes ( Node * root , vector < int > & levelMin , vector < int > & levelResult , int level ) { if ( root == NULL ) return ; findNodes ( root -> left , levelMin , levelResult , level + 1 ) ; findNodes ( root -> right , levelMin , levelResult , level + 1 ) ; for ( int i = 0 ; i < level ; i ++ ) { if ( root -> key <= levelMin [ i ] ) { levelResult [ i ] += 1 ; } } } void printNodes ( Node * root ) { vector < int > levelMin ; calculateMin ( root , levelMin ) ; int numLevels = levelMin . size ( ) ; vector < int > levelResult ( numLevels , 0 ) ; findNodes ( root , levelMin , levelResult , 0 ) ; for ( int i = 0 ; i < numLevels ; i ++ ) { cout << levelResult [ i ] << " ▁ " ; } } int main ( ) { Node * root = newNode ( 4 ) ; root -> left = newNode ( 3 ) ; root -> right = newNode ( 5 ) ; root -> right -> left = newNode ( 3 ) ; root -> right -> right = newNode ( 1 ) ; root -> left -> left = newNode ( 10 ) ; root -> left -> right = newNode ( 2 ) ; printNodes ( root ) ; } |
Design a data structure that supports insert , delete , search and getRandom in constant time | C ++ program to design a DS that supports following operations in Theta ( n ) timea ) Insertb ) Deletec ) Searchd ) getRandom ; class to represent the required data structure ; A resizable array ; A hash where keys are array elements and values are indexes in arr [ ] ; A Theta ( 1 ) function to add an element to MyDS data structure ; If element is already present , then nothing to do ; Else put element at the end of arr [ ] ; and hashmap also ; function to remove a number to DS in O ( 1 ) ; element not found then return ; remove element from map ; swap with last element in arr ; then remove element at back ; Update hash table for new index of last element ; Returns a random element from myStructure ; Find a random index from 0 to size - 1 ; Return element at randomly picked index ; Returns index of element if element is present , otherwise null ; Driver main | #include <bits/stdc++.h> NEW_LINE using namespace std ; class myStructure { vector < int > arr ; map < int , int > Map ; public : void add ( int x ) { if ( Map . find ( x ) != Map . end ( ) ) return ; int index = arr . size ( ) ; arr . push_back ( x ) ; Map . insert ( std :: pair < int , int > ( x , index ) ) ; } void remove ( int x ) { if ( Map . find ( x ) == Map . end ( ) ) return ; int index = Map . at ( x ) ; Map . erase ( x ) ; int last = arr . size ( ) - 1 ; swap ( arr [ index ] , arr [ last ] ) ; arr . pop_back ( ) ; Map . at ( arr [ index ] ) = index ; } int getRandom ( ) { srand ( time ( NULL ) ) ; int random_index = rand ( ) % arr . size ( ) ; return arr . at ( random_index ) ; } int search ( int x ) { if ( Map . find ( x ) != Map . end ( ) ) return Map . at ( x ) ; return -1 ; } } ; int main ( ) { myStructure ds ; ds . add ( 10 ) ; ds . add ( 20 ) ; ds . add ( 30 ) ; ds . add ( 40 ) ; cout << ds . search ( 30 ) << endl ; ds . remove ( 20 ) ; ds . add ( 50 ) ; cout << ds . search ( 50 ) << endl ; cout << ds . getRandom ( ) << endl ; } |
Count subarrays which contains both the maximum and minimum array element | C ++ program for the above approach ; Function to count subarray containing both maximum and minimum array elements ; If the length of the array is less than 2 ; Find the index of maximum element ; Find the index of minimum element ; If i > j , then swap the value of i and j ; Return the answer ; Driver Code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countSubArray ( int arr [ ] , int n ) { if ( n < 2 ) return n ; int i = max_element ( arr , arr + n ) - arr ; int j = min_element ( arr , arr + n ) - arr ; if ( i > j ) swap ( i , j ) ; return ( i + 1 ) * ( n - j ) ; } int main ( ) { int arr [ ] = { 4 , 1 , 2 , 3 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countSubArray ( arr , n ) ; return 0 ; } |
Count pairs of leaf nodes in a Binary Tree which are at most K distance apart | C ++ 14 implementation of the above approach ; Structure of a Node ; Constructor of the class ; Stores the count of required pairs ; Function to perform dfs to find pair of leaf nodes at most K distance apart ; Return empty array if node is NULL ; If node is a leaf node and return res ; Traverse to the left ; Traverse to the right ; Update the distance between left and right leaf node ; Count all pair of leaf nodes which are at most K distance apart ; Return res to parent node ; Driver Code ; 1 / \ 2 3 / 4 ; Given distance K ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; struct Node { int data ; Node * left , * right ; Node ( int item ) { data = item ; left = right = NULL ; } } ; int result = 0 ; vector < int > dfs ( Node * root , int distance ) { if ( root == NULL ) { vector < int > res ( distance + 1 , 0 ) ; return res ; } if ( root -> left == NULL && root -> right == NULL ) { vector < int > res ( distance + 1 , 0 ) ; res [ 1 ] ++ ; return res ; } vector < int > left = dfs ( root -> left , distance ) ; vector < int > right = dfs ( root -> right , distance ) ; vector < int > res ( distance + 1 , 0 ) ; for ( int i = res . size ( ) - 2 ; i >= 1 ; i -- ) res [ i + 1 ] = left [ i ] + right [ i ] ; for ( int l = 1 ; l < left . size ( ) ; l ++ ) { for ( int r = 0 ; r < right . size ( ) ; r ++ ) { if ( l + r <= distance ) { result += left [ l ] * right [ r ] ; } } } return res ; } int main ( ) { Node * root = new Node ( 1 ) ; root -> left = new Node ( 2 ) ; root -> right = new Node ( 3 ) ; root -> left -> left = new Node ( 4 ) ; int K = 3 ; dfs ( root , K ) ; cout << result ; } |
Count number of triangles possible with length of sides not exceeding N | C ++ implementation of the above approach ; Function to count total number of right angled triangle ; Consider a set to store the three sides ; Find possible third side ; Condition for a right angled triangle ; Check if the third side is an integer ; Push the three sides ; Insert the three sides in the set to find unique triangles ; return the size of set ; Driver code ; Given N ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int right_angled ( int n ) { set < pair < int , pair < int , int > > > s ; for ( int x = 1 ; x <= n ; x ++ ) { for ( int y = 1 ; y <= n ; y ++ ) { if ( x * x + y * y <= n * n ) { int z = sqrt ( x * x + y * y ) ; if ( z * z != ( x * x + y * y ) ) continue ; vector < int > v ; v . push_back ( x ) ; v . push_back ( y ) ; v . push_back ( sqrt ( x * x + y * y ) ) ; sort ( v . begin ( ) , v . end ( ) ) ; s . insert ( { v [ 0 ] , { v [ 1 ] , v [ 2 ] } } ) ; } else break ; } } return s . size ( ) ; } int main ( ) { int n = 5 ; cout << right_angled ( n ) ; return 0 ; } |
Maximum absolute difference between any two level sum in a N | C ++ program for the above approach ; Function to find the maximum absolute difference of level sum ; Create the adjacency list ; Initialize value of maximum and minimum level sum ; Do Level order traversal keeping track of nodes at every level ; Get the size of queue when the level order traversal for one level finishes ; Iterate for all the nodes in the queue currently ; Dequeue an node from queue ; Enqueue the children of dequeued node ; Update the maximum level sum value ; Update the minimum level sum value ; Return the result ; Driver Code ; Number of nodes and edges ; Edges of the N - ary tree ; Given cost ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; void maxAbsDiffLevelSum ( int N , int M , vector < int > cost , int Edges [ ] [ 2 ] ) { vector < int > adj [ N ] ; for ( int i = 0 ; i < M ; i ++ ) { int u = Edges [ i ] [ 0 ] ; int v = Edges [ i ] [ 1 ] ; adj [ u ] . push_back ( v ) ; } int maxSum = cost [ 0 ] , minSum = cost [ 0 ] ; queue < int > q ; q . push ( 0 ) ; while ( ! q . empty ( ) ) { int count = q . size ( ) ; int sum = 0 ; while ( count -- ) { int temp = q . front ( ) ; q . pop ( ) ; sum = sum + cost [ temp ] ; for ( int i = 0 ; i < adj [ temp ] . size ( ) ; i ++ ) { q . push ( adj [ temp ] [ i ] ) ; } } maxSum = max ( sum , maxSum ) ; minSum = min ( sum , minSum ) ; } cout << abs ( maxSum - minSum ) ; } int main ( ) { int N = 10 , M = 9 ; int Edges [ ] [ 2 ] = { { 0 , 1 } , { 0 , 2 } , { 0 , 3 } , { 1 , 4 } , { 1 , 5 } , { 3 , 6 } , { 6 , 7 } , { 6 , 8 } , { 6 , 9 } } ; vector < int > cost = { 1 , 2 , -1 , 3 , 4 , 5 , 8 , 6 , 12 , 7 } ; maxAbsDiffLevelSum ( N , M , cost , Edges ) ; return 0 ; } |
Split array into subarrays at minimum cost by minimizing count of repeating elements in each subarray | C ++ program for the above approach ; Function to find the minimum cost of splitting the array into subarrays ; Size of the array ; Get the maximum element ; dp [ ] will store the minimum cost upto index i ; Initialize the result array ; Initialise the first element ; Create the frequency array ; Update the frequency ; Counting the cost of the duplicate element ; Minimum cost of operation from 0 to j ; Total cost of the array ; Driver Code ; Given cost K ; Function Call | #include <bits/stdc++.h> NEW_LINE #define ll long long NEW_LINE using namespace std ; int findMinCost ( vector < int > & a , int k ) { int n = ( int ) a . size ( ) ; int max_ele = * max_element ( a . begin ( ) , a . end ( ) ) ; ll dp [ n + 1 ] ; for ( int i = 1 ; i <= n ; ++ i ) dp [ i ] = INT_MAX ; dp [ 0 ] = 0 ; for ( int i = 0 ; i < n ; ++ i ) { int freq [ max_ele + 1 ] ; memset ( freq , 0 , sizeof freq ) ; for ( int j = i ; j < n ; ++ j ) { freq [ a [ j ] ] ++ ; int cost = 0 ; for ( int x = 0 ; x <= max_ele ; ++ x ) { cost += ( freq [ x ] == 1 ) ? 0 : freq [ x ] ; } dp [ j + 1 ] = min ( dp [ i ] + cost + k , dp [ j + 1 ] ) ; } } return dp [ n ] ; } int main ( ) { vector < int > arr = { 1 , 2 , 1 , 1 , 1 } ; int K = 2 ; cout << findMinCost ( arr , K ) ; return 0 ; } |
Find subarray with given sum | Set 2 ( Handles Negative Numbers ) | C ++ program to print subarray with sum as given sum ; Function to print subarray with sum as given sum ; create an empty map ; if curr_sum is equal to target sum we found a subarray starting from index 0 and ending at index i ; If curr_sum - sum already exists in map we have found a subarray with target sum ; if value is not present then add to hashmap ; If we reach here , then no subarray exists ; Driver program to test above function | #include <bits/stdc++.h> NEW_LINE using namespace std ; void subArraySum ( int arr [ ] , int n , int sum ) { unordered_map < int , int > map ; int curr_sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { curr_sum = curr_sum + arr [ i ] ; if ( curr_sum == sum ) { cout << " Sum ▁ found ▁ between ▁ indexes ▁ " << 0 << " ▁ to ▁ " << i << endl ; return ; } if ( map . find ( curr_sum - sum ) != map . end ( ) ) { cout << " Sum ▁ found ▁ between ▁ indexes ▁ " << map [ curr_sum - sum ] + 1 << " ▁ to ▁ " << i << endl ; return ; } map [ curr_sum ] = i ; } cout << " No ▁ subarray ▁ with ▁ given ▁ sum ▁ exists " ; } int main ( ) { int arr [ ] = { 10 , 2 , -2 , -20 , 10 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int sum = -10 ; subArraySum ( arr , n , sum ) ; return 0 ; } |
Write Code to Determine if Two Trees are Identical | C ++ program to see if two trees are identical ; A binary tree node has data , pointer to left child and a pointer to right child ; Helper function that allocates a new node with the given data and NULL left and right pointers . ; Given two trees , return true if they are structurally identical ; 1. both empty ; 2. both non - empty -> compare them ; 3. one empty , one not -> false ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; class node { public : int data ; node * left ; node * right ; } ; node * newNode ( int data ) { node * Node = new node ( ) ; Node -> data = data ; Node -> left = NULL ; Node -> right = NULL ; return ( Node ) ; } int identicalTrees ( node * a , node * b ) { if ( a == NULL && b == NULL ) return 1 ; if ( a != NULL && b != NULL ) { return ( a -> data == b -> data && identicalTrees ( a -> left , b -> left ) && identicalTrees ( a -> right , b -> right ) ) ; } return 0 ; } int main ( ) { node * root1 = newNode ( 1 ) ; node * root2 = newNode ( 1 ) ; root1 -> left = newNode ( 2 ) ; root1 -> right = newNode ( 3 ) ; root1 -> left -> left = newNode ( 4 ) ; root1 -> left -> right = newNode ( 5 ) ; root2 -> left = newNode ( 2 ) ; root2 -> right = newNode ( 3 ) ; root2 -> left -> left = newNode ( 4 ) ; root2 -> left -> right = newNode ( 5 ) ; if ( identicalTrees ( root1 , root2 ) ) cout << " Both ▁ tree ▁ are ▁ identical . " ; else cout << " Trees ▁ are ▁ not ▁ identical . " ; return 0 ; } |
Queries to find Kth greatest character in a range [ L , R ] from a string with updates | C ++ Program to implement the above approach ; Maximum Size of a String ; Fenwick Tree to store the frequencies of 26 alphabets ; Size of the String . ; Function to update Fenwick Tree for Character c at index val ; Add val to current node Fenwick Tree ; Move index to parent node in update View ; Function to get sum of frequencies of character c till index ; Stores the sum ; Add current element of Fenwick tree to sum ; Move index to parent node in getSum View ; Function to create the Fenwick tree ; Function to print the kth largest character in the range of l to r ; Stores the count of characters ; Stores the required character ; Calculate frequency of C in the given range ; Increase count ; If count exceeds K ; Required character found ; Function to update character at pos by character s ; 0 based index system ; Driver Code ; Makes the string 1 - based indexed ; Number of queries ; Construct the Fenwick Tree | #include " bits / stdc + + . h " NEW_LINE using namespace std ; const int maxn = 100005 ; int BITree [ 26 ] [ maxn ] ; int N ; void update_BITree ( int index , char C , int val ) { while ( index <= N ) { BITree [ C - ' a ' ] [ index ] += val ; index += ( index & - index ) ; } } int sum_BITree ( int index , char C ) { int s = 0 ; while ( index ) { s += BITree [ C - ' a ' ] [ index ] ; index -= ( index & - index ) ; } return s ; } void buildTree ( string str ) { for ( int i = 1 ; i <= N ; i ++ ) { update_BITree ( i , str [ i ] , 1 ) ; } cout << endl ; } char printCharacter ( string str , int l , int r , int k ) { int count = 0 ; char ans ; for ( char C = ' z ' ; C >= ' a ' ; C -- ) { int times = sum_BITree ( r , C ) - sum_BITree ( l - 1 , C ) ; count += times ; if ( count >= k ) { ans = C ; break ; } } return ans ; } void updateTree ( string str , int pos , char s ) { int index = pos ; update_BITree ( index , str [ index ] , -1 ) ; str [ index ] = s ; update_BITree ( index , s , 1 ) ; } int main ( ) { string str = " abcddef " ; N = str . size ( ) ; str = ' # ' + str ; int Q = 3 ; buildTree ( str ) ; cout << printCharacter ( str , 1 , 2 , 2 ) << endl ; updateTree ( str , 4 , ' g ' ) ; cout << printCharacter ( str , 1 , 5 , 4 ) << endl ; return 0 ; } |
Generate a string from an array of alphanumeric strings based on given conditions | C ++ program for the above approach ; Function to generate required string ; To store the result ; Split name and number ; Stores the maximum number less than or equal to the length of name ; Check for number by parsing it to integer if it is greater than max number so far ; Check if no such number is found then we append X to the result . ; Otherwise ; Append max index of the name ; Return the final string ; Driver Code ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; string generatePassword ( vector < string > arr , char T ) { string result ; for ( auto s : arr ) { int index ; for ( int i = 0 ; i < s . size ( ) ; i ++ ) { if ( s [ i ] == ' : ' ) { index = i ; break ; } } string name = s . substr ( 0 , index ) ; string number = s . substr ( index + 1 , s . size ( ) - index - 1 ) ; int n = name . length ( ) ; int max = 0 ; for ( int i = 0 ; i < number . length ( ) ; i ++ ) { int temp = number [ i ] - '0' ; if ( temp > max && temp <= n ) max = temp ; } if ( max == 0 ) result . push_back ( T ) ; else result . push_back ( name [ max - 1 ] ) ; } return result ; } int main ( ) { vector < string > arr = { " Geeks : 89167" , " gfg : 68795" } ; char T = ' X ' ; cout << ( generatePassword ( arr , T ) ) ; } |
Minimum number of edges required to be removed from an Undirected Graph to make it acyclic | C ++ Program to implement the above approach ; Stores the adjacency list ; Stores if a vertex is visited or not ; Function to perform DFS Traversal to count the number and size of all connected components ; Mark the current node as visited ; Traverse the adjacency list of the current node ; For every unvisited node ; Recursive DFS Call ; Function to add undirected edge in the graph ; Function to calculate minimum number of edges to be removed ; Create Adjacency list ; Iterate over all the nodes ; Print the final count ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; vector < int > vec [ 100001 ] ; bool vis [ 100001 ] ; int cc = 1 ; void dfs ( int node ) { vis [ node ] = true ; for ( auto x : vec [ node ] ) { if ( ! vis [ x ] ) { cc ++ ; dfs ( x ) ; } } } void addEdge ( int u , int v ) { vec [ u ] . push_back ( v ) ; vec [ v ] . push_back ( u ) ; } void minEdgeRemoved ( int N , int M , int Edges [ ] [ 2 ] ) { for ( int i = 0 ; i < M ; i ++ ) { addEdge ( Edges [ i ] [ 0 ] , Edges [ i ] [ 1 ] ) ; } memset ( vis , false , sizeof ( vis ) ) ; int k = 0 ; for ( int i = 1 ; i <= N ; i ++ ) { if ( ! vis [ i ] ) { cc = 1 ; dfs ( i ) ; k ++ ; } } cout << M - N + k << endl ; } int main ( ) { int N = 3 , M = 2 ; int Edges [ ] [ 2 ] = { { 1 , 2 } , { 2 , 3 } } ; minEdgeRemoved ( N , M , Edges ) ; } |
Group Shifted String | C / C ++ program to print groups of shifted strings together . ; Total lowercase letter ; Method to a difference string for a given string . If string is " adf " then difference string will be " cb " ( first difference 3 then difference 2 ) ; Representing the difference as char ; This string will be 1 less length than str ; Method for grouping shifted string ; map for storing indices of string which are in same group ; iterating through map to print group ; Driver method to test above methods | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int ALPHA = 26 ; string getDiffString ( string str ) { string shift = " " ; for ( int i = 1 ; i < str . length ( ) ; i ++ ) { int dif = str [ i ] - str [ i - 1 ] ; if ( dif < 0 ) dif += ALPHA ; shift += ( dif + ' a ' ) ; } return shift ; } void groupShiftedString ( string str [ ] , int n ) { map < string , vector < int > > groupMap ; for ( int i = 0 ; i < n ; i ++ ) { string diffStr = getDiffString ( str [ i ] ) ; groupMap [ diffStr ] . push_back ( i ) ; } for ( auto it = groupMap . begin ( ) ; it != groupMap . end ( ) ; it ++ ) { vector < int > v = it -> second ; for ( int i = 0 ; i < v . size ( ) ; i ++ ) cout << str [ v [ i ] ] << " ▁ " ; cout << endl ; } } int main ( ) { string str [ ] = { " acd " , " dfg " , " wyz " , " yab " , " mop " , " bdfh " , " a " , " x " , " moqs " } ; int n = sizeof ( str ) / sizeof ( str [ 0 ] ) ; groupShiftedString ( str , n ) ; return 0 ; } |
Check if a Binary Tree consists of a pair of leaf nodes with sum K | C ++ Program to implement the above approach ; Stores if a pair exists or not ; Struct binary tree node ; Creates a new node ; Function to check if a pair of leaf nodes exists with sum K ; checks if root is NULL ; Checks if the current node is a leaf node ; Checks for a valid pair of leaf nodes ; Insert value of current node into the set ; Traverse left and right subtree ; Driver Code ; Construct binary tree ; Stores the leaf nodes | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool pairFound = false ; struct Node { int data ; Node * left , * right ; } ; Node * newNode ( int data ) { Node * temp = new Node ( ) ; temp -> data = data ; temp -> left = temp -> right = NULL ; return temp ; } void pairSum ( Node * root , int target , unordered_set < int > & S ) { if ( ! root ) return ; if ( ! root -> left and ! root -> right ) { if ( S . count ( target - root -> data ) ) { cout << target - root -> data << " ▁ " << root -> data ; pairFound = true ; return ; } else S . insert ( root -> data ) ; } pairSum ( root -> left , target , S ) ; pairSum ( root -> right , target , S ) ; } int main ( ) { Node * root = newNode ( 1 ) ; root -> left = newNode ( 2 ) ; root -> left -> left = newNode ( 4 ) ; root -> left -> right = newNode ( 5 ) ; root -> right = newNode ( 3 ) ; root -> right -> left = newNode ( 6 ) ; root -> right -> right = newNode ( 7 ) ; root -> right -> right -> right = newNode ( 8 ) ; unordered_set < int > S ; int K = 13 ; pairSum ( root , K , S ) ; if ( pairFound == false ) cout << " - 1" ; return 0 ; } |
Maximum non | C ++ Program to implement the above approach ; Function to print the maximum rooks and their positions ; Initialize row and col array ; Marking the location of already placed rooks ; Print number of non - attacking rooks that can be placed ; To store the placed rook location ; Print lexographically smallest order ; Driver Code ; Size of board ; Number of rooks already placed ; Position of rooks ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; void countRooks ( int n , int k , int pos [ 2 ] [ 2 ] ) { int row [ n ] = { 0 } ; int col [ n ] = { 0 } ; for ( int i = 0 ; i < n ; i ++ ) { row [ i ] = 0 ; col [ i ] = 0 ; } for ( int i = 0 ; i < k ; i ++ ) { row [ pos [ i ] [ 0 ] - 1 ] = 1 ; col [ pos [ i ] [ 1 ] - 1 ] = 1 ; } int res = n - k ; cout << res << " ▁ " << endl ; int ri = 0 , ci = 0 ; while ( res -- > 0 ) { while ( row [ ri ] == 1 ) { ri ++ ; } while ( col [ ci ] == 1 ) { ci ++ ; } cout << ( ri + 1 ) << " ▁ " << ( ci + 1 ) << " ▁ " << endl ; ri ++ ; ci ++ ; } } int main ( ) { int N = 4 ; int K = 2 ; int pos [ 2 ] [ 2 ] = { { 1 , 4 } , { 2 , 2 } } ; countRooks ( N , K , pos ) ; } |
Minimum insertions to form a palindrome with permutations allowed | CPP program to find minimum number of insertions to make a string palindrome ; Function will return number of characters to be added ; To store string length ; To store number of characters occurring odd number of times ; To store count of each character ; To store occurrence of each character ; To count characters with odd occurrence ; As one character can be odd return res - 1 but if string is already palindrome return 0 ; Driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int minInsertion ( string str ) { int n = str . length ( ) ; int res = 0 ; int count [ 26 ] = { 0 } ; for ( int i = 0 ; i < n ; i ++ ) count [ str [ i ] - ' a ' ] ++ ; for ( int i = 0 ; i < 26 ; i ++ ) if ( count [ i ] % 2 == 1 ) res ++ ; return ( res == 0 ) ? 0 : res - 1 ; } int main ( ) { string str = " geeksforgeeks " ; cout << minInsertion ( str ) ; return 0 ; } |
Check for Palindrome after every character replacement Query | C ++ program to find if string becomes palindrome after every query . ; Function to check if string is Palindrome or Not ; Takes two inputs for Q queries . For every query , it prints Yes if string becomes palindrome and No if not . ; Process all queries one by one ; query 1 : i1 = 3 , i2 = 0 , ch = ' e ' query 2 : i1 = 0 , i2 = 2 , ch = ' s ' replace character at index i1 & i2 with new ' ch ' ; check string is palindrome or not ; Driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool IsPalindrome ( string & str ) { int n = strlen ( str ) ; for ( int i = 0 ; i < n / 2 ; i ++ ) if ( str [ i ] != str [ n - 1 - i ] ) return false ; return true ; } void Query ( string & str , int Q ) { int i1 , i2 ; char ch ; for ( int q = 1 ; q <= Q ; q ++ ) { cin >> i1 >> i2 >> ch ; str [ i1 ] = str [ i2 ] = ch ; ( isPalindrome ( str ) == true ) ? cout << " YES " << endl : cout << " NO " << endl ; } } int main ( ) { char str [ ] = " geeks " ; int Q = 2 ; Query ( str , Q ) ; return 0 ; } |
Generate a string which differs by only a single character from all given strings | C ++ Program to implement the above approach ; Function to check if a given string differs by a single character from all the strings in an array ; Traverse over the strings ; Stores the count of characters differing from the strings ; If differs by more than one character ; Function to find the string which only differ at one position from the all given strings of the array ; Size of the array ; Length of a string ; Replace i - th character by all possible characters ; Check if it differs by a single character from all other strings ; If desired string is obtained ; Print the answer ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE #define ll long long NEW_LINE using namespace std ; bool check ( string ans , vector < string > & s , int n , int m ) { for ( int i = 1 ; i < n ; ++ i ) { int count = 0 ; for ( int j = 0 ; j < m ; ++ j ) { if ( ans [ j ] != s [ i ] [ j ] ) count ++ ; } if ( count > 1 ) return false ; } return true ; } string findString ( vector < string > & s ) { int n = s . size ( ) ; int m = s [ 0 ] . size ( ) ; string ans = s [ 0 ] ; int flag = 0 ; for ( int i = 0 ; i < m ; ++ i ) { for ( int j = 0 ; j < 26 ; ++ j ) { string x = ans ; x [ i ] = ( j + ' a ' ) ; if ( check ( x , s , n , m ) ) { ans = x ; flag = 1 ; break ; } } if ( flag == 1 ) break ; } if ( flag == 0 ) return " - 1" ; else return ans ; } int main ( ) { vector < string > s = { " geeks " , " teeds " } ; cout << findString ( s ) << endl ; } |
Minimum increments of Non | C ++ program to implement the above approach ; Function to return to the minimum number of operations required to make the array non - decreasing ; Stores the count of operations ; If arr [ i ] > arr [ i + 1 ] , add arr [ i ] - arr [ i + 1 ] to the answer Otherwise , add 0 ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int getMinOps ( int arr [ ] , int n ) { int ans = 0 ; for ( int i = 0 ; i < n - 1 ; i ++ ) { ans += max ( arr [ i ] - arr [ i + 1 ] , 0 ) ; } return ans ; } int main ( ) { int arr [ ] = { 1 , 3 , 1 , 2 , 4 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << ( getMinOps ( arr , n ) ) ; } |
Maximum difference between frequency of two elements such that element having greater frequency is also greater | C ++ program to find maximum difference between frequency of any two element such that element with greater frequency is also greater in value . ; Return the maximum difference between frequencies of any two elements such that element with greater frequency is also greater in value . ; Finding the frequency of each element . ; finding difference such that element having greater frequency is also greater in value . ; Driven Program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxdiff ( int arr [ ] , int n ) { unordered_map < int , int > freq ; for ( int i = 0 ; i < n ; i ++ ) freq [ arr [ i ] ] ++ ; int ans = 0 ; for ( int i = 0 ; i < n ; i ++ ) { for ( int j = 0 ; j < n ; j ++ ) { if ( freq [ arr [ i ] ] > freq [ arr [ j ] ] && arr [ i ] > arr [ j ] ) ans = max ( ans , freq [ arr [ i ] ] - freq [ arr [ j ] ] ) ; else if ( freq [ arr [ i ] ] < freq [ arr [ j ] ] && arr [ i ] < arr [ j ] ) ans = max ( ans , freq [ arr [ j ] ] - freq [ arr [ i ] ] ) ; } } return ans ; } int main ( ) { int arr [ ] = { 3 , 1 , 3 , 2 , 3 , 2 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << maxdiff ( arr , n ) << endl ; return 0 ; } |
Maximum difference between frequency of two elements such that element having greater frequency is also greater | Efficient C ++ program to find maximum difference between frequency of any two elements such that element with greater frequency is also greater in value . ; Return the maximum difference between frequencies of any two elements such that element with greater frequency is also greater in value . ; Finding the frequency of each element . ; Sorting the distinct element ; Iterate through all sorted distinct elements . For each distinct element , maintaining the element with minimum frequency than that element and also finding the maximum frequency difference ; Driven Program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxdiff ( int arr [ ] , int n ) { unordered_map < int , int > freq ; int dist [ n ] ; int j = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( freq . find ( arr [ i ] ) == freq . end ( ) ) dist [ j ++ ] = arr [ i ] ; freq [ arr [ i ] ] ++ ; } sort ( dist , dist + j ) ; int min_freq = n + 1 ; int ans = 0 ; for ( int i = 0 ; i < j ; i ++ ) { int cur_freq = freq [ dist [ i ] ] ; ans = max ( ans , cur_freq - min_freq ) ; min_freq = min ( min_freq , cur_freq ) ; } return ans ; } int main ( ) { int arr [ ] = { 3 , 1 , 3 , 2 , 3 , 2 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << maxdiff ( arr , n ) << endl ; return 0 ; } |
Maximum Sum possible by selecting X elements from a Matrix based on given conditions | C ++ 14 program to implement the above approach ; Function to calculate the maximum possible sum by selecting X elements from the Matrix ; Generate prefix sum of the matrix ; Initialize [ , ] dp ; Maximum possible sum by selecting 0 elements from the first i rows ; If a single row is present ; If elements from the current row is not selected ; Iterate over all possible selections from current row ; Return maximum possible sum ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int n , m , X ; int maxSum ( vector < vector < int > > grid ) { vector < vector < int > > prefsum ( n , vector < int > ( m ) ) ; for ( int i = 0 ; i < n ; i ++ ) { for ( int x = 0 ; x < m ; x ++ ) { if ( x == 0 ) prefsum [ i ] [ x ] = grid [ i ] [ x ] ; else prefsum [ i ] [ x ] = prefsum [ i ] [ x - 1 ] + grid [ i ] [ x ] ; } } vector < vector < int > > dp ( n , vector < int > ( X + 1 , INT_MIN ) ) ; for ( int i = 0 ; i < n ; i ++ ) dp [ i ] [ 0 ] = 0 ; for ( int i = 1 ; i <= min ( m , X ) ; ++ i ) { dp [ 0 ] [ i ] = dp [ 0 ] [ i - 1 ] + grid [ 0 ] [ i - 1 ] ; } for ( int i = 1 ; i < n ; ++ i ) { for ( int j = 1 ; j <= X ; ++ j ) { dp [ i ] [ j ] = dp [ i - 1 ] [ j ] ; for ( int x = 1 ; x <= min ( j , m ) ; x ++ ) { dp [ i ] [ j ] = max ( dp [ i ] [ j ] , dp [ i - 1 ] [ j - x ] + prefsum [ i ] [ x - 1 ] ) ; } } } return dp [ n - 1 ] [ X ] ; } int main ( ) { n = 4 ; m = 4 ; X = 6 ; vector < vector < int > > grid = { { 3 , 2 , 6 , 1 } , { 1 , 9 , 2 , 4 } , { 4 , 1 , 3 , 9 } , { 3 , 8 , 2 , 1 } } ; int ans = maxSum ( grid ) ; cout << ( ans ) ; return 0 ; } |
Difference between highest and least frequencies in an array | CPP code to find the difference between highest and least frequencies ; sort the array ; checking consecutive elements ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findDiff ( int arr [ ] , int n ) { sort ( arr , arr + n ) ; int count = 0 , max_count = 0 , min_count = n ; for ( int i = 0 ; i < ( n - 1 ) ; i ++ ) { if ( arr [ i ] == arr [ i + 1 ] ) { count += 1 ; continue ; } else { max_count = max ( max_count , count ) ; min_count = min ( min_count , count ) ; count = 0 ; } } return ( max_count - min_count ) ; } int main ( ) { int arr [ ] = { 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << findDiff ( arr , n ) << " STRNEWLINE " ; return 0 ; } |
Minimum Decrements on Subarrays required to reduce all Array elements to zero | C ++ Program to implement the above approach ; Function to count the minimum number of subarrays that are required to be decremented by 1 ; Base Case ; Initialize ans to first element ; For A [ i ] > A [ i - 1 ] , operation ( A [ i ] - A [ i - 1 ] ) is required ; Return the answer ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int min_operations ( vector < int > & A ) { if ( A . size ( ) == 0 ) return 0 ; int ans = A [ 0 ] ; for ( int i = 1 ; i < A . size ( ) ; i ++ ) { ans += max ( A [ i ] - A [ i - 1 ] , 0 ) ; } return ans ; } int main ( ) { vector < int > A { 1 , 2 , 3 , 2 , 1 } ; cout << min_operations ( A ) << " STRNEWLINE " ; return 0 ; } |
Difference between highest and least frequencies in an array | CPP code to find the difference between highest and least frequencies ; Put all elements in a hash map ; Find counts of maximum and minimum frequent elements ; Driver | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findDiff ( int arr [ ] , int n ) { unordered_map < int , int > hm ; for ( int i = 0 ; i < n ; i ++ ) hm [ arr [ i ] ] ++ ; int max_count = 0 , min_count = n ; for ( auto x : hm ) { max_count = max ( max_count , x . second ) ; min_count = min ( min_count , x . second ) ; } return ( max_count - min_count ) ; } int main ( ) { int arr [ ] = { 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << findDiff ( arr , n ) << " STRNEWLINE " ; return 0 ; } |
Iterative function to check if two trees are identical | Iterative C ++ program to check if two ; A Binary Tree Node ; Iterative method to find height of Binary Tree ; Return true if both trees are empty ; Return false if one is empty and other is not ; Create an empty queues for simultaneous traversals ; Enqueue Roots of trees in respective queues ; Get front nodes and compare them ; Remove front nodes from queues ; Enqueue left children of both nodes ; If one left child is empty and other is not ; Right child code ( Similar to left child code ) ; Utility function to create a new tree node ; Driver program to test above functions | #include <bits/stdc++.h> NEW_LINE using namespace std ; struct Node { int data ; struct Node * left , * right ; } ; bool areIdentical ( Node * root1 , Node * root2 ) { if ( root1 == NULL && root2 == NULL ) return true ; if ( root1 == NULL ) return false ; if ( root2 == NULL ) return false ; queue < Node * > q1 , q2 ; q1 . push ( root1 ) ; q2 . push ( root2 ) ; while ( ! q1 . empty ( ) && ! q2 . empty ( ) ) { Node * n1 = q1 . front ( ) ; Node * n2 = q2 . front ( ) ; if ( n1 -> data != n2 -> data ) return false ; q1 . pop ( ) , q2 . pop ( ) ; if ( n1 -> left && n2 -> left ) { q1 . push ( n1 -> left ) ; q2 . push ( n2 -> left ) ; } else if ( n1 -> left n2 -> left ) return false ; if ( n1 -> right && n2 -> right ) { q1 . push ( n1 -> right ) ; q2 . push ( n2 -> right ) ; } else if ( n1 -> right n2 -> right ) return false ; } return true ; } Node * newNode ( int data ) { Node * temp = new Node ; temp -> data = data ; temp -> left = temp -> right = NULL ; return temp ; } int main ( ) { Node * root1 = newNode ( 1 ) ; root1 -> left = newNode ( 2 ) ; root1 -> right = newNode ( 3 ) ; root1 -> left -> left = newNode ( 4 ) ; root1 -> left -> right = newNode ( 5 ) ; Node * root2 = newNode ( 1 ) ; root2 -> left = newNode ( 2 ) ; root2 -> right = newNode ( 3 ) ; root2 -> left -> left = newNode ( 4 ) ; root2 -> left -> right = newNode ( 5 ) ; areIdentical ( root1 , root2 ) ? cout << " Yes " : cout << " No " ; return 0 ; } |
Queries to check if vertices X and Y are in the same Connected Component of an Undirected Graph | C ++ Program to implement the above approach ; Maximum number of nodes or vertices that can be present in the graph ; Store the parent of each vertex ; Stores the size of each set ; Function to initialize the parent of each vertices ; Function to find the representative of the set which contain element v ; Path compression technique to optimize the time complexity ; Function to merge two different set into a single set by finding the representative of each set and merge the smallest set with the larger one ; Finding the set representative of each element ; Check if they have different set repersentative ; Compare the set sizes ; Assign parent of smaller set to the larger one ; Add the size of smaller set to the larger one ; Function to check the vertices are on the same set or not ; Check if they have same set representative or not ; Driver Code ; Connected vertices and taking them into single set ; Number of queries ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define MAX_NODES 100005 NEW_LINE int parent [ MAX_NODES ] ; int size_set [ MAX_NODES ] ; void make_set ( int v ) { parent [ v ] = v ; size_set [ v ] = 1 ; } int find_set ( int v ) { if ( v == parent [ v ] ) return v ; return parent [ v ] = find_set ( parent [ v ] ) ; } void union_set ( int a , int b ) { a = find_set ( a ) ; b = find_set ( b ) ; if ( a != b ) { if ( size_set [ a ] < size_set [ b ] ) swap ( a , b ) ; parent [ b ] = a ; size_set [ a ] += size_set [ b ] ; } } string check ( int a , int b ) { a = find_set ( a ) ; b = find_set ( b ) ; return ( a == b ) ? " Yes " : " No " ; } int main ( ) { int n = 5 , m = 3 ; make_set ( 1 ) ; make_set ( 2 ) ; make_set ( 3 ) ; make_set ( 4 ) ; make_set ( 5 ) ; union_set ( 1 , 3 ) ; union_set ( 3 , 4 ) ; union_set ( 3 , 5 ) ; int q = 3 ; cout << check ( 1 , 5 ) << endl ; cout << check ( 3 , 2 ) << endl ; cout << check ( 5 , 2 ) << endl ; return 0 ; } |
Count of N | C ++ Program to implement the above approach ; Function to calculate the total count of N - digit numbers such that the sum of digits at even positions and odd positions are divisible by A and B respectively ; For single digit numbers ; Largest possible number ; Count of possible odd digits ; Count of possible even digits ; Calculate total count of sequences of length even_count with sum divisible by A where first digit can be zero ; Calculate total count of sequences of length odd_count with sum divisible by B where cannot be zero ; Return their product as answer ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; long count ( int N , int A , int B ) { if ( N == 1 ) { return 9 / B + 1 ; } int max_sum = 9 * N ; int odd_count = N / 2 + N % 2 ; int even_count = N - odd_count ; long dp [ even_count ] [ max_sum + 1 ] = { 0 } ; for ( int i = 0 ; i <= 9 ; i ++ ) dp [ 0 ] [ i % A ] ++ ; for ( int i = 1 ; i < even_count ; i ++ ) { for ( int j = 0 ; j <= 9 ; j ++ ) { for ( int k = 0 ; k <= max_sum ; k ++ ) { if ( dp [ i - 1 ] [ k ] > 0 ) dp [ i ] [ ( j + k ) % A ] += dp [ i - 1 ] [ k ] ; } } } long dp1 [ odd_count ] [ max_sum + 1 ] = { 0 } ; for ( int i = 1 ; i <= 9 ; i ++ ) dp1 [ 0 ] [ i % B ] ++ ; for ( int i = 1 ; i < odd_count ; i ++ ) { for ( int j = 0 ; j <= 9 ; j ++ ) { for ( int k = 0 ; k <= max_sum ; k ++ ) { if ( dp1 [ i - 1 ] [ k ] > 0 ) dp1 [ i ] [ ( j + k ) % B ] += dp1 [ i - 1 ] [ k ] ; } } } return dp [ even_count - 1 ] [ 0 ] * dp1 [ odd_count - 1 ] [ 0 ] ; } int main ( ) { int N = 2 , A = 2 , B = 5 ; cout << count ( N , A , B ) ; } |
Maximum possible difference of two subsets of an array | CPP find maximum difference of subset sum ; function for maximum subset diff ; if frequency of any element is two make both equal to zero ; driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxDiff ( int arr [ ] , int n ) { int SubsetSum_1 = 0 , SubsetSum_2 = 0 ; for ( int i = 0 ; i <= n - 1 ; i ++ ) { bool isSingleOccurance = true ; for ( int j = i + 1 ; j <= n - 1 ; j ++ ) { if ( arr [ i ] == arr [ j ] ) { isSingleOccurance = false ; arr [ i ] = arr [ j ] = 0 ; break ; } } if ( isSingleOccurance ) { if ( arr [ i ] > 0 ) SubsetSum_1 += arr [ i ] ; else SubsetSum_2 += arr [ i ] ; } } return abs ( SubsetSum_1 - SubsetSum_2 ) ; } int main ( ) { int arr [ ] = { 4 , 2 , -3 , 3 , -2 , -2 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Maximum ▁ Difference ▁ = ▁ " << maxDiff ( arr , n ) ; return 0 ; } |
Count of all possible Paths in a Tree such that Node X does not appear before Node Y | C ++ Program to implement the above approach ; Maximum number of nodes ; Vector to store the tree ; Function to perform DFS Traversal ; Mark the node as visited ; Initialize the subtree size of each node as 1 ; If the node is same as A ; Mark check_subtree [ node ] as true ; Otherwise ; Iterate over the adjacent nodes ; If the adjacent node is not visited ; Update the size of the subtree of current node ; Check if the subtree of current node contains node A ; Return size of subtree of node ; Function to add edges to the tree ; Function to calculate the number of possible paths ; Stores the size of subtree of each node ; Stores which nodes are visited ; Stores if the subtree of a node contains node A ; DFS Call ; Stores the difference between total number of nodes and subtree size of an immediate child of Y lies between the path from A to B ; Iterate over the adjacent nodes B ; If the node is in the path from A to B ; Calculate the difference ; Return the final answer ; Driver Code ; Insert Edges | #include <bits/stdc++.h> NEW_LINE #define int long long int NEW_LINE using namespace std ; const int NN = 3e5 ; vector < int > G [ NN + 1 ] ; int dfs ( int node , int A , int * subtree_size , int * visited , int * check_subtree ) { visited [ node ] = true ; subtree_size [ node ] = 1 ; if ( node == A ) { check_subtree [ node ] = true ; } else check_subtree [ node ] = false ; for ( int v : G [ node ] ) { if ( ! visited [ v ] ) { subtree_size [ node ] += dfs ( v , A , subtree_size , visited , check_subtree ) ; check_subtree [ node ] = check_subtree [ node ] | check_subtree [ v ] ; } } return subtree_size [ node ] ; } void addedge ( int node1 , int node2 ) { G [ node1 ] . push_back ( node2 ) ; G [ node2 ] . push_back ( node1 ) ; } int numberOfPairs ( int N , int B , int A ) { int subtree_size [ N + 1 ] ; int visited [ N + 1 ] ; memset ( visited , 0 , sizeof ( visited ) ) ; int check_subtree [ N + 1 ] ; dfs ( B , A , subtree_size , visited , check_subtree ) ; int difference ; for ( int v : G [ B ] ) { if ( check_subtree [ v ] ) { difference = N - subtree_size [ v ] ; break ; } } return ( N * ( N - 1 ) ) - difference * ( subtree_size [ A ] ) ; } int32_t main ( ) { int N = 9 ; int X = 5 , Y = 3 ; addedge ( 0 , 2 ) ; addedge ( 1 , 2 ) ; addedge ( 2 , 3 ) ; addedge ( 3 , 4 ) ; addedge ( 4 , 6 ) ; addedge ( 4 , 5 ) ; addedge ( 5 , 7 ) ; addedge ( 5 , 8 ) ; cout << numberOfPairs ( N , Y , X ) ; return 0 ; } |
Largest possible value of M not exceeding N having equal Bitwise OR and XOR between them | C ++ Program to implement the above approach ; Function to find required number M ; Initialising m ; Finding the index of the most significant bit of N ; Calculating required number ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int equalXORandOR ( int n ) { int m = 0 ; int MSB = ( int ) log2 ( n ) ; for ( int i = 0 ; i <= MSB ; i ++ ) { if ( ! ( n & ( 1 << i ) ) ) { m += ( 1 << i ) ; } } return m ; } int main ( ) { int n = 14 ; cout << equalXORandOR ( n ) ; return 0 ; } |
Maximum possible difference of two subsets of an array | CPP find maximum difference of subset sum ; function for maximum subset diff ; sort the array ; calculate the result ; check for last element ; return result ; driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxDiff ( int arr [ ] , int n ) { int result = 0 ; sort ( arr , arr + n ) ; for ( int i = 0 ; i < n - 1 ; i ++ ) { if ( arr [ i ] != arr [ i + 1 ] ) result += abs ( arr [ i ] ) ; else i ++ ; } if ( arr [ n - 2 ] != arr [ n - 1 ] ) result += abs ( arr [ n - 1 ] ) ; return result ; } int main ( ) { int arr [ ] = { 4 , 2 , -3 , 3 , -2 , -2 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Maximum ▁ Difference ▁ = ▁ " << maxDiff ( arr , n ) ; return 0 ; } |
Count of Palindromic Strings possible by swapping of a pair of Characters | C ++ Program to implement the above approach ; Function to return the count of possible palindromic strings ; Stores the frequencies of each character ; Stores the length of the string ; Increase the number of swaps , the current character make with its previous occurrences ; Increase frequency ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; long long findNewString ( string s ) { long long ans = 0 ; int freq [ 26 ] ; int n = s . length ( ) ; memset ( freq , 0 , sizeof freq ) ; for ( int i = 0 ; i < ( int ) s . length ( ) ; ++ i ) { ans += freq [ s [ i ] - ' a ' ] ; freq [ s [ i ] - ' a ' ] ++ ; } return ans ; } int main ( ) { string s = " aaabaaa " ; cout << findNewString ( s ) << ' ' ; return 0 ; } |
Maximum possible difference of two subsets of an array | CPP find maximum difference of subset sum ; function for maximum subset diff ; construct hash for positive elements ; calculate subset sum for positive elements ; construct hash for negative elements ; calculate subset sum for negative elements ; driver program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxDiff ( int arr [ ] , int n ) { unordered_map < int , int > hashPositive ; unordered_map < int , int > hashNegative ; int SubsetSum_1 = 0 , SubsetSum_2 = 0 ; for ( int i = 0 ; i <= n - 1 ; i ++ ) if ( arr [ i ] > 0 ) hashPositive [ arr [ i ] ] ++ ; for ( int i = 0 ; i <= n - 1 ; i ++ ) if ( arr [ i ] > 0 && hashPositive [ arr [ i ] ] == 1 ) SubsetSum_1 += arr [ i ] ; for ( int i = 0 ; i <= n - 1 ; i ++ ) if ( arr [ i ] < 0 ) hashNegative [ abs ( arr [ i ] ) ] ++ ; for ( int i = 0 ; i <= n - 1 ; i ++ ) if ( arr [ i ] < 0 && hashNegative [ abs ( arr [ i ] ) ] == 1 ) SubsetSum_2 += arr [ i ] ; return abs ( SubsetSum_1 - SubsetSum_2 ) ; } int main ( ) { int arr [ ] = { 4 , 2 , -3 , 3 , -2 , -2 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Maximum ▁ Difference ▁ = ▁ " << maxDiff ( arr , n ) ; return 0 ; } |
Change the given string according to the given conditions | C ++ program for the above approach ; Function to proofread the spells ; Loop to iterate over the characters of the string ; Push the current character c in the stack ; Check for Rule 1 ; Check for Rule 2 ; To store the resultant string ; Loop to iterate over the characters of stack ; Return the resultant string ; Driver Code ; Given string str ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; string proofreadSpell ( string & str ) { vector < char > result ; for ( char c : str ) { result . push_back ( c ) ; int n = result . size ( ) ; if ( n >= 3 ) { if ( result [ n - 1 ] == result [ n - 2 ] && result [ n - 1 ] == result [ n - 3 ] ) { result . pop_back ( ) ; } } n = result . size ( ) ; if ( n >= 4 ) { if ( result [ n - 1 ] == result [ n - 2 ] && result [ n - 3 ] == result [ n - 4 ] ) { result . pop_back ( ) ; } } } string resultStr = " " ; for ( char c : result ) { resultStr += c ; } return resultStr ; } int main ( ) { string str = " hello " ; cout << proofreadSpell ( str ) ; } |
Smallest subarray with k distinct numbers | C ++ program to find minimum range that contains exactly k distinct numbers . ; Prints the minimum range that contains exactly k distinct numbers . ; Consider every element as starting point . ; Find the smallest window starting with arr [ i ] and containing exactly k distinct elements . ; There are less than k distinct elements now , so no need to continue . ; If there was no window with k distinct elements ( k is greater than total distinct elements ) ; Driver code for above function . | #include <bits/stdc++.h> NEW_LINE using namespace std ; void minRange ( int arr [ ] , int n , int k ) { int l = 0 , r = n ; for ( int i = 0 ; i < n ; i ++ ) { unordered_set < int > s ; int j ; for ( j = i ; j < n ; j ++ ) { s . insert ( arr [ j ] ) ; if ( s . size ( ) == k ) { if ( ( j - i ) < ( r - l ) ) { r = j ; l = i ; } break ; } } if ( j == n ) break ; } if ( l == 0 && r == n ) cout << " Invalid ▁ k " ; else cout << l << " ▁ " << r ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 4 , 5 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int k = 3 ; minRange ( arr , n , k ) ; return 0 ; } |
Smallest subarray with k distinct numbers | C ++ program to find minimum range that contains exactly k distinct numbers . ; prints the minimum range that contains exactly k distinct numbers . ; Initially left and right side is - 1 and - 1 , number of distinct elements are zero and range is n . ; Initialize right side ; increment right side . ; if number of distinct elements less than k . ; if distinct elements are equal to k and length is less than previous length . ; if number of distinct elements less than k , then break . ; if distinct elements equals to k then try to increment left side . ; increment left side . ; it is same as explained in above loop . ; Driver code for above function . | #include <bits/stdc++.h> NEW_LINE using namespace std ; void minRange ( int arr [ ] , int n , int k ) { int l = 0 , r = n ; int j = -1 ; map < int , int > hm ; for ( int i = 0 ; i < n ; i ++ ) { while ( j < n ) { j ++ ; if ( hm . size ( ) < k ) hm [ arr [ j ] ] ++ ; if ( hm . size ( ) == k && ( ( r - l ) >= ( j - i ) ) ) { l = i ; r = j ; break ; } } if ( hm . size ( ) < k ) break ; while ( hm . size ( ) == k ) { if ( hm [ arr [ i ] ] == 1 ) hm . erase ( arr [ i ] ) ; else hm [ arr [ i ] ] -- ; i ++ ; if ( hm . size ( ) == k && ( r - l ) >= ( j - i ) ) { l = i ; r = j ; } } if ( hm [ arr [ i ] ] == 1 ) hm . erase ( arr [ i ] ) ; else hm [ arr [ i ] ] -- ; } if ( l == 0 && r == n ) cout << " Invalid ▁ k " << endl ; else cout << l << " ▁ " << r << endl ; } int main ( ) { int arr [ ] = { 1 , 1 , 2 , 2 , 3 , 3 , 4 , 5 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int k = 3 ; minRange ( arr , n , k ) ; return 0 ; } |
Sum of f ( a [ i ] , a [ j ] ) over all pairs in an array of n integers | CPP program to calculate the sum of f ( a [ i ] , aj ] ) ; Function to calculate the sum ; map to keep a count of occurrences ; Traverse in the list from start to end number of times a [ i ] can be in a pair and to get the difference we subtract pre_sum . ; if the ( a [ i ] - 1 ) is present then subtract that value as f ( a [ i ] , a [ i ] - 1 ) = 0 ; if the ( a [ i ] + 1 ) is present then add that value as f ( a [ i ] , a [ i ] - 1 ) = 0 here we add as a [ i ] - ( a [ i ] - 1 ) < 0 which would have been added as negative sum , so we add to remove this pair from the sum value ; keeping a counter for every element ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int sum ( int a [ ] , int n ) { unordered_map < int , int > cnt ; int ans = 0 , pre_sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { ans += ( i * a [ i ] ) - pre_sum ; pre_sum += a [ i ] ; if ( cnt [ a [ i ] - 1 ] ) ans -= cnt [ a [ i ] - 1 ] ; if ( cnt [ a [ i ] + 1 ] ) ans += cnt [ a [ i ] + 1 ] ; cnt [ a [ i ] ] ++ ; } return ans ; } int main ( ) { int a [ ] = { 1 , 2 , 3 , 1 , 3 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << sum ( a , n ) ; return 0 ; } |
Minimum distance between the maximum and minimum element of a given Array | C ++ Program to implement the above approach ; Function to find the minimum distance between the minimum and the maximum element ; Stores the minimum and maximum array element ; Stores the most recently traversed indices of the minimum and the maximum element ; Stores the minimum distance between the minimum and the maximium ; Find the maximum and the minimum element from the given array ; Find the minimum distance ; Check if current element is equal to minimum ; Check if current element is equal to maximum ; If both the minimum and the maximum element has occurred at least once ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int minDistance ( int a [ ] , int n ) { int maximum = -1 , minimum = INT_MAX ; int min_index = -1 , max_index = -1 ; int min_dist = n + 1 ; for ( int i = 0 ; i < n ; i ++ ) { if ( a [ i ] > maximum ) maximum = a [ i ] ; if ( a [ i ] < minimum ) minimum = a [ i ] ; } for ( int i = 0 ; i < n ; i ++ ) { if ( a [ i ] == minimum ) min_index = i ; if ( a [ i ] == maximum ) max_index = i ; if ( min_index != -1 && max_index != -1 ) min_dist = min ( min_dist , abs ( min_index - max_index ) ) ; } return min_dist ; } int main ( ) { int a [ ] = { 3 , 2 , 1 , 2 , 1 , 4 , 5 , 8 , 6 , 7 , 8 , 2 } ; int n = sizeof a / sizeof a [ 0 ] ; cout << minDistance ( a , n ) ; } |
Kth diagonal from the top left of a given matrix | C ++ implementation of the above approach ; Function returns required diagonal ; Initialize values to print upper diagonals ; Initialize values to print lower diagonals ; Traverse the diagonal ; Print its contents ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printDiagonal ( int K , int N , vector < vector < int > > & M ) { int startrow , startcol ; if ( K - 1 < N ) { startrow = K - 1 ; startcol = 0 ; } else { startrow = N - 1 ; startcol = K - N ; } for ( ; startrow >= 0 && startcol < N ; startrow -- , startcol ++ ) { cout << M [ startrow ] [ startcol ] << " ▁ " ; } } int main ( ) { int N = 3 , K = 4 ; vector < vector < int > > M = { { 4 , 7 , 8 } , { 9 , 2 , 3 } , { 0 , 4 , 1 } } ; printDiagonal ( K , N , M ) ; return 0 ; } |
Longest substring that starts with X and ends with Y | C ++ program for the above approach ; Function returns length of longest substring starting with X and ending with Y ; Length of string ; Find the length of the string starting with X from the beginning ; Find the length of the string ending with Y from the end ; Longest substring ; Print the length ; Driver Code ; Given string str ; Starting and Ending characters ; Function Call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int longestSubstring ( string str , char X , char Y ) { int N = str . length ( ) ; int start = 0 ; int end = N - 1 ; int xPos = 0 ; int yPos = 0 ; while ( true ) { if ( str [ start ] == X ) { xPos = start ; break ; } start ++ ; } while ( true ) { if ( str [ end ] == Y ) { yPos = end ; break ; } end -- ; } int length = ( yPos - xPos ) + 1 ; cout << length ; } int main ( ) { string str = " HASFJGHOGAKZZFEGA " ; char X = ' A ' , Y = ' Z ' ; longestSubstring ( str , X , Y ) ; return 0 ; } |
Find parent of given node in a Binary Tree with given postorder traversal | C ++ implementation to find the parent of the given node K in a binary tree whose post - order traversal is N natural numbers ; Function to find the parent of the given node ; Condition to check whether the given node is a root node . if it is then return - 1 because root node has no parent ; Loop till we found the given node ; Finding the middle node of the tree because at every level tree parent is divided into two halves ; if the node is found return the parent always the child nodes of every node is node / 2 or ( node - 1 ) ; if the node to be found is greater than the mid search for left subtree else search in right subtree ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findParent ( int height , int node ) { int start = 1 ; int end = pow ( 2 , height ) - 1 ; if ( end == node ) return -1 ; while ( node >= 1 ) { end = end - 1 ; int mid = start + ( end - start ) / 2 ; if ( mid == node end == node ) { return ( end + 1 ) ; } else if ( node < mid ) { end = mid ; } else { start = mid ; } } } int main ( ) { int height = 4 ; int node = 6 ; int k = findParent ( height , node ) ; cout << k ; return 0 ; } |
Count subarrays with equal number of 1 ' s ▁ and ▁ 0' s | C ++ implementation to count subarrays with equal number of 1 ' s ▁ and ▁ 0' s ; function to count subarrays with equal number of 1 ' s ▁ and ▁ 0' s ; ' um ' implemented as hash table to store frequency of values obtained through cumulative sum ; Traverse original array and compute cumulative sum and increase count by 1 for this sum in ' um ' . Adds ' - 1' when arr [ i ] == 0 ; traverse the hash table ' um ' ; If there are more than one prefix subarrays with a particular sum ; add the subarrays starting from 1 st element and have equal number of 1 ' s ▁ and ▁ 0' s ; required count of subarrays ; Driver program to test above | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countSubarrWithEqualZeroAndOne ( int arr [ ] , int n ) { unordered_map < int , int > um ; int curr_sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { curr_sum += ( arr [ i ] == 0 ) ? -1 : arr [ i ] ; um [ curr_sum ] ++ ; } int count = 0 ; for ( auto itr = um . begin ( ) ; itr != um . end ( ) ; itr ++ ) { if ( itr -> second > 1 ) count += ( ( itr -> second * ( itr -> second - 1 ) ) / 2 ) ; } if ( um . find ( 0 ) != um . end ( ) ) count += um [ 0 ] ; return count ; } int main ( ) { int arr [ ] = { 1 , 0 , 0 , 1 , 0 , 1 , 1 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Count ▁ = ▁ " << countSubarrWithEqualZeroAndOne ( arr , n ) ; return 0 ; } |
Longest subarray having count of 1 s one more than count of 0 s | C ++ implementation to find the length of longest subarray having count of 1 ' s ▁ one ▁ more ▁ than ▁ count ▁ of ▁ 0' s ; function to find the length of longest subarray having count of 1 ' s ▁ one ▁ more ▁ than ▁ count ▁ of ▁ 0' s ; unordered_map ' um ' implemented as hash table ; traverse the given array ; consider '0' as ' - 1' ; when subarray starts form index '0' ; make an entry for ' sum ' if it is not present in ' um ' ; check if ' sum - 1' is present in ' um ' or not ; update maxLength ; required maximum length ; Driver program to test above | #include <bits/stdc++.h> NEW_LINE using namespace std ; int lenOfLongSubarr ( int arr [ ] , int n ) { unordered_map < int , int > um ; int sum = 0 , maxLen = 0 ; for ( int i = 0 ; i < n ; i ++ ) { sum += arr [ i ] == 0 ? -1 : 1 ; if ( sum == 1 ) maxLen = i + 1 ; else if ( um . find ( sum ) == um . end ( ) ) um [ sum ] = i ; if ( um . find ( sum - 1 ) != um . end ( ) ) { if ( maxLen < ( i - um [ sum - 1 ] ) ) maxLen = i - um [ sum - 1 ] ; } } return maxLen ; } int main ( ) { int arr [ ] = { 0 , 1 , 1 , 0 , 0 , 1 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Length ▁ = ▁ " << lenOfLongSubarr ( arr , n ) ; return 0 ; } |
Maximum sum subarray having sum less than or equal to given sum using Set | C ++ program to find maximum sum subarray less than K ; Function to maximum required sum < K ; Hash to lookup for value ( cum_sum - K ) ; getting cummulative sum from [ 0 to i ] ; lookup for upperbound of ( cSum - K ) in hash ; check if upper_bound of ( cSum - K ) exists then update max sum ; insert cummulative value in hash ; return maximum sum lesser than K ; Driver code ; initialise the array ; initialise the value of K ; size of array | #include <bits/stdc++.h> NEW_LINE using namespace std ; int maxSubarraySum ( int arr [ ] , int N , int K ) { set < int > cum_set ; cum_set . insert ( 0 ) ; int max_sum = INT_MIN , cSum = 0 ; for ( int i = 0 ; i < N ; i ++ ) { cSum += arr [ i ] ; set < int > :: iterator sit = cum_set . lower_bound ( cSum - K ) ; if ( sit != cum_set . end ( ) ) max_sum = max ( max_sum , cSum - * sit ) ; cum_set . insert ( cSum ) ; } return max_sum ; } int main ( ) { int arr [ ] = { 5 , -2 , 6 , 3 , -5 } ; int K = 15 ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << maxSubarraySum ( arr , N , K ) ; return 0 ; } |
Print all triplets in sorted array that form AP | C ++ program to print all triplets in given array that form Arithmetic Progression C ++ program to print all triplets in given array that form Arithmetic Progression ; Function to print all triplets in given sorted array that forms AP ; Use hash to find if there is a previous element with difference equal to arr [ j ] - arr [ i ] ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printAllAPTriplets ( int arr [ ] , int n ) { unordered_set < int > s ; for ( int i = 0 ; i < n - 1 ; i ++ ) { for ( int j = i + 1 ; j < n ; j ++ ) { int diff = arr [ j ] - arr [ i ] ; if ( s . find ( arr [ i ] - diff ) != s . end ( ) ) cout << arr [ i ] - diff << " ▁ " << arr [ i ] << " ▁ " << arr [ j ] << endl ; } s . insert ( arr [ i ] ) ; } } int main ( ) { int arr [ ] = { 2 , 6 , 9 , 12 , 17 , 22 , 31 , 32 , 35 , 42 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; printAllAPTriplets ( arr , n ) ; return 0 ; } |
Print all triplets in sorted array that form AP | C ++ program to print all triplets in given array that form Arithmetic Progression ; Function to print all triplets in given sorted array that forms AP ; Search other two elements of AP with arr [ i ] as middle . ; if a triplet is found ; Since elements are distinct , arr [ k ] and arr [ j ] cannot form any more triplets with arr [ i ] ; If middle element is more move to higher side , else move lower side . ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printAllAPTriplets ( int arr [ ] , int n ) { for ( int i = 1 ; i < n - 1 ; i ++ ) { for ( int j = i - 1 , k = i + 1 ; j >= 0 && k < n ; ) { if ( arr [ j ] + arr [ k ] == 2 * arr [ i ] ) { cout << arr [ j ] << " ▁ " << arr [ i ] << " ▁ " << arr [ k ] << endl ; k ++ ; j -- ; } else if ( arr [ j ] + arr [ k ] < 2 * arr [ i ] ) k ++ ; else j -- ; } } } int main ( ) { int arr [ ] = { 2 , 6 , 9 , 12 , 17 , 22 , 31 , 32 , 35 , 42 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; printAllAPTriplets ( arr , n ) ; return 0 ; } |
Check if there is a root to leaf path with given sequence | C ++ program to see if there is a root to leaf path with given sequence . ; A binary tree node has data , pointer to left child and a pointer to right child ; utility that allocates a new node with the given data and NULL left and right pointers . ; Util function ; If root is NULL or reached end of the array ; If current node is leaf ; If current node is equal to arr [ index ] this means that till this level path has been matched and remaining path can be either in left subtree or right subtree . ; Function to check given sequence of root to leaf path exist in tree or not . index represents current element in sequence of rooth to leaf path ; Driver function to run the case ; arr [ ] -- > sequence of root to leaf path | #include <bits/stdc++.h> NEW_LINE using namespace std ; struct Node { int data ; struct Node * left , * right ; } ; struct Node * newnode ( int data ) { struct Node * node = new Node ; node -> data = data ; node -> left = node -> right = NULL ; return ( node ) ; } bool existPathUtil ( struct Node * root , int arr [ ] , int n , int index ) { if ( root == NULL or index == n ) return false ; if ( root -> left == NULL && root -> right == NULL ) { if ( ( root -> data == arr [ index ] ) && ( index == n - 1 ) ) return true ; return false ; } return ( ( index < n ) && ( root -> data == arr [ index ] ) && ( existPathUtil ( root -> left , arr , n , index + 1 ) || existPathUtil ( root -> right , arr , n , index + 1 ) ) ) ; } bool existPath ( struct Node * root , int arr [ ] , int n , int index ) { if ( ! root ) return ( n == 0 ) ; return existPathUtil ( root , arr , n , 0 ) ; } int main ( ) { int arr [ ] = { 5 , 8 , 6 , 7 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; struct Node * root = newnode ( 5 ) ; root -> left = newnode ( 3 ) ; root -> right = newnode ( 8 ) ; root -> left -> left = newnode ( 2 ) ; root -> left -> right = newnode ( 4 ) ; root -> left -> left -> left = newnode ( 1 ) ; root -> right -> left = newnode ( 6 ) ; root -> right -> left -> right = newnode ( 7 ) ; existPath ( root , arr , n , 0 ) ? cout << " Path ▁ Exists " : cout << " Path ▁ does ▁ not ▁ Exist " ; return 0 ; } |
All unique triplets that sum up to a given value | C ++ program to find all unique triplets without using any extra space . ; Function to all find unique triplets without using extra space ; Sort the input array ; For handling the cases when no such triplets exits . ; Iterate over the array from start to n - 2. ; Index of the first element in remaining range . ; Index of the last element ; Setting our new target ; Checking if current element is same as previous ; Checking if current element is same as previous ; If we found the triplets then print it and set the flag ; If target is greater then increment the start index ; If target is smaller than decrement the end index ; If no such triplets found ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; void findTriplets ( int a [ ] , int n , int sum ) { int i ; sort ( a , a + n ) ; bool flag = false ; for ( i = 0 ; i < n - 2 ; i ++ ) { if ( i == 0 a [ i ] > a [ i - 1 ] ) { int start = i + 1 ; int end = n - 1 ; int target = sum - a [ i ] ; while ( start < end ) { if ( start > i + 1 && a [ start ] == a [ start - 1 ] ) { start ++ ; continue ; } if ( end < n - 1 && a [ end ] == a [ end + 1 ] ) { end -- ; continue ; } if ( target == a [ start ] + a [ end ] ) { cout << " [ " << a [ i ] << " , " << a [ start ] << " , " << a [ end ] << " ] ▁ " ; flag = true ; start ++ ; end -- ; } else if ( target > ( a [ start ] + a [ end ] ) ) { start ++ ; } else { end -- ; } } } } if ( flag == false ) { cout << " No ▁ Such ▁ Triplets ▁ Exist " << " STRNEWLINE " ; } } int main ( ) { int a [ ] = { 12 , 3 , 6 , 1 , 6 , 9 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; int sum = 24 ; findTriplets ( a , n , sum ) ; return 0 ; } |
Find the position of the given row in a 2 | C ++ implementation of the approach ; Function to find a row in the given matrix using linear search ; Assume that the current row matched with the given array ; If any element of the current row doesn 't match with the corresponding element of the given array ; Set matched to false and break ; ; If matched then return the row number ; No row matched with the given array ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int m = 6 , n = 4 ; int linearCheck ( int ar [ ] [ n ] , int arr [ ] ) { for ( int i = 0 ; i < m ; i ++ ) { bool matched = true ; for ( int j = 0 ; j < n ; j ++ ) { if ( ar [ i ] [ j ] != arr [ j ] ) { matched = false ; break ; } } if ( matched ) return i + 1 ; } return -1 ; } int main ( ) { int mat [ m ] [ n ] = { { 0 , 0 , 1 , 0 } , { 10 , 9 , 22 , 23 } , { 40 , 40 , 40 , 40 } , { 43 , 44 , 55 , 68 } , { 81 , 73 , 100 , 132 } , { 100 , 75 , 125 , 133 } } ; int row [ n ] = { 10 , 9 , 22 , 23 } ; cout << linearCheck ( mat , row ) ; return 0 ; } |
Count number of triplets with product equal to given number | C ++ program to count triplets with given product m ; Function to count such triplets ; Consider all triplets and count if their product is equal to m ; Drivers code | #include <iostream> NEW_LINE using namespace std ; int countTriplets ( int arr [ ] , int n , int m ) { int count = 0 ; for ( int i = 0 ; i < n - 2 ; i ++ ) for ( int j = i + 1 ; j < n - 1 ; j ++ ) for ( int k = j + 1 ; k < n ; k ++ ) if ( arr [ i ] * arr [ j ] * arr [ k ] == m ) count ++ ; return count ; } int main ( ) { int arr [ ] = { 1 , 4 , 6 , 2 , 3 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int m = 24 ; cout << countTriplets ( arr , n , m ) ; return 0 ; } |
Count number of triplets with product equal to given number | C ++ program to count triplets with given product m ; Function to count such triplets ; Store all the elements in a set ; Consider all pairs and check for a third number so their product is equal to m ; Check if current pair divides m or not If yes , then search for ( m / arr [ i ] * arr [ j ] ) ; Check if the third number is present in the map and it is not equal to any other two elements and also check if this triplet is not counted already using their indexes ; Return number of triplets ; Drivers code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countTriplets ( int arr [ ] , int n , int m ) { unordered_map < int , int > occ ; for ( int i = 0 ; i < n ; i ++ ) occ [ arr [ i ] ] = i ; int count = 0 ; for ( int i = 0 ; i < n - 1 ; i ++ ) { for ( int j = i + 1 ; j < n ; j ++ ) { if ( ( arr [ i ] * arr [ j ] <= m ) && ( arr [ i ] * arr [ j ] != 0 ) && ( m % ( arr [ i ] * arr [ j ] ) == 0 ) ) { int check = m / ( arr [ i ] * arr [ j ] ) ; auto it = occ . find ( check ) ; if ( check != arr [ i ] && check != arr [ j ] && it != occ . end ( ) && it -> second > i && it -> second > j ) count ++ ; } } } return count ; } int main ( ) { int arr [ ] = { 1 , 4 , 6 , 2 , 3 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int m = 24 ; cout << countTriplets ( arr , n , m ) ; return 0 ; } |
Count of index pairs with equal elements in an array | C ++ program to count of pairs with equal elements in an array . ; Return the number of pairs with equal values . ; for each index i and j ; finding the index with same value but different index . ; Driven Program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countPairs ( int arr [ ] , int n ) { int ans = 0 ; for ( int i = 0 ; i < n ; i ++ ) for ( int j = i + 1 ; j < n ; j ++ ) if ( arr [ i ] == arr [ j ] ) ans ++ ; return ans ; } int main ( ) { int arr [ ] = { 1 , 1 , 2 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countPairs ( arr , n ) << endl ; return 0 ; } |
Queries to answer the number of ones and zero to the left of given index | C ++ implementation of the approach ; Function to pre - calculate the left [ ] array ; Iterate in the binary array ; Initialize the number of 1 and 0 ; Increase the count ; Driver code ; Queries ; Solve queries | #include <bits/stdc++.h> NEW_LINE using namespace std ; void preCalculate ( int binary [ ] , int n , pair < int , int > left [ ] ) { int count1 = 0 , count0 = 0 ; for ( int i = 0 ; i < n ; i ++ ) { left [ i ] . first = count1 ; left [ i ] . second = count0 ; if ( binary [ i ] ) count1 ++ ; else count0 ++ ; } } int main ( ) { int binary [ ] = { 1 , 1 , 1 , 0 , 0 , 1 , 0 , 1 , 1 } ; int n = sizeof ( binary ) / sizeof ( binary [ 0 ] ) ; pair < int , int > left [ n ] ; preCalculate ( binary , n , left ) ; int queries [ ] = { 0 , 1 , 2 , 4 } ; int q = sizeof ( queries ) / sizeof ( queries [ 0 ] ) ; for ( int i = 0 ; i < q ; i ++ ) cout << left [ queries [ i ] ] . first << " ▁ ones ▁ " << left [ queries [ i ] ] . second << " ▁ zeros STRNEWLINE " ; return 0 ; } |
Count of index pairs with equal elements in an array | C ++ program to count of index pairs with equal elements in an array . ; Return the number of pairs with equal values . ; Finding frequency of each number . ; Calculating pairs of each value . ; Driven Program | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countPairs ( int arr [ ] , int n ) { unordered_map < int , int > mp ; for ( int i = 0 ; i < n ; i ++ ) mp [ arr [ i ] ] ++ ; int ans = 0 ; for ( auto it = mp . begin ( ) ; it != mp . end ( ) ; it ++ ) { int count = it -> second ; ans += ( count * ( count - 1 ) ) / 2 ; } return ans ; } int main ( ) { int arr [ ] = { 1 , 1 , 2 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countPairs ( arr , n ) << endl ; return 0 ; } |
Partition the array into three equal sum segments | C ++ implementation of the approach ; First segment 's end index ; Third segment 's start index ; This function returns true if the array can be divided into three equal sum segments ; Prefix Sum Array ; Suffix Sum Array ; Stores the total sum of the array ; We can also take pre [ pos2 - 1 ] - pre [ pos1 ] == total_sum / 3 here . ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; static int pos1 = -1 ; static int pos2 = -1 ; bool equiSumUtil ( int arr [ ] , int n ) { int pre [ n ] ; int sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { sum += arr [ i ] ; pre [ i ] = sum ; } int suf [ n ] ; sum = 0 ; for ( int i = n - 1 ; i >= 0 ; i -- ) { sum += arr [ i ] ; suf [ i ] = sum ; } int total_sum = sum ; int i = 0 , j = n - 1 ; while ( i < j - 1 ) { if ( pre [ i ] == total_sum / 3 ) { pos1 = i ; } if ( suf [ j ] == total_sum / 3 ) { pos2 = j ; } if ( pos1 != -1 && pos2 != -1 ) { if ( suf [ pos1 + 1 ] - suf [ pos2 ] == total_sum / 3 ) { return true ; } else { return false ; } } if ( pre [ i ] < suf [ j ] ) { i ++ ; } else { j -- ; } } return false ; } void equiSum ( int arr [ ] , int n ) { bool ans = equiSumUtil ( arr , n ) ; if ( ans ) { cout << " First ▁ Segment ▁ : ▁ " ; for ( int i = 0 ; i <= pos1 ; i ++ ) { cout << arr [ i ] << " ▁ " ; } cout << endl ; cout << " Second ▁ Segment ▁ : ▁ " ; for ( int i = pos1 + 1 ; i < pos2 ; i ++ ) { cout << arr [ i ] << " ▁ " ; } cout << endl ; cout << " Third ▁ Segment ▁ : ▁ " ; for ( int i = pos2 ; i < n ; i ++ ) { cout << arr [ i ] << " ▁ " ; } cout << endl ; } else { cout << " Array ▁ cannot ▁ be ▁ divided ▁ into ▁ three ▁ equal ▁ sum ▁ segments " ; } } int main ( ) { int arr [ ] = { 1 , 3 , 6 , 2 , 7 , 1 , 2 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; equiSum ( arr , n ) ; return 0 ; } |
Palindrome Substring Queries | A C ++ program to answer queries to check whether the substrings are palindrome or not efficiently ; Structure to represent a query . A query consists of ( L , R ) and we have to answer whether the substring from index - L to R is a palindrome or not ; A function to check if a string str is palindrome in the ranfe L to R ; Keep comparing characters while they are same ; A Function to find pow ( base , exponent ) % MOD in log ( exponent ) time ; A Function to calculate Modulo Multiplicative Inverse of ' n ' ; A Function to calculate the prefix hash ; A Function to calculate the suffix hash Suffix hash is nothing but the prefix hash of the reversed string ; A Function to answer the Queries ; Hash Value of Substring [ L , R ] ; Reverse Hash Value of Substring [ L , R ] ; If both are equal then the substring is a palindrome ; A Dynamic Programming Based Approach to compute the powers of 101 ; 101 ^ 0 = 1 ; Driver program to test above function ; A Table to store the powers of 101 ; Arrays to hold prefix and suffix hash values ; Compute Prefix Hash and Suffix Hash Arrays | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define p 101 NEW_LINE #define MOD 1000000007 NEW_LINE struct Query { int L , R ; } ; bool isPalindrome ( string str , int L , int R ) { while ( R > L ) if ( str [ L ++ ] != str [ R -- ] ) return ( false ) ; return ( true ) ; } unsigned long long int modPow ( unsigned long long int base , unsigned long long int exponent ) { if ( exponent == 0 ) return 1 ; if ( exponent == 1 ) return base ; unsigned long long int temp = modPow ( base , exponent / 2 ) ; if ( exponent % 2 == 0 ) return ( temp % MOD * temp % MOD ) % MOD ; else return ( ( ( temp % MOD * temp % MOD ) % MOD ) * base % MOD ) % MOD ; } unsigned long long int findMMI ( unsigned long long int n ) { return modPow ( n , MOD - 2 ) ; } void computePrefixHash ( string str , int n , unsigned long long int prefix [ ] , unsigned long long int power [ ] ) { prefix [ 0 ] = 0 ; prefix [ 1 ] = str [ 0 ] ; for ( int i = 2 ; i <= n ; i ++ ) prefix [ i ] = ( prefix [ i - 1 ] % MOD + ( str [ i - 1 ] % MOD * power [ i - 1 ] % MOD ) % MOD ) % MOD ; return ; } void computeSuffixHash ( string str , int n , unsigned long long int suffix [ ] , unsigned long long int power [ ] ) { suffix [ 0 ] = 0 ; suffix [ 1 ] = str [ n - 1 ] ; for ( int i = n - 2 , j = 2 ; i >= 0 && j <= n ; i -- , j ++ ) suffix [ j ] = ( suffix [ j - 1 ] % MOD + ( str [ i ] % MOD * power [ j - 1 ] % MOD ) % MOD ) % MOD ; return ; } void queryResults ( string str , Query q [ ] , int m , int n , unsigned long long int prefix [ ] , unsigned long long int suffix [ ] , unsigned long long int power [ ] ) { for ( int i = 0 ; i <= m - 1 ; i ++ ) { int L = q [ i ] . L ; int R = q [ i ] . R ; unsigned long long hash_LR = ( ( prefix [ R + 1 ] - prefix [ L ] + MOD ) % MOD * findMMI ( power [ L ] ) % MOD ) % MOD ; unsigned long long reverse_hash_LR = ( ( suffix [ n - L ] - suffix [ n - R - 1 ] + MOD ) % MOD * findMMI ( power [ n - R - 1 ] ) % MOD ) % MOD ; if ( hash_LR == reverse_hash_LR ) { if ( isPalindrome ( str , L , R ) == true ) printf ( " The ▁ Substring ▁ [ % d ▁ % d ] ▁ is ▁ a ▁ " " palindrome STRNEWLINE " , L , R ) ; else printf ( " The ▁ Substring ▁ [ % d ▁ % d ] ▁ is ▁ not ▁ a ▁ " " palindrome STRNEWLINE " , L , R ) ; } else printf ( " The ▁ Substring ▁ [ % d ▁ % d ] ▁ is ▁ not ▁ a ▁ " " palindrome STRNEWLINE " , L , R ) ; } return ; } void computePowers ( unsigned long long int power [ ] , int n ) { power [ 0 ] = 1 ; for ( int i = 1 ; i <= n ; i ++ ) power [ i ] = ( power [ i - 1 ] % MOD * p % MOD ) % MOD ; return ; } int main ( ) { string str = " abaaabaaaba " ; int n = str . length ( ) ; unsigned long long int power [ n + 1 ] ; computePowers ( power , n ) ; unsigned long long int prefix [ n + 1 ] , suffix [ n + 1 ] ; computePrefixHash ( str , n , prefix , power ) ; computeSuffixHash ( str , n , suffix , power ) ; Query q [ ] = { { 0 , 10 } , { 5 , 8 } , { 2 , 5 } , { 5 , 9 } } ; int m = sizeof ( q ) / sizeof ( q [ 0 ] ) ; queryResults ( str , q , m , n , prefix , suffix , power ) ; return ( 0 ) ; } |
Print cousins of a given node in Binary Tree | C ++ program to print cousins of a node ; A Binary Tree Node ; A utility function to create a new Binary Tree Node ; It returns level of the node if it is present in tree , otherwise returns 0. ; base cases ; If node is present in left subtree ; If node is not present in left subtree ; Print nodes at a given level such that sibling of node is not printed if it exists ; Base cases ; If current node is parent of a node with given level ; Recur for left and right subtrees ; This function prints cousins of a given node ; Get level of given node ; Print nodes of given level . ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; struct Node { int data ; Node * left , * right ; } ; Node * newNode ( int item ) { Node * temp = new Node ; temp -> data = item ; temp -> left = temp -> right = NULL ; return temp ; } int getLevel ( Node * root , Node * node , int level ) { if ( root == NULL ) return 0 ; if ( root == node ) return level ; int downlevel = getLevel ( root -> left , node , level + 1 ) ; if ( downlevel != 0 ) return downlevel ; return getLevel ( root -> right , node , level + 1 ) ; } void printGivenLevel ( Node * root , Node * node , int level ) { if ( root == NULL level < 2 ) return ; if ( level == 2 ) { if ( root -> left == node root -> right == node ) return ; if ( root -> left ) cout << root -> left -> data << " ▁ " ; if ( root -> right ) cout << root -> right -> data ; } else if ( level > 2 ) { printGivenLevel ( root -> left , node , level - 1 ) ; printGivenLevel ( root -> right , node , level - 1 ) ; } } void printCousins ( Node * root , Node * node ) { int level = getLevel ( root , node , 1 ) ; printGivenLevel ( root , node , level ) ; } int main ( ) { Node * root = newNode ( 1 ) ; root -> left = newNode ( 2 ) ; root -> right = newNode ( 3 ) ; root -> left -> left = newNode ( 4 ) ; root -> left -> right = newNode ( 5 ) ; root -> left -> right -> right = newNode ( 15 ) ; root -> right -> left = newNode ( 6 ) ; root -> right -> right = newNode ( 7 ) ; root -> right -> left -> right = newNode ( 8 ) ; printCousins ( root , root -> left -> right ) ; return 0 ; } |
Leftmost and rightmost indices of the maximum and the minimum element of an array | C ++ implementation of above idea ; Function to return the index of the rightmost minimum element from the array ; First element is the minimum in a sorted array ; While the elements are equal to the minimum update rightMin ; Final check whether there are any elements which are equal to the minimum ; Function to return the index of the leftmost maximum element from the array ; Last element is the maximum in a sorted array ; While the elements are equal to the maximum update leftMax ; Final check whether there are any elements which are equal to the maximum ; Driver code ; First element is the leftmost minimum in a sorted array ; Last element is the rightmost maximum in a sorted array | #include <bits/stdc++.h> NEW_LINE using namespace std ; int getRightMin ( int arr [ ] , int n ) { int min = arr [ 0 ] ; int rightMin = 0 ; int i = 1 ; while ( i < n ) { if ( arr [ i ] == min ) rightMin = i ; i *= 2 ; } i = rightMin + 1 ; while ( i < n && arr [ i ] == min ) { rightMin = i ; i ++ ; } return rightMin ; } int getLeftMax ( int arr [ ] , int n ) { int max = arr [ n - 1 ] ; int leftMax = n - 1 ; int i = n - 2 ; while ( i > 0 ) { if ( arr [ i ] == max ) leftMax = i ; i /= 2 ; } i = leftMax - 1 ; while ( i >= 0 && arr [ i ] == max ) { leftMax = i ; i -- ; } return leftMax ; } int main ( ) { int arr [ ] = { 0 , 0 , 1 , 2 , 5 , 5 , 6 , 8 , 8 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Minimum ▁ left ▁ : ▁ " << 0 << " STRNEWLINE " ; cout << " Minimum ▁ right ▁ : ▁ " << getRightMin ( arr , n ) << " STRNEWLINE " ; cout << " Maximum ▁ left ▁ : ▁ " << getLeftMax ( arr , n ) << " STRNEWLINE " ; cout << " Maximum ▁ right ▁ : ▁ " << ( n - 1 ) ; } |
Elements to be added so that all elements of a range are present in array | C ++ program for above implementation ; Function to count numbers to be added ; Sort the array ; Check if elements are consecutive or not . If not , update count ; Drivers code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countNum ( int arr [ ] , int n ) { int count = 0 ; sort ( arr , arr + n ) ; for ( int i = 0 ; i < n - 1 ; i ++ ) if ( arr [ i ] != arr [ i + 1 ] && arr [ i ] != arr [ i + 1 ] - 1 ) count += arr [ i + 1 ] - arr [ i ] - 1 ; return count ; } int main ( ) { int arr [ ] = { 3 , 5 , 8 , 6 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countNum ( arr , n ) << endl ; return 0 ; } |
Find the k smallest numbers after deleting given elements | ; Find k minimum element from arr [ 0. . m - 1 ] after deleting elements from del [ 0. . n - 1 ] ; Hash Map of the numbers to be deleted ; Increment the count of del [ i ] ; Search if the element is present ; Decrement its frequency ; If the frequency becomes 0 , erase it from the map ; Else push it in the min heap ; Print top k elements in the min heap ; Pop the top element ; Driver code | #include " iostream " NEW_LINE #include " queue " NEW_LINE #include " unordered _ map " NEW_LINE #include " vector " NEW_LINE using namespace std ; void findElementsAfterDel ( int arr [ ] , int m , int del [ ] , int n , int k ) { unordered_map < int , int > mp ; for ( int i = 0 ; i < n ; ++ i ) { mp [ del [ i ] ] ++ ; } priority_queue < int , vector < int > , greater < int > > heap ; for ( int i = 0 ; i < m ; ++ i ) { if ( mp . find ( arr [ i ] ) != mp . end ( ) ) { mp [ arr [ i ] ] -- ; if ( mp [ arr [ i ] ] == 0 ) mp . erase ( arr [ i ] ) ; } else heap . push ( arr [ i ] ) ; } for ( int i = 0 ; i < k ; ++ i ) { cout << heap . top ( ) << " ▁ " ; heap . pop ( ) ; } } int main ( ) { int array [ ] = { 5 , 12 , 33 , 4 , 56 , 12 , 20 } ; int m = sizeof ( array ) / sizeof ( array [ 0 ] ) ; int del [ ] = { 12 , 56 , 5 } ; int n = sizeof ( del ) / sizeof ( del [ 0 ] ) ; int k = 3 ; findElementsAfterDel ( array , m , del , n , k ) ; return 0 ; } |
Elements to be added so that all elements of a range are present in array | C ++ program for above implementation ; Function to count numbers to be added ; Make a hash of elements and store minimum and maximum element ; Traverse all elements from minimum to maximum and count if it is not in the hash ; Drivers code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countNum ( int arr [ ] , int n ) { unordered_set < int > s ; int count = 0 , maxm = INT_MIN , minm = INT_MAX ; for ( int i = 0 ; i < n ; i ++ ) { s . insert ( arr [ i ] ) ; if ( arr [ i ] < minm ) minm = arr [ i ] ; if ( arr [ i ] > maxm ) maxm = arr [ i ] ; } for ( int i = minm ; i <= maxm ; i ++ ) if ( s . find ( arr [ i ] ) == s . end ( ) ) count ++ ; return count ; } int main ( ) { int arr [ ] = { 3 , 5 , 8 , 6 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countNum ( arr , n ) << endl ; return 0 ; } |
Find minimum speed to finish all Jobs | CPP program to find minimum speed to finish all jobs ; Function to check if the person can do all jobs in H hours with speed K ; Function to return the minimum speed of person to complete all jobs ; If H < N it is not possible to complete all jobs as person can not move from one element to another during current hour ; Max element of array ; Use binary search to find smallest K ; Driver program ; Print required maxLenwer | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool isPossible ( int A [ ] , int n , int H , int K ) { int time = 0 ; for ( int i = 0 ; i < n ; ++ i ) time += ( A [ i ] - 1 ) / K + 1 ; return time <= H ; } int minJobSpeed ( int A [ ] , int n , int H ) { if ( H < n ) return -1 ; int * max = max_element ( A , A + n ) ; int lo = 1 , hi = * max ; while ( lo < hi ) { int mi = lo + ( hi - lo ) / 2 ; if ( ! isPossible ( A , n , H , mi ) ) lo = mi + 1 ; else hi = mi ; } return lo ; } int main ( ) { int A [ ] = { 3 , 6 , 7 , 11 } , H = 8 ; int n = sizeof ( A ) / sizeof ( A [ 0 ] ) ; cout << minJobSpeed ( A , n , H ) ; return 0 ; } |
Cuckoo Hashing | C ++ program to demonstrate working of Cuckoo hashing . ; upper bound on number of elements in our set ; choices for position ; Auxiliary space bounded by a small multiple of MAXN , minimizing wastage ; Array to store possible positions for a key ; function to fill hash table with dummy value * dummy value : INT_MIN * number of hashtables : ver ; return hashed value for a key * function : ID of hash function according to which key has to hashed * key : item to be hashed ; function to place a key in one of its possible positions * tableID : table in which key has to be placed , also equal to function according to which key must be hashed * cnt : number of times function has already been called in order to place the first input key * n : maximum number of times function can be recursively called before stopping and declaring presence of cycle ; if function has been recursively called max number of times , stop and declare cycle . Rehash . ; calculate and store possible positions for the key . * check if key already present at any of the positions . If YES , return . ; check if another key is already present at the position for the new key in the table * If YES : place the new key in its position * and place the older key in an alternate position for it in the next table ; else : place the new key in its position ; function to print hash table contents ; function for Cuckoo - hashing keys * keys [ ] : input array of keys * n : size of input array ; initialize hash tables to a dummy value ( INT - MIN ) indicating empty position ; start with placing every key at its position in the first hash table according to first hash function ; print the final hash tables ; driver function ; following array doesn 't have any cycles and hence all keys will be inserted without any rehashing ; following array has a cycle and hence we will have to rehash to position every key | #include <bits/stdc++.h> NEW_LINE #define MAXN 11 NEW_LINE #define ver 2 NEW_LINE int hashtable [ ver ] [ MAXN ] ; int pos [ ver ] ; void initTable ( ) { for ( int j = 0 ; j < MAXN ; j ++ ) for ( int i = 0 ; i < ver ; i ++ ) hashtable [ i ] [ j ] = INT_MIN ; } int hash ( int function , int key ) { switch ( function ) { case 1 : return key % MAXN ; case 2 : return ( key / MAXN ) % MAXN ; } } void place ( int key , int tableID , int cnt , int n ) { if ( cnt == n ) { printf ( " % d ▁ unpositioned STRNEWLINE " , key ) ; printf ( " Cycle ▁ present . ▁ REHASH . STRNEWLINE " ) ; return ; } for ( int i = 0 ; i < ver ; i ++ ) { pos [ i ] = hash ( i + 1 , key ) ; if ( hashtable [ i ] [ pos [ i ] ] == key ) return ; } if ( hashtable [ tableID ] [ pos [ tableID ] ] != INT_MIN ) { int dis = hashtable [ tableID ] [ pos [ tableID ] ] ; hashtable [ tableID ] [ pos [ tableID ] ] = key ; place ( dis , ( tableID + 1 ) % ver , cnt + 1 , n ) ; } else hashtable [ tableID ] [ pos [ tableID ] ] = key ; } void printTable ( ) { printf ( " Final ▁ hash ▁ tables : STRNEWLINE " ) ; for ( int i = 0 ; i < ver ; i ++ , printf ( " STRNEWLINE " ) ) for ( int j = 0 ; j < MAXN ; j ++ ) ( hashtable [ i ] [ j ] == INT_MIN ) ? printf ( " - ▁ " ) : printf ( " % d ▁ " , hashtable [ i ] [ j ] ) ; printf ( " STRNEWLINE " ) ; } void cuckoo ( int keys [ ] , int n ) { initTable ( ) ; for ( int i = 0 , cnt = 0 ; i < n ; i ++ , cnt = 0 ) place ( keys [ i ] , 0 , cnt , n ) ; printTable ( ) ; } int main ( ) { int keys_1 [ ] = { 20 , 50 , 53 , 75 , 100 , 67 , 105 , 3 , 36 , 39 } ; int n = sizeof ( keys_1 ) / sizeof ( int ) ; cuckoo ( keys_1 , n ) ; int keys_2 [ ] = { 20 , 50 , 53 , 75 , 100 , 67 , 105 , 3 , 36 , 39 , 6 } ; int m = sizeof ( keys_2 ) / sizeof ( int ) ; cuckoo ( keys_2 , m ) ; return 0 ; } |
Number of anomalies in an array | ; Sort the array so that we can apply binary search . ; One by one check every element if it is anomaly or not using binary search . ; If arr [ i ] is not largest element and element just greater than it is within k , then return false . ; If there are more than one occurrences of arr [ i ] , return false . ; If arr [ i ] is not smallest element and just smaller element is not k distance away ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countAnomalies ( int a [ ] , int n , int k ) { sort ( a , a + n ) ; int res = 0 ; for ( int i = 0 ; i < n ; i ++ ) { int * u = upper_bound ( a , a + n , a [ i ] ) ; if ( u != a + n && ( ( * u ) - a [ i ] ) <= k ) continue ; int * s = lower_bound ( a , a + n , a [ i ] ) ; if ( u - s > 1 ) continue ; if ( s != a && ( * ( s - 1 ) - a [ i ] ) <= k ) continue ; res ++ ; } return res ; } int main ( ) { int arr [ ] = { 7 , 1 , 8 } , k = 5 ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countAnomalies ( arr , n , k ) ; return 0 ; } |
Subarrays with distinct elements | C ++ program to calculate sum of lengths of subarrays of distinct elements . ; Returns sum of lengths of all subarrays with distinct elements . ; For maintaining distinct elements . ; Initialize ending point and result ; Fix starting point ; Calculating and adding all possible length subarrays in arr [ i . . j ] ; Remove arr [ i ] as we pick new stating point from next ; Driven Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int sumoflength ( int arr [ ] , int n ) { unordered_set < int > s ; int j = 0 , ans = 0 ; for ( int i = 0 ; i < n ; i ++ ) { while ( j < n && s . find ( arr [ j ] ) == s . end ( ) ) { s . insert ( arr [ j ] ) ; j ++ ; } ans += ( ( j - i ) * ( j - i + 1 ) ) / 2 ; s . erase ( arr [ i ] ) ; } return ans ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 4 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << sumoflength ( arr , n ) << endl ; return 0 ; } |
Count subarrays having total distinct elements same as original array | C ++ program Count total number of sub - arrays having total distinct elements same as that original array . ; Function to calculate distinct sub - array ; Count distinct elements in whole array ; Reset the container by removing all elements ; Use sliding window concept to find count of subarrays having k distinct elements . ; If window size equals to array distinct element size , then update answer ; Decrease the frequency of previous element for next sliding window ; If frequency is zero then decrease the window size ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countDistictSubarray ( int arr [ ] , int n ) { unordered_map < int , int > vis ; for ( int i = 0 ; i < n ; ++ i ) vis [ arr [ i ] ] = 1 ; int k = vis . size ( ) ; vis . clear ( ) ; int ans = 0 , right = 0 , window = 0 ; for ( int left = 0 ; left < n ; ++ left ) { while ( right < n && window < k ) { ++ vis [ arr [ right ] ] ; if ( vis [ arr [ right ] ] == 1 ) ++ window ; ++ right ; } if ( window == k ) ans += ( n - right + 1 ) ; -- vis [ arr [ left ] ] ; if ( vis [ arr [ left ] ] == 0 ) -- window ; } return ans ; } int main ( ) { int arr [ ] = { 2 , 1 , 3 , 2 , 3 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countDistictSubarray ( arr , n ) << " n " ; return 0 ; } |
Count subarrays with same even and odd elements | C ++ program to find total number of even - odd subarrays present in given array ; function that returns the count of subarrays that contain equal number of odd as well as even numbers ; initialize difference and answer with 0 ; create two auxiliary hash arrays to count frequency of difference , one array for non - negative difference and other array for negative difference . Size of these two auxiliary arrays is ' n + 1' because difference can reach maximum value ' n ' as well as minimum value ' - n ' ; initialize these auxiliary arrays with 0 ; since the difference is initially 0 , we have to initialize hash_positive [ 0 ] with 1 ; for loop to iterate through whole array ( zero - based indexing is used ) ; incrementing or decrementing difference based on arr [ i ] being even or odd , check if arr [ i ] is odd ; adding hash value of ' difference ' to our answer as all the previous occurrences of the same difference value will make even - odd subarray ending at index ' i ' . After that , we will increment hash array for that ' difference ' value for its occurrence at index ' i ' . if difference is negative then use hash_negative ; else use hash_positive ; return total number of even - odd subarrays ; Driver code ; Printing total number of even - odd subarrays | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countSubarrays ( int arr [ ] , int n ) { int difference = 0 ; int ans = 0 ; int hash_positive [ n + 1 ] , hash_negative [ n + 1 ] ; fill_n ( hash_positive , n + 1 , 0 ) ; fill_n ( hash_negative , n + 1 , 0 ) ; hash_positive [ 0 ] = 1 ; for ( int i = 0 ; i < n ; i ++ ) { if ( arr [ i ] & 1 == 1 ) difference ++ ; else difference -- ; if ( difference < 0 ) { ans += hash_negative [ - difference ] ; hash_negative [ - difference ] ++ ; } else { ans += hash_positive [ difference ] ; hash_positive [ difference ] ++ ; } } return ans ; } int main ( ) { int arr [ ] = { 3 , 4 , 6 , 8 , 1 , 10 , 5 , 7 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << " Total ▁ Number ▁ of ▁ Even - Odd ▁ subarrays " " ▁ are ▁ " << countSubarrays ( arr , n ) ; return 0 ; } |
Given a binary tree , print out all of its root | C ++ program to print all of its root - to - leaf paths for a tree ; A binary tree node has data , pointer to left child and a pointer to right child ; Function prototypes ; Given a binary tree , print out all of its root - to - leaf paths , one per line . Uses a recursive helper to do the work . ; Recursive helper function -- given a node , and an array containing the path from the root node up to but not including this node , print out all the root - leaf paths . ; append this node to the path array ; it 's a leaf, so print the path that led to here ; otherwise try both subtrees ; Helper function that allocates a new node with the given data and NULL left and right pointers . ; Utility that prints out an array on a line ; Driver code ; Print all root - to - leaf paths of the input tree | #include <bits/stdc++.h> NEW_LINE using namespace std ; class node { public : int data ; node * left ; node * right ; } ; void printArray ( int [ ] , int ) ; void printPathsRecur ( node * , int [ ] , int ) ; node * newNode ( int ) ; void printPaths ( node * ) ; void printPaths ( node * node ) { int path [ 1000 ] ; printPathsRecur ( node , path , 0 ) ; } void printPathsRecur ( node * node , int path [ ] , int pathLen ) { if ( node == NULL ) return ; path [ pathLen ] = node -> data ; pathLen ++ ; if ( node -> left == NULL && node -> right == NULL ) { printArray ( path , pathLen ) ; } else { printPathsRecur ( node -> left , path , pathLen ) ; printPathsRecur ( node -> right , path , pathLen ) ; } } node * newNode ( int data ) { node * Node = new node ( ) ; Node -> data = data ; Node -> left = NULL ; Node -> right = NULL ; return ( Node ) ; } void printArray ( int ints [ ] , int len ) { int i ; for ( i = 0 ; i < len ; i ++ ) { cout << ints [ i ] << " ▁ " ; } cout << endl ; } int main ( ) { node * root = newNode ( 1 ) ; root -> left = newNode ( 2 ) ; root -> right = newNode ( 3 ) ; root -> left -> left = newNode ( 4 ) ; root -> left -> right = newNode ( 5 ) ; printPaths ( root ) ; return 0 ; } |
Evaluation of Expression Tree | C ++ program to evaluate an expression tree ; Class to represent the nodes of syntax tree ; Utility function to return the integer value of a given string ; Check if the integral value is negative or not If it is not negative , generate the number normally ; If it is negative , calculate the + ve number first ignoring the sign and invert the sign at the end ; This function receives a node of the syntax tree and recursively evaluates it ; empty tree ; leaf node i . e , an integer ; Evaluate left subtree ; Evaluate right subtree ; Check which operator to apply ; create a syntax tree | #include <bits/stdc++.h> NEW_LINE using namespace std ; class node { public : string info ; node * left = NULL , * right = NULL ; node ( string x ) { info = x ; } } ; int toInt ( string s ) { int num = 0 ; if ( s [ 0 ] != ' - ' ) for ( int i = 0 ; i < s . length ( ) ; i ++ ) num = num * 10 + ( int ( s [ i ] ) - 48 ) ; else for ( int i = 1 ; i < s . length ( ) ; i ++ ) { num = num * 10 + ( int ( s [ i ] ) - 48 ) ; num = num * -1 ; } return num ; } int eval ( node * root ) { if ( ! root ) return 0 ; if ( ! root -> left && ! root -> right ) return toInt ( root -> info ) ; int l_val = eval ( root -> left ) ; int r_val = eval ( root -> right ) ; if ( root -> info == " + " ) return l_val + r_val ; if ( root -> info == " - " ) return l_val - r_val ; if ( root -> info == " * " ) return l_val * r_val ; return l_val / r_val ; } int main ( ) { node * root = new node ( " + " ) ; root -> left = new node ( " * " ) ; root -> left -> left = new node ( "5" ) ; root -> left -> right = new node ( " - 4" ) ; root -> right = new node ( " - " ) ; root -> right -> left = new node ( "100" ) ; root -> right -> right = new node ( "20" ) ; cout << eval ( root ) << endl ; delete ( root ) ; root = new node ( " + " ) ; root -> left = new node ( " * " ) ; root -> left -> left = new node ( "5" ) ; root -> left -> right = new node ( "4" ) ; root -> right = new node ( " - " ) ; root -> right -> left = new node ( "100" ) ; root -> right -> right = new node ( " / " ) ; root -> right -> right -> left = new node ( "20" ) ; root -> right -> right -> right = new node ( "2" ) ; cout << eval ( root ) ; return 0 ; } |
Saddleback Search Algorithm in a 2D array | C ++ program to search an element in row - wise and column - wise sorted matrix ; Searches the element x in mat [ m ] [ n ] . If the element is found , then prints its position and returns true , otherwise prints " not ▁ found " and returns false ; set indexes for bottom left element ; if mat [ i ] [ j ] < x ; driver program to test above function | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define MAX 100 NEW_LINE bool search ( int mat [ ] [ MAX ] , int m , int n , int x ) { int i = m - 1 , j = 0 ; while ( i >= 0 && j < n ) { if ( mat [ i ] [ j ] == x ) return true ; if ( mat [ i ] [ j ] > x ) i -- ; else j ++ ; } return false ; } int main ( ) { int mat [ ] [ MAX ] = { { 10 , 20 , 30 , 40 } , { 15 , 25 , 35 , 45 } , { 27 , 29 , 37 , 48 } , { 32 , 33 , 39 , 50 } , { 50 , 60 , 70 , 80 } , } ; if ( search ( mat , 5 , 4 , 29 ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Variants of Binary Search | C ++ program to variants of Binary Search ; array size ; Sorted array ; Find if key is in array * Returns : True if key belongs to array , * False if key doesn 't belong to array ; if mid is less than key , all elements in range [ low , mid ] are also less so we now search in [ mid + 1 , high ] ; if mid is greater than key , all elements in range [ mid + 1 , high ] are also greater so we now search in [ low , mid - 1 ] ; comparison added just for the sake of clarity if mid is equal to key , we have found that key exists in array ; Find first occurrence index of key in array * Returns : an index in range [ 0 , n - 1 ] if key belongs * to array , - 1 if key doesn 't belong to array ; if mid is less than key , all elements in range [ low , mid ] are also less so we now search in [ mid + 1 , high ] ; if mid is greater than key , all elements in range [ mid + 1 , high ] are also greater so we now search in [ low , mid - 1 ] ; if mid is equal to key , we note down the last found index then we search for more in left side of mid so we now search in [ low , mid - 1 ] ; Find last occurrence index of key in array * Returns : an index in range [ 0 , n - 1 ] if key belongs to array , * - 1 if key doesn 't belong to array ; if mid is less than key , then all elements in range [ low , mid - 1 ] are also less so we now search in [ mid + 1 , high ] ; if mid is greater than key , then all elements in range [ mid + 1 , high ] are also greater so we now search in [ low , mid - 1 ] ; if mid is equal to key , we note down the last found index then we search for more in right side of mid so we now search in [ mid + 1 , high ] ; Find index of first occurrence of least element greater than key in array * Returns : an index in range [ 0 , n - 1 ] if key is not the greatest element in array , * - 1 if key is the greatest element in array ; if mid is less than key , all elements in range [ low , mid - 1 ] are <= key then we search in right side of mid so we now search in [ mid + 1 , high ] ; if mid is greater than key , all elements in range [ mid + 1 , high ] are >= key we note down the last found index , then we search in left side of mid so we now search in [ low , mid - 1 ] ; if mid is equal to key , all elements in range [ low , mid ] are <= key so we now search in [ mid + 1 , high ] ; Find index of last occurrence of greatest element less than key in array * Returns : an index in range [ 0 , n - 1 ] if key is not the least element in array , * - 1 if key is the least element in array ; if mid is less than key , all elements in range [ low , mid - 1 ] are < key we note down the last found index , then we search in right side of mid so we now search in [ mid + 1 , high ] ; if mid is greater than key , all elements in range [ mid + 1 , high ] are > key then we search in left side of mid so we now search in [ low , mid - 1 ] ; if mid is equal to key , all elements in range [ mid + 1 , high ] are >= key then we search in left side of mid so we now search in [ low , mid - 1 ] ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int n = 8 ; int a [ ] = { 2 , 3 , 3 , 5 , 5 , 5 , 6 , 6 } ; bool contains ( int low , int high , int key ) { bool ans = false ; while ( low <= high ) { int mid = low + ( high - low ) / 2 ; int midVal = a [ mid ] ; if ( midVal < key ) { low = mid + 1 ; } else if ( midVal > key ) { high = mid - 1 ; } else if ( midVal == key ) { ans = true ; break ; } } return ans ; } int first ( int low , int high , int key ) { int ans = -1 ; while ( low <= high ) { int mid = low + ( high - low + 1 ) / 2 ; int midVal = a [ mid ] ; if ( midVal < key ) { low = mid + 1 ; } else if ( midVal > key ) { high = mid - 1 ; } else if ( midVal == key ) { ans = mid ; high = mid - 1 ; } } return ans ; } int last ( int low , int high , int key ) { int ans = -1 ; while ( low <= high ) { int mid = low + ( high - low + 1 ) / 2 ; int midVal = a [ mid ] ; if ( midVal < key ) { low = mid + 1 ; } else if ( midVal > key ) { high = mid - 1 ; } else if ( midVal == key ) { ans = mid ; low = mid + 1 ; } } return ans ; } int leastgreater ( int low , int high , int key ) { int ans = -1 ; while ( low <= high ) { int mid = low + ( high - low + 1 ) / 2 ; int midVal = a [ mid ] ; if ( midVal < key ) { low = mid + 1 ; } else if ( midVal > key ) { ans = mid ; high = mid - 1 ; } else if ( midVal == key ) { low = mid + 1 ; } } return ans ; } int greatestlesser ( int low , int high , int key ) { int ans = -1 ; while ( low <= high ) { int mid = low + ( high - low + 1 ) / 2 ; int midVal = a [ mid ] ; if ( midVal < key ) { ans = mid ; low = mid + 1 ; } else if ( midVal > key ) { high = mid - 1 ; } else if ( midVal == key ) { high = mid - 1 ; } } return ans ; } int main ( ) { printf ( " Contains STRNEWLINE " ) ; for ( int i = 0 ; i < 10 ; i ++ ) printf ( " % d ▁ % d STRNEWLINE " , i , contains ( 0 , n - 1 , i ) ) ; printf ( " First ▁ occurrence ▁ of ▁ key STRNEWLINE " ) ; for ( int i = 0 ; i < 10 ; i ++ ) printf ( " % d ▁ % d STRNEWLINE " , i , first ( 0 , n - 1 , i ) ) ; printf ( " Last ▁ occurrence ▁ of ▁ key STRNEWLINE " ) ; for ( int i = 0 ; i < 10 ; i ++ ) printf ( " % d ▁ % d STRNEWLINE " , i , last ( 0 , n - 1 , i ) ) ; printf ( " Least ▁ integer ▁ greater ▁ than ▁ key STRNEWLINE " ) ; for ( int i = 0 ; i < 10 ; i ++ ) printf ( " % d ▁ % d STRNEWLINE " , i , leastgreater ( 0 , n - 1 , i ) ) ; printf ( " Greatest ▁ integer ▁ lesser ▁ than ▁ key STRNEWLINE " ) ; for ( int i = 0 ; i < 10 ; i ++ ) printf ( " % d ▁ % d STRNEWLINE " , i , greatestlesser ( 0 , n - 1 , i ) ) ; return 0 ; } |
Minimum number of distinct elements after removing m items | C ++ program for above implementation ; Function to find distintc id 's ; Store the occurrence of ids ; Store into the vector second as first and vice - versa ; Sort the vector ; Start removing elements from the beginning ; Remove if current value is less than or equal to mi ; Return the remaining size ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int distinctIds ( int arr [ ] , int n , int mi ) { unordered_map < int , int > m ; vector < pair < int , int > > v ; int count = 0 ; for ( int i = 0 ; i < n ; i ++ ) m [ arr [ i ] ] ++ ; for ( auto it = m . begin ( ) ; it != m . end ( ) ; it ++ ) v . push_back ( make_pair ( it -> second , it -> first ) ) ; sort ( v . begin ( ) , v . end ( ) ) ; int size = v . size ( ) ; for ( int i = 0 ; i < size ; i ++ ) { if ( v [ i ] . first <= mi ) { mi -= v [ i ] . first ; count ++ ; } else return size - count ; } return size - count ; } int main ( ) { int arr [ ] = { 2 , 3 , 1 , 2 , 3 , 3 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int m = 3 ; cout << distinctIds ( arr , n , m ) ; return 0 ; } |
Number of Larger Elements on right side in a string | CPP program to find counts of right greater characters for every character . ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printGreaterCount ( string str ) { int len = str . length ( ) , right [ len ] = { 0 } ; for ( int i = 0 ; i < len ; i ++ ) for ( int j = i + 1 ; j < len ; j ++ ) if ( str [ i ] < str [ j ] ) right [ i ] ++ ; for ( int i = 0 ; i < len ; i ++ ) cout << right [ i ] << " ▁ " ; } int main ( ) { string str = " abcd " ; printGreaterCount ( str ) ; return 0 ; } |
Maximum consecutive numbers present in an array | CPP program to find largest consecutive numbers present in arr [ ] . ; We insert all the array elements into unordered set . ; check each possible sequence from the start then update optimal length ; if current element is the starting element of a sequence ; Then check for next elements in the sequence ; increment the value of array element and repeat search in the set ; Update optimal length if this length is more . To get the length as it is incremented one by one ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findLongestConseqSubseq ( int arr [ ] , int n ) { unordered_set < int > S ; for ( int i = 0 ; i < n ; i ++ ) S . insert ( arr [ i ] ) ; int ans = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( S . find ( arr [ i ] - 1 ) == S . end ( ) ) { int j = arr [ i ] ; while ( S . find ( j ) != S . end ( ) ) j ++ ; ans = max ( ans , j - arr [ i ] ) ; } } return ans ; } int main ( ) { int arr [ ] = { 1 , 94 , 93 , 1000 , 5 , 92 , 78 } ; int n = sizeof ( arr ) / sizeof ( int ) ; cout << findLongestConseqSubseq ( arr , n ) << endl ; return 0 ; } |
N / 3 repeated number in an array with O ( 1 ) space | CPP program to find if any element appears more than n / 3. ; take the integers as the maximum value of integer hoping the integer would not be present in the array ; if this element is previously seen , increment count1 . ; if this element is previously seen , increment count2 . ; if current element is different from both the previously seen variables , decrement both the counts . ; Again traverse the array and find the actual counts . ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int appearsNBy3 ( int arr [ ] , int n ) { int count1 = 0 , count2 = 0 ; int first = INT_MAX , second = INT_MAX ; for ( int i = 0 ; i < n ; i ++ ) { if ( first == arr [ i ] ) count1 ++ ; else if ( second == arr [ i ] ) count2 ++ ; else if ( count1 == 0 ) { count1 ++ ; first = arr [ i ] ; } else if ( count2 == 0 ) { count2 ++ ; second = arr [ i ] ; } else { count1 -- ; count2 -- ; } } count1 = 0 ; count2 = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( arr [ i ] == first ) count1 ++ ; else if ( arr [ i ] == second ) count2 ++ ; } if ( count1 > n / 3 ) return first ; if ( count2 > n / 3 ) return second ; return -1 ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 1 , 1 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << appearsNBy3 ( arr , n ) << endl ; return 0 ; } |
Subsets and Splits