text
stringlengths 17
4.49k
| code
stringlengths 49
5.46k
|
|---|---|
Minimum absolute difference between N and any power of 2 | C ++ implementation of the approach ; Function to return the highest power of 2 less than or equal to n ; Function to return the smallest power of 2 greater than or equal to n ; Function that returns the minimum absolute difference between n and any power of 2 ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int prevPowerof2 ( int n ) { int p = ( int ) log2 ( n ) ; return ( int ) pow ( 2 , p ) ; } int nextPowerOf2 ( int n ) { int p = 1 ; if ( n && ! ( n & ( n - 1 ) ) ) return n ; while ( p < n ) p <<= 1 ; return p ; } int minDiff ( int n ) { int low = prevPowerof2 ( n ) ; int high = nextPowerOf2 ( n ) ; return min ( n - low , high - n ) ; } int main ( ) { int n = 6 ; cout << minDiff ( n ) ; return 0 ; } |
Maximum possible number with the given operation | C ++ implementation of the approach ; Function to return the maximum possible integer that can be obtained from the given integer after performing the given operations ; For every digit ; Digits greater than or equal to 5 need not to be changed as changing them will lead to a smaller number ; The resulting integer cannot have leading zero ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; string maxInt ( string str ) { for ( int i = 0 ; i < str . length ( ) ; i ++ ) { if ( str [ i ] < '5' ) { str [ i ] = ( '9' - str [ i ] ) + '0' ; } } if ( str [ 0 ] == '0' ) str [ 0 ] = '9' ; return str ; } int main ( ) { string str = "42" ; cout << maxInt ( str ) ; return 0 ; } |
Find the ratio of number of elements in two Arrays from their individual and combined average | C ++ program to Find the Ratio of number of Elements in two Arrays from their individual and combined Average ; C ++ function to find the ratio of number of array elements ; calculating GCD of them ; make neumarator and denominator coprime ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void FindRatio ( int a , int b , int c ) { int up = abs ( b - c ) ; int down = abs ( c - a ) ; int g = __gcd ( up , down ) ; up /= g ; down /= g ; cout << up << " : " << down << " STRNEWLINE " ; } int main ( ) { int a = 4 , b = 10 , c = 6 ; FindRatio ( a , b , c ) ; return 0 ; } |
Maximum distance between two 1 's in Binary representation of N | C ++ program to find the Maximum distance between two 1 's in Binary representation of N ; Compute the binary representation ; if N is a power of 2 then return - 1 ; else find the distance between the first position of 1 and last position of 1 ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int longest_gap ( int N ) { int distance = 0 , count = 0 , first_1 = -1 , last_1 = -1 ; while ( N ) { count ++ ; int r = N & 1 ; if ( r == 1 ) { first_1 = first_1 == -1 ? count : first_1 ; last_1 = count ; } N = N / 2 ; } if ( last_1 <= first_1 ) { return -1 ; } else { distance = ( last_1 - first_1 - 1 ) ; return distance ; } } int main ( ) { int N = 131 ; cout << longest_gap ( N ) << endl ; N = 8 ; cout << longest_gap ( N ) << endl ; N = 17 ; cout << longest_gap ( N ) << endl ; N = 33 ; cout << longest_gap ( N ) << endl ; return 0 ; } |
Check if it is possible to move from ( 0 , 0 ) to ( X , Y ) in exactly K steps | C ++ implementation of the approach ; Function that returns true if it is possible to move from ( 0 , 0 ) to ( x , y ) in exactly k moves ; Minimum moves required ; If possible ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool isPossible ( int x , int y , int k ) { int minMoves = abs ( x ) + abs ( y ) ; if ( k >= minMoves && ( k - minMoves ) % 2 == 0 ) return true ; return false ; } int main ( ) { int x = 5 , y = 8 , k = 20 ; if ( isPossible ( x , y , k ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Check whether N is a Factorion or not | C ++ implementation of the approach ; Function that returns true if n is a Factorion ; fact [ i ] will store i ! ; A copy of the given integer ; To store the sum of factorials of the digits of n ; Get the last digit ; Add the factorial of the current digit to the sum ; Remove the last digit ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define MAX 10 NEW_LINE bool isFactorion ( int n ) { int fact [ MAX ] ; fact [ 0 ] = 1 ; for ( int i = 1 ; i < MAX ; i ++ ) fact [ i ] = i * fact [ i - 1 ] ; int org = n ; int sum = 0 ; while ( n > 0 ) { int d = n % 10 ; sum += fact [ d ] ; n /= 10 ; } if ( sum == org ) return true ; return false ; } int main ( ) { int n = 40585 ; if ( isFactorion ( n ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Find the possible permutation of the bits of N | C ++ implementation of the approach ; Function that returns true if it is possible to arrange the bits of n in alternate fashion ; To store the count of 1 s in the binary representation of n ; If the number set bits and the number of unset bits is equal ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int TOTAL_BITS = 32 ; bool isPossible ( int n ) { int cnt = __builtin_popcount ( n ) ; if ( cnt == TOTAL_BITS / 2 ) return true ; return false ; } int main ( ) { int n = 524280 ; if ( isPossible ( n ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Check if two Integer are anagrams of each other | C ++ implementation of the approach ; Function to update the frequency array such that freq [ i ] stores the frequency of digit i in n ; While there are digits left to process ; Update the frequency of the current digit ; Remove the last digit ; Function that returns true if a and b are anagarams of each other ; To store the frequencies of the digits in a and b ; Update the frequency of the digits in a ; Update the frequency of the digits in b ; Match the frequencies of the common digits ; If frequency differs for any digit then the numbers are not anagrams of each other ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int TEN = 10 ; void updateFreq ( int n , int freq [ ] ) { while ( n ) { int digit = n % TEN ; freq [ digit ] ++ ; n /= TEN ; } } bool areAnagrams ( int a , int b ) { int freqA [ TEN ] = { 0 } ; int freqB [ TEN ] = { 0 } ; updateFreq ( a , freqA ) ; updateFreq ( b , freqB ) ; for ( int i = 0 ; i < TEN ; i ++ ) { if ( freqA [ i ] != freqB [ i ] ) return false ; } return true ; } int main ( ) { int a = 240 , b = 204 ; if ( areAnagrams ( a , b ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Find the permutation of first N natural numbers such that sum of i % Pi is maximum possible | C ++ implementation of the approach ; Function to find the permutation of the first N natural numbers such that the sum of ( i % Pi ) is maximum possible and return the maximum sum ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int Max_Sum ( int n ) { return ( n * ( n - 1 ) ) / 2 ; } int main ( ) { int n = 8 ; cout << Max_Sum ( n ) ; return 0 ; } |
Check if the number formed by the last digits of N numbers is divisible by 10 or not | C ++ implementation of the approach ; Function that returns true if the number formed by the last digits of all the elements is divisible by 10 ; Last digit of the last element ; Number formed will be divisible by 10 ; Driver code | #include <iostream> NEW_LINE using namespace std ; bool isDivisible ( int arr [ ] , int n ) { int lastDigit = arr [ n - 1 ] % 10 ; if ( lastDigit == 0 ) return true ; return false ; } int main ( ) { int arr [ ] = { 12 , 65 , 46 , 37 , 99 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; if ( isDivisible ( arr , n ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Count of Multiples of A , B or C less than or equal to N | C ++ implementation of the approach ; Function to return the gcd of a and b ; Function to return the count of integers from the range [ 1 , num ] which are divisible by either a , b or c ; Calculate the number of terms divisible by a , b and c then remove the terms which are divisible by both ( a , b ) or ( b , c ) or ( c , a ) and then add the numbers which are divisible by a , b and c ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; long gcd ( long a , long b ) { if ( a == 0 ) return b ; return gcd ( b % a , a ) ; } long divTermCount ( long a , long b , long c , long num ) { return ( ( num / a ) + ( num / b ) + ( num / c ) - ( num / ( ( a * b ) / gcd ( a , b ) ) ) - ( num / ( ( c * b ) / gcd ( c , b ) ) ) - ( num / ( ( a * c ) / gcd ( a , c ) ) ) + ( num / ( ( a * b * c ) / gcd ( gcd ( a , b ) , c ) ) ) ) ; } int main ( ) { long a = 7 , b = 3 , c = 5 , n = 100 ; cout << divTermCount ( a , b , c , n ) ; return 0 ; } |
Array containing power of 2 whose XOR and Sum of elements equals X | C ++ implementation of the above approach ; Function to return the required array ; Store the power of 2 ; while n is greater than 0 ; if there is 1 in binary representation ; Divide n by 2 Multiply p2 by 2 ; Driver code ; Get the answer ; Printing the array | #include <bits/stdc++.h> NEW_LINE using namespace std ; vector < long > getArray ( int n ) { vector < long > ans ; long p2 = 1 ; while ( n > 0 ) { if ( n & 1 ) ans . push_back ( p2 ) ; n >>= 1 ; p2 *= 2 ; } return ans ; } int main ( ) { long n = 15 ; vector < long > ans = getArray ( n ) ; for ( int i : ans ) cout << i << " ▁ " ; return 0 ; } |
Find out the correct position of the ball after shuffling | C ++ implementation of the above approach ; Function to generate the index of the glass containing the ball ; Change the index ; Change the index ; Print the index ; Driver 's Code ; Storing all the shuffle operation | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int M = 3 , N = 2 ; void getIndex ( int n , int shuffle [ ] [ N ] ) { for ( int i = 0 ; i < 3 ; i ++ ) { if ( shuffle [ i ] [ 0 ] == n ) n = shuffle [ i ] [ 1 ] ; else if ( shuffle [ i ] [ 1 ] == n ) n = shuffle [ i ] [ 0 ] ; } cout << n ; } int main ( ) { int n = 3 ; int shuffle [ M ] [ N ] = { { 3 , 1 } , { 2 , 1 } , { 1 , 2 } } ; getIndex ( n , shuffle ) ; } |
Count the number of subsequences of length k having equal LCM and HCF | C ++ implementation ; Returns factorial of n ; Returns nCr for the given values of r and n ; Map to store the frequencies of each elements ; Loop to store the frequencies of elements in the map ; Using nCR formula to calculate the number of subsequences of a given length ; Driver Code ; Function calling | #include <bits/stdc++.h> NEW_LINE using namespace std ; long long fact ( int n ) { long long res = 1 ; for ( int i = 2 ; i <= n ; i ++ ) res = res * i ; return res ; } long long nCr ( int n , int r ) { return fact ( n ) / ( 1LL * fact ( r ) * fact ( n - r ) ) ; } long long number_of_subsequences ( int arr [ ] , int k , int n ) { long long s = 0 ; map < int , int > m ; for ( int i = 0 ; i < n ; i ++ ) { m [ arr [ i ] ] ++ ; } for ( auto j : m ) { s = s + 1LL * nCr ( j . second , k ) ; } return s ; } int main ( ) { int arr [ ] = { 1 , 1 , 1 , 1 , 2 , 2 , 2 } ; int k = 2 ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << number_of_subsequences ( arr , k , n ) ; return 0 ; } |
Find the sum of all possible pairs in an array of N elements | C ++ implementation of the approach ; Function to return the sum of the elements of all possible pairs from the array ; To store the required sum ; For every element of the array ; It appears ( 2 * n ) times ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int sumPairs ( int arr [ ] , int n ) { int sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { sum = sum + ( arr [ i ] * ( 2 * n ) ) ; } return sum ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << sumPairs ( arr , n ) ; return 0 ; } |
Minimum sum obtained from groups of four elements from the given array | C ++ implementation of the approach ; Function to return the minimum required sum ; To store the required sum ; Sort the array in descending order ; The indices which give 0 or 1 as the remainder when divided by 4 will be the maximum two elements of the group ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int minSum ( int arr [ ] , int n ) { int sum = 0 ; sort ( arr , arr + n , greater < int > ( ) ) ; for ( int i = 0 ; i < n ; i ++ ) { if ( i % 4 < 2 ) sum = sum + arr [ i ] ; } return sum ; } int main ( ) { int arr [ ] = { 1 , 1 , 10 , 2 , 2 , 2 , 1 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << minSum ( arr , n ) ; return 0 ; } |
Count of triples ( A , B , C ) where A * C is greater than B * B | C ++ implementation ; function to return the count of the valid triplets ; Driver Code ; function calling | #include <bits/stdc++.h> NEW_LINE using namespace std ; long long countTriplets ( int A , int B , int C ) { long long ans = 0 ; for ( int i = 1 ; i <= A ; i ++ ) { for ( int j = 1 ; j <= B ; j ++ ) { for ( int k = 1 ; k <= C ; k ++ ) { if ( i * k > j * j ) ans ++ ; } } } return ans ; } int main ( ) { int A , B , C ; A = 3 , B = 2 , C = 2 ; cout << countTriplets ( A , B , C ) ; } |
Count of triples ( A , B , C ) where A * C is greater than B * B | C ++ implementation ; Counts the number of triplets for a given value of b ; Count all triples in which a = i ; Smallest value j such that i * j > B2 ; Count all ( i , B2 , x ) such that x >= j ; count all ( x , B2 , y ) such that x >= j this counts all such triples in which a >= j ; As all triples with a >= j have been counted reduce A to j - 1. ; Counts the number of triples that satisfy the given constraints ; GetCount of triples in which b = i ; Driver Code ; Function calling | #include <bits/stdc++.h> NEW_LINE using namespace std ; long long getCount ( int A , int B2 , int C ) { long long count = 0 ; for ( int i = 1 ; i <= A ; i ++ ) { long long j = ( B2 / i ) + 1 ; if ( C >= j ) count = ( count + C - j + 1 ) ; if ( A >= j && C >= i ) count = ( count + ( C - i + 1 ) * ( A - j + 1 ) ) ; if ( A >= j ) A = j - 1 ; } return count ; } long long countTriplets ( int A , int B , int C ) { long long ans = 0 ; for ( int i = 1 ; i <= B ; i ++ ) { ans = ( ans + getCount ( A , i * i , C ) ) ; } return ans ; } int main ( ) { int A , B , C ; A = 3 , B = 2 , C = 2 ; cout << countTriplets ( A , B , C ) ; } |
Summation of floor of harmonic progression | C ++ implementation of the approach ; Function to return the summation of the given harmonic series ; To store the summation ; Floor of sqrt ( n ) ; Summation of floor ( n / i ) ; From the formula ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; long long int getSum ( int n ) { long long int sum = 0 ; int k = sqrt ( n ) ; for ( int i = 1 ; i <= k ; i ++ ) { sum += floor ( n / i ) ; } sum *= 2 ; sum -= pow ( k , 2 ) ; return sum ; } int main ( ) { int n = 5 ; cout << getSum ( n ) ; return 0 ; } |
Count of distinct remainders when N is divided by all the numbers from the range [ 1 , N ] | C ++ implementation of the approach ; Function to return the count of distinct remainders that can be obtained when n is divided by every element from the range [ 1 , n ] ; If n is even ; If n is odd ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int distinctRemainders ( int n ) { if ( n % 2 == 0 ) return ( n / 2 ) ; return ( 1 + ( n / 2 ) ) ; } int main ( ) { int n = 5 ; cout << distinctRemainders ( n ) ; return 0 ; } |
Count total unset bits in all the numbers from 1 to N | C ++ implementation of the approach ; Function to return the count of unset bits in the binary representation of all the numbers from 1 to n ; To store the count of unset bits ; For every integer from the range [ 1 , n ] ; A copy of the current integer ; Count of unset bits in the current integer ; If current bit is unset ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countUnsetBits ( int n ) { int cnt = 0 ; for ( int i = 1 ; i <= n ; i ++ ) { int temp = i ; while ( temp ) { if ( temp % 2 == 0 ) cnt ++ ; temp = temp / 2 ; } } return cnt ; } int main ( ) { int n = 5 ; cout << countUnsetBits ( n ) ; return 0 ; } |
Find if a degree sequence can form a simple graph | Havel | C ++ implementation of the approach ; Function that returns true if a simple graph exists ; Keep performing the operations until one of the stopping condition is met ; Sort the list in non - decreasing order ; Check if all the elements are equal to 0 ; Store the first element in a variable and delete it from the list ; Check if enough elements are present in the list ; Subtract first element from next v elements ; Check if negative element is encountered after subtraction ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool graphExists ( vector < int > & a , int n ) { while ( 1 ) { sort ( a . begin ( ) , a . end ( ) , greater < > ( ) ) ; if ( a [ 0 ] == 0 ) return true ; int v = a [ 0 ] ; a . erase ( a . begin ( ) + 0 ) ; if ( v > a . size ( ) ) return false ; for ( int i = 0 ; i < v ; i ++ ) { a [ i ] -- ; if ( a [ i ] < 0 ) return false ; } } } int main ( ) { vector < int > a = { 3 , 3 , 3 , 3 } ; int n = a . size ( ) ; graphExists ( a , n ) ? cout << " Yes " : cout << " NO " << endl ; return 0 ; } |
Number of sub arrays with negative product | C ++ implementation of the approach ; Function to return the count of subarrays with negative product ; Replace current element with 1 if it is positive else replace it with - 1 instead ; Take product with previous element to form the prefix product ; Count positive and negative elements in the prefix product array ; Return the required count of subarrays ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int negProdSubArr ( int arr [ ] , int n ) { int positive = 1 , negative = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( arr [ i ] > 0 ) arr [ i ] = 1 ; else arr [ i ] = -1 ; if ( i > 0 ) arr [ i ] *= arr [ i - 1 ] ; if ( arr [ i ] == 1 ) positive ++ ; else negative ++ ; } return ( positive * negative ) ; } int main ( ) { int arr [ ] = { 5 , -4 , -3 , 2 , -5 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << negProdSubArr ( arr , n ) ; return ( 0 ) ; } |
Repeated sum of first N natural numbers | C ++ implementation of the approach ; Function to return the sum of the first n natural numbers ; Function to return the repeated sum ; Perform the operation exactly k times ; Update n with the sum of first n natural numbers ; Driver code | #include <iostream> NEW_LINE using namespace std ; int sum ( int n ) { int sum = ( n * ( n + 1 ) ) / 2 ; return sum ; } int repeatedSum ( int n , int k ) { for ( int i = 0 ; i < k ; i ++ ) { n = sum ( n ) ; } return n ; } int main ( ) { int n = 2 , k = 2 ; cout << repeatedSum ( n , k ) ; return 0 ; } |
Difference between Sum of Cubes and Sum of First N Natural Numbers | C ++ program to find the difference between the sum of the cubes of the first N natural numbers and the sum of the first N natural number ; Sum of first n natural numbers ; Find the required difference ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int difference ( int n ) { int S , res ; S = ( n * ( n + 1 ) ) / 2 ; res = S * ( S - 1 ) ; return res ; } int main ( ) { int n = 5 ; cout << difference ( n ) ; return 0 ; } |
Check if the sum of digits of number is divisible by all of its digits | C ++ implementation of the approach ; Function that returns true if all the digits of n divide the sum of the digits of n ; Store a copy of the original number ; Find the sum of the digits of n ; Restore the original value ; Check if all the digits divide the calculated sum ; If current digit doesn 't divide the sum ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool isDivisible ( long long int n ) { long long int temp = n ; int sum = 0 ; while ( n ) { int digit = n % 10 ; sum += digit ; n /= 10 ; } n = temp ; while ( n ) { int digit = n % 10 ; if ( sum % digit != 0 ) return false ; n /= 10 ; } return true ; } int main ( ) { long long int n = 123 ; if ( isDivisible ( n ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Program for Mobius Function | Set 2 | C ++ implementation of the approach ; Function to calculate least prime factor of each number ; If it is a prime number ; For all multiples which are not visited yet . ; Function to find the value of Mobius function for all the numbers from 1 to n ; To store the values of Mobius function ; If number is one ; If number has a squared prime factor ; Multiply - 1 with the previous number ; Driver code ; Function to find least prime factor ; Function to find mobius function | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define N 100005 NEW_LINE int lpf [ N ] ; void least_prime_factor ( ) { for ( int i = 2 ; i < N ; i ++ ) if ( ! lpf [ i ] ) for ( int j = i ; j < N ; j += i ) if ( ! lpf [ j ] ) lpf [ j ] = i ; } void Mobius ( int n ) { int mobius [ N ] ; for ( int i = 1 ; i < N ; i ++ ) { if ( i == 1 ) mobius [ i ] = 1 ; else { if ( lpf [ i / lpf [ i ] ] == lpf [ i ] ) mobius [ i ] = 0 ; else mobius [ i ] = -1 * mobius [ i / lpf [ i ] ] ; } } for ( int i = 1 ; i <= n ; i ++ ) cout << mobius [ i ] << " ▁ " ; } int main ( ) { int n = 5 ; least_prime_factor ( ) ; Mobius ( n ) ; } |
Make the list non | C ++ implementation of the approach ; Function to return the minimum element from the range [ prev , MAX ] such that it differs in at most 1 digit with cur ; To start with the value we have achieved in the last step ; Store the value with which the current will be compared ; Current value ; There are at most 4 digits ; If the current digit differs in both the numbers ; Eliminate last digits in both the numbers ; If the number of different digits is at most 1 ; If we can 't find any number for which the number of change is less than or equal to 1 then return -1 ; Function to get the non - decreasing list ; Creating a vector for the updated list ; Let 's assume that it is possible to make the list non-decreasing ; Element of the original array ; Can 't make the list non-decreasing ; If possible then print the list ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int DIGITS = 4 , MIN = 1000 , MAX = 9999 ; int getBest ( int prev , int cur ) { int maximum = max ( MIN , prev ) ; for ( int i = maximum ; i <= MAX ; i ++ ) { int cnt = 0 ; int a = i ; int b = cur ; for ( int k = 0 ; k < DIGITS ; k ++ ) { if ( a % 10 != b % 10 ) cnt += 1 ; a /= 10 ; b /= 10 ; } if ( cnt <= 1 ) return i ; } return -1 ; } void getList ( int arr [ ] , int n ) { vector < int > myList ; int i , cur ; bool possible = true ; myList . push_back ( 0 ) ; for ( i = 0 ; i < n ; i ++ ) { cur = arr [ i ] ; myList . push_back ( getBest ( myList . back ( ) , cur ) ) ; if ( myList . back ( ) == -1 ) { possible = false ; break ; } } if ( possible ) { for ( i = 1 ; i < myList . size ( ) ; i ++ ) cout << myList [ i ] << " ▁ " ; } else cout << " - 1" ; } int main ( ) { int arr [ ] = { 1095 , 1094 , 1095 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; getList ( arr , n ) ; return 0 ; } |
Maximum items that can be bought with the given type of coins | C ++ implementation of the approach ; Function to find maximum fruits Can buy from given values of x , y , z . ; Items of type 1 that can be bought ; Update the coins ; Items of type 2 that can be bought ; Update the coins ; Items of type 3 that can be bought ; Update the coins ; Items of type 4 that can be bought To buy a type 4 item , a coin of each type is required ; Total items that can be bought ; Driver code | #include <iostream> NEW_LINE using namespace std ; const int COST = 3 ; int maxItems ( int x , int y , int z ) { int type1 = x / COST ; x %= COST ; int type2 = y / COST ; y %= COST ; int type3 = z / COST ; z %= COST ; int type4 = min ( x , min ( y , z ) ) ; int maxItems = type1 + type2 + type3 + type4 ; return maxItems ; } int main ( ) { int x = 4 , y = 5 , z = 6 ; cout << maxItems ( x , y , z ) ; return 0 ; } |
Count occurrences of a prime number in the prime factorization of every element from the given range | C ++ implementation of the approach ; Function to return the highest power of p that divides n ; Function to return the count of times p appears in the prime factors of the elements from the range [ l , r ] ; To store the required count ; For every element of the range ; Add the highest power of p that divides i ; Driver code | #include <iostream> NEW_LINE using namespace std ; int countFactors ( int n , int p ) { int pwr = 0 ; while ( n > 0 && n % p == 0 ) { n /= p ; pwr ++ ; } return pwr ; } int getCount ( int l , int r , int p ) { int cnt = 0 ; for ( int i = l ; i <= r ; i ++ ) { cnt += countFactors ( i , p ) ; } return cnt ; } int main ( ) { int l = 2 , r = 8 , p = 2 ; cout << getCount ( l , r , p ) ; return 0 ; } |
Count occurrences of a prime number in the prime factorization of every element from the given range | C ++ implementation of the approach ; Function to return the count of times p appears in the prime factors of the elements from the range [ l , r ] ; To store the required count ; Number of values in the range [ 0 , r ] that are divisible by val ; Number of values in the range [ 0 , l - 1 ] that are divisible by val ; Increment the power of the val ; ( a - b ) is the count of numbers in the range [ l , r ] that are divisible by val ; No values that are divisible by val thus exiting from the loop ; Driver code | #include <iostream> NEW_LINE using namespace std ; int getCount ( int l , int r , int p ) { int cnt = 0 ; int val = p ; while ( 1 ) { int a = r / val ; int b = ( l - 1 ) / val ; val *= p ; if ( a - b ) { cnt += ( a - b ) ; } else break ; } return cnt ; } int main ( ) { int l = 2 , r = 8 , p = 2 ; cout << getCount ( l , r , p ) ; return 0 ; } |
Check if the number is valid when flipped upside down | C ++ implementation of the approach ; Function that returns true if str is Topsy Turvy ; For every character of the string ; If the current digit cannot form a valid digit when turned upside - down ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool topsyTurvy ( string str ) { for ( int i = 0 ; i < str . length ( ) ; i ++ ) { if ( str [ i ] == '2' str [ i ] == '4' str [ i ] == '5' str [ i ] == '6' str [ i ] == '7' str [ i ] == '9' ) { return false ; } } return true ; } int main ( ) { string str = "1234" ; if ( topsyTurvy ( str ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Find the count of subsequences where each element is divisible by K | C ++ implementation of the approach ; Function to return the count of all valid subsequences ; To store the count of elements which are divisible by k ; If current element is divisible by k then increment the count ; Total ( 2 ^ n - 1 ) non - empty subsequences are possible with n element ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countSubSeq ( int arr [ ] , int n , int k ) { int count = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( arr [ i ] % k == 0 ) { count ++ ; } } return ( pow ( 2 , count ) - 1 ) ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 6 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; int k = 3 ; cout << countSubSeq ( arr , n , k ) ; return 0 ; } |
Count of numbers below N whose sum of prime divisors is K | C ++ implementation of the approach ; Function to return the count of numbers below N whose sum of prime factors is K ; To store the sum of prime factors for all the numbers ; If i is prime ; Add i to all the numbers which are divisible by i ; To store the count of required numbers ; Return the required count ; Driver code | #include <iostream> NEW_LINE using namespace std ; #define MAX 1000001 NEW_LINE int countNum ( int N , int K ) { int sumPF [ MAX ] = { 0 } ; for ( int i = 2 ; i < N ; i ++ ) { if ( sumPF [ i ] == 0 ) { for ( int j = i ; j < N ; j += i ) { sumPF [ j ] += i ; } } } int count = 0 ; for ( int i = 2 ; i < N ; i ++ ) { if ( sumPF [ i ] == K ) count ++ ; } return count ; } int main ( ) { int N = 20 , K = 7 ; cout << countNum ( N , K ) ; return 0 ; } |
Queries for the smallest and the largest prime number of given digit | C ++ implementation of the approach ; Create a boolean array " prime [ 0 . . n ] " and initialize all entries it as true . A value in prime [ i ] will finally be false if i is Not a prime , else true . ; If prime [ p ] is not changed , then it is a prime ; Update all multiples of p greater than or equal to the square of it numbers which are multiple of p and are less than p ^ 2 are already been marked . ; Function to return the smallest prime number with d digits ; check if prime ; Function to return the largest prime number with d digits ; check if prime ; Driver code ; Perform queries | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define MAX 100000 NEW_LINE bool prime [ MAX + 1 ] ; void SieveOfEratosthenes ( ) { memset ( prime , true , sizeof ( prime ) ) ; for ( int p = 2 ; p * p <= MAX ; p ++ ) { if ( prime [ p ] == true ) { for ( int i = p * p ; i <= MAX ; i += p ) prime [ i ] = false ; } } } int smallestPrime ( int d ) { int l = pow ( 10 , d - 1 ) ; int r = pow ( 10 , d ) - 1 ; for ( int i = l ; i <= r ; i ++ ) { if ( prime [ i ] ) { return i ; } } return -1 ; } int largestPrime ( int d ) { int l = pow ( 10 , d - 1 ) ; int r = pow ( 10 , d ) - 1 ; for ( int i = r ; i >= l ; i -- ) { if ( prime [ i ] ) { return i ; } } return -1 ; } int main ( ) { SieveOfEratosthenes ( ) ; int queries [ ] = { 2 , 5 } ; int q = sizeof ( queries ) / sizeof ( queries [ 0 ] ) ; for ( int i = 0 ; i < q ; i ++ ) { cout << smallestPrime ( queries [ i ] ) << " ▁ " << largestPrime ( queries [ i ] ) << endl ; } return 0 ; } |
Find a Square Matrix such that sum of elements in every row and column is K | C ++ implementation of the approach ; Function to print the required matrix ; Print k for the left diagonal elements ; Print 0 for the rest ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printMatrix ( int n , int k ) { for ( int i = 0 ; i < n ; i ++ ) { for ( int j = 0 ; j < n ; j ++ ) { if ( i == j ) cout << k << " ▁ " ; else cout << "0 ▁ " ; } cout << " STRNEWLINE " ; } } int main ( ) { int n = 3 , k = 7 ; printMatrix ( n , k ) ; return ( 0 ) ; } |
Divide first N natural numbers into 3 equal sum subsets | C ++ implementation of the approach ; Function that returns true if the subsets are possible ; If n <= 3 then it is not possible to divide the elements in three subsets satisfying the given conditions ; Sum of all the elements in the range [ 1 , n ] ; If the sum is divisible by 3 then it is possible ; Driver code | #include <iostream> NEW_LINE using namespace std ; bool possible ( int n ) { if ( n > 3 ) { int sum = ( n * ( n + 1 ) ) / 2 ; if ( sum % 3 == 0 ) { return true ; } } return false ; } int main ( ) { int n = 5 ; if ( possible ( n ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Find the Nth element of the modified Fibonacci series | C ++ implementation of the approach ; Function to return the Nth number of the modified Fibonacci series where A and B are the first two terms ; To store the current element which is the sum of previous two elements of the series ; This loop will terminate when the Nth element is found ; Return the Nth element ; Driver code | #include <iostream> NEW_LINE using namespace std ; int findNthNumber ( int A , int B , int N ) { int sum = 0 ; for ( int i = 2 ; i < N ; i ++ ) { sum = A + B ; A = B ; B = sum ; } return sum ; } int main ( ) { int A = 5 , B = 7 , N = 10 ; cout << findNthNumber ( A , B , N ) ; return 0 ; } |
Check if an array is increasing or decreasing | C ++ implementation of the approach ; Function to check the type of the array ; If the first two and the last two elements of the array are in increasing order ; If the first two and the last two elements of the array are in decreasing order ; If the first two elements of the array are in increasing order and the last two elements of the array are in decreasing order ; If the first two elements of the array are in decreasing order and the last two elements of the array are in increasing order ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void checkType ( int arr [ ] , int n ) { if ( arr [ 0 ] <= arr [ 1 ] && arr [ n - 2 ] <= arr [ n - 1 ] ) cout << " Increasing " ; else if ( arr [ 0 ] >= arr [ 1 ] && arr [ n - 2 ] >= arr [ n - 1 ] ) cout << " Decreasing " ; else if ( arr [ 0 ] <= arr [ 1 ] && arr [ n - 2 ] >= arr [ n - 1 ] ) cout << " Increasing ▁ then ▁ decreasing " ; else cout << " Decreasing ▁ then ▁ increasing " ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 4 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; checkType ( arr , n ) ; return 0 ; } |
Calculate the IST : Indian Standard Time | C ++ implementation of the approach ; Function to calculate Indian Standard Time ; Separate integer part ; Separate float part and return ceil value ; Driver code ; Number of hours ( 1 - 24 ) ; Rotations in degrees | #include <cmath> NEW_LINE #include <iostream> NEW_LINE using namespace std ; void cal_IST ( int h , float r ) { float IST = ( h * r * 1.0 ) / 360 ; int int_IST = ( int ) IST ; int float_IST = ceil ( ( IST - int_IST ) * 60 ) ; cout << int_IST << " : " << float_IST ; } int main ( ) { int h = 20 ; float r = 150 ; cal_IST ( h , r ) ; return 0 ; } |
Check if it is possible to perform the given Grid Division | C ++ implementation of the approach ; Function that returns true if it is possible to divide the grid satisfying the given conditions ; To store the sum of all the cells of the given parts ; If the sum is equal to the total number of cells in the given grid ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool isPossible ( int arr [ ] , int p , int n , int m ) { int sum = 0 ; for ( int i = 0 ; i < p ; i ++ ) sum += arr [ i ] ; if ( sum == ( n * m ) ) return true ; return false ; } int main ( ) { int n = 3 , m = 4 ; int arr [ ] = { 6 , 3 , 2 , 1 } ; int p = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; if ( isPossible ( arr , p , n , m ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Minimum steps to make the product of the array equal to 1 | C ++ implementation of the approach ; Function to return the minimum steps required ; To store the count of 0 s , positive and negative numbers ; To store the ans ; If array element is equal to 0 ; If array element is a negative number ; Extra cost needed to make it - 1 ; If array element is a positive number ; Extra cost needed to make it 1 ; Now the array will have - 1 , 0 and 1 only ; As count of negative is even so we will change all 0 to 1 total cost here will be count of 0 s ; If there are zeroes present in the array ; Change one zero to - 1 and rest of them to 1 Total cost here will be count of '0' ; If there are no zeros in the array ; As no 0 s are available so we have to change one - 1 to 1 which will cost 2 to change - 1 to 1 ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int MinStep ( int a [ ] , int n ) { int positive = 0 , negative = 0 , zero = 0 ; int step = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( a [ i ] == 0 ) { zero ++ ; } else if ( a [ i ] < 0 ) { negative ++ ; step = step + ( -1 - a [ i ] ) ; } else { positive ++ ; step = step + ( a [ i ] - 1 ) ; } } if ( negative % 2 == 0 ) { step = step + zero ; } else { if ( zero > 0 ) { step = step + zero ; } else { step = step + 2 ; } } return step ; } int main ( ) { int a [ ] = { 0 , -2 , -1 , -3 , 4 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << MinStep ( a , n ) ; return 0 ; } |
Find the first N integers such that the sum of their digits is equal to 10 | C ++ implementation of the approach ; Function to return the sum of digits of n ; Add the last digit to the sum ; Remove last digit ; Return the sum of digits ; Function to print the first n numbers whose sum of digits is 10 ; First number of the series is 19 ; If the sum of digits of the current number is equal to 10 ; Print the number ; Add 9 to the previous number ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int sum ( int n ) { int sum = 0 ; while ( n ) { sum = sum + n % 10 ; n = n / 10 ; } return sum ; } void firstN ( int n ) { int num = 19 , cnt = 1 ; while ( cnt != n ) { if ( sum ( num ) == 10 ) { cout << num << " ▁ " ; cnt ++ ; } num += 9 ; } } int main ( ) { int n = 10 ; firstN ( n ) ; return 0 ; } |
Sum of last digit of all integers from 1 to N divisible by M | C ++ implementation of the approach ; Function to return the required sum ; Number of element between 1 to n divisible by m ; Array to store the last digit of elements in a cycle ; Storing and adding last digit of cycle ; Number of elements present in last cycle ; Sum of k / 10 cycle ; Adding value of digits of last cycle to the answer ; Driver Code ; input n and m | #include <iostream> NEW_LINE using namespace std ; #define long long long NEW_LINE long sumOfLastDig ( long n , long m ) { long sum = 0 , k ; k = n / m ; long arr [ 10 ] ; for ( int i = 0 ; i < 10 ; i ++ ) { arr [ i ] = m * ( i + 1 ) % 10 ; sum += arr [ i ] ; } long rem = k % 10 ; long ans = ( k / 10 ) * sum ; for ( int i = 0 ; i < rem ; i ++ ) { ans += arr [ i ] ; } return ans ; } int main ( ) { long n = 100 , m = 3 ; cout << sumOfLastDig ( n , m ) ; return 0 ; } |
Number of Subsequences with Even and Odd Sum | Set 2 | CPP program to find number of Subsequences with Even and Odd Sum ; Function to find number of Subsequences with Even and Odd Sum ; Counting number of odds ; Even count ; Total Subsequences is ( 2 ^ n - 1 ) For NumberOfEvenSubsequences subtract NumberOfOddSubsequences from total ; Driver code ; Calling the function | #include <bits/stdc++.h> NEW_LINE using namespace std ; pair < int , int > countSum ( int arr [ ] , int n ) { int NumberOfOdds = 0 , NumberOfEvens = 0 ; for ( int i = 0 ; i < n ; i ++ ) if ( arr [ i ] & 1 ) NumberOfOdds ++ ; NumberOfEvens = n - NumberOfOdds ; int NumberOfOddSubsequences = ( 1 << NumberOfEvens ) * ( 1 << ( NumberOfOdds - 1 ) ) ; int NumberOfEvenSubsequences = ( 1 << n ) - 1 - NumberOfOddSubsequences ; return { NumberOfEvenSubsequences , NumberOfOddSubsequences } ; } int main ( ) { int arr [ ] = { 1 , 2 , 2 , 3 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; pair < int , int > ans = countSum ( arr , n ) ; cout << " EvenSum ▁ = ▁ " << ans . first ; cout << " ▁ OddSum ▁ = ▁ " << ans . second ; return 0 ; } |
Program to find the next prime number | C ++ implementation of the approach ; Function that returns true if n is prime else returns false ; Corner cases ; This is checked so that we can skip middle five numbers in below loop ; Function to return the smallest prime number greater than N ; Base case ; Loop continuously until isPrime returns true for a number greater than n ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool isPrime ( int n ) { if ( n <= 1 ) return false ; if ( n <= 3 ) return true ; if ( n % 2 == 0 n % 3 == 0 ) return false ; for ( int i = 5 ; i * i <= n ; i = i + 6 ) if ( n % i == 0 || n % ( i + 2 ) == 0 ) return false ; return true ; } int nextPrime ( int N ) { if ( N <= 1 ) return 2 ; int prime = N ; bool found = false ; while ( ! found ) { prime ++ ; if ( isPrime ( prime ) ) found = true ; } return prime ; } int main ( ) { int N = 3 ; cout << nextPrime ( N ) ; return 0 ; } |
Check if a number is Flavius Number | C ++ implementation ; Return the number is Flavious Number or not ; index i starts from 2 because at 1 st iteration every 2 nd element was remove and keep going for k - th iteration ; removing the elements which are already removed at kth iteration ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool Survives ( int n ) { int i ; for ( int i = 2 ; ; i ++ ) { if ( i > n ) return true ; if ( n % i == 0 ) return false ; n -= n / i ; } } int main ( ) { int n = 17 ; if ( Survives ( n ) ) cout << " Yes " << endl ; else cout << " No " << endl ; return 0 ; } |
Nth XOR Fibonacci number | C ++ implementation of the approach ; Function to return the nth XOR Fibonacci number ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int nthXorFib ( int n , int a , int b ) { if ( n == 0 ) return a ; if ( n == 1 ) return b ; if ( n == 2 ) return ( a ^ b ) ; return nthXorFib ( n % 3 , a , b ) ; } int main ( ) { int a = 1 , b = 2 , n = 10 ; cout << nthXorFib ( n , a , b ) ; return 0 ; } |
Sand Timer Flip Counting Problem | C ++ 14 implementation of the approach ; Recursive function to return the gcd of a and b ; Everything divides 0 ; Function to print the number of flips for both the sand timers ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int gcd ( int a , int b ) { if ( b == 0 ) return a ; return gcd ( b , a % b ) ; } void flip ( int a , int b ) { int lcm = ( a * b ) / gcd ( a , b ) ; a = lcm / a ; b = lcm / b ; cout << a - 1 << " ▁ " << b - 1 ; } int main ( ) { int a = 10 ; int b = 5 ; flip ( a , b ) ; } |
Sum of N terms in the expansion of Arcsin ( x ) | C ++ implementation of the approach ; Function to find the arcsin ( x ) ; The power to which ' x ' is raised ; Numerator value ; Denominator value ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void find_Solution ( double x , int n ) { double sum = x , e = 2 , o = 1 , p = 1 ; for ( int i = 2 ; i <= n ; i ++ ) { p += 2 ; sum += ( double ) ( o / e ) * ( double ) ( pow ( x , p ) / p ) ; o = o * ( o + 2 ) ; e = e * ( e + 2 ) ; } cout << setprecision ( 10 ) << sum ; } int main ( ) { double x = -0.5 ; if ( abs ( x ) >= 1 ) { cout << " Invalid ▁ Input STRNEWLINE " ; return 0 ; } int n = 8 ; find_Solution ( x , n ) ; return 0 ; } |
Minimize the cost of buying the Objects | C ++ program of above approach ; Function that will calculate the price ; Calculate the number of items we can get for free ; Calculate the number of items we will have to pay the price for ; Calculate the price ; Driver code ; Calling function | #include <bits/stdc++.h> NEW_LINE using namespace std ; int totalPay ( int totalItems , int priceOfOneItem , int N , int M ) { int freeItems = 0 , actual = 0 ; freeItems = totalItems / ( N + M ) ; actual = totalItems - freeItems ; int amount = actual * priceOfOneItem ; return amount ; } int main ( ) { int T = 12 , P = 8 ; int N = 2 , M = 1 ; cout << " Amount ▁ = ▁ " << totalPay ( T , P , N , M ) ; return 0 ; } |
Count of all possible pairs of disjoint subsets of integers from 1 to N | C ++ implementation of the approach ; Modulo exponentiation function ; Function to calculate ( x ^ y ) % p in O ( log ( y ) ) ; Driver function ; Evaluating ( ( 3 ^ n - 2 ^ ( n + 1 ) + 1 ) / 2 ) % p ; From Fermatss little theorem a ^ - 1 ? a ^ ( m - 2 ) ( mod m ) | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define p 1000000007 NEW_LINE long long power ( long long x , long long y ) { long long res = 1 ; x = x % p ; while ( y > 0 ) { if ( y & 1 ) res = ( res * x ) % p ; y = y >> 1 ; x = ( x * x ) % p ; } return res % p ; } int main ( ) { long long n = 3 ; long long x = ( power ( 3 , n ) % p + 1 ) % p ; x = ( x - power ( 2 , n + 1 ) + p ) % p ; x = ( x * power ( 2 , p - 2 ) ) % p ; cout << x << " STRNEWLINE " ; } |
Right most non | C ++ implementation of the approach ; Function to return the rightmost non - zero digit in the multiplication of the array elements ; To store the count of times 5 can divide the array elements ; Divide the array elements by 5 as much as possible ; increase count of 5 ; Divide the array elements by 2 as much as possible ; Decrease count of 5 , because a '2' and a '5' makes a number with last digit '0' ; If c5 is more than the multiplier should be taken as 5 ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int rightmostNonZero ( int a [ ] , int n ) { int c5 = 0 ; for ( int i = 0 ; i < n ; i ++ ) { while ( a [ i ] > 0 && a [ i ] % 5 == 0 ) { a [ i ] /= 5 ; c5 ++ ; } } for ( int i = 0 ; i < n ; i ++ ) { while ( c5 && a [ i ] > 0 && ! ( a [ i ] & 1 ) ) { a [ i ] >>= 1 ; c5 -- ; } } long long ans = 1 ; for ( int i = 0 ; i < n ; i ++ ) { ans = ( ans * a [ i ] % 10 ) % 10 ; } if ( c5 ) ans = ( ans * 5 ) % 10 ; if ( ans ) return ans ; return -1 ; } int main ( ) { int a [ ] = { 7 , 42 , 11 , 64 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << rightmostNonZero ( a , n ) ; return 0 ; } |
Find the remainder when First digit of a number is divided by its Last digit | C ++ program to find the remainder when the First digit of a number is divided by its Last digit ; Function to find the remainder ; Get the last digit ; Get the first digit ; Compute the remainder ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void findRemainder ( int n ) { int l = n % 10 ; while ( n >= 10 ) n /= 10 ; int f = n ; int remainder = f % l ; cout << remainder << endl ; } int main ( ) { int n = 5223 ; findRemainder ( n ) ; return 0 ; } |
Percentage increase in the volume of cuboid if length , breadth and height are increased by fixed percentages | C ++ implementation of the approach ; Function to return the percentage increase in the volume of the cuboid ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; double increaseInVol ( double l , double b , double h ) { double percentInc = ( 1 + ( l / 100 ) ) * ( 1 + ( b / 100 ) ) * ( 1 + ( h / 100 ) ) ; percentInc -= 1 ; percentInc *= 100 ; return percentInc ; } int main ( ) { double l = 50 , b = 20 , h = 10 ; cout << increaseInVol ( l , b , h ) << " % " ; return 0 ; } |
Count the number of occurrences of a particular digit in a number | C ++ program to count the number of occurrences of a particular digit in a number ; Function to count the occurrences of the digit D in N ; Loop to find the digits of N ; check if the digit is D ; return the count of the occurrences of D in N ; Driver code | #include <iostream> NEW_LINE using namespace std ; long long int countOccurrances ( long long int n , int d ) { long long int count = 0 ; while ( n > 0 ) { count = ( n % 10 == d ) ? count + 1 : count ; n = n / 10 ; } return count ; } int main ( ) { int d = 2 ; long long int n = 214215421 ; cout << countOccurrances ( n , d ) << endl ; return 0 ; } |
Find number of factors of N when location of its two factors whose product is N is given | C ++ program to implement the above problem ; Function to find the number of factors ; print the number of factors ; Driver code ; initialize the factors position | #include <bits/stdc++.h> NEW_LINE using namespace std ; void findFactors ( int a , int b ) { int c ; c = a + b - 1 ; cout << c ; } int main ( ) { int a , b ; a = 13 ; b = 36 ; findFactors ( a , b ) ; return 0 ; } |
21 Matchsticks Problem | C ++ implementation of the approach ; Function to return the optimal strategy ; Removing matchsticks in blocks of five ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void TwentyoneMatchstick ( int arr [ ] , int N ) { for ( int i = 0 ; i < N ; i += 1 ) { cout << 5 - arr [ i ] << " ▁ " ; } cout << endl ; } int main ( ) { int arr [ ] = { 3 , 4 , 2 , 2 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; TwentyoneMatchstick ( arr , N ) ; return 0 ; } |
Find the smallest positive number which can not be represented by given digits | CPP program to find the smallest positive number which can not be represented by given digits ; Function to find the smallest positive number which can not be represented by given digits ; Storing the count of 0 digit or store the value at 0 th index ; Calculates the min value in the array starting from 1 st index and also store it index . ; If its value at 0 th index is less than min value than either 10 , 100 , 1000 ... can 't be expressed ; If it value is greater than min value than iterate the loop upto first min value index and simply print it index value . ; Driver code ; Value of N is always 10 as we take digit from 0 to 9 ; Calling function | #include <bits/stdc++.h> NEW_LINE using namespace std ; void expressDigit ( int arr [ ] , int n ) { int min = 9 , index = 0 , temp = 0 ; temp = arr [ 0 ] ; for ( int i = 1 ; i < 10 ; i ++ ) { if ( arr [ i ] < min ) { min = arr [ i ] ; index = i ; } } if ( temp < min ) { cout << 1 ; for ( int i = 1 ; i <= temp + 1 ; i ++ ) cout << 0 ; } else { for ( int i = 0 ; i < min ; i ++ ) cout << index ; cout << index ; } } int main ( ) { int arr [ ] = { 2 , 2 , 1 , 2 , 1 , 1 , 3 , 1 , 1 , 1 } ; int N = 10 ; expressDigit ( arr , N ) ; return 0 ; } |
Find the average of k digits from the beginning and l digits from the end of the given number | implementation of the approach ; Function to return the count of digits in num ; Function to return the sum of first n digits of num ; Remove the unnecessary digits ; Function to return the sum of the last n digits of num ; If the average can 't be calculated without using the same digit more than once ; Sum of the last l digits of n ; Sum of the first k digits of n ( totalDigits - k ) must be removed from the end of the number to get the remaining k digits from the beginning ; Return the average ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countDigits ( int num ) { int cnt = 0 ; while ( num > 0 ) { cnt ++ ; num /= 10 ; } return cnt ; } int sumFromStart ( int num , int n , int rem ) { num /= ( ( int ) pow ( 10 , rem ) ) ; int sum = 0 ; while ( num > 0 ) { sum += ( num % 10 ) ; num /= 10 ; } return sum ; } int sumFromEnd ( int num , int n ) { int sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { sum += ( num % 10 ) ; num /= 10 ; } return sum ; } float getAverage ( int n , int k , int l ) { int totalDigits = countDigits ( n ) ; if ( totalDigits < ( k + l ) ) return -1 ; int sum1 = sumFromEnd ( n , l ) ; int sum2 = sumFromStart ( n , k , totalDigits - k ) ; return ( ( float ) ( sum1 + sum2 ) / ( float ) ( k + l ) ) ; } int main ( ) { int n = 123456 , k = 2 , l = 3 ; cout << getAverage ( n , k , l ) ; return 0 ; } |
Print N terms of Withoff Sequence | C ++ program to find Wythoff array ; Function to find the n , k term of Wythoff array ; tau = ( sqrt ( 5 ) + 1 ) / 2 ; Already_stored ; T ( n , - 1 ) = n - 1. ; T ( n , 0 ) = floor ( n * tau ) . ; T ( n , k ) = T ( n , k - 1 ) + T ( n , k - 2 ) for k >= 1. ; Store ; Return the ans ; Function to find first n terms of Wythoff array by traversing in anti - diagonal ; Map to store the Wythoff array ; Anti diagonal ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int Wythoff ( map < int , map < int , int > > & mp , int n , int k ) { double tau = ( sqrt ( 5 ) + 1 ) / 2.0 , t_n_k ; if ( mp [ n ] [ k ] != 0 ) return mp [ n ] [ k ] ; if ( k == -1 ) { return n - 1 ; } else if ( k == 0 ) { t_n_k = floor ( n * tau ) ; } else { t_n_k = Wythoff ( mp , n , k - 1 ) + Wythoff ( mp , n , k - 2 ) ; } mp [ n ] [ k ] = t_n_k ; return ( int ) t_n_k ; } void Wythoff_Array ( int n ) { int i = 0 , j = 0 , count = 0 ; map < int , map < int , int > > mp ; while ( count < n ) { cout << Wythoff ( mp , i + 1 , j + 1 ) ; count ++ ; if ( count != n ) cout << " , ▁ " ; i ++ ; j -- ; if ( j < 0 ) { j = i ; i = 0 ; } } } int main ( ) { int n = 15 ; Wythoff_Array ( n ) ; return 0 ; } |
Sum of two numbers if the original ratio and new ratio obtained by adding a given number to each number is given | C ++ implementation of the approach ; Function to return the sum of numbers which are in the ration a : b and after adding x to both the numbers the new ratio becomes c : d ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; double sum ( double a , double b , double c , double d , double x ) { double ans = ( x * ( a + b ) * ( c - d ) ) / ( ( a * d ) - ( b * c ) ) ; return ans ; } int main ( ) { double a = 1 , b = 2 , c = 9 , d = 13 , x = 5 ; cout << sum ( a , b , c , d , x ) ; return 0 ; } |
Triangle of numbers arising from Gilbreath 's conjecture | C ++ code for printing the Triangle of numbers arising from Gilbreath 's conjecture ; Check whether the number is prime or not ; Set the 0 th row of the matrix with c primes from 0 , 0 to 0 , c - 1 ; Find the n , k term of matrix of Gilbreath 's conjecture ; recursively find ; store the ans ; Print first n terms of Gilbreath sequence successive absolute differences of primes read by antidiagonals upwards . ; map to store the matrix and hash to check if the element is present or not ; set the primes of first row ; print the Gilbreath number ; increase the count ; anti diagonal upwards ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool is_Prime ( int n ) { if ( n < 2 ) return false ; for ( int i = 2 ; i <= sqrt ( n ) ; i ++ ) if ( n % i == 0 ) return false ; return true ; } void set_primes ( map < int , map < int , int > > & mp , map < int , map < int , int > > & hash , int c ) { int count = 0 ; for ( int i = 2 ; count < c ; i ++ ) { if ( is_Prime ( i ) ) { mp [ 0 ] [ count ++ ] = i ; hash [ 0 ] [ count - 1 ] = 1 ; } } } int Gilbreath ( map < int , map < int , int > > & mp , map < int , map < int , int > > & hash , int n , int k ) { if ( hash [ n ] [ k ] != 0 ) return mp [ n ] [ k ] ; int ans = abs ( Gilbreath ( mp , hash , n - 1 , k + 1 ) - Gilbreath ( mp , hash , n - 1 , k ) ) ; mp [ n ] [ k ] = ans ; return ans ; } void solve ( int n ) { int i = 0 , j = 0 , count = 0 ; map < int , map < int , int > > mp , hash ; set_primes ( mp , hash , 100 ) ; while ( count < n ) { cout << Gilbreath ( mp , hash , i , j ) << " , ▁ " ; count ++ ; i -- ; j ++ ; if ( i < 0 ) { i = j ; j = 0 ; } } } int main ( ) { int n = 15 ; solve ( n ) ; return 0 ; } |
Roots of the quadratic equation when a + b + c = 0 without using Shridharacharya formula | C ++ implementation of the approach ; Function to print the roots of the quadratic equation when a + b + c = 0 ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void printRoots ( long a , long b , long c ) { cout << 1 << " , ▁ " << c / ( a * 1.0 ) ; } int main ( ) { long a = 2 ; long b = 3 ; long c = -5 ; printRoots ( a , b , c ) ; return 0 ; } |
Longest alternative parity subsequence | C ++ program to find the length of the longest alternative parity subsequence ; Function to find the longest ; Marks the starting of odd number as sequence and alternatively changes ; Finding the longest odd / even sequence ; Find odd number ; Find even number ; Length of the longest even / odd sequence ; Find odd number ; Find even number ; Answer is maximum of both odd / even or even / odd subsequence ; Driver Code | #include <iostream> NEW_LINE using namespace std ; int longestAlternativeSequence ( int a [ ] , int n ) { int maxi1 = 0 ; int f1 = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( ! f1 ) { if ( a [ i ] % 2 ) { f1 = 1 ; maxi1 ++ ; } } else { if ( a [ i ] % 2 == 0 ) { maxi1 ++ ; f1 = 0 ; } } } int maxi2 = 0 ; int f2 = 0 ; for ( int i = 0 ; i < n ; i ++ ) { if ( f2 ) { if ( a [ i ] % 2 ) { f2 = 1 ; maxi2 ++ ; } } else { if ( a [ i ] % 2 == 0 ) { maxi2 ++ ; f2 = 0 ; } } } return max ( maxi1 , maxi2 ) ; } int main ( ) { int a [ ] = { 13 , 16 , 8 , 9 , 32 , 10 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << longestAlternativeSequence ( a , n ) ; } |
Nambiar Number Generator | C ++ implementation of the approach ; Function to return the Nambiar number of the given number ; If there is no digit to choose ; Choose the first digit ; Chosen digit 's parity ; To store the sum of the consecutive digits starting from the chosen digit ; While there are digits to choose ; Update the sum ; If the parity differs ; Return the current sum concatenated with the Numbiar number for the rest of the string ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; string numbiarNumber ( string str , int i ) { if ( i > str . length ( ) ) return " " ; int firstDigit = str [ i ] - '0' ; int digitParity = firstDigit % 2 ; int sumDigits = 0 ; while ( i < str . length ( ) ) { sumDigits += ( str [ i ] - '0' ) ; int sumParity = sumDigits % 2 ; if ( digitParity != sumParity ) break ; i ++ ; } return ( to_string ( sumDigits ) + numbiarNumber ( str , i + 1 ) ) ; } int main ( ) { string str = "9880127431" ; cout << numbiarNumber ( str , 0 ) << endl ; return 0 ; } |
Program to find the Depreciation of Value | CPP program to find depreciation of the value initial value , rate and time are given ; Function to return the depreciation of value ; Driver Code | #include <bits/stdc++.h> NEW_LINE using namespace std ; float Depreciation ( float v , float r , float t ) { float D = v * pow ( ( 1 - r / 100 ) , t ) ; return D ; } int main ( ) { float V1 = 200 , R = 10 , T = 2 ; cout << Depreciation ( V1 , R , T ) ; return 0 ; } |
Program to find first N Fermat Numbers | CPP program to print fermat numbers ; Iterative Function to calculate ( x ^ y ) in O ( log y ) ; llu res = 1 ; Initialize result ; If y is odd , multiply x with the result ; n must be even now y = y >> 1 ; y = y / 2 x = x * x ; Change x to x ^ 2 ; Function to find nth fermat number ; 2 to the power i ; 2 to the power 2 ^ i ; Function to find first n Fermat numbers ; Calculate 2 ^ 2 ^ i ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE #include <boost/multiprecision/cpp_int.hpp> NEW_LINE using namespace boost :: multiprecision ; #define llu int128_t NEW_LINE using namespace std ; llu power ( llu x , llu y ) { while ( y > 0 ) { if ( y & 1 ) res = res * x ; } return res ; } llu Fermat ( llu i ) { llu power2_i = power ( 2 , i ) ; llu power2_2_i = power ( 2 , power2_i ) ; return power2_2_i + 1 ; } void Fermat_Number ( llu n ) { for ( llu i = 0 ; i < n ; i ++ ) { cout << Fermat ( i ) ; if ( i != n - 1 ) cout << " , ▁ " ; } } int main ( ) { llu n = 7 ; Fermat_Number ( n ) ; return 0 ; } |
Highly Totient Number | CPP program to find highly totient numbers ; Function to find euler totient number ; Consider all prime factors of n and subtract their multiples from result ; Check if p is a prime factor . ; If yes , then update n and result ; If n has a prime factor greater than sqrt ( n ) ( There can be at - most one such prime factor ) ; Function to find first n highly totient numbers ; Count of Highly totient numbers and value of count of phi of previous numbers ; Store all the values of phi ( x ) upto 10 ^ 5 with frequencies ; If count is greater than count of previous element ; Display the number ; Store the value of phi ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int phi ( int n ) { for ( int p = 2 ; p * p <= n ; ++ p ) { if ( n % p == 0 ) { while ( n % p == 0 ) n /= p ; result -= result / p ; } } if ( n > 1 ) result -= result / n ; return result ; } void Highly_Totient ( int n ) { int count = 0 , p_count = -1 , i = 1 ; map < int , int > mp ; for ( int i = 1 ; i < 100000 ; i ++ ) mp [ phi ( i ) ] ++ ; while ( count < n ) { if ( mp [ i ] > p_count ) { cout << i ; if ( count < n - 1 ) cout << " , ▁ " ; p_count = mp [ i ] ; count ++ ; } i ++ ; } } int main ( ) { int n = 20 ; Highly_Totient ( n ) ; return 0 ; } |
Program to find the Speed of train as per speed of sound | C ++ implementation of the approach ; Function to find the Speed of train ; Driver code ; calling Function | #include <bits/stdc++.h> NEW_LINE using namespace std ; float speedOfTrain ( float X , float Y ) { float Speed = 0 ; Speed = 1188 * ( ( X - Y ) / Y ) ; return Speed ; } int main ( ) { float X = 8 , Y = 7.2 ; cout << speedOfTrain ( X , Y ) << " ▁ km / hr " ; return 0 ; } |
Maximum value of division of two numbers in an Array | CPP program to maximum value of division of two numbers in an array ; Function to maximum value of division of two numbers in an array ; Traverse through the array ; Return the required answer ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int Division ( int a [ ] , int n ) { int maxi = INT_MIN , mini = INT_MAX ; for ( int i = 0 ; i < n ; i ++ ) { maxi = max ( a [ i ] , maxi ) ; mini = min ( a [ i ] , mini ) ; } return maxi / mini ; } int main ( ) { int a [ ] = { 3 , 7 , 9 , 3 , 11 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << Division ( a , n ) ; return 0 ; } |
Ramanujan Prime | CPP program to find Ramanujan numbers ; FUnction to return a vector of primes ; Create a boolean array " prime [ 0 . . n ] " and initialize all entries it as true . A value in prime [ i ] will finally be false if i is Not a prime , else true . ; If prime [ p ] is not changed , then it is a prime ; Update all multiples of p greater than or equal to the square of it numbers which are multiple of p and are less than p ^ 2 are already been marked . ; Print all prime numbers ; Function to find number of primes less than or equal to x ; Binary search to find out number of primes less than or equal to x ; Function to find the nth ramanujan prime ; For n >= 1 , a ( n ) < 4 * n * log ( 4 n ) ; We start from upperbound and find where pi ( i ) - pi ( i / 2 ) < n the previous number being the nth ramanujan prime ; Function to find first n Ramanujan numbers ; Get the prime numbers ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define MAX 1000000 NEW_LINE vector < int > addPrimes ( ) { int n = MAX ; bool prime [ n + 1 ] ; memset ( prime , true , sizeof ( prime ) ) ; for ( int p = 2 ; p * p <= n ; p ++ ) { if ( prime [ p ] == true ) { for ( int i = p * p ; i <= n ; i += p ) prime [ i ] = false ; } } vector < int > ans ; for ( int p = 2 ; p <= n ; p ++ ) if ( prime [ p ] ) ans . push_back ( p ) ; return ans ; } int pi ( int x , vector < int > v ) { int l = 0 , r = v . size ( ) - 1 , m , in = -1 ; while ( l <= r ) { m = ( l + r ) / 2 ; if ( v [ m ] <= x ) { in = m ; l = m + 1 ; } else { r = m - 1 ; } } return in + 1 ; } int Ramanujan ( int n , vector < int > v ) { int upperbound = 4 * n * ( log ( 4 * n ) / log ( 2 ) ) ; for ( int i = upperbound ; ; i -- ) { if ( pi ( i , v ) - pi ( i / 2 , v ) < n ) return 1 + i ; } } void Ramanujan_Numbers ( int n ) { int c = 1 ; vector < int > v = addPrimes ( ) ; for ( int i = 1 ; i <= n ; i ++ ) { cout << Ramanujan ( i , v ) ; if ( i != n ) cout << " , ▁ " ; } } int main ( ) { int n = 10 ; Ramanujan_Numbers ( n ) ; return 0 ; } |
Quadruplet pair with XOR zero in the given Array | C ++ implementation of the approach ; Function that returns true if the array contains a valid quadruplet pair ; We can always find a valid quadruplet pair for array size greater than MAX ; For smaller size arrays , perform brute force ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; const int MAX = 130 ; bool validQuadruple ( int arr [ ] , int n ) { if ( n >= MAX ) return true ; for ( int i = 0 ; i < n ; i ++ ) for ( int j = i + 1 ; j < n ; j ++ ) for ( int k = j + 1 ; k < n ; k ++ ) for ( int l = k + 1 ; l < n ; l ++ ) { if ( ( arr [ i ] ^ arr [ j ] ^ arr [ k ] ^ arr [ l ] ) == 0 ) { return true ; } } return false ; } int main ( ) { int arr [ ] = { 1 , 0 , 2 , 3 , 7 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; if ( validQuadruple ( arr , n ) ) cout << " Yes " ; else cout << " No " ; return 0 ; } |
Find the number of words of X vowels and Y consonants that can be formed from M vowels and N consonants | CPP program to find the number of words of X vowels and Y consonants can be formed from M vowels and N consonants ; Function to returns factorial of n ; Function to find nCr ; Function to find the number of words of X vowels and Y consonants can be formed from M vowels and N consonants ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int fact ( int n ) { int res = 1 ; for ( int i = 2 ; i <= n ; i ++ ) res = res * i ; return res ; } int nCr ( int n , int r ) { return fact ( n ) / ( fact ( r ) * fact ( n - r ) ) ; } int NumberOfWays ( int X , int Y , int M , int N ) { return fact ( X + Y ) * nCr ( M , X ) * nCr ( N , Y ) ; } int main ( ) { int X = 2 , Y = 2 , M = 3 , N = 3 ; cout << NumberOfWays ( X , Y , M , N ) ; return 0 ; } |
Program for sum of cosh ( x ) series upto Nth term | C ++ program for the sum of cosh ( x ) series ; function to return the factorial of a number ; function to return the sum of the series ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int fact ( int n ) { int i = 1 , fac = 1 ; for ( i = 1 ; i <= n ; i ++ ) fac = fac * i ; return fac ; } double log_Expansion ( double x , int n ) { double sum = 0 ; int i = 0 ; for ( i = 0 ; i < n ; i ++ ) { sum = sum + pow ( x , 2 * i ) / fact ( 2 * i ) ; } return sum ; } int main ( ) { double x = 1 ; int n = 10 ; cout << setprecision ( 12 ) << log_Expansion ( x , n ) << endl ; return 0 ; } |
Find prime numbers in the first half and second half of an array | C ++ program to print the prime numbers in the first half and second half of an array ; Function to check if a number is prime or not ; Function to find whether elements are prime or not ; Traverse in the given range ; Check if a number is prime or not ; Function to print the prime numbers in the first half and second half of an array ; Driver Code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool prime ( int n ) { for ( int i = 2 ; i * i <= n ; i ++ ) if ( n % i == 0 ) return false ; return true ; } void prime_range ( int start , int end , int * a ) { for ( int i = start ; i < end ; i ++ ) { if ( prime ( a [ i ] ) ) cout << a [ i ] << " ▁ " ; } } void Print ( int arr [ ] , int n ) { cout << " Prime ▁ numbers ▁ in ▁ the ▁ first ▁ half ▁ are ▁ " ; prime_range ( 0 , n / 2 , arr ) ; cout << endl ; cout << " Prime ▁ numbers ▁ in ▁ the ▁ second ▁ half ▁ are ▁ " ; prime_range ( n / 2 , n , arr ) ; cout << endl ; } int main ( ) { int arr [ ] = { 2 , 5 , 10 , 15 , 17 , 21 , 23 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; Print ( arr , n ) ; return 0 ; } |
Count of elements that can be deleted without disturbing the mean of the initial array | C ++ implementation of the approach ; Function to find the elements which do not change the mean on removal ; To store the sum of the array elements ; To store the initial mean ; to store the count of required elements ; Iterate over the array ; Finding the new mean ; If the new mean equals to the initial mean ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countElements ( int arr [ ] , int n ) { int sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) sum += arr [ i ] ; float mean = ( float ) sum / n ; int cnt = 0 ; for ( int i = 0 ; i < n ; i ++ ) { float newMean = ( float ) ( sum - arr [ i ] ) / ( n - 1 ) ; if ( newMean == mean ) cnt ++ ; } return cnt ; } int main ( ) { int arr [ ] = { 1 , 2 , 3 , 4 , 5 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << countElements ( arr , n ) ; return 0 ; } |
Find maximum xor of k elements in an array | C ++ implementation of the approach ; Function to return the maximum xor for a subset of size j from the given array ; If the subset is complete then return the xor value of the selected elements ; Return if already calculated for some mask and j at the i 'th index ; Initialize answer to 0 ; If we can still include elements in our subset include the i 'th element ; Exclude the i 'th element ans store the max of both operations ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; #define MAX 10000 NEW_LINE #define MAX_ELEMENT 50 NEW_LINE int dp [ MAX_ELEMENT ] [ MAX_ELEMENT ] [ MAX ] ; int Max_Xor ( int arr [ ] , int i , int j , int mask , int n ) { if ( i >= n ) { if ( j == 0 ) return mask ; else return 0 ; } if ( dp [ i ] [ j ] [ mask ] != -1 ) return dp [ i ] [ j ] [ mask ] ; int ans = 0 ; if ( j > 0 ) ans = Max_Xor ( arr , i + 1 , j - 1 , mask ^ arr [ i ] , n ) ; ans = max ( ans , Max_Xor ( arr , i + 1 , j , mask , n ) ) ; return dp [ i ] [ j ] [ mask ] = ans ; } int main ( ) { int arr [ ] = { 2 , 5 , 4 , 1 , 3 , 7 , 6 , 8 } ; int n = sizeof ( arr ) / sizeof ( int ) ; int k = 3 ; memset ( dp , -1 , sizeof ( dp ) ) ; cout << Max_Xor ( arr , 0 , k , 0 , n ) ; return 0 ; } |
Find the prime P using given four integers | CPP program to possible prime number ; Function to check if a number is prime or not ; Function to find possible prime number ; Find a possible prime number ; Last condition ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool Prime ( int n ) { for ( int j = 2 ; j <= sqrt ( n ) ; j ++ ) if ( n % j == 0 ) return false ; return true ; } int find_prime ( int x , int xsqmodp , int y , int ysqmodp ) { int n = x * x - xsqmodp ; int n1 = y * y - ysqmodp ; for ( int j = 2 ; j <= max ( sqrt ( n ) , sqrt ( n1 ) ) ; j ++ ) { if ( n % j == 0 && ( x * x ) % j == xsqmodp && n1 % j == 0 && ( y * y ) % j == ysqmodp ) if ( Prime ( j ) ) return j ; int j1 = n / j ; if ( n % j1 == 0 && ( x * x ) % j1 == xsqmodp && n1 % j1 == 0 && ( y * y ) % j1 == ysqmodp ) if ( Prime ( j1 ) ) return j1 ; j1 = n1 / j ; if ( n % j1 == 0 && ( x * x ) % j1 == xsqmodp && n1 % j1 == 0 && ( y * y ) % j1 == ysqmodp ) if ( Prime ( j1 ) ) return j1 ; } if ( n == n1 ) return n ; } int main ( ) { int x = 3 , xsqmodp = 0 , y = 5 , ysqmodp = 1 ; cout << find_prime ( x , xsqmodp , y , ysqmodp ) ; return 0 ; } |
Time taken per hour for stoppage of Car | C ++ implementation of the approach ; Function to return the time taken per hour for stoppage ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int numberOfMinutes ( int S , int S1 ) { int Min = 0 ; Min = ( ( S - S1 ) / floor ( S ) ) * 60 ; return Min ; } int main ( ) { int S = 30 , S1 = 10 ; cout << numberOfMinutes ( S , S1 ) << " ▁ min " ; return 0 ; } |
Removing a number from array without changing its arithmetic mean | CPP program to remove a number from the array without changing its arithmetic mean ; Function to remove a number from the array without changing its arithmetic mean ; Find sum of all elements ; If mean is an integer ; Check if mean is present in the array or not ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int FindElement ( int a [ ] , int n ) { int sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) sum = sum + a [ i ] ; if ( sum % n == 0 ) { int m = sum / n ; for ( int i = 0 ; i < n ; i ++ ) if ( a [ i ] == m ) return m ; } return -1 ; } int main ( ) { int a [ ] = { 1 , 2 , 3 , 4 , 5 } ; int n = sizeof ( a ) / sizeof ( int ) ; cout << FindElement ( a , n ) ; return 0 ; } |
Sum of the Tan ( x ) expansion upto N terms | CPP program to find tan ( x ) expansion ; Function to find factorial of a number ; To store factorial of a number ; Return the factorial of a number ; Function to find tan ( x ) upto n terms ; To store value of the expansion ; This loops here calculate Bernoulli number which is further used to get the coefficient in the expansion of tan x ; Print the value of expansion ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int fac ( int num ) { if ( num == 0 ) return 1 ; int fact = 1 ; for ( int i = 1 ; i <= num ; i ++ ) fact = fact * i ; return fact ; } void Tanx_expansion ( int terms , int x ) { double sum = 0 ; for ( int i = 1 ; i <= terms ; i += 1 ) { double B = 0 ; int Bn = 2 * i ; for ( int k = 0 ; k <= Bn ; k ++ ) { double temp = 0 ; for ( int r = 0 ; r <= k ; r ++ ) temp = temp + pow ( -1 , r ) * fac ( k ) * pow ( r , Bn ) / ( fac ( r ) * fac ( k - r ) ) ; B = B + temp / ( ( double ) ( k + 1 ) ) ; } sum = sum + pow ( -4 , i ) * ( 1 - pow ( 4 , i ) ) * B * pow ( x , 2 * i - 1 ) / fac ( 2 * i ) ; } cout << setprecision ( 10 ) << sum ; } int main ( ) { int n = 6 , x = 1 ; Tanx_expansion ( n , x ) ; return 0 ; } |
Minimum elements to be inserted in Array to make adjacent differences equal | C ++ program for the above approach ; Function to find gcd of two numbers ; Function to calculate minimum numbers to be inserted to make equal differences between two consecutive elements ; Check if there is only one element in the array then answer will be 0 ; Calculate difference between first and second element of array ; If there is only two elements in the array then gcd of differences of consecutive elements of array will be equal to difference of first and second element of the array ; Loop to calculate the gcd of the differences between consecutive elements of the array ; Loop to calculate the elements to be inserted ; Return the answer ; Driver code | #include <iostream> NEW_LINE using namespace std ; int gcd ( int a , int b ) { if ( b == 0 ) return a ; return gcd ( b , a % b ) ; } int minimum_elements ( int n , int arr [ ] ) { if ( n < 3 ) return 0 ; int g , ans = 0 , diff , cnt ; diff = arr [ 1 ] - arr [ 0 ] ; g = diff ; for ( int i = 2 ; i < n ; i ++ ) { diff = arr [ i ] - arr [ i - 1 ] ; g = gcd ( g , diff ) ; } for ( int i = 1 ; i < n ; i ++ ) { diff = arr [ i ] - arr [ i - 1 ] ; cnt = diff / g ; ans += ( cnt - 1 ) ; } return ans ; } int main ( ) { int arr [ ] = { 1 , 5 , 8 , 10 , 12 , 16 } ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; cout << minimum_elements ( n , arr ) ; return 0 ; } |
Check if a number is Fermat Pseudoprime | C ++ program to check if N is Fermat pseudoprime to the base A or not ; Function to check if the given number is composite ; Check if there is any divisor of n less than sqrt ( n ) ; Effectively calculate ( x ^ y ) modulo mod ; Initialize result ; If power is odd , then update the answer ; Square the number and reduce the power to its half ; Return the result ; Function to check for Fermat Pseudoprime ; If it is composite and satisfy Fermat criterion ; Else return 0 ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool checkcomposite ( int n ) { for ( int i = 2 ; i <= sqrt ( n ) ; i ++ ) { if ( n % i == 0 ) return 1 ; } return 0 ; } int power ( int x , int y , int mod ) { int res = 1 ; while ( y ) { if ( y & 1 ) res = ( res * x ) % mod ; y = y >> 1 ; x = ( x * x ) % mod ; } return res ; } bool Check ( int n , int a ) { if ( a > 1 && checkcomposite ( n ) && power ( a , n - 1 , n ) == 1 ) return 1 ; return 0 ; } int main ( ) { int N = 645 ; int a = 2 ; cout << Check ( N , a ) ; return 0 ; } |
Largest and smallest digit of a number | CPP program to largest and smallest digit of a number ; Function to the largest and smallest digit of a number ; Find the largest digit ; Find the smallest digit ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; void Digits ( int n ) { int largest = 0 ; int smallest = 9 ; while ( n ) { int r = n % 10 ; largest = max ( r , largest ) ; smallest = min ( r , smallest ) ; n = n / 10 ; } cout << largest << " ▁ " << smallest ; } int main ( ) { int n = 2346 ; Digits ( n ) ; return 0 ; } |
Probability of distributing M items among X bags such that first bag contains N items | CPP program to find probability of first bag to contain N items such that M items are distributed among X bags ; Function to find factorial of a number ; Function to find nCr ; Function to find probability of first bag to contain N items such that M items are distributed among X bags ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int factorial ( int n ) { if ( n <= 1 ) return 1 ; return n * factorial ( n - 1 ) ; } int nCr ( int n , int r ) { return factorial ( n ) / ( factorial ( r ) * factorial ( n - r ) ) ; } float Probability ( int M , int N , int X ) { return ( float ) ( nCr ( M - N - 1 , X - 2 ) / ( nCr ( M - 1 , X - 1 ) * 1.0 ) ) ; } int main ( ) { int M = 9 , X = 3 , N = 4 ; cout << Probability ( M , N , X ) ; return 0 ; } |
Count of N digit numbers possible which satisfy the given conditions | C ++ implementation of the approach ; Function to return the factorial of n ; Function to return the count of numbers possible ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int fact ( int n ) { int res = 1 ; for ( int i = 2 ; i <= n ; i ++ ) res = res * i ; return res ; } int Count_number ( int N ) { return ( N * fact ( N ) ) ; } int main ( ) { int N = 2 ; cout << Count_number ( N ) ; return 0 ; } |
Find the count of M character words which have at least one character repeated | C ++ implementation for the above approach ; Function to return the factorial of a number ; Function to return the value of nPr ; Function to return the total number of M length words which have at least a single character repeated more than once ; Driver code | #include <math.h> NEW_LINE #include <iostream> NEW_LINE using namespace std ; int fact ( int n ) { if ( n <= 1 ) return 1 ; return n * fact ( n - 1 ) ; } int nPr ( int n , int r ) { return fact ( n ) / fact ( n - r ) ; } int countWords ( int N , int M ) { return pow ( N , M ) - nPr ( N , M ) ; } int main ( ) { int N = 10 , M = 5 ; cout << ( countWords ( N , M ) ) ; return 0 ; } |
Minimum and maximum possible length of the third side of a triangle | C ++ implementation of the approach ; Function to find the minimum and the maximum possible length of the third side of the given triangle ; Not a valid triangle ; Not a valid triangle ; Driver code | #include <iostream> NEW_LINE using namespace std ; void find_length ( int s1 , int s2 ) { if ( s1 <= 0 s2 <= 0 ) { cout << -1 ; return ; } int max_length = s1 + s2 - 1 ; int min_length = max ( s1 , s2 ) - min ( s1 , s2 ) + 1 ; if ( min_length > max_length ) { cout << -1 ; return ; } cout << " Max ▁ = ▁ " << max_length << endl ; cout << " Min ▁ = ▁ " << min_length ; } int main ( ) { int s1 = 8 , s2 = 5 ; find_length ( s1 , s2 ) ; return 0 ; } |
Number formed by the rightmost set bit in N | C ++ implementation of the approach ; Function to return the integer formed by taking the rightmost set bit in n ; n & ( n - 1 ) unsets the first set bit from the right in n ; Take xor with the original number The position of the ' changed ▁ bit ' will be set and rest will be unset ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int firstSetBit ( int n ) { int x = n & ( n - 1 ) ; return ( n ^ x ) ; } int main ( ) { int n = 12 ; cout << firstSetBit ( n ) ; return 0 ; } |
Number of N length sequences whose product is M | C ++ implementation of the above approach ; Function to calculate the value of ncr effectively ; Initializing the result ; Multiply and divide simultaneously to avoid overflow ; Return the answer ; Function to return the number of sequences of length N such that their product is M ; Hashmap to store the prime factors of M ; Calculate the prime factors of M ; If i divides M it means it is a factor Divide M by i till it could be divided to store the exponent ; Increase the exponent count ; If the number is a prime number greater than sqrt ( M ) ; Initializing the ans ; Multiply the answer for every prime factor ; it . second represents the exponent of every prime factor ; Return the result ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int ncr ( int n , int r ) { int res = 1 ; for ( int i = 1 ; i <= r ; i += 1 ) { res *= ( n - r + i ) ; res /= i ; } return res ; } int NoofSequences ( int N , int M ) { unordered_map < int , int > prime ; for ( int i = 2 ; i <= sqrt ( M ) ; i += 1 ) { while ( M % i == 0 ) { prime [ i ] += 1 ; M /= i ; } } if ( M > 1 ) { prime [ M ] += 1 ; } int ans = 1 ; for ( auto it : prime ) { ans *= ( ncr ( N + it . second - 1 , N - 1 ) ) ; } return ans ; } int main ( ) { int N = 2 , M = 6 ; cout << NoofSequences ( N , M ) ; return 0 ; } |
Number of hours after which the second person moves ahead of the first person if they travel at a given speed | C ++ implementation of the above approach ; Function to return the number of hours for the second person to move ahead ; Time taken to equalize ; Time taken to move ahead ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int findHours ( int a , int b , int k ) { if ( a >= b ) return -1 ; int time = k / ( b - a ) ; time = time + 1 ; return time ; } int main ( ) { int a = 4 , b = 5 , k = 1 ; cout << findHours ( a , b , k ) ; return 0 ; } |
Number of ways of distributing N identical objects in R distinct groups with no groups empty | C ++ implementation of the above approach ; Function to return the value of ncr effectively ; Initialize the answer ; Divide simultaneously by i to avoid overflow ; Function to return the number of ways to distribute N identical objects in R distinct objects ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int ncr ( int n , int r ) { int ans = 1 ; for ( int i = 1 ; i <= r ; i += 1 ) { ans *= ( n - r + i ) ; ans /= i ; } return ans ; } int NoOfDistributions ( int N , int R ) { return ncr ( N - 1 , R - 1 ) ; } int main ( ) { int N = 4 ; int R = 3 ; cout << NoOfDistributions ( N , R ) ; return 0 ; } |
Number of ways of distributing N identical objects in R distinct groups | C ++ implementation of the above approach ; Function to return the value of ncr effectively ; Initialize the answer ; Divide simultaneously by i to avoid overflow ; Function to return the number of ways to distribute N identical objects in R distinct objects ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int ncr ( int n , int r ) { int ans = 1 ; for ( int i = 1 ; i <= r ; i += 1 ) { ans *= ( n - r + i ) ; ans /= i ; } return ans ; } int NoOfDistributions ( int N , int R ) { return ncr ( N + R - 1 , R - 1 ) ; } int main ( ) { int N = 4 , R = 3 ; cout << NoOfDistributions ( N , R ) ; return 0 ; } |
Smallest perfect cube in an array | C ++ implementation of the approach ; Function that returns true if n is a perfect cube ; Takes the sqrt of the number ; Checks if it is a perfect cube number ; Function to return the smallest perfect cube from the array ; Stores the minimum of all the perfect cubes from the array ; Traverse all elements in the array ; Store the minimum if current element is a perfect cube ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; bool checkPerfectcube ( int n ) { int d = cbrt ( n ) ; if ( d * d * d == n ) return true ; return false ; } int smallestPerfectCube ( int a [ ] , int n ) { int mini = INT_MAX ; for ( int i = 0 ; i < n ; i ++ ) { if ( checkPerfectcube ( a [ i ] ) ) { mini = min ( a [ i ] , mini ) ; } } return mini ; } int main ( ) { int a [ ] = { 16 , 8 , 25 , 2 , 3 , 10 } ; int n = sizeof ( a ) / sizeof ( a [ 0 ] ) ; cout << smallestPerfectCube ( a , n ) ; return 0 ; } |
Find two vertices of an isosceles triangle in which there is rectangle with opposite corners ( 0 , 0 ) and ( X , Y ) | C ++ program to find two vertices of an isosceles triangle in which there is rectangle with opposite side ( 0 , 0 ) and ( x , y ) ; Function to find two vertices of an isosceles triangle in which there is rectangle with opposite side ( 0 , 0 ) and ( x , y ) ; Required value ; ; print x1 and y1 ; print x2 and y3 ; Driver code ; Function call | #include <bits/stdc++.h> NEW_LINE using namespace std ; int Vertices ( int x , int y ) { int val = abs ( x ) + abs ( y ) ; cout << val * ( x < 0 ? -1 : 1 ) << " ▁ 0 ▁ " ; cout << "0 ▁ " << val * ( y < 0 ? -1 : 1 ) ; } int main ( ) { int x = 3 , y = 3 ; Vertices ( x , y ) ; return 0 ; } |
Find a subarray whose sum is divisible by size of the array | C ++ implementation of above approach ; Function to find a subarray whose sum is a multiple of N ; Prefix sum array to store cumulative sum ; Single state dynamic programming relation for prefix sum array ; Generating all sub - arrays ; If the sum of the sub - array [ i : j ] is a multiple of N ; If the function reaches here it means there are no subarrays with sum as a multiple of N ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void CheckSubarray ( int arr [ ] , int N ) { int presum [ N + 1 ] = { 0 } ; for ( int i = 1 ; i <= N ; i += 1 ) { presum [ i ] = presum [ i - 1 ] + arr [ i - 1 ] ; } for ( int i = 1 ; i <= N ; i += 1 ) { for ( int j = i ; j <= N ; j += 1 ) { if ( ( presum [ j ] - presum [ i - 1 ] ) % N == 0 ) { cout << i - 1 << " ▁ " << j - 1 ; return ; } } } cout << -1 ; } int main ( ) { int arr [ ] = { 7 , 5 , 3 , 7 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; CheckSubarray ( arr , N ) ; return 0 ; } |
Find a subarray whose sum is divisible by size of the array | C ++ implementation of above approach ; Function to check is there exists a subarray whose sum is a multiple of N ; Prefix sum array to store cumulative sum ; Single state dynamic programming relation for prefix sum array ; Modulo class vector ; Storing the index value in the modulo class vector ; If there exists a sub - array with starting index equal to zero ; In this class , there are more than two presums % N Hence difference of any two subarrays would be a multiple of N ; 0 based indexing ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; void CheckSubarray ( int arr [ ] , int N ) { int presum [ N + 1 ] = { 0 } ; for ( int i = 1 ; i <= N ; i += 1 ) { presum [ i ] = presum [ i - 1 ] + arr [ i - 1 ] ; } vector < int > moduloclass [ N ] ; for ( int i = 1 ; i <= N ; i += 1 ) { moduloclass [ presum [ i ] % N ] . push_back ( i - 1 ) ; } if ( moduloclass [ 0 ] . size ( ) > 0 ) { cout << 0 << " ▁ " << moduloclass [ 0 ] [ 0 ] ; return ; } for ( int i = 1 ; i < N ; i += 1 ) { if ( moduloclass [ i ] . size ( ) >= 2 ) { cout << moduloclass [ i ] [ 0 ] + 1 << " ▁ " << moduloclass [ i ] [ 1 ] ; return ; } } } int main ( ) { int arr [ ] = { 7 , 3 , 5 , 2 } ; int N = sizeof ( arr ) / sizeof ( arr [ 0 ] ) ; CheckSubarray ( arr , N ) ; return 0 ; } |
Smallest number greater or equals to N such that it has no odd positioned bit set | C ++ implementation of the above approach ; Function to count the total bits ; Iterate and find the number of set bits ; Right shift the number by 1 ; Function to find the nearest number ; Count the total number of bits ; To get the position ; If the last set bit is at odd position then answer will always be a number with the left bit set ; Set all the even bits which are possible ; If the number still is less than N ; Return the number by setting the next even set bit ; If we have reached this position it means tempsum > n hence turn off even bits to get the first possible number ; Turn off the bit ; If it gets lower than N then set it and return that number ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countBits ( int n ) { int count = 0 ; while ( n ) { count ++ ; n >>= 1 ; } return count ; } int findNearestNumber ( int n ) { int cnt = countBits ( n ) ; cnt -= 1 ; if ( cnt % 2 ) { return 1 << ( cnt + 1 ) ; } else { int tempnum = 0 ; for ( int i = 0 ; i <= cnt ; i += 2 ) tempnum += 1 << i ; if ( tempnum < n ) { return ( 1 << ( cnt + 2 ) ) ; } else if ( tempnum == n ) return n ; for ( int i = 0 ; i <= cnt ; i += 2 ) { tempnum -= ( 1 << i ) ; if ( tempnum < n ) return tempnum += ( 1 << i ) ; } } } int main ( ) { int n = 19 ; cout << findNearestNumber ( n ) ; } |
Count of numbers whose 0 th and Nth bits are set | C ++ implementation of the approach ; Function to return the count of n - bit numbers whose 0 th and nth bits are set ; Driver code | #include <bits/stdc++.h> NEW_LINE using namespace std ; int countNum ( int n ) { if ( n == 1 ) return 1 ; int count = pow ( 2 , n - 2 ) ; return count ; } int main ( ) { int n = 3 ; cout << countNum ( n ) ; return 0 ; } |
Subsets and Splits