text
stringlengths
1
636
code
stringlengths
8
1.89k
Recursive function to print from N to 1
def PrintReverseOrder ( N ) : NEW_LINE INDENT for i in range ( N , 0 , - 1 ) : NEW_LINE INDENT print ( i , end = " ▁ " ) ; NEW_LINE DEDENT DEDENT
Driver code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT N = 5 ; NEW_LINE PrintReverseOrder ( N ) ; NEW_LINE DEDENT
Function to find the values
def findAns ( a , b , n ) : NEW_LINE
Calculate the LCM
lcm = ( a * b ) // __gcd ( a , b ) ; NEW_LINE
Calculate the multiples of lcm
multiples = ( n // lcm ) + 1 ; NEW_LINE
Find the values which satisfies the given condition
answer = max ( a , b ) * multiples ; NEW_LINE
Subtract the extra values
lastvalue = lcm * ( n // lcm ) + max ( a , b ) ; NEW_LINE if ( lastvalue > n ) : NEW_LINE INDENT answer = answer - ( lastvalue - n - 1 ) ; NEW_LINE DEDENT
Return the final result
return answer ; NEW_LINE def __gcd ( a , b ) : NEW_LINE if ( b == 0 ) : NEW_LINE INDENT return a ; NEW_LINE DEDENT else : NEW_LINE INDENT return __gcd ( b , a % b ) ; NEW_LINE DEDENT
Driver code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT a = 1 ; NEW_LINE b = 13 ; NEW_LINE n = 500 ; NEW_LINE print ( findAns ( a , b , n ) ) ; NEW_LINE DEDENT
Python3 program to check if two numbers are present in an array then their AM and HM are also present . Finally , find the GM of the numbers
from math import sqrt NEW_LINE
Function to find the arithmetic mean of 2 numbers
def ArithmeticMean ( A , B ) : NEW_LINE INDENT return ( A + B ) / 2 NEW_LINE DEDENT
Function to find the harmonic mean of 2 numbers
def HarmonicMean ( A , B ) : NEW_LINE INDENT return ( 2 * A * B ) / ( A + B ) NEW_LINE DEDENT
Following function checks and computes the desired results based on the means
def CheckArithmeticHarmonic ( arr , A , B , N ) : NEW_LINE
Calculate means
AM = ArithmeticMean ( A , B ) NEW_LINE HM = HarmonicMean ( A , B ) NEW_LINE
Hash container ( set ) to store elements
Hash = set ( ) NEW_LINE
Insertion of array elements in the set
for i in range ( N ) : NEW_LINE INDENT Hash . add ( arr [ i ] ) NEW_LINE DEDENT
Conditionals to check if numbers are present in array by Hashing
if ( A in Hash and B in Hash ) : NEW_LINE
Conditionals to check if the AM and HM of the numbers are present in array
if ( AM in Hash and HM in Hash ) : NEW_LINE
If all conditions are satisfied , the Geometric Mean is calculated
print ( " GM ▁ = " , round ( sqrt ( AM * HM ) , 2 ) ) NEW_LINE else : NEW_LINE
If numbers are found but the respective AM and HM are not found in the array
print ( " AM ▁ and ▁ HM ▁ not ▁ found " ) NEW_LINE else : NEW_LINE
If none of the conditions are satisfied
print ( " Numbers ▁ not ▁ found " ) NEW_LINE
Driver Code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 1.0 , 2.0 , 2.5 , 3.0 , 4.0 , 4.5 , 5.0 , 6.0 ] NEW_LINE N = len ( arr ) NEW_LINE A = 3.0 NEW_LINE B = 6.0 NEW_LINE CheckArithmeticHarmonic ( arr , A , B , N ) NEW_LINE DEDENT
Function that print number of moves required
def movesRequired ( a , b ) : NEW_LINE
Calculate modulo
total_moves = a % b NEW_LINE
Print the required answer
print ( total_moves ) NEW_LINE
Driver Code
if __name__ == ' _ _ main _ _ ' : NEW_LINE
Initialise A and B
A = 10 NEW_LINE B = 3 NEW_LINE movesRequired ( A , B ) NEW_LINE
Function to calculate the Pythagorean triplet in O ( n )
def PythagoreanTriplet ( n ) : NEW_LINE INDENT flag = 0 NEW_LINE DEDENT
Iterate a from 1 to N - 1.
for a in range ( 1 , n , 1 ) : NEW_LINE
Calculate value of b
b = ( n * n - 2 * n * a ) // ( 2 * n - 2 * a ) NEW_LINE
The value of c = n - a - b
c = n - a - b NEW_LINE if ( a * a + b * b == c * c and b > 0 and c > 0 ) : NEW_LINE INDENT print ( a , b , c ) NEW_LINE flag = 1 NEW_LINE break NEW_LINE DEDENT if ( flag == 0 ) : NEW_LINE print ( " - 1" ) NEW_LINE return NEW_LINE
Driver code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT N = 12 NEW_LINE DEDENT
Function call
PythagoreanTriplet ( N ) NEW_LINE
Python3 program to check if there exists a number with X factors out of which exactly K are prime
from math import sqrt NEW_LINE
Function to check if such number exists
def check ( X , K ) : NEW_LINE
To store the sum of powers of prime factors of X which determines the maximum count of numbers whose product can form X
prime = 0 NEW_LINE temp = X NEW_LINE sqr = int ( sqrt ( X ) ) NEW_LINE
Determining the prime factors of X
for i in range ( 2 , sqr + 1 , 1 ) : NEW_LINE INDENT while ( temp % i == 0 ) : NEW_LINE INDENT temp = temp // i NEW_LINE prime += 1 NEW_LINE DEDENT DEDENT
To check if the number is prime
if ( temp > 2 ) : NEW_LINE INDENT prime += 1 NEW_LINE DEDENT
If X is 1 , then we cannot form a number with 1 factor and K prime factor ( as K is atleast 1 )
if ( X == 1 ) : NEW_LINE INDENT return False NEW_LINE DEDENT
If X itself is prime then it can be represented as a power of only 1 prime factor w0hich is X itself so we return true
if ( prime == 1 and K == 1 ) : NEW_LINE INDENT return True NEW_LINE DEDENT
If sum of the powers of prime factors of X is greater than or equal to K , which means X can be represented as a product of K numbers , we return true
elif ( prime >= K ) : NEW_LINE INDENT return True NEW_LINE DEDENT
In any other case , we return false as we cannot form a number with X factors and K prime factors
else : NEW_LINE INDENT return False NEW_LINE DEDENT
Driver code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT X = 4 NEW_LINE K = 2 NEW_LINE if ( check ( X , K ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT DEDENT
A Tree node
class Node : NEW_LINE INDENT def __init__ ( self , key ) : NEW_LINE INDENT self . key = key NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT
Utility function to create a new node
def newNode ( key ) : NEW_LINE INDENT temp = Node ( key ) NEW_LINE return temp NEW_LINE DEDENT N = 1000000 NEW_LINE
Vector to store all the prime numbers
prime = [ ] NEW_LINE
Function to store all the prime numbers in an array
def SieveOfEratosthenes ( ) : NEW_LINE
Create a boolean array " prime [ 0 . . N ] " and initialize all the entries in it as true . A value in prime [ i ] will finally be false if i is Not a prime , else true .
check = [ True for i in range ( N + 1 ) ] NEW_LINE p = 2 NEW_LINE while ( p * p <= N ) : NEW_LINE
If prime [ p ] is not changed , then it is a prime
if ( check [ p ] ) : NEW_LINE INDENT prime . append ( p ) NEW_LINE DEDENT
Update all multiples of p greater than or equal to the square of it numbers which are multiples of p and are less than p ^ 2 are already marked .
for i in range ( p * p , N + 1 , p ) : NEW_LINE INDENT check [ i ] = False NEW_LINE DEDENT p += 1 NEW_LINE
Function to check whether Path is Co - prime or not
def isPathCo_Prime ( path ) : NEW_LINE INDENT max = 0 NEW_LINE DEDENT
Iterating through the array to find the maximum element in the array
for x in path : NEW_LINE INDENT if ( max < x ) : NEW_LINE INDENT max = x NEW_LINE DEDENT DEDENT i = 0 NEW_LINE while ( i * prime [ i ] <= max // 2 ) : NEW_LINE INDENT ct = 0 NEW_LINE DEDENT
Incrementing the variable if any of the value has a factor
for x in path : NEW_LINE INDENT if ( x % prime [ i ] == 0 ) : NEW_LINE INDENT ct += 1 NEW_LINE DEDENT DEDENT
If not co - prime
if ( ct > 1 ) : NEW_LINE INDENT return False NEW_LINE DEDENT i += 1 NEW_LINE return True NEW_LINE
Function to print a Co - Prime path
def printCo_PrimePaths ( path ) : NEW_LINE INDENT for x in path : NEW_LINE INDENT print ( x , end = ' ▁ ' ) NEW_LINE DEDENT print ( ) NEW_LINE DEDENT
Function to find co - prime paths of binary tree
def findCo_PrimePaths ( root , path ) : NEW_LINE
Base case
if ( root == None ) : NEW_LINE INDENT return path NEW_LINE DEDENT
Store the value in path vector
path . append ( root . key ) NEW_LINE
Recursively call for left sub tree
path = findCo_PrimePaths ( root . left , path ) NEW_LINE
Recursively call for right sub tree
path = findCo_PrimePaths ( root . right , path ) NEW_LINE
Condition to check , if leaf node
if ( root . left == None and root . right == None ) : NEW_LINE
Condition to check , if path co - prime or not
if ( isPathCo_Prime ( path ) ) : NEW_LINE
Print co - prime path
printCo_PrimePaths ( path ) NEW_LINE
Remove the last element from the path vector
path . pop ( ) NEW_LINE return path NEW_LINE
Function to find Co - Prime paths In a given binary tree
def printCo_PrimePath ( node ) : NEW_LINE
To save all prime numbers
SieveOfEratosthenes ( ) NEW_LINE path = [ ] NEW_LINE
Function call
path = findCo_PrimePaths ( node , path ) NEW_LINE
Driver code
if __name__ == " _ _ main _ _ " : NEW_LINE
Create Binary Tree as shown
root = newNode ( 10 ) NEW_LINE root . left = newNode ( 48 ) NEW_LINE root . right = newNode ( 3 ) NEW_LINE root . right . left = newNode ( 11 ) NEW_LINE root . right . right = newNode ( 37 ) NEW_LINE root . right . left . left = newNode ( 7 ) NEW_LINE root . right . left . right = newNode ( 29 ) NEW_LINE root . right . right . left = newNode ( 42 ) NEW_LINE root . right . right . right = newNode ( 19 ) NEW_LINE root . right . right . right . left = newNode ( 7 ) NEW_LINE
Print Co - Prime Paths
printCo_PrimePath ( root ) NEW_LINE
Python3 implementation to find the number of subsets with equal bitwise AND , OR and XOR values
mod = 1000000007 ; NEW_LINE
Function to find the number of subsets with equal bitwise AND , OR and XOR values
def countSubsets ( a , n ) : NEW_LINE INDENT answer = 0 ; NEW_LINE DEDENT
Traverse through all the subsets
for i in range ( 1 << n ) : NEW_LINE INDENT bitwiseAND = - 1 ; NEW_LINE bitwiseOR = 0 ; NEW_LINE bitwiseXOR = 0 ; NEW_LINE DEDENT
Finding the subsets with the bits of ' i ' which are set
for j in range ( n ) : NEW_LINE
Computing the bitwise AND
if ( i & ( 1 << j ) ) : NEW_LINE INDENT if ( bitwiseAND == - 1 ) : NEW_LINE INDENT bitwiseAND = a [ j ] ; NEW_LINE DEDENT else : NEW_LINE INDENT bitwiseAND &= a [ j ] ; NEW_LINE DEDENT DEDENT
Computing the bitwise OR
bitwiseOR |= a [ j ] ; NEW_LINE
Computing the bitwise XOR
bitwiseXOR ^= a [ j ] ; NEW_LINE
Comparing all the three values
if ( bitwiseAND == bitwiseOR and bitwiseOR == bitwiseXOR ) : NEW_LINE INDENT answer = ( answer + 1 ) % mod ; NEW_LINE DEDENT return answer ; NEW_LINE
Driver code
if __name__ == " _ _ main _ _ " : NEW_LINE INDENT N = 6 ; NEW_LINE A = [ 1 , 3 , 2 , 1 , 2 , 1 ] ; NEW_LINE print ( countSubsets ( A , N ) ) ; NEW_LINE DEDENT
Function to find the number of subsets formed by the given value K
def count ( arr , N , K ) : NEW_LINE
Count is used to maintain the number of continuous K 's
count = 0 NEW_LINE ans = 0 NEW_LINE
Iterating through the array
for i in range ( N ) : NEW_LINE
If the element in the array is equal to K
if ( arr [ i ] == K ) : NEW_LINE INDENT count = count + 1 NEW_LINE DEDENT else : NEW_LINE
count * ( count + 1 ) / 2 is the total number of subsets with only K as their element
ans += ( count * ( count + 1 ) ) // 2 NEW_LINE
Change count to 0 because other element apart from K has been found
count = 0 NEW_LINE
To handle the last set of K 's
ans = ans + ( count * ( count + 1 ) ) // 2 NEW_LINE return ans NEW_LINE
Driver code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 1 , 0 , 0 , 1 , 1 , 0 , 0 ] NEW_LINE N = len ( arr ) NEW_LINE K = 0 NEW_LINE print ( count ( arr , N , K ) ) NEW_LINE DEDENT
Function to convert a decimal number to a ternary number
def convertToTernary ( N ) : NEW_LINE
Base case
if ( N == 0 ) : NEW_LINE INDENT return ; NEW_LINE DEDENT
Finding the remainder when N is divided by 3
x = N % 3 ; NEW_LINE N //= 3 ; NEW_LINE if ( x < 0 ) : NEW_LINE INDENT N += 1 ; NEW_LINE DEDENT
Recursive function to call the function for the integer division of the value N / 3
convertToTernary ( N ) ; NEW_LINE
Handling the negative cases
if ( x < 0 ) : NEW_LINE INDENT print ( x + ( 3 * - 1 ) , end = " " ) ; NEW_LINE DEDENT else : NEW_LINE INDENT print ( x , end = " " ) ; NEW_LINE DEDENT
Function to convert the decimal to ternary
def convert ( Decimal ) : NEW_LINE INDENT print ( " Ternary ▁ number ▁ of ▁ " , Decimal , " ▁ is : ▁ " , end = " " ) ; NEW_LINE DEDENT
If the number is greater than 0 , compute the ternary representation of the number
if ( Decimal != 0 ) : NEW_LINE INDENT convertToTernary ( Decimal ) ; NEW_LINE DEDENT else : NEW_LINE INDENT print ( "0" , end = " " ) ; NEW_LINE DEDENT
Driver Code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT Decimal = 2747 ; NEW_LINE convert ( Decimal ) ; NEW_LINE DEDENT
Function to get the number
def get ( x , y , z ) : NEW_LINE
remainder can ' t ▁ be ▁ larger ▁ ▁ than ▁ the ▁ largest ▁ number , ▁ ▁ if ▁ so ▁ then ▁ answer ▁ doesn ' t exist .
if ( x > z ) : NEW_LINE INDENT return - 1 NEW_LINE DEDENT
reduce number by x
val = z - x NEW_LINE
finding the possible number that is divisible by y
div = ( z - x ) // y NEW_LINE
this number is always <= x as we calculated over z - x
ans = div * y + x NEW_LINE return ans NEW_LINE