text
stringlengths 17
3.65k
| code
stringlengths 70
5.84k
|
|---|---|
How to validate Visa Card number using Regular Expression | Python3 program to validate Visa Card number using regular expression ; Function to validate Visa Card number using regular expression . ; Regex to check valid Visa Card number ; Compile the ReGex ; If the string is empty return false ; Pattern class contains matcher ( ) method to find matching between given string and regular expression . ; Return True if the string matched the ReGex else False ; Driver code ; Test Case 1 ; Test Case 2 ; Test Case 3 ; Test Case 4 ; Test Case 5 str5 = "415a2760457" ; | import re NEW_LINE def isValidVisaCardNo ( string ) : NEW_LINE INDENT regex = " ^ 4[0-9 ] { 12 } ( ? : [0-9 ] { 3 } ) ? $ " ; NEW_LINE p = re . compile ( regex ) ; NEW_LINE if ( string == ' ' ) : NEW_LINE INDENT return False ; NEW_LINE DEDENT m = re . match ( p , string ) ; NEW_LINE if m is None : NEW_LINE INDENT return False NEW_LINE DEDENT else : NEW_LINE INDENT return True NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT str1 = "4155279860457" ; NEW_LINE print ( isValidVisaCardNo ( str1 ) ) ; NEW_LINE str2 = "4155279860457201" ; NEW_LINE print ( isValidVisaCardNo ( str2 ) ) ; NEW_LINE str3 = "4155279" ; NEW_LINE print ( isValidVisaCardNo ( str3 ) ) ; NEW_LINE str4 = "6155279860457" ; NEW_LINE print ( isValidVisaCardNo ( str4 ) ) ; NEW_LINE print ( isValidVisaCardNo ( str5 ) ) ; NEW_LINE DEDENT |
How to validate MasterCard number using Regular Expression | Python3 program to validate Master Card number using regular expression ; Function to validate Master Card number using regular expression . ; Regex to check valid Master Card number . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : ; Test Case 5 : str5 = "2221149a635843" | import re NEW_LINE def isValidMasterCardNo ( str ) : NEW_LINE INDENT regex = " ^ 5[1-5 ] [ 0-9 ] { 14 } | " + NEW_LINE INDENT " ^ ( 222[1-9 ] ▁ 22[3-9 ] \\d ▁ " + "2[3-6 ] \\d { 2 } ▁ 27[0-1 ] \\d ▁ " + "2720 ) [ 0-9 ] { 12 } $ " NEW_LINE DEDENT p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = "5114496353984312" NEW_LINE print ( isValidMasterCardNo ( str1 ) ) NEW_LINE str2 = "2720822463109651" NEW_LINE print ( isValidMasterCardNo ( str2 ) ) NEW_LINE str3 = "5582822410" NEW_LINE print ( isValidMasterCardNo ( str3 ) ) NEW_LINE str4 = "6082822463100051" NEW_LINE print ( isValidMasterCardNo ( str4 ) ) NEW_LINE print ( isValidMasterCardNo ( str5 ) ) NEW_LINE |
How to validate CVV number using Regular Expression | Python3 program to validate CVV ( Card Verification Value ) number using regex . ; Function to validate CVV ( Card Verification Value ) number . using regular expression . ; Regex to check valid CVV number . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : str4 = "5a1" | import re NEW_LINE def isValidCVVNumber ( str ) : NEW_LINE INDENT regex = " ^ [ 0-9 ] { 3,4 } $ " NEW_LINE p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = "561" NEW_LINE print ( isValidCVVNumber ( str1 ) ) NEW_LINE str2 = "5061" NEW_LINE print ( isValidCVVNumber ( str2 ) ) NEW_LINE str3 = "50614" NEW_LINE print ( isValidCVVNumber ( str3 ) ) NEW_LINE print ( isValidCVVNumber ( str4 ) ) NEW_LINE |
How to validate IFSC Code using Regular Expression | Python3 program to validate IFSC ( Indian Financial System ) Code using regular expression ; Function to validate IFSC ( Indian Financial System ) Code using regular expression . ; Regex to check valid IFSC Code . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : | import re NEW_LINE def isValidIFSCode ( str ) : NEW_LINE INDENT regex = " ^ [ A - Z ] {4}0 [ A - Z0-9 ] { 6 } $ " NEW_LINE p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = " SBIN0125620" NEW_LINE print ( isValidIFSCode ( str1 ) ) NEW_LINE str2 = " SBIN0125" NEW_LINE print ( isValidIFSCode ( str2 ) ) NEW_LINE str3 = "1234SBIN012" NEW_LINE print ( isValidIFSCode ( str3 ) ) NEW_LINE str4 = " SBIN7125620" NEW_LINE print ( isValidIFSCode ( str4 ) ) NEW_LINE |
How to validate GST ( Goods and Services Tax ) number using Regular Expression | Python3 program to validate GST ( Goods and Services Tax ) number using regular expression ; Function to validate GST ( Goods and Services Tax ) number . ; Regex to check valid GST ( Goods and Services Tax ) number ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : ; Test Case 5 : | import re NEW_LINE def isValidMasterCardNo ( str ) : NEW_LINE INDENT regex = " ^ [ 0-9 ] { 2 } [ A - Z ] {5 } [ 0-9 ] { 4 } " + NEW_LINE INDENT " [ A - Z ] {1 } [ 1-9A - Z ] {1 } " + NEW_LINE DEDENT p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = "06BZAHM6385P6Z2" NEW_LINE print ( isValidMasterCardNo ( str1 ) ) NEW_LINE str2 = "06BZAF67" NEW_LINE print ( isValidMasterCardNo ( str2 ) ) NEW_LINE str3 = " AZBZAHM6385P6Z2" NEW_LINE print ( isValidMasterCardNo ( str3 ) ) NEW_LINE str4 = "06BZ63AHM85P6Z2" NEW_LINE print ( isValidMasterCardNo ( str4 ) ) NEW_LINE str5 = "06BZAHM6385P6F2" NEW_LINE print ( isValidMasterCardNo ( str5 ) ) NEW_LINE |
How to validate HTML tag using Regular Expression | Python3 program to validate HTML tag using regex . using regular expression ; Function to validate HTML tag using regex . ; Regex to check valid HTML tag using regex . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : | import re NEW_LINE def isValidHTMLTag ( str ) : NEW_LINE INDENT regex = " < ( \ " [ ^ \ " ] * \ " ▁ ' [ ^ ' ] * ' ▁ [ ^ ' \ " > ] ) * > " NEW_LINE p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = " < input ▁ value ▁ = ▁ ' > ' > " NEW_LINE print ( isValidHTMLTag ( str1 ) ) NEW_LINE str2 = " < br / > " NEW_LINE print ( isValidHTMLTag ( str2 ) ) NEW_LINE str3 = " br / > " NEW_LINE print ( isValidHTMLTag ( str3 ) ) NEW_LINE str4 = " < ' br / > " NEW_LINE print ( isValidHTMLTag ( str4 ) ) NEW_LINE |
How to validate a domain name using Regular Expression | Python3 program to validate domain name using regular expression ; Function to validate domain name . ; Regex to check valid domain name . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : ; Test Case 5 : | import re NEW_LINE def isValidDomain ( str ) : NEW_LINE INDENT regex = " ^ ( ( ? ! - ) [ A - Za - z0-9 - ] " + NEW_LINE INDENT " { 1,63 } ( ? < ! - ) \\ . ) " + NEW_LINE DEDENT p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = " geeksforgeeks . org " NEW_LINE print ( isValidDomain ( str1 ) ) NEW_LINE str2 = " contribute . geeksforgeeks . org " NEW_LINE print ( isValidDomain ( str2 ) ) NEW_LINE str3 = " - geeksforgeeks . org " NEW_LINE print ( isValidDomain ( str3 ) ) NEW_LINE str4 = " geeksforgeeks . o " NEW_LINE print ( isValidDomain ( str4 ) ) NEW_LINE str5 = " . org " NEW_LINE print ( isValidDomain ( str5 ) ) NEW_LINE |
How to validate SSN ( Social Security Number ) using Regular Expression | Python3 program to validate SSN ( Social Security Number ) using regular expression ; Function to validate SSN ( Social Security Number ) . ; Regex to check valid SSN ( Social Security Number ) . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : | import re NEW_LINE def isValidSSN ( str ) : NEW_LINE INDENT regex = " ^ ( ? ! 666 ▁ 000 ▁ 9\\d { 2 } ) \\d { 3 } - ( ? !00 ) \\d { 2 } - ( ? !0{4 } ) \\d { 4 } $ " NEW_LINE p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = "856-45-6789" NEW_LINE print ( isValidSSN ( str1 ) ) NEW_LINE str2 = "000-45-6789" NEW_LINE print ( isValidSSN ( str2 ) ) NEW_LINE str3 = "856-452-6789" NEW_LINE print ( isValidSSN ( str3 ) ) NEW_LINE str4 = "856-45-0000" NEW_LINE print ( isValidSSN ( str4 ) ) NEW_LINE |
How to validate image file extension using Regular Expression | Python3 program to validate image file extension using regex ; Function to validate image file extension . ; Regex to check valid image file extension . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : ; Test Case 5 : | import re NEW_LINE def imageFile ( str ) : NEW_LINE INDENT regex = " ( [ ^ \\s ] + ( \\ . ( ? i ) ( jpe ? g ▁ png ▁ gif ▁ bmp ) ) $ ) " NEW_LINE p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = " abc . png " NEW_LINE print ( imageFile ( str1 ) ) NEW_LINE str2 = " im . jpg " NEW_LINE print ( imageFile ( str2 ) ) NEW_LINE str3 = " . gif " NEW_LINE print ( imageFile ( str3 ) ) NEW_LINE str4 = " abc . mp3" NEW_LINE print ( imageFile ( str4 ) ) NEW_LINE str5 = " ▁ . jpg " NEW_LINE print ( imageFile ( str5 ) ) NEW_LINE |
How to check Aadhar number is valid or not using Regular Expression | Python3 program to validate Aadhar number using regex . ; Function to validate Aadhar number . ; Regex to check valid Aadhar number . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : str4 = "3675 ▁ 98AF ▁ 602" ; Test Case 5 : | import re NEW_LINE def isValidAadharNumber ( str ) : NEW_LINE INDENT regex = ( " ^ [ 2-9 ] { 1 } [ 0-9 ] { 3 } \\ " + " s [ 0-9 ] { 4 } \\s [ 0-9 ] { 4 } $ " ) NEW_LINE p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = "3675 ▁ 9834 ▁ 6015" NEW_LINE print ( isValidAadharNumber ( str1 ) ) NEW_LINE str2 = "4675 ▁ 9834 ▁ 6012 ▁ 8" NEW_LINE print ( isValidAadharNumber ( str2 ) ) NEW_LINE str3 = "0175 ▁ 9834 ▁ 6012" NEW_LINE print ( isValidAadharNumber ( str3 ) ) NEW_LINE print ( isValidAadharNumber ( str4 ) ) NEW_LINE str5 = "417598346012" NEW_LINE print ( isValidAadharNumber ( str5 ) ) NEW_LINE |
How to validate pin code of India using Regular Expression | Python3 program to validate the pin code of India using Regular Expression . ; Function to validate the pin code of India . ; Regex to check valid pin code of India . ; Compile the ReGex ; If the pin code is empty return false ; Pattern class contains matcher ( ) method to find matching between given pin code and regular expression . ; Return True if the pin code matched the ReGex else False ; Driver code ; Test case 1 ; Test case 2 : ; Test case 3 : ; Test case 4 : | import re NEW_LINE def isValidPinCode ( pinCode ) : NEW_LINE INDENT regex = " ^ [ 1-9 ] { 1 } [ 0-9 ] { 2 } \\s { 0,1 } [ 0-9 ] { 3 } $ " ; NEW_LINE p = re . compile ( regex ) ; NEW_LINE if ( pinCode == ' ' ) : NEW_LINE INDENT return False ; NEW_LINE DEDENT m = re . match ( p , pinCode ) ; NEW_LINE if m is None : NEW_LINE INDENT return False NEW_LINE DEDENT else : NEW_LINE INDENT return True NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT num1 = "132103" ; NEW_LINE print ( num1 , " : ▁ " , isValidPinCode ( num1 ) ) ; NEW_LINE num2 = "201 ▁ 305" ; NEW_LINE print ( num2 , " : ▁ " , isValidPinCode ( num2 ) ) ; NEW_LINE num3 = "014205" ; NEW_LINE print ( num3 , " : ▁ " , isValidPinCode ( num3 ) ) ; NEW_LINE num4 = "1473598" ; NEW_LINE print ( num4 , " : ▁ " , isValidPinCode ( num4 ) ) ; NEW_LINE DEDENT |
How to validate time in 24 | Python3 program to validate the time in 24 - hour format using Regular Expression . ; Function to validate the time in 24 - hour format ; Regex to check valid time in 24 - hour format . ; Compile the ReGex ; If the time is empty return false ; Pattern class contains matcher ( ) method to find matching between given time and regular expression . ; Return True if the time matched the ReGex otherwise False ; Driver Code . ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : ; Test Case 5 : | import re NEW_LINE def isValidTime ( time ) : NEW_LINE INDENT regex = " ^ ( [01 ] ? [0-9 ] ▁ 2[0-3 ] ) : [ 0-5 ] [ 0-9 ] $ " ; NEW_LINE p = re . compile ( regex ) ; NEW_LINE if ( time == " " ) : NEW_LINE INDENT return False ; NEW_LINE DEDENT m = re . search ( p , time ) ; NEW_LINE if m is None : NEW_LINE INDENT return False ; NEW_LINE DEDENT else : NEW_LINE INDENT return True NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT str1 = "13:05" ; NEW_LINE print ( str1 , " : ▁ " , isValidTime ( str1 ) ) ; NEW_LINE str2 = "02:15" ; NEW_LINE print ( str2 , " : ▁ " , isValidTime ( str2 ) ) ; NEW_LINE str3 = "24:00" ; NEW_LINE print ( str3 , " : ▁ " , isValidTime ( str3 ) ) ; NEW_LINE str4 = "10:60" ; NEW_LINE print ( str4 , " : ▁ " , isValidTime ( str4 ) ) ; NEW_LINE str5 = "10:15 ▁ PM " ; NEW_LINE print ( str5 , " : ▁ " , isValidTime ( str5 ) ) ; NEW_LINE DEDENT |
How to validate Hexadecimal Color Code using Regular Expression | Python3 program to validate hexadecimal colour code using Regular Expression ; Function to validate hexadecimal color code . ; Compile the ReGex ; If the string is empty return false ; Return if the string matched the ReGex ; Test Case 1 : str1 = "1AFFa1" ; Test Case 2 : str2 = " F00" ; Test Case 3 : ; Test Case 4 : str4 = "123abce " ; Test Case 5 : str5 = " afafah " | import re NEW_LINE def isValidHexaCode ( str ) : NEW_LINE INDENT p = re . compile ( regex ) NEW_LINE if ( str == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , str ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT print ( str1 , " : " , isValidHexaCode ( str1 ) ) NEW_LINE print ( str2 , " : " , isValidHexaCode ( str2 ) ) NEW_LINE str3 = "123456" NEW_LINE print ( str3 , " : " , isValidHexaCode ( str3 ) ) NEW_LINE print ( str4 , " : " , isValidHexaCode ( str4 ) ) NEW_LINE print ( str5 , " : " , isValidHexaCode ( str5 ) ) NEW_LINE |
How to validate PAN Card number using Regular Expression | Python3 program to validate the PAN Card number using Regular Expression ; Function to validate the PAN Card number . ; Regex to check valid PAN Card number ; Compile the ReGex ; If the PAN Card number is empty return false ; Return if the PAN Card number matched the ReGex ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : ; Test Case 5 : | import re NEW_LINE def isValidPanCardNo ( panCardNo ) : NEW_LINE INDENT regex = " [ A - Z ] {5 } [ 0-9 ] { 4 } [ A - Z ] {1 } " NEW_LINE p = re . compile ( regex ) NEW_LINE if ( panCardNo == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( re . search ( p , panCardNo ) and len ( panCardNo ) == 10 ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT str1 = " BNZAA2318J " NEW_LINE print ( isValidPanCardNo ( str1 ) ) NEW_LINE str2 = "23ZAABN18J " NEW_LINE print ( isValidPanCardNo ( str2 ) ) NEW_LINE str3 = " BNZAA2318JM " NEW_LINE print ( isValidPanCardNo ( str3 ) ) NEW_LINE str4 = " BNZAA23184" NEW_LINE print ( isValidPanCardNo ( str4 ) ) NEW_LINE str5 = " BNZAA ▁ 23184" NEW_LINE print ( isValidPanCardNo ( str5 ) ) NEW_LINE |
How to validate time in 12 | Python3 program to validate the time in 12 - hour format using Regular Expression . ; Function to validate the time in 12 - hour format . ; Regex to check valid time in 12 - hour format . ; Compile the ReGex ; If the time is empty return false ; Return if the time matched the ReGex ; Driver Code . ; Test Case 1 : ; Test Case 2 : ; Test Case 3 : ; Test Case 4 : | import re NEW_LINE def isValidTime ( time ) : NEW_LINE INDENT regexPattern = " ( 1[012 ] ▁ [ 1-9 ] ) : " + " [ 0-5 ] [ 0-9 ] ( \\s ) " + " ? ( ? i ) ( am ▁ pm ) " ; NEW_LINE compiledPattern = re . compile ( regexPattern ) ; NEW_LINE if ( time == None ) : NEW_LINE INDENT return False ; NEW_LINE DEDENT if re . search ( compiledPattern , time ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT str1 = "12:15 ▁ AM " ; NEW_LINE print ( isValidTime ( str1 ) ) ; NEW_LINE str2 = "9:45PM " ; NEW_LINE print ( isValidTime ( str2 ) ) ; NEW_LINE str3 = "1:15" ; NEW_LINE print ( isValidTime ( str3 ) ) ; NEW_LINE str4 = "17:30" ; NEW_LINE print ( isValidTime ( str4 ) ) ; NEW_LINE DEDENT |
Program to build a DFA that checks if a string ends with "01" or "10" | End position is checked using the string length value . q0 is the starting state . q1 and q2 are intermediate states . q3 and q4 are final states . ; state transitions 0 takes to q1 , 1 takes to q3 ; state transitions 0 takes to q4 , 1 takes to q2 ; state transitions 0 takes to q4 , 1 takes to q2 ; state transitions 0 takes to q1 , 1 takes to q3 ; state transitions 0 takes to q1 , 1 takes to q2 ; Driver Code ; all state transitions are printed . if string is accpetable , YES is printed . else NO is printed | def q1 ( s , i ) : NEW_LINE INDENT print ( " q1 - > " , end = " " ) ; NEW_LINE if ( i == len ( s ) ) : NEW_LINE INDENT print ( " NO " ) ; NEW_LINE return ; NEW_LINE DEDENT if ( s [ i ] == '0' ) : NEW_LINE INDENT q1 ( s , i + 1 ) ; NEW_LINE DEDENT else : NEW_LINE INDENT q3 ( s , i + 1 ) ; NEW_LINE DEDENT DEDENT def q2 ( s , i ) : NEW_LINE INDENT print ( " q2 - > " , end = " " ) ; NEW_LINE if ( i == len ( s ) ) : NEW_LINE INDENT print ( " NO " ) ; NEW_LINE return ; NEW_LINE DEDENT if ( s [ i ] == '0' ) : NEW_LINE INDENT q4 ( s , i + 1 ) ; NEW_LINE DEDENT else : NEW_LINE INDENT q2 ( s , i + 1 ) ; NEW_LINE DEDENT DEDENT def q3 ( s , i ) : NEW_LINE INDENT print ( " q3 - > " , end = " " ) ; NEW_LINE if ( i == len ( s ) ) : NEW_LINE INDENT print ( " YES " ) ; NEW_LINE return ; NEW_LINE DEDENT if ( s [ i ] == '0' ) : NEW_LINE INDENT q4 ( s , i + 1 ) ; NEW_LINE DEDENT else : NEW_LINE INDENT q2 ( s , i + 1 ) ; NEW_LINE DEDENT DEDENT def q4 ( s , i ) : NEW_LINE INDENT print ( " q4 - > " , end = " " ) ; NEW_LINE if ( i == len ( s ) ) : NEW_LINE INDENT print ( " YES " ) ; NEW_LINE return ; NEW_LINE DEDENT if ( s [ i ] == '0' ) : NEW_LINE INDENT q1 ( s , i + 1 ) ; NEW_LINE DEDENT else : NEW_LINE INDENT q3 ( s , i + 1 ) ; NEW_LINE DEDENT DEDENT def q0 ( s , i ) : NEW_LINE INDENT print ( " q0 - > " , end = " " ) ; NEW_LINE if ( i == len ( s ) ) : NEW_LINE INDENT print ( " NO " ) ; NEW_LINE return ; NEW_LINE DEDENT if ( s [ i ] == '0' ) : NEW_LINE INDENT q1 ( s , i + 1 ) ; NEW_LINE DEDENT else : NEW_LINE INDENT q2 ( s , i + 1 ) ; NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT s = "010101" ; NEW_LINE print ( " State ▁ transitions ▁ are " , end = " ▁ " ) ; NEW_LINE q0 ( s , 0 ) ; NEW_LINE DEDENT |
Check whether two strings contain same characters in same order | Python3 implementation of approach ; if length of the b = 0 then we return true ; if length of a = 0 that means b is not present in a so we return false ; Driver code | def checkSequence ( a , b ) : NEW_LINE INDENT if len ( b ) == 0 : NEW_LINE INDENT return True NEW_LINE DEDENT if len ( a ) == 0 : NEW_LINE INDENT return False NEW_LINE DEDENT if ( a [ 0 ] == b [ 0 ] ) : NEW_LINE INDENT return checkSequence ( a [ 1 : ] , b [ 1 : ] ) NEW_LINE DEDENT else : NEW_LINE INDENT return checkSequence ( a [ 1 : ] , b ) NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT s1 = " Geeks " NEW_LINE s2 = " Geks " NEW_LINE if ( checkSequence ( s1 , s2 ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT DEDENT |
String matching with * ( that matches with any ) in any of the two strings | Function to check if the two strings can be matched or not ; if the string don 't have * then character t that position must be same. ; Driver code | def doMatch ( A , B ) : NEW_LINE INDENT for i in range ( len ( A ) ) : NEW_LINE INDENT if A [ i ] != ' * ' and B [ i ] != ' * ' : NEW_LINE INDENT if A [ i ] != B [ i ] : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT DEDENT return True NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT A = " gee * sforgeeks " NEW_LINE B = " geeksforgeeks " NEW_LINE print ( int ( doMatch ( A , B ) ) ) NEW_LINE DEDENT |
Find Nth term of the series 0 , 2 , 4 , 8 , 12 , 18. . . | Calculate Nth term of series ; Driver Code | def nthTerm ( N ) : NEW_LINE INDENT return ( N + N * ( N - 1 ) ) // 2 NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT N = 5 NEW_LINE print ( nthTerm ( N ) ) NEW_LINE DEDENT |
Find Nth term of series 1 , 4 , 15 , 72 , 420. . . | Function for finding factorial of N ; return factorial of N ; Function for calculating Nth term of series ; Driver code | def factorial ( N ) : NEW_LINE INDENT fact = 1 NEW_LINE for i in range ( 1 , N + 1 ) : NEW_LINE INDENT fact = fact * i NEW_LINE DEDENT return fact NEW_LINE DEDENT def nthTerm ( N ) : NEW_LINE INDENT return ( factorial ( N ) * ( N + 2 ) // 2 ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT N = 6 NEW_LINE print ( nthTerm ( N ) ) NEW_LINE DEDENT |
Sum of nodes at maximum depth of a Binary Tree | Python3 code to find the sum of the nodes which are present at the maximum depth . ; Binary tree node ; Function to find the sum of the node which are present at the maximum depth . While traversing the nodes compare the level of the node with max_level ( Maximum level till the current node ) . If the current level exceeds the maximum level , update the max_level as current level . If the max level and current level are same , add the root data to current sum . ; Driver Code | sum = [ 0 ] NEW_LINE max_level = [ - ( 2 ** 32 ) ] NEW_LINE class createNode : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . d = data NEW_LINE self . l = None NEW_LINE self . r = None NEW_LINE DEDENT DEDENT def sumOfNodesAtMaxDepth ( ro , level ) : NEW_LINE INDENT if ( ro == None ) : NEW_LINE INDENT return NEW_LINE DEDENT if ( level > max_level [ 0 ] ) : NEW_LINE INDENT sum [ 0 ] = ro . d NEW_LINE max_level [ 0 ] = level NEW_LINE DEDENT elif ( level == max_level [ 0 ] ) : NEW_LINE INDENT sum [ 0 ] = sum [ 0 ] + ro . d NEW_LINE DEDENT sumOfNodesAtMaxDepth ( ro . l , level + 1 ) NEW_LINE sumOfNodesAtMaxDepth ( ro . r , level + 1 ) NEW_LINE DEDENT root = createNode ( 1 ) NEW_LINE root . l = createNode ( 2 ) NEW_LINE root . r = createNode ( 3 ) NEW_LINE root . l . l = createNode ( 4 ) NEW_LINE root . l . r = createNode ( 5 ) NEW_LINE root . r . l = createNode ( 6 ) NEW_LINE root . r . r = createNode ( 7 ) NEW_LINE sumOfNodesAtMaxDepth ( root , 0 ) NEW_LINE print ( sum [ 0 ] ) NEW_LINE |
Sum of nodes at maximum depth of a Binary Tree | Constructor ; Function to find the sum of nodes at maximum depth arguments are node and max , where Max is to match the depth of node at every call to node , if Max will be equal to 1 , means we are at deepest node . ; base case ; Max == 1 to track the node at deepest level ; recursive call to left and right nodes ; maxDepth function to find the max depth of the tree ; base case ; Either leftDepth of rightDepth is greater add 1 to include height of node at which call is ; call to function to calculate max depth ; Driver code ; Constructing tree ; call to calculate required sum | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def sumMaxLevelRec ( node , Max ) : NEW_LINE INDENT if node == None : NEW_LINE INDENT return 0 NEW_LINE DEDENT if Max == 1 : NEW_LINE INDENT return node . data NEW_LINE DEDENT return ( sumMaxLevelRec ( node . left , Max - 1 ) + sumMaxLevelRec ( node . right , Max - 1 ) ) NEW_LINE DEDENT def maxDepth ( node ) : NEW_LINE INDENT if node == None : NEW_LINE INDENT return 0 NEW_LINE DEDENT return 1 + max ( maxDepth ( node . left ) , maxDepth ( node . right ) ) NEW_LINE DEDENT def sumMaxLevel ( root ) : NEW_LINE INDENT MaxDepth = maxDepth ( root ) NEW_LINE return sumMaxLevelRec ( root , MaxDepth ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right . left = Node ( 6 ) NEW_LINE root . right . right = Node ( 7 ) NEW_LINE print ( sumMaxLevel ( root ) ) NEW_LINE DEDENT |
Sum of Manhattan distances between repetitions in a String | Function to find the sum of the manhattan distances between same characters in string ; Vector to store indices for each unique character of the string ; Append the position of each character in their respective vectors ; Store the required result ; Iterate over all the characters ; Calculate sum of all elements present in the vector ; Traverse the current vector ; Find suffix [ i + 1 ] ; Adding distance of all pairs whose first element is i and second element belongs to [ i + 1 , n ] ; Prthe result ; Driver Code ; Given Input ; Function Call | def SumofDistances ( s ) : NEW_LINE INDENT v = [ [ ] for i in range ( 26 ) ] NEW_LINE for i in range ( len ( s ) ) : NEW_LINE INDENT v [ ord ( s [ i ] ) - ord ( ' a ' ) ] . append ( i ) NEW_LINE DEDENT ans = 0 NEW_LINE for i in range ( 26 ) : NEW_LINE INDENT sum = 0 NEW_LINE for j in range ( len ( v [ i ] ) ) : NEW_LINE INDENT sum += v [ i ] [ j ] NEW_LINE DEDENT for j in range ( len ( v [ i ] ) ) : NEW_LINE INDENT sum -= v [ i ] [ j ] NEW_LINE ans += ( sum - ( len ( v [ i ] ) - 1 - j ) * ( v [ i ] [ j ] ) ) NEW_LINE DEDENT DEDENT print ( ans ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT s = " ababa " NEW_LINE SumofDistances ( s ) NEW_LINE DEDENT |
Minimum prefixes required to be flipped to convert a Binary String to another | Function to count flips required to make strings A and B equal ; Stores the count of the number of operations ; Stores the length of the chosen prefixes ; Stores if operations are performed even or odd times ; Traverse the given string ; If current characters in the two strings are unequal ; If A [ i ] is not flipped ; Increment count of operations ; Insert the length of the chosen prefix ; Update invert to true ; If A [ i ] is flipped ; Increment count of operations ; Insert length of the chosen prefix ; Update invert to false ; Print the number of operations required ; Print the chosen prefix length in each operation ; Driver Code ; Given binary strings | def findOperations ( A , B , N ) : NEW_LINE INDENT operations = 0 NEW_LINE ops = [ ] NEW_LINE invert = False NEW_LINE for i in range ( N - 1 , - 1 , - 1 ) : NEW_LINE INDENT if ( A [ i ] != B [ i ] ) : NEW_LINE INDENT if ( not invert ) : NEW_LINE INDENT operations += 1 NEW_LINE ops . append ( i + 1 ) NEW_LINE invert = True NEW_LINE DEDENT DEDENT else : NEW_LINE INDENT if ( invert ) : NEW_LINE INDENT operations += 1 NEW_LINE ops . append ( i + 1 ) NEW_LINE invert = False NEW_LINE DEDENT DEDENT DEDENT print ( operations ) NEW_LINE if ( operations != 0 ) : NEW_LINE INDENT for x in ops : NEW_LINE INDENT print ( x , end = " ▁ " ) NEW_LINE DEDENT DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT A , B = "001" , "000" NEW_LINE N = len ( A ) NEW_LINE findOperations ( A , B , N ) NEW_LINE DEDENT |
Maximize cost of forming a set of words using given set of characters | Function to find the maximum cost of any valid set of words formed by using the given letters ; Stores frequency of characters ; Find the maximum cost ; Utility function to find maximum cost of generating any possible subsets of strings ; Base Case ; Stores the current cost ; Stores the cost of by the current word ; Create a copy of the letterCounts array ; Traverse the current word ; Store the current index & check if its frequency is 0 or not ; If true , then update wordScore to - 1 ; Otherwise , add the cost of the current index to wordScore ; Decrease its frequency ; If wordScore > 0 , then recursively call for next index ; Find the cost by not including current word ; Return the maximum score ; Given arrays ; Function Call | def maxScoreWords ( words , letters , score ) : NEW_LINE INDENT letterCounts = [ 0 ] * ( 26 ) NEW_LINE for letter in letters : NEW_LINE INDENT letterCounts [ ord ( letter ) - ord ( ' a ' ) ] += 1 NEW_LINE DEDENT return helper ( words , 0 , letterCounts , score ) NEW_LINE DEDENT def helper ( words , start , letterCounts , score ) : NEW_LINE INDENT if ( start == len ( words ) ) : NEW_LINE INDENT return 0 NEW_LINE DEDENT currScore = 0 NEW_LINE wordScore = 1 NEW_LINE nextCounts = letterCounts NEW_LINE for i in range ( len ( words [ start ] ) ) : NEW_LINE INDENT idx = ord ( words [ start ] [ i ] ) - ord ( ' a ' ) NEW_LINE if ( nextCounts [ idx ] == 0 ) : NEW_LINE INDENT wordScore = - 1 NEW_LINE break NEW_LINE DEDENT wordScore += score [ idx ] NEW_LINE nextCounts [ idx ] -= 1 NEW_LINE DEDENT if ( wordScore > 0 ) : NEW_LINE INDENT currScore = helper ( words , start + 1 , nextCounts , score ) + wordScore NEW_LINE DEDENT currScore = max ( currScore , helper ( words , start + 1 , letterCounts , score ) ) NEW_LINE return currScore NEW_LINE DEDENT words = [ " dog " , " cat " , " dad " , " good " ] NEW_LINE letters = [ ' a ' , ' a ' , ' c ' , ' d ' , ' d ' , ' d ' , ' g ' , ' o ' , ' o ' ] NEW_LINE score = [ 1 , 0 , 9 , 5 , 0 , 0 , 3 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 2 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] NEW_LINE print ( maxScoreWords ( words , letters , score ) ) NEW_LINE |
Modify string by sorting characters after removal of characters whose frequency is not equal to power of 2 | Python3 program for the above approach ; Function to remove all the characters from a that whose frequencies are not equal to a perfect power of 2 ; Stores the frequency of each character in S ; Iterate over characters of string ; Update frequency of current character in the array freq [ ] ; Traverse the array freq [ ] ; Check if the i - th letter is absent from S ; Calculate log of frequency of the current character in the S ; Calculate power of 2 of lg ; Check if freq [ i ] is a power of 2 ; Print letter i + ' a ' freq [ i ] times ; Driver Code | from math import log2 NEW_LINE def countFrequency ( S , N ) : NEW_LINE INDENT freq = [ 0 ] * 26 NEW_LINE for i in range ( N ) : NEW_LINE INDENT freq [ ord ( S [ i ] ) - ord ( ' a ' ) ] += 1 NEW_LINE DEDENT for i in range ( 26 ) : NEW_LINE INDENT if ( freq [ i ] == 0 ) : NEW_LINE INDENT continue NEW_LINE DEDENT lg = int ( log2 ( freq [ i ] ) ) NEW_LINE a = pow ( 2 , lg ) NEW_LINE if ( a == freq [ i ] ) : NEW_LINE INDENT while ( freq [ i ] ) : NEW_LINE INDENT print ( chr ( i + ord ( ' a ' ) ) , end = " " ) NEW_LINE freq [ i ] -= 1 NEW_LINE DEDENT DEDENT DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT S = " aaacbb " NEW_LINE N = len ( S ) NEW_LINE countFrequency ( S , N ) NEW_LINE DEDENT |
Queries to calculate sum of squares of ASCII values of characters of a substring with updates | Structure of a node of a Segment Tree ; Function to construct the Segment Tree ; If start and end are equa ; Assign squares of positions of the characters ; Stores the mid value of the range [ start , end ] ; Recursive call to left subtree ; Recursive call to right subtree ; Update the current node ; Function to perform the queries of type 2 ; No overlap ; If l <= start and r >= end ; Return the value of treeNode ; Calculate middle of the range [ start , end ] ; Function call to left subtree ; Function call to right subtree ; Return the sum of X and Y ; Function to perform update queries on a Segment Tree ; If start is equal to end and idx is equal to start ; Base Case ; Calculate middle of the range [ start , end ] ; If idx <= mid ; Function call to left subtree ; Otherwise ; Function call to the right subtree ; Update the current node ; Function to perform the given queries ; Stores the segment tree ; Traverse the segment tree ; Assign 0 to each node ; Builds segment tree ; Traverse the query array Q [ ] [ ] ; If query is of type S ; Stores the left boundary ; Stores the right boundary ; Prints the sum of squares of the alphabetic positions of the characters ; Otherwise ; Stores the index of the character to be updated ; Update the segment tree ; Driver Code ; Input ; Function call | class treeNode : NEW_LINE INDENT def __init__ ( self , x ) : NEW_LINE INDENT self . square_sum = x NEW_LINE DEDENT DEDENT def buildTree ( s , tree , start , end , treeNode ) : NEW_LINE INDENT if ( start == end ) : NEW_LINE INDENT tree [ treeNode ] . square_sum = pow ( ord ( s [ start ] ) - ord ( ' a ' ) + 1 , 2 ) NEW_LINE return NEW_LINE DEDENT mid = start + ( ( end - start ) // 2 ) NEW_LINE buildTree ( s , tree , start , mid , 2 * treeNode ) NEW_LINE buildTree ( s , tree , mid + 1 , end , 1 + 2 * treeNode ) NEW_LINE tree [ treeNode ] . square_sum = ( tree [ ( 2 * treeNode ) ] . square_sum + tree [ ( 2 * treeNode ) + 1 ] . square_sum ) NEW_LINE DEDENT def querySquareSum ( tree , start , end , treeNode , l , r ) : NEW_LINE INDENT if ( ( l > end ) or ( r < start ) ) : NEW_LINE INDENT return 0 NEW_LINE DEDENT if ( ( l <= start ) and ( r >= end ) ) : NEW_LINE INDENT return tree [ treeNode ] . square_sum NEW_LINE DEDENT mid = start + ( ( end - start ) // 2 ) NEW_LINE X = querySquareSum ( tree , start , mid , 2 * treeNode , l , r ) NEW_LINE Y = + querySquareSum ( tree , mid + 1 , end , 1 + 2 * treeNode , l , r ) NEW_LINE return X + Y NEW_LINE DEDENT def updateTree ( s , tree , start , end , treeNode , idx , X ) : NEW_LINE INDENT if ( ( start == end ) and ( idx == start ) ) : NEW_LINE INDENT s [ idx ] = X NEW_LINE tree [ treeNode ] . square_sum = pow ( ord ( X ) - ord ( ' a ' ) + 1 , 2 ) NEW_LINE return NEW_LINE DEDENT mid = start + ( ( end - start ) // 2 ) NEW_LINE if ( idx <= mid ) : NEW_LINE INDENT updateTree ( s , tree , start , mid , ( 2 * treeNode ) , idx , X ) NEW_LINE DEDENT else : NEW_LINE INDENT updateTree ( s , tree , mid + 1 , end , ( 2 * treeNode ) + 1 , idx , X ) NEW_LINE DEDENT tree [ treeNode ] . square_sum = ( tree [ ( 2 * treeNode ) ] . square_sum + tree [ ( 2 * treeNode ) + 1 ] . square_sum ) NEW_LINE DEDENT def PerformQuery ( S , Q ) : NEW_LINE INDENT n = len ( S ) NEW_LINE tree = [ treeNode ( 0 ) for i in range ( ( 4 * n ) + 1 ) ] NEW_LINE for i in range ( 4 * n + 1 ) : NEW_LINE INDENT tree [ i ] . square_sum = 0 NEW_LINE DEDENT buildTree ( S , tree , 0 , n - 1 , 1 ) NEW_LINE for i in range ( len ( Q ) ) : NEW_LINE INDENT if ( Q [ i ] [ 0 ] == " S " ) : NEW_LINE INDENT L = int ( Q [ i ] [ 1 ] ) NEW_LINE R = int ( Q [ i ] [ 2 ] ) NEW_LINE print ( querySquareSum ( tree , 0 , n - 1 , 1 , L , R ) ) NEW_LINE DEDENT elif ( Q [ i ] [ 0 ] == " U " ) : NEW_LINE INDENT I = int ( Q [ i ] [ 1 ] ) NEW_LINE updateTree ( S , tree , 0 , n - 1 , 1 , I , Q [ i ] [ 2 ] [ 0 ] ) NEW_LINE DEDENT DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT S = " geeksforgeeks " NEW_LINE Q = [ [ " S " , "0" , "2" ] , [ " S " , "1" , "2" ] , [ " U " , "1" , " a " ] , [ " S " , "0" , "2" ] , [ " S " , "4" , "5" ] ] NEW_LINE PerformQuery ( [ i for i in S ] , Q ) NEW_LINE DEDENT |
Longest Common Subsequence ( LCS ) by repeatedly swapping characters of a string with characters of another string | Function to find the length of LCS possible by swapping any character of a with that of another string ; Store the size of the strings ; Stores frequency of characters ; Iterate over characters of the A ; Update frequency of character A [ i ] ; Iterate over characters of the B ; Update frequency of character B [ i ] ; Store the count of all pairs of similar characters ; Traverse the array freq [ ] ; Update cnt ; Print the minimum of cnt , N and M ; Driver Code ; Given strings | def lcsBySwapping ( A , B ) : NEW_LINE INDENT N = len ( A ) NEW_LINE M = len ( B ) NEW_LINE freq = [ 0 ] * 26 NEW_LINE for i in range ( len ( A ) ) : NEW_LINE INDENT freq [ ord ( A [ i ] ) - ord ( ' a ' ) ] += 1 NEW_LINE DEDENT for i in range ( len ( B ) ) : NEW_LINE INDENT freq [ ord ( B [ i ] ) - ord ( ' a ' ) ] += 1 NEW_LINE DEDENT cnt = 0 NEW_LINE for i in range ( 26 ) : NEW_LINE INDENT cnt += freq [ i ] // 2 NEW_LINE DEDENT print ( min ( cnt , min ( N , M ) ) ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT A = " abdeff " NEW_LINE B = " abbet " NEW_LINE lcsBySwapping ( A , B ) NEW_LINE DEDENT |
Length of longest subsequence whose difference between maximum and minimum ASCII value of characters is exactly one | Function to find the maximum length of subsequence having difference of ASCII value of longest and smallest character as 1 ; Stores frequency of characters ; Iterate over characters of the string ; Stores the resultant length of subsequence ; Check if there exists any elements with ASCII value one less than character ch ; Size of current subsequence ; Update the value of ans ; Print the resultant count ; Driver Code | def maximumLengthSubsequence ( str ) : NEW_LINE INDENT mp = { } NEW_LINE for ch in str : NEW_LINE INDENT if ch in mp . keys ( ) : NEW_LINE INDENT mp [ ch ] += 1 NEW_LINE DEDENT else : NEW_LINE INDENT mp [ ch ] = 1 NEW_LINE DEDENT DEDENT ans = 0 NEW_LINE for ch in str : NEW_LINE INDENT if chr ( ord ( ch ) - 1 ) in mp . keys ( ) : NEW_LINE INDENT curr_max = mp [ ch ] NEW_LINE if chr ( ord ( ch ) - 1 ) in mp . keys ( ) : NEW_LINE INDENT curr_max += mp [ chr ( ord ( ch ) - 1 ) ] NEW_LINE DEDENT ans = max ( ans , curr_max ) NEW_LINE DEDENT DEDENT print ( ans ) NEW_LINE DEDENT S = " acbbebcg " NEW_LINE maximumLengthSubsequence ( S ) NEW_LINE |
Minimum increments by 1 or K required to convert a string into another given string | Function to count minimum increments by 1 or K required to convert X to Y ; Traverse the string X ; Case 1 ; Case 2 ; Add the difference / K to the count ; Add the difference % K to the count ; Case 3 ; Add the difference / K to the count ; Add the difference % K to the count ; Print the answer ; Driver Code | def countOperations ( X , Y , K ) : NEW_LINE INDENT count = 0 NEW_LINE for i in range ( len ( X ) ) : NEW_LINE INDENT c = 0 NEW_LINE if ( X [ i ] == Y [ i ] ) : NEW_LINE INDENT continue NEW_LINE DEDENT elif ( X [ i ] < Y [ i ] ) : NEW_LINE INDENT if ( ( ord ( Y [ i ] ) - ord ( X [ i ] ) ) >= K ) : NEW_LINE INDENT c = ( ord ( Y [ i ] ) - ord ( X [ i ] ) ) // K NEW_LINE DEDENT c += ( ord ( Y [ i ] ) - ord ( X [ i ] ) ) % K NEW_LINE DEDENT else : NEW_LINE INDENT t = 90 - ord ( X [ i ] ) NEW_LINE t += ord ( Y [ i ] ) - 65 + 1 NEW_LINE if ( t >= K ) : NEW_LINE INDENT c = t // K NEW_LINE DEDENT c += ( t % K ) NEW_LINE DEDENT count += c NEW_LINE DEDENT print ( count ) NEW_LINE DEDENT X = " ABCT " NEW_LINE Y = " PBDI " NEW_LINE K = 6 NEW_LINE countOperations ( X , Y , K ) NEW_LINE |
Minimum number of swaps required such that a given substring consists of exactly K 1 s | Function to find the minimum number of swaps required such that the substring { s [ l ] , . . , s [ r ] } consists of exactly k 1 s ; Store the size of the string ; Store the total number of 1 s and 0 s in the entire string ; Traverse the string S to find the frequency of 1 and 0 ; Store the number of 1 s and 0 s in the substring s [ l , r ] ; Traverse the substring S [ l , r ] to find the frequency of 1 s and 0 s in it ; Store the count of 1 s and 0 s outside substring s [ l , r ] ; Check if the sum of the substring is at most K ; Store number of 1 s required ; Check if there are enough 1 s remaining to be swapped ; If the count of 1 s in the substring exceeds k ; Store the number of 0 s required ; Check if there are enough 0 s remaining to be swapped ; In all other cases , print - 1 ; Driver Code | def minimumSwaps ( s , l , r , k ) : NEW_LINE INDENT n = len ( s ) NEW_LINE tot_ones , tot_zeros = 0 , 0 NEW_LINE for i in range ( 0 , len ( s ) ) : NEW_LINE INDENT if ( s [ i ] == '1' ) : NEW_LINE INDENT tot_ones += 1 NEW_LINE DEDENT else : NEW_LINE INDENT tot_zeros += 1 NEW_LINE DEDENT DEDENT ones , zeros , Sum = 0 , 0 , 0 NEW_LINE for i in range ( l - 1 , r ) : NEW_LINE INDENT if ( s [ i ] == '1' ) : NEW_LINE INDENT ones += 1 NEW_LINE Sum += 1 NEW_LINE DEDENT else : NEW_LINE INDENT zeros += 1 NEW_LINE DEDENT DEDENT rem_ones = tot_ones - ones NEW_LINE rem_zeros = tot_zeros - zeros NEW_LINE if ( k >= Sum ) : NEW_LINE INDENT rem = k - Sum NEW_LINE if ( zeros >= rem and rem_ones >= rem ) : NEW_LINE INDENT return rem NEW_LINE DEDENT DEDENT elif ( k < Sum ) : NEW_LINE INDENT rem = Sum - k NEW_LINE if ( ones >= rem and rem_zeros >= rem ) : NEW_LINE INDENT return rem NEW_LINE DEDENT DEDENT return - 1 NEW_LINE DEDENT S = "110011111000101" NEW_LINE L , R , K = 5 , 8 , 2 NEW_LINE print ( minimumSwaps ( S , L , R , K ) ) NEW_LINE |
Check if given number contains only “ 01 ” and “ 10 ” as substring in its binary representation | Python3 program to implement the above approach ; Function to generate all numbers having "01" and "10" as a substring ; Insert 2 and 5 ; Iterate till x is 10 ^ 15 ; Multiply x by 2 ; Update x as x * 2 + 1 ; Function to check if binary representation of N contains only "01" and "10" as substring ; Function Call to generate all such numbers ; Check if a number N exists in Ans [ ] or not ; If the number exists ; Driver Code | Ans = [ ] NEW_LINE def populateNumber ( ) : NEW_LINE INDENT Ans . append ( 2 ) NEW_LINE Ans . append ( 5 ) NEW_LINE x = 5 NEW_LINE while ( x < 1000000000001 ) : NEW_LINE INDENT x *= 2 NEW_LINE Ans . append ( x ) NEW_LINE x = x * 2 + 1 NEW_LINE Ans . append ( x ) NEW_LINE DEDENT DEDENT def checkString ( N ) : NEW_LINE INDENT populateNumber ( ) NEW_LINE for it in Ans : NEW_LINE INDENT if ( it == N ) : NEW_LINE INDENT return " Yes " NEW_LINE DEDENT DEDENT return " No " NEW_LINE DEDENT N = 5 NEW_LINE print ( checkString ( N ) ) NEW_LINE |
Count minimum substring removals required to reduce string to a single distinct character | Python3 program for the above approach ; Function to find minimum removals required to convert given string to single distinct characters only ; Unordered map to store positions of characters X , Y and Z ; Update indices of X , Y , Z ; ; Stores the count of minimum removals ; Traverse the Map ; Count the number of removals required for current character ; Update the answer ; Print the answer ; Driver Code ; Given string ; Size of string ; Function call | import sys ; NEW_LINE INT_MAX = sys . maxsize ; NEW_LINE def minimumOperations ( s , n ) : NEW_LINE INDENT mp = { } ; NEW_LINE for i in range ( n ) : NEW_LINE INDENT if s [ i ] in mp : NEW_LINE INDENT mp [ s [ i ] ] . append ( i ) ; NEW_LINE DEDENT else : NEW_LINE INDENT mp [ s [ i ] ] = [ i ] ; NEW_LINE DEDENT DEDENT ans = INT_MAX ; NEW_LINE for x in mp : NEW_LINE INDENT curr = 0 ; NEW_LINE prev = 0 ; NEW_LINE first = True ; NEW_LINE for index in mp [ x ] : NEW_LINE INDENT if ( first ) : NEW_LINE INDENT if ( index > 0 ) : NEW_LINE INDENT curr += 1 ; NEW_LINE DEDENT prev = index ; NEW_LINE first = False ; NEW_LINE DEDENT else : NEW_LINE INDENT if ( index != prev + 1 ) : NEW_LINE INDENT curr += 1 ; NEW_LINE DEDENT prev = index ; NEW_LINE DEDENT DEDENT if ( prev != n - 1 ) : NEW_LINE INDENT curr += 1 ; NEW_LINE DEDENT ans = min ( ans , curr ) ; NEW_LINE DEDENT print ( ans ) ; NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT s = " YYXYZYXYZXY " ; NEW_LINE N = len ( s ) ; NEW_LINE minimumOperations ( s , N ) ; NEW_LINE DEDENT |
Program to construct DFA accepting odd number of 0 s and odd number of 1 s | Function to check whether the given is accepted by DFA or not ; Stores initial state of DFA ; Stores final state of DFA ; Stores previous state of DFA ; Iterate through the string ; Checking for all combinations ; Update the previous_state ; If final state is reached ; Otherwise ; Driver Code ; Given string ; Function Call | def checkValidDFA ( s ) : NEW_LINE INDENT initial_state = 0 NEW_LINE final_state = 0 NEW_LINE previous_state = 0 NEW_LINE for i in range ( len ( s ) ) : NEW_LINE INDENT if ( ( s [ i ] == '0' and previous_state == 0 ) or ( s [ i ] == '1' and previous_state == 3 ) ) : NEW_LINE INDENT final_state = 1 NEW_LINE DEDENT elif ( ( s [ i ] == '0' and previous_state == 3 ) or ( s [ i ] == '1' and previous_state == 0 ) ) : NEW_LINE INDENT final_state = 2 NEW_LINE DEDENT elif ( ( s [ i ] == '0' and previous_state == 1 ) or ( s [ i ] == '1' and previous_state == 2 ) ) : NEW_LINE INDENT final_state = 0 NEW_LINE DEDENT elif ( ( s [ i ] == '0' and previous_state == 2 ) or ( s [ i ] == '1' and previous_state == 1 ) ) : NEW_LINE INDENT final_state = 3 NEW_LINE DEDENT previous_state = final_state NEW_LINE DEDENT if ( final_state == 3 ) : NEW_LINE INDENT print ( " Accepted " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " Not ▁ Accepted " ) NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT s = "010011" NEW_LINE checkValidDFA ( s ) NEW_LINE DEDENT |
Difference between sums of odd level and even level nodes of a Binary Tree | Helper function that allocates a new node with the given data and None left and right poers . ; Construct to create a new node ; return difference of sums of odd level and even level ; create a queue for level order traversal ; traverse until the queue is empty ; traverse for complete level ; check if level no . is even or odd and accordingly update the evenSum or oddSum ; check for left child ; check for right child ; Driver Code ; Let us create Binary Tree shown in above example | class newNode : NEW_LINE INDENT def __init__ ( self , key ) : NEW_LINE INDENT self . data = key NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def evenOddLevelDifference ( root ) : NEW_LINE INDENT if ( not root ) : NEW_LINE INDENT return 0 NEW_LINE DEDENT q = [ ] NEW_LINE q . append ( root ) NEW_LINE level = 0 NEW_LINE evenSum = 0 NEW_LINE oddSum = 0 NEW_LINE while ( len ( q ) ) : NEW_LINE INDENT size = len ( q ) NEW_LINE level += 1 NEW_LINE while ( size > 0 ) : NEW_LINE INDENT temp = q [ 0 ] NEW_LINE q . pop ( 0 ) NEW_LINE if ( level % 2 == 0 ) : NEW_LINE INDENT evenSum += temp . data NEW_LINE DEDENT else : NEW_LINE INDENT oddSum += temp . data NEW_LINE DEDENT if ( temp . left ) : NEW_LINE INDENT q . append ( temp . left ) NEW_LINE DEDENT if ( temp . right ) : NEW_LINE INDENT q . append ( temp . right ) NEW_LINE DEDENT size -= 1 NEW_LINE DEDENT DEDENT return ( oddSum - evenSum ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root = newNode ( 5 ) NEW_LINE root . left = newNode ( 2 ) NEW_LINE root . right = newNode ( 6 ) NEW_LINE root . left . left = newNode ( 1 ) NEW_LINE root . left . right = newNode ( 4 ) NEW_LINE root . left . right . left = newNode ( 3 ) NEW_LINE root . right . right = newNode ( 8 ) NEW_LINE root . right . right . right = newNode ( 9 ) NEW_LINE root . right . right . left = newNode ( 7 ) NEW_LINE result = evenOddLevelDifference ( root ) NEW_LINE print ( " Diffence ▁ between ▁ sums ▁ is " , result ) NEW_LINE DEDENT |
Difference between sums of odd level and even level nodes of a Binary Tree | A Binary Tree node ; The main function that returns difference between odd and even level nodes ; Base Case ; Difference for root is root 's data - difference for left subtree - difference for right subtree ; Driver program to test above function | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def getLevelDiff ( root ) : NEW_LINE INDENT if root is None : NEW_LINE INDENT return 0 NEW_LINE DEDENT return ( root . data - getLevelDiff ( root . left ) - getLevelDiff ( root . right ) ) NEW_LINE DEDENT root = Node ( 5 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 6 ) NEW_LINE root . left . left = Node ( 1 ) NEW_LINE root . left . right = Node ( 4 ) NEW_LINE root . left . right . left = Node ( 3 ) NEW_LINE root . right . right = Node ( 8 ) NEW_LINE root . right . right . right = Node ( 9 ) NEW_LINE root . right . right . left = Node ( 7 ) NEW_LINE print " % d ▁ is ▁ the ▁ required ▁ difference " % ( getLevelDiff ( root ) ) NEW_LINE |
Sum of all leaf nodes of binary tree | Class for node creation ; constructor ; Utility function to calculate the sum of all leaf nodes ; add root data to sum if root is a leaf node ; propagate recursively in left and right subtree ; Binary tree Fromation ; Variable to store the sum of leaf nodes | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def leafSum ( root ) : NEW_LINE INDENT global total NEW_LINE if root is None : NEW_LINE INDENT return NEW_LINE DEDENT if ( root . left is None and root . right is None ) : NEW_LINE INDENT total += root . data NEW_LINE DEDENT leafSum ( root . left ) NEW_LINE leafSum ( root . right ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . right . right = Node ( 7 ) NEW_LINE root . right . left = Node ( 6 ) NEW_LINE root . right . left . right = Node ( 8 ) NEW_LINE total = 0 NEW_LINE leafSum ( root ) NEW_LINE print ( total ) NEW_LINE DEDENT |
Inorder Tree Traversal without recursion and without stack ! | A binary tree node ; Generator function for iterative inorder tree traversal ; Find the inorder predecessor of current ; Make current as right child of its inorder predecessor ; Revert the changes made in the ' if ' part to restore the original tree . i . e . , fix the right child of predecessor ; Constructed binary tree is 1 / \ 2 3 / \ 4 5 | class Node : NEW_LINE INDENT def __init__ ( self , data , left = None , right = None ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = left NEW_LINE self . right = right NEW_LINE DEDENT DEDENT def morris_traversal ( root ) : NEW_LINE INDENT current = root NEW_LINE while current is not None : NEW_LINE INDENT if current . left is None : NEW_LINE INDENT yield current . data NEW_LINE current = current . right NEW_LINE DEDENT else : NEW_LINE INDENT pre = current . left NEW_LINE while pre . right is not None and pre . right is not current : NEW_LINE INDENT pre = pre . right NEW_LINE DEDENT if pre . right is None : NEW_LINE INDENT pre . right = current NEW_LINE current = current . left NEW_LINE DEDENT else : NEW_LINE INDENT pre . right = None NEW_LINE yield current . data NEW_LINE current = current . right NEW_LINE DEDENT DEDENT DEDENT DEDENT root = Node ( 1 , right = Node ( 3 ) , left = Node ( 2 , left = Node ( 4 ) , right = Node ( 5 ) ) ) NEW_LINE for v in morris_traversal ( root ) : NEW_LINE INDENT print ( v , end = ' ▁ ' ) NEW_LINE DEDENT |
Sum of leaf nodes at minimum level | Python3 implementation to find the sum of leaf node at minimum level ; Structure of a node in binary tree ; function to find the sum of leaf nodes at minimum level ; if tree is empty ; if there is only root node ; Queue used for level order traversal ; push rioot node in the queue ; count no . of nodes present at current level ; traverse current level nodes ; get front element from ' q ' ; if node is leaf node ; accumulate data to ' sum ' ; set flag = 1 to signify that we have encountered the minimum level ; if top 's left or right child exist push them to Queue ; return the sum ; Driver code ; binary tree creation | from collections import deque NEW_LINE class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def sumOfLeafNodesAtLeafLevel ( root ) : NEW_LINE INDENT if not root : NEW_LINE INDENT return 0 NEW_LINE DEDENT if not root . left and not root . right : NEW_LINE INDENT return root . data NEW_LINE DEDENT Queue = deque ( ) NEW_LINE sum = f = 0 NEW_LINE Queue . append ( root ) NEW_LINE while not f : NEW_LINE INDENT nc = len ( Queue ) NEW_LINE while nc : NEW_LINE INDENT top = Queue . popleft ( ) NEW_LINE if not top . left and not top . right : NEW_LINE INDENT sum += top . data NEW_LINE f = 1 NEW_LINE DEDENT else : NEW_LINE INDENT if top . left : NEW_LINE INDENT Queue . append ( top . left ) NEW_LINE DEDENT if top . right : NEW_LINE INDENT Queue . append ( top . right ) NEW_LINE DEDENT DEDENT nc -= 1 NEW_LINE DEDENT DEDENT return sum NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right . left = Node ( 6 ) NEW_LINE root . right . right = Node ( 7 ) NEW_LINE root . left . right . left = Node ( 8 ) NEW_LINE root . right . left . right = Node ( 9 ) NEW_LINE print ( " Sum ▁ = ▁ " , sumOfLeafNodesAtLeafLevel ( root ) ) NEW_LINE DEDENT |
Root to leaf path sum equal to a given number | A binary tree node ; Given a tree and a sum , return true if there is a path from the root down to a leaf , such that adding up all the values along the path equals the given sum . Strategy : subtract the node value from the sum when recurring down , and check to see if the sum is 0 when you run out of tree . s is the sum ; Constructed binary tree is 10 / \ 8 2 / \ / 3 5 2 | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def hasPathSum ( node , s ) : NEW_LINE INDENT if node is None : NEW_LINE INDENT return ( s == 0 ) NEW_LINE DEDENT else : NEW_LINE INDENT ans = 0 NEW_LINE subSum = s - node . data NEW_LINE if ( subSum == 0 and node . left == None and node . right == None ) : NEW_LINE INDENT return True NEW_LINE DEDENT if node . left is not None : NEW_LINE INDENT ans = ans or hasPathSum ( node . left , subSum ) NEW_LINE DEDENT if node . right is not None : NEW_LINE INDENT ans = ans or hasPathSum ( node . right , subSum ) NEW_LINE DEDENT return ans NEW_LINE DEDENT DEDENT s = 21 NEW_LINE root = Node ( 10 ) NEW_LINE root . left = Node ( 8 ) NEW_LINE root . right = Node ( 2 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . left . left = Node ( 3 ) NEW_LINE root . right . left = Node ( 2 ) NEW_LINE if hasPathSum ( root , s ) : NEW_LINE INDENT print " There ▁ is ▁ a ▁ root - to - leaf ▁ path ▁ with ▁ sum ▁ % d " % ( s ) NEW_LINE DEDENT else : NEW_LINE INDENT print " There ▁ is ▁ no ▁ root - to - leaf ▁ path ▁ with ▁ sum ▁ % d " % ( s ) NEW_LINE DEDENT |
Sum of all the numbers that are formed from root to leaf paths | Python program to find sum of all paths from root to leaves A Binary tree node ; Returs sums of all root to leaf paths . The first parameter is root of current subtree , the second paramete "r is value of the number formed by nodes from root to this node ; Base Case ; Update val ; If current node is leaf , return the current value of val ; Recur sum of values for left and right subtree ; A wrapper function over treePathSumUtil ( ) ; Pass the initial value as 0 as ther is nothing above root ; Driver function to test above function | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def treePathsSumUtil ( root , val ) : NEW_LINE INDENT if root is None : NEW_LINE INDENT return 0 NEW_LINE DEDENT val = ( val * 10 + root . data ) NEW_LINE if root . left is None and root . right is None : NEW_LINE INDENT return val NEW_LINE DEDENT return ( treePathsSumUtil ( root . left , val ) + treePathsSumUtil ( root . right , val ) ) NEW_LINE DEDENT def treePathsSum ( root ) : NEW_LINE INDENT return treePathsSumUtil ( root , 0 ) NEW_LINE DEDENT root = Node ( 6 ) NEW_LINE root . left = Node ( 3 ) NEW_LINE root . right = Node ( 5 ) NEW_LINE root . left . left = Node ( 2 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right . right = Node ( 4 ) NEW_LINE root . left . right . left = Node ( 7 ) NEW_LINE root . left . right . right = Node ( 4 ) NEW_LINE print " Sum ▁ of ▁ all ▁ paths ▁ is " , treePathsSum ( root ) NEW_LINE |
Merge Two Binary Trees by doing Node Sum ( Recursive and Iterative ) | Helper class that allocates a new node with the given data and None left and right pointers . ; Given a binary tree , prits nodes in inorder ; first recur on left child ; then print the data of node ; now recur on right child ; Function to merge given two binary trees ; Driver code ; Let us construct the first Binary Tree 1 / \ 2 3 / \ \ 4 5 6 ; Let us construct the second Binary Tree 4 / \ 1 7 / / \ 3 2 6 | class newNode : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = self . right = None NEW_LINE DEDENT DEDENT def inorder ( node ) : NEW_LINE INDENT if ( not node ) : NEW_LINE INDENT return NEW_LINE DEDENT inorder ( node . left ) NEW_LINE print ( node . data , end = " ▁ " ) NEW_LINE inorder ( node . right ) NEW_LINE DEDENT def MergeTrees ( t1 , t2 ) : NEW_LINE INDENT if ( not t1 ) : NEW_LINE INDENT return t2 NEW_LINE DEDENT if ( not t2 ) : NEW_LINE INDENT return t1 NEW_LINE DEDENT t1 . data += t2 . data NEW_LINE t1 . left = MergeTrees ( t1 . left , t2 . left ) NEW_LINE t1 . right = MergeTrees ( t1 . right , t2 . right ) NEW_LINE return t1 NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root1 = newNode ( 1 ) NEW_LINE root1 . left = newNode ( 2 ) NEW_LINE root1 . right = newNode ( 3 ) NEW_LINE root1 . left . left = newNode ( 4 ) NEW_LINE root1 . left . right = newNode ( 5 ) NEW_LINE root1 . right . right = newNode ( 6 ) NEW_LINE root2 = newNode ( 4 ) NEW_LINE root2 . left = newNode ( 1 ) NEW_LINE root2 . right = newNode ( 7 ) NEW_LINE root2 . left . left = newNode ( 3 ) NEW_LINE root2 . right . left = newNode ( 2 ) NEW_LINE root2 . right . right = newNode ( 6 ) NEW_LINE root3 = MergeTrees ( root1 , root2 ) NEW_LINE print ( " The ▁ Merged ▁ Binary ▁ Tree ▁ is : " ) NEW_LINE inorder ( root3 ) NEW_LINE DEDENT |
Merge Two Binary Trees by doing Node Sum ( Recursive and Iterative ) | A binary tree node has data , pointer to left child and a pointer to right child ; Structure to store node pair onto stack ; Helper function that allocates a new node with the given data and None left and right pointers . ; Given a binary tree , print its nodes in inorder ; first recur on left child ; then print the data of node ; now recur on right child ; Function to merge given two binary trees ; Driver code ; Let us construct the first Binary Tree 1 / \ 2 3 / \ \ 4 5 6 ; Let us construct the second Binary Tree 4 / \ 1 7 / / \ 3 2 6 | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT class snode : NEW_LINE INDENT def __init__ ( self , l , r ) : NEW_LINE INDENT self . l = l NEW_LINE self . r = r NEW_LINE DEDENT DEDENT def newNode ( data ) : NEW_LINE INDENT new_node = Node ( data ) NEW_LINE return new_node NEW_LINE DEDENT def inorder ( node ) : NEW_LINE INDENT if ( not node ) : NEW_LINE INDENT return ; NEW_LINE DEDENT inorder ( node . left ) ; NEW_LINE print ( node . data , end = ' ▁ ' ) ; NEW_LINE inorder ( node . right ) ; NEW_LINE DEDENT def MergeTrees ( t1 , t2 ) : NEW_LINE INDENT if ( not t1 ) : NEW_LINE INDENT return t2 ; NEW_LINE DEDENT if ( not t2 ) : NEW_LINE INDENT return t1 ; NEW_LINE DEDENT s = [ ] NEW_LINE temp = snode ( t1 , t2 ) NEW_LINE s . append ( temp ) ; NEW_LINE n = None NEW_LINE while ( len ( s ) != 0 ) : NEW_LINE INDENT n = s [ - 1 ] NEW_LINE s . pop ( ) ; NEW_LINE if ( n . l == None or n . r == None ) : NEW_LINE INDENT continue ; NEW_LINE DEDENT n . l . data += n . r . data ; NEW_LINE if ( n . l . left == None ) : NEW_LINE INDENT n . l . left = n . r . left ; NEW_LINE DEDENT else : NEW_LINE INDENT t = snode ( n . l . left , n . r . left ) NEW_LINE s . append ( t ) ; NEW_LINE DEDENT if ( n . l . right == None ) : NEW_LINE INDENT n . l . right = n . r . right ; NEW_LINE DEDENT else : NEW_LINE INDENT t = snode ( n . l . right , n . r . right ) NEW_LINE s . append ( t ) ; NEW_LINE DEDENT DEDENT return t1 ; NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root1 = newNode ( 1 ) ; NEW_LINE root1 . left = newNode ( 2 ) ; NEW_LINE root1 . right = newNode ( 3 ) ; NEW_LINE root1 . left . left = newNode ( 4 ) ; NEW_LINE root1 . left . right = newNode ( 5 ) ; NEW_LINE root1 . right . right = newNode ( 6 ) ; NEW_LINE root2 = newNode ( 4 ) ; NEW_LINE root2 . left = newNode ( 1 ) ; NEW_LINE root2 . right = newNode ( 7 ) ; NEW_LINE root2 . left . left = newNode ( 3 ) ; NEW_LINE root2 . right . left = newNode ( 2 ) ; NEW_LINE root2 . right . right = newNode ( 6 ) ; NEW_LINE root3 = MergeTrees ( root1 , root2 ) ; NEW_LINE print ( " The ▁ Merged ▁ Binary ▁ Tree ▁ is : " ) ; NEW_LINE inorder ( root3 ) ; NEW_LINE DEDENT |
Find root of the tree where children id sum for every node is given | Find root of tree where children sum for every node id is given ; Every node appears once as an id , and every node except for the root appears once in a sum . So if we subtract all the sums from all the ids , we 're left with the root id. ; Driver Code | def findRoot ( arr , n ) : NEW_LINE INDENT root = 0 NEW_LINE for i in range ( n ) : NEW_LINE INDENT root += ( arr [ i ] [ 0 ] - arr [ i ] [ 1 ] ) NEW_LINE DEDENT return root NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ [ 1 , 5 ] , [ 2 , 0 ] , [ 3 , 0 ] , [ 4 , 0 ] , [ 5 , 5 ] , [ 6 , 5 ] ] NEW_LINE n = len ( arr ) NEW_LINE print ( findRoot ( arr , n ) ) NEW_LINE DEDENT |
Print Postorder traversal from given Inorder and Preorder traversals | A utility function to search x in arr [ ] of size n ; Prints postorder traversal from given inorder and preorder traversals ; The first element in pre [ ] is always root , search it in in [ ] to find left and right subtrees ; If left subtree is not empty , print left subtree ; If right subtree is not empty , print right subtree ; Print root ; Driver code | def search ( arr , x , n ) : NEW_LINE INDENT for i in range ( n ) : NEW_LINE INDENT if ( arr [ i ] == x ) : NEW_LINE INDENT return i NEW_LINE DEDENT DEDENT return - 1 NEW_LINE DEDENT def printPostOrder ( In , pre , n ) : NEW_LINE INDENT root = search ( In , pre [ 0 ] , n ) NEW_LINE if ( root != 0 ) : NEW_LINE INDENT printPostOrder ( In , pre [ 1 : n ] , root ) NEW_LINE DEDENT if ( root != n - 1 ) : NEW_LINE INDENT printPostOrder ( In [ root + 1 : n ] , pre [ root + 1 : n ] , n - root - 1 ) NEW_LINE DEDENT print ( pre [ 0 ] , end = " ▁ " ) NEW_LINE DEDENT In = [ 4 , 2 , 5 , 1 , 3 , 6 ] NEW_LINE pre = [ 1 , 2 , 4 , 5 , 3 , 6 ] NEW_LINE n = len ( In ) NEW_LINE print ( " Postorder ▁ traversal ▁ " ) NEW_LINE printPostOrder ( In , pre , n ) NEW_LINE |
Lowest Common Ancestor in a Binary Tree | Set 1 | A binary tree node ; This function returns pointer to LCA of two given values n1 and n2 This function assumes that n1 and n2 are present in Binary Tree ; Base Case ; If either n1 or n2 matches with root 's key, report the presence by returning root (Note that if a key is ancestor of other, then the ancestor key becomes LCA ; Look for keys in left and right subtrees ; If both of the above calls return Non - NULL , then one key is present in once subtree and other is present in other , So this node is the LCA ; Otherwise check if left subtree or right subtree is LCA ; Driver program to test above function Let us create a binary tree given in the above example | 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 def findLCA ( root , n1 , n2 ) : NEW_LINE INDENT if root is None : NEW_LINE INDENT return None NEW_LINE DEDENT if root . key == n1 or root . key == n2 : NEW_LINE INDENT return root NEW_LINE DEDENT left_lca = findLCA ( root . left , n1 , n2 ) NEW_LINE right_lca = findLCA ( root . right , n1 , n2 ) NEW_LINE if left_lca and right_lca : NEW_LINE INDENT return root NEW_LINE DEDENT return left_lca if left_lca is not None else right_lca NEW_LINE DEDENT root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right . left = Node ( 6 ) NEW_LINE root . right . right = Node ( 7 ) NEW_LINE print " LCA ( 4,5 ) ▁ = ▁ " , findLCA ( root , 4 , 5 ) . key NEW_LINE print " LCA ( 4,6 ) ▁ = ▁ " , findLCA ( root , 4 , 6 ) . key NEW_LINE print " LCA ( 3,4 ) ▁ = ▁ " , findLCA ( root , 3 , 4 ) . key NEW_LINE print " LCA ( 2,4 ) ▁ = ▁ " , findLCA ( root , 2 , 4 ) . key NEW_LINE |
Lowest Common Ancestor in a Binary Tree | Set 1 | A binary tree node ; This function retturn pointer to LCA of two given values n1 and n2 v1 is set as true by this function if n1 is found v2 is set as true by this function if n2 is found ; Base Case ; IF either n1 or n2 matches ith root 's key, report the presence by setting v1 or v2 as true and return root (Note that if a key is ancestor of other, then the ancestor key becomes LCA) ; Look for keys in left and right subtree ; If both of the above calls return Non - NULL , then one key is present in once subtree and other is present in other , So this node is the LCA ; Otherwise check if left subtree or right subtree is LCA ; Returns true if key k is present in tree rooted with root ; This function returns LCA of n1 and n2 onlue if both n1 and n2 are present in tree , otherwise returns None ; Initialize n1 and n2 as not visited ; Find lac of n1 and n2 using the technique discussed above ; Returns LCA only if both n1 and n2 are present in tree ; Else return None ; Driver program to test above function | 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 def findLCAUtil ( root , n1 , n2 , v ) : NEW_LINE INDENT if root is None : NEW_LINE INDENT return None NEW_LINE DEDENT if root . key == n1 : NEW_LINE INDENT v [ 0 ] = True NEW_LINE return root NEW_LINE DEDENT if root . key == n2 : NEW_LINE INDENT v [ 1 ] = True NEW_LINE return root NEW_LINE DEDENT left_lca = findLCAUtil ( root . left , n1 , n2 , v ) NEW_LINE right_lca = findLCAUtil ( root . right , n1 , n2 , v ) NEW_LINE if left_lca and right_lca : NEW_LINE INDENT return root NEW_LINE DEDENT return left_lca if left_lca is not None else right_lca NEW_LINE DEDENT def find ( root , k ) : NEW_LINE INDENT if root is None : NEW_LINE INDENT return False NEW_LINE DEDENT if ( root . key == k or find ( root . left , k ) or find ( root . right , k ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT return False NEW_LINE DEDENT def findLCA ( root , n1 , n2 ) : NEW_LINE INDENT v = [ False , False ] NEW_LINE lca = findLCAUtil ( root , n1 , n2 , v ) NEW_LINE if ( v [ 0 ] and v [ 1 ] or v [ 0 ] and find ( lca , n2 ) or v [ 1 ] and find ( lca , n1 ) ) : NEW_LINE INDENT return lca NEW_LINE DEDENT return None NEW_LINE DEDENT root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right . left = Node ( 6 ) NEW_LINE root . right . right = Node ( 7 ) NEW_LINE lca = findLCA ( root , 4 , 5 ) NEW_LINE if lca is not None : NEW_LINE INDENT print " LCA ( 4 , ▁ 5 ) ▁ = ▁ " , lca . key NEW_LINE DEDENT else : NEW_LINE INDENT print " Keys ▁ are ▁ not ▁ present " NEW_LINE DEDENT lca = findLCA ( root , 4 , 10 ) NEW_LINE if lca is not None : NEW_LINE INDENT print " LCA ( 4,10 ) ▁ = ▁ " , lca . key NEW_LINE DEDENT else : NEW_LINE INDENT print " Keys ▁ are ▁ not ▁ present " NEW_LINE DEDENT |
Lowest Common Ancestor in a Binary Tree | Set 3 ( Using RMQ ) | Python code to find LCA of given two nodes in a tree ; the graph ; level of each node ; the segment tree ; adding edges to the graph ( tree ) ; assigning level to nodes ; storing the dfs traversal in the array e ; making the array l ; making the array h ; if is already stored ; Range minimum query to return the index of minimum in the subarray L [ qs : qe ] ; out of range ; in the range ; constructs the segment tree ; leaf ; Function to get LCA ; Driver Code ; n = number of nodes in the tree q = number of queries to answer ; 1 / | \ 2 3 4 | \ 5 6 / | \ 8 7 9 ( right of 5 ) / | \ | \ 10 11 12 13 14 | 15 | maxn = 100005 NEW_LINE g = [ [ ] for i in range ( maxn ) ] NEW_LINE level = [ 0 ] * maxn NEW_LINE e = [ ] NEW_LINE l = [ ] NEW_LINE h = [ 0 ] * maxn NEW_LINE st = [ 0 ] * ( 5 * maxn ) NEW_LINE def add_edge ( u : int , v : int ) : NEW_LINE INDENT g [ u ] . append ( v ) NEW_LINE g [ v ] . append ( u ) NEW_LINE DEDENT def leveling ( src : int ) : NEW_LINE INDENT for i in range ( len ( g [ src ] ) ) : NEW_LINE INDENT des = g [ src ] [ i ] NEW_LINE if not level [ des ] : NEW_LINE INDENT level [ des ] = level [ src ] + 1 NEW_LINE leveling ( des ) NEW_LINE DEDENT DEDENT DEDENT visited = [ False ] * maxn NEW_LINE def dfs ( src : int ) : NEW_LINE INDENT e . append ( src ) NEW_LINE visited [ src ] = True NEW_LINE for i in range ( len ( g [ src ] ) ) : NEW_LINE INDENT des = g [ src ] [ i ] NEW_LINE if not visited [ des ] : NEW_LINE INDENT dfs ( des ) NEW_LINE e . append ( src ) NEW_LINE DEDENT DEDENT DEDENT def setting_l ( n : int ) : NEW_LINE INDENT for i in range ( len ( e ) ) : NEW_LINE INDENT l . append ( level [ e [ i ] ] ) NEW_LINE DEDENT DEDENT def setting_h ( n : int ) : NEW_LINE INDENT for i in range ( n + 1 ) : NEW_LINE INDENT h [ i ] = - 1 NEW_LINE DEDENT for i in range ( len ( e ) ) : NEW_LINE INDENT if h [ e [ i ] ] == - 1 : NEW_LINE INDENT h [ e [ i ] ] = i NEW_LINE DEDENT DEDENT DEDENT def RMQ ( ss : int , se : int , qs : int , qe : int , i : int ) -> int : NEW_LINE INDENT global st NEW_LINE if ss > se : NEW_LINE INDENT return - 1 NEW_LINE DEDENT if se < qs or qe < ss : NEW_LINE INDENT return - 1 NEW_LINE DEDENT if qs <= ss and se <= qe : NEW_LINE INDENT return st [ i ] NEW_LINE DEDENT mid = ( se + ss ) >> 1 NEW_LINE stt = RMQ ( ss , mid , qs , qe , 2 * i + 1 ) NEW_LINE en = RMQ ( mid + 1 , se , qs , qe , 2 * i + 2 ) NEW_LINE if stt != - 1 and en != - 1 : NEW_LINE INDENT if l [ stt ] < l [ en ] : NEW_LINE INDENT return stt NEW_LINE DEDENT return en NEW_LINE DEDENT elif stt != - 1 : NEW_LINE INDENT return stt NEW_LINE DEDENT elif en != - 1 : NEW_LINE INDENT return en NEW_LINE DEDENT DEDENT def segmentTreeConstruction ( ss : int , se : int , i : int ) : NEW_LINE INDENT if ss > se : NEW_LINE INDENT return NEW_LINE DEDENT if ss == se : NEW_LINE INDENT st [ i ] = ss NEW_LINE return NEW_LINE DEDENT mid = ( ss + se ) >> 1 NEW_LINE segmentTreeConstruction ( ss , mid , 2 * i + 1 ) NEW_LINE segmentTreeConstruction ( mid + 1 , se , 2 * i + 2 ) NEW_LINE if l [ st [ 2 * i + 1 ] ] < l [ st [ 2 * i + 2 ] ] : NEW_LINE INDENT st [ i ] = st [ 2 * i + 1 ] NEW_LINE DEDENT else : NEW_LINE INDENT st [ i ] = st [ 2 * i + 2 ] NEW_LINE DEDENT DEDENT def LCA ( x : int , y : int ) -> int : NEW_LINE INDENT if h [ x ] > h [ y ] : NEW_LINE INDENT x , y = y , x NEW_LINE DEDENT return e [ RMQ ( 0 , len ( l ) - 1 , h [ x ] , h [ y ] , 0 ) ] NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT n = 15 NEW_LINE q = 5 NEW_LINE add_edge ( 1 , 2 ) NEW_LINE add_edge ( 1 , 3 ) NEW_LINE add_edge ( 1 , 4 ) NEW_LINE add_edge ( 3 , 5 ) NEW_LINE add_edge ( 4 , 6 ) NEW_LINE add_edge ( 5 , 7 ) NEW_LINE add_edge ( 5 , 8 ) NEW_LINE add_edge ( 5 , 9 ) NEW_LINE add_edge ( 7 , 10 ) NEW_LINE add_edge ( 7 , 11 ) NEW_LINE add_edge ( 7 , 12 ) NEW_LINE add_edge ( 9 , 13 ) NEW_LINE add_edge ( 9 , 14 ) NEW_LINE add_edge ( 12 , 15 ) NEW_LINE level [ 1 ] = 1 NEW_LINE leveling ( 1 ) NEW_LINE dfs ( 1 ) NEW_LINE setting_l ( n ) NEW_LINE setting_h ( n ) NEW_LINE segmentTreeConstruction ( 0 , len ( l ) - 1 , 0 ) NEW_LINE print ( LCA ( 10 , 15 ) ) NEW_LINE print ( LCA ( 11 , 14 ) ) NEW_LINE DEDENT |
Print common nodes on path from root ( or common ancestors ) | Utility class to create a new tree Node ; Utility function to find the LCA of two given values n1 and n2 . ; Base case ; If either n1 or n2 matches with root 's key, report the presence by returning root (Note that if a key is ancestor of other, then the ancestor key becomes LCA ; Look for keys in left and right subtrees ; If both of the above calls return Non - None , then one key is present in once subtree and other is present in other , So this node is the LCA ; Otherwise check if left subtree or right subtree is LCA ; Utility Function to print all ancestors of LCA ; base cases ; If target is present in either left or right subtree of this node , then prthis node ; Else return False ; Function to find nodes common to given two nodes ; Driver Code ; Let us create binary tree given in the above example | class newNode : NEW_LINE INDENT def __init__ ( self , key ) : NEW_LINE INDENT self . key = key NEW_LINE self . left = self . right = None NEW_LINE DEDENT DEDENT def findLCA ( root , n1 , n2 ) : NEW_LINE INDENT if ( root == None ) : NEW_LINE INDENT return None NEW_LINE DEDENT if ( root . key == n1 or root . key == n2 ) : NEW_LINE INDENT return root NEW_LINE DEDENT left_lca = findLCA ( root . left , n1 , n2 ) NEW_LINE right_lca = findLCA ( root . right , n1 , n2 ) NEW_LINE if ( left_lca and right_lca ) : NEW_LINE INDENT return root NEW_LINE DEDENT if ( left_lca != None ) : NEW_LINE INDENT return left_lca NEW_LINE DEDENT else : NEW_LINE INDENT return right_lca NEW_LINE DEDENT DEDENT def printAncestors ( root , target ) : NEW_LINE INDENT if ( root == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( root . key == target ) : NEW_LINE INDENT print ( root . key , end = " ▁ " ) NEW_LINE return True NEW_LINE DEDENT if ( printAncestors ( root . left , target ) or printAncestors ( root . right , target ) ) : NEW_LINE INDENT print ( root . key , end = " ▁ " ) NEW_LINE return True NEW_LINE DEDENT return False NEW_LINE DEDENT def findCommonNodes ( root , first , second ) : NEW_LINE INDENT LCA = findLCA ( root , first , second ) NEW_LINE if ( LCA == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT printAncestors ( root , LCA . key ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root = newNode ( 1 ) NEW_LINE root . left = newNode ( 2 ) NEW_LINE root . right = newNode ( 3 ) NEW_LINE root . left . left = newNode ( 4 ) NEW_LINE root . left . right = newNode ( 5 ) NEW_LINE root . right . left = newNode ( 6 ) NEW_LINE root . right . right = newNode ( 7 ) NEW_LINE root . left . left . left = newNode ( 8 ) NEW_LINE root . right . left . left = newNode ( 9 ) NEW_LINE root . right . left . right = newNode ( 10 ) NEW_LINE if ( findCommonNodes ( root , 9 , 7 ) == False ) : NEW_LINE INDENT print ( " No ▁ Common ▁ nodes " ) NEW_LINE DEDENT DEDENT |
Binary Tree | Set 1 ( Introduction ) | A Python class that represents an individual node in a Binary Tree | class Node : NEW_LINE INDENT def __init__ ( self , key ) : NEW_LINE INDENT self . left = None NEW_LINE self . right = None NEW_LINE self . val = key NEW_LINE DEDENT DEDENT |
Maximum difference between node and its ancestor in Binary Tree | Python3 program to find maximum difference between node and its ancestor ; Helper function that allocates a new node with the given data and None left and right poers . ; Recursive function to calculate maximum ancestor - node difference in binary tree . It updates value at ' res ' to store the result . The returned value of this function is minimum value in subtree rooted with ' t ' ; Returning Maximum value if node is not there ( one child case ) ; If leaf node then just return node 's value ; Recursively calling left and right subtree for minimum value ; Updating res if ( node value - minimum value from subtree ) is bigger than res ; Returning minimum value got so far ; This function mainly calls maxDiffUtil ( ) ; Initialising result with minimum value ; Helper function to print inorder traversal of binary tree ; Driver Code ; Let us create Binary Tree shown in above example | _MIN = - 2147483648 NEW_LINE _MAX = 2147483648 NEW_LINE class newNode : 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 def maxDiffUtil ( t , res ) : NEW_LINE INDENT if ( t == None ) : NEW_LINE INDENT return _MAX , res NEW_LINE DEDENT if ( t . left == None and t . right == None ) : NEW_LINE INDENT return t . key , res NEW_LINE DEDENT a , res = maxDiffUtil ( t . left , res ) NEW_LINE b , res = maxDiffUtil ( t . right , res ) NEW_LINE val = min ( a , b ) NEW_LINE res = max ( res , t . key - val ) NEW_LINE return min ( val , t . key ) , res NEW_LINE DEDENT def maxDiff ( root ) : NEW_LINE INDENT res = _MIN NEW_LINE x , res = maxDiffUtil ( root , res ) NEW_LINE return res NEW_LINE DEDENT def inorder ( root ) : NEW_LINE INDENT if ( root ) : NEW_LINE INDENT inorder ( root . left ) NEW_LINE prf ( " % d ▁ " , root . key ) NEW_LINE inorder ( root . right ) NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root = newNode ( 8 ) NEW_LINE root . left = newNode ( 3 ) NEW_LINE root . left . left = newNode ( 1 ) NEW_LINE root . left . right = newNode ( 6 ) NEW_LINE root . left . right . left = newNode ( 4 ) NEW_LINE root . left . right . right = newNode ( 7 ) NEW_LINE root . right = newNode ( 10 ) NEW_LINE root . right . right = newNode ( 14 ) NEW_LINE root . right . right . left = newNode ( 13 ) NEW_LINE print ( " Maximum ▁ difference ▁ between ▁ a ▁ node ▁ and " , " its ▁ ancestor ▁ is ▁ : " , maxDiff ( root ) ) NEW_LINE DEDENT |
Print the path common to the two paths from the root to the two given nodes | Initialize n1 and n2 as not visited ; structure of a node of binary tree ; This function returns pointer to LCA of two given values n1 and n2 . v1 is set as True by this function if n1 is found v2 is set as True by this function if n2 is found ; Base case ; If either n1 or n2 matches with root 's data, report the presence by setting v1 or v2 as True and return root (Note that if a key is ancestor of other, then the ancestor key becomes LCA) ; Look for nodes in left and right subtrees ; If both of the above calls return Non - None , then one node is present in one subtree and other is present in other , So this current node is the LCA ; Otherwise check if left subtree or right subtree is LCA ; Returns True if key k is present in tree rooted with root ; Base Case ; If key k is present at root , or in left subtree or right subtree , return True ; Else return False ; This function returns LCA of n1 and n2 only if both n1 and n2 are present in tree , otherwise returns None ; Find lca of n1 and n2 ; Return LCA only if both n1 and n2 are present in tree ; Else return None ; function returns True if there is a path from root to the given node . It also populates arr ' with the given path ; if root is None there is no path ; push the node ' s ▁ value ▁ in ▁ ' arr ; if it is the required node return True ; else check whether there the required node lies in the left subtree or right subtree of the current node ; required node does not lie either in the left or right subtree of the current node Thus , remove current node ' s ▁ value ▁ from ▁ ' arr ' and then return False; ; function to print the path common to the two paths from the root to the two given nodes if the nodes lie in the binary tree ; vector to store the common path ; LCA of node n1 and n2 ; if LCA of both n1 and n2 exists ; then print the path from root to LCA node ; LCA is not present in the binary tree either n1 or n2 or both are not present ; Driver Code | v1 = False NEW_LINE INDENT v2 = False NEW_LINE DEDENT class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def findLCAUtil ( root : Node , n1 : int , n2 : int ) -> Node : NEW_LINE INDENT global v1 , v2 NEW_LINE if ( root is None ) : NEW_LINE INDENT return None NEW_LINE DEDENT if ( root . data == n1 ) : NEW_LINE INDENT v1 = True NEW_LINE return root NEW_LINE DEDENT if ( root . data == n2 ) : NEW_LINE INDENT v2 = True NEW_LINE return root NEW_LINE DEDENT left_lca = findLCAUtil ( root . left , n1 , n2 ) NEW_LINE right_lca = findLCAUtil ( root . right , n1 , n2 ) NEW_LINE if ( left_lca and right_lca ) : NEW_LINE INDENT return root NEW_LINE DEDENT return left_lca if ( left_lca != None ) else right_lca NEW_LINE DEDENT def find ( root : Node , k : int ) -> bool : NEW_LINE INDENT if ( root == None ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( root . data == k or find ( root . left , k ) or find ( root . right , k ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT return False NEW_LINE DEDENT def findLCA ( root : Node , n1 : int , n2 : int ) -> Node : NEW_LINE INDENT global v1 , v2 NEW_LINE lca = findLCAUtil ( root , n1 , n2 ) NEW_LINE if ( v1 and v2 or v1 and find ( lca , n2 ) or v2 and find ( lca , n1 ) ) : NEW_LINE INDENT return lca NEW_LINE DEDENT return None NEW_LINE DEDENT def hasPath ( root : Node , arr : list , x : int ) -> Node : NEW_LINE INDENT if ( root is None ) : NEW_LINE INDENT return False NEW_LINE DEDENT arr . append ( root . data ) NEW_LINE if ( root . data == x ) : NEW_LINE INDENT return True NEW_LINE DEDENT if ( hasPath ( root . left , arr , x ) or hasPath ( root . right , arr , x ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT arr . pop ( ) NEW_LINE return False NEW_LINE DEDENT def printCommonPath ( root : Node , n1 : int , n2 : int ) : NEW_LINE INDENT arr = [ ] NEW_LINE lca = findLCA ( root , n1 , n2 ) NEW_LINE if ( lca ) : NEW_LINE INDENT if ( hasPath ( root , arr , lca . data ) ) : NEW_LINE INDENT for i in range ( len ( arr ) - 1 ) : NEW_LINE INDENT print ( arr [ i ] , end = " - > " ) NEW_LINE DEDENT print ( arr [ - 1 ] ) NEW_LINE DEDENT DEDENT else : NEW_LINE INDENT print ( " No ▁ Common ▁ Path " ) NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT v1 = 0 NEW_LINE v2 = 0 NEW_LINE root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . right . left = Node ( 6 ) NEW_LINE root . right . right = Node ( 7 ) NEW_LINE root . left . right . left = Node ( 8 ) NEW_LINE root . right . left . right = Node ( 9 ) NEW_LINE n1 = 4 NEW_LINE n2 = 8 NEW_LINE printCommonPath ( root , n1 , n2 ) NEW_LINE DEDENT |
Query for ancestor | Python program to query whether two node has ancestor - descendant relationship or not ; Utility dfs method to assign in and out time to each node ; assign In - time to node u ; call dfs over all neighbors except parent ; assign Out - time to node u ; method to preprocess all nodes for assigning time ; construct array of vector data structure for tree ; call dfs method from root ; method returns " yes " if u is a ancestor node of v ; Driver Code | cnt = 0 NEW_LINE def dfs ( g : list , u : int , parent : int , timeIn : list , timeOut : list ) : NEW_LINE INDENT global cnt NEW_LINE timeIn [ u ] = cnt NEW_LINE cnt += 1 NEW_LINE for i in range ( len ( g [ u ] ) ) : NEW_LINE INDENT v = g [ u ] [ i ] NEW_LINE if v != parent : NEW_LINE INDENT dfs ( g , v , u , timeIn , timeOut ) NEW_LINE DEDENT DEDENT timeOut [ u ] = cnt NEW_LINE cnt += 1 NEW_LINE DEDENT def preProcess ( edges : list , V : int , timeIn : list , timeOut : list ) : NEW_LINE INDENT global cnt NEW_LINE g = [ [ ] for i in range ( V ) ] NEW_LINE for i in range ( V - 1 ) : NEW_LINE INDENT u = edges [ i ] [ 0 ] NEW_LINE v = edges [ i ] [ 1 ] NEW_LINE g [ u ] . append ( v ) NEW_LINE g [ v ] . append ( u ) NEW_LINE DEDENT cnt = 0 NEW_LINE dfs ( g , 0 , - 1 , timeIn , timeOut ) NEW_LINE DEDENT def isAncestor ( u : int , v : int , timeIn : list , timeOut : list ) -> str : NEW_LINE INDENT b = timeIn [ u ] <= timeIn [ u ] and timeOut [ v ] <= timeOut [ u ] NEW_LINE return " yes " if b else " no " NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT edges = [ ( 0 , 1 ) , ( 0 , 2 ) , ( 1 , 3 ) , ( 1 , 4 ) , ( 2 , 5 ) , ( 4 , 6 ) , ( 5 , 7 ) ] NEW_LINE E = len ( edges ) NEW_LINE V = E + 1 NEW_LINE timeIn = [ 0 ] * V NEW_LINE timeOut = [ 0 ] * V NEW_LINE preProcess ( edges , V , timeIn , timeOut ) NEW_LINE u = 1 NEW_LINE v = 6 NEW_LINE print ( isAncestor ( u , v , timeIn , timeOut ) ) NEW_LINE u = 1 NEW_LINE v = 7 NEW_LINE print ( isAncestor ( u , v , timeIn , timeOut ) ) NEW_LINE DEDENT |
Print path from root to a given node in a binary tree | Helper Class that allocates a new node with the given data and None left and right pointers . ; Returns true if there is a path from root to the given node . It also populates ' arr ' with the given path ; if root is None there is no path ; push the node ' s ▁ value ▁ in ▁ ' arr ' ; if it is the required node return true ; else check whether the required node lies in the left subtree or right subtree of the current node ; required node does not lie either in the left or right subtree of the current node . Thus , remove current node ' s ▁ value ▁ ▁ ▁ from ▁ ' arr 'and then return false ; function to print the path from root to the given node if the node lies in the binary tree ; vector to store the path ; if required node ' x ' is present then print the path ; ' x ' is not present in the binary tree ; Driver Code ; binary tree formation | class getNode : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = self . right = None NEW_LINE DEDENT DEDENT def hasPath ( root , arr , x ) : NEW_LINE INDENT if ( not root ) : NEW_LINE INDENT return False NEW_LINE DEDENT arr . append ( root . data ) NEW_LINE if ( root . data == x ) : NEW_LINE INDENT return True NEW_LINE DEDENT if ( hasPath ( root . left , arr , x ) or hasPath ( root . right , arr , x ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT arr . pop ( - 1 ) NEW_LINE return False NEW_LINE DEDENT def printPath ( root , x ) : NEW_LINE INDENT arr = [ ] NEW_LINE if ( hasPath ( root , arr , x ) ) : NEW_LINE INDENT for i in range ( len ( arr ) - 1 ) : NEW_LINE INDENT print ( arr [ i ] , end = " - > " ) NEW_LINE DEDENT print ( arr [ len ( arr ) - 1 ] ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No ▁ Path " ) NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root = getNode ( 1 ) NEW_LINE root . left = getNode ( 2 ) NEW_LINE root . right = getNode ( 3 ) NEW_LINE root . left . left = getNode ( 4 ) NEW_LINE root . left . right = getNode ( 5 ) NEW_LINE root . right . left = getNode ( 6 ) NEW_LINE root . right . right = getNode ( 7 ) NEW_LINE x = 5 NEW_LINE printPath ( root , x ) NEW_LINE DEDENT |
Print Ancestors of a given node in Binary Tree | A Binary Tree node ; If target is present in tree , then prints the ancestors and returns true , otherwise returns false ; Base case ; If target is present in either left or right subtree of this node , then print this node ; Else return False ; Construct the following binary tree 1 / \ 2 3 / \ 4 5 / 7 | class Node : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def printAncestors ( root , target ) : NEW_LINE INDENT if root == None : NEW_LINE INDENT return False NEW_LINE DEDENT if root . data == target : NEW_LINE INDENT return True NEW_LINE DEDENT if ( printAncestors ( root . left , target ) or printAncestors ( root . right , target ) ) : NEW_LINE INDENT print root . data , NEW_LINE return True NEW_LINE DEDENT return False NEW_LINE DEDENT root = Node ( 1 ) NEW_LINE root . left = Node ( 2 ) NEW_LINE root . right = Node ( 3 ) NEW_LINE root . left . left = Node ( 4 ) NEW_LINE root . left . right = Node ( 5 ) NEW_LINE root . left . left . left = Node ( 7 ) NEW_LINE printAncestors ( root , 7 ) NEW_LINE |
Kth ancestor of a node in binary tree | Set 2 | A Binary Tree Node ; recursive function to calculate Kth ancestor ; Base case ; print the kth ancestor ; return None to stop further backtracking ; return current node to previous call ; Driver Code ; prkth ancestor of given node ; check if parent is not None , it means there is no Kth ancestor of the node | class newNode : NEW_LINE INDENT def __init__ ( self , data ) : NEW_LINE INDENT self . data = data NEW_LINE self . left = None NEW_LINE self . right = None NEW_LINE DEDENT DEDENT def kthAncestorDFS ( root , node , k ) : NEW_LINE INDENT if ( not root ) : NEW_LINE INDENT return None NEW_LINE DEDENT if ( root . data == node or ( kthAncestorDFS ( root . left , node , k ) ) or ( kthAncestorDFS ( root . right , node , k ) ) ) : NEW_LINE INDENT if ( k [ 0 ] > 0 ) : NEW_LINE INDENT k [ 0 ] -= 1 NEW_LINE DEDENT elif ( k [ 0 ] == 0 ) : NEW_LINE INDENT print ( " Kth ▁ ancestor ▁ is : " , root . data ) NEW_LINE return None NEW_LINE DEDENT return root NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT root = newNode ( 1 ) NEW_LINE root . left = newNode ( 2 ) NEW_LINE root . right = newNode ( 3 ) NEW_LINE root . left . left = newNode ( 4 ) NEW_LINE root . left . right = newNode ( 5 ) NEW_LINE k = [ 2 ] NEW_LINE node = 5 NEW_LINE parent = kthAncestorDFS ( root , node , k ) NEW_LINE if ( parent ) : NEW_LINE INDENT print ( " - 1" ) NEW_LINE DEDENT DEDENT |
Succinct Encoding of Binary Tree | Node structure ; This function fills lists ' struc ' and ' data ' . ' struc ' list stores structure information . ' data ' list stores tree data ; If root is None , put 0 in structure array and return ; Else place 1 in structure array , key in ' data ' array and recur for left and right children ; Constructs tree from ' struc ' and 'data ; Remove one item from structure list ; If removed bit is 1 ; Remove an item from data list ; Create a tree node with removed data ; And recur to create left and right subtrees ; A utility function to print tree ; Let us conthe Tree shown in the above figure ; Structure iterator ; Data iterator | 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 def EncodeSuccint ( root , struc , data ) : NEW_LINE INDENT if root is None : NEW_LINE INDENT struc . append ( 0 ) NEW_LINE return NEW_LINE DEDENT struc . append ( 1 ) NEW_LINE data . append ( root . key ) NEW_LINE EncodeSuccint ( root . left , struc , data ) NEW_LINE EncodeSuccint ( root . right , struc , data ) NEW_LINE DEDENT def DecodeSuccinct ( struc , data ) : NEW_LINE INDENT if ( len ( struc ) <= 0 ) : NEW_LINE INDENT return None NEW_LINE DEDENT b = struc [ 0 ] NEW_LINE struc . pop ( 0 ) NEW_LINE if b == 1 : NEW_LINE INDENT key = data [ 0 ] NEW_LINE data . pop ( 0 ) NEW_LINE root = Node ( key ) NEW_LINE root . left = DecodeSuccinct ( struc , data ) ; NEW_LINE root . right = DecodeSuccinct ( struc , data ) ; NEW_LINE return root NEW_LINE DEDENT return None NEW_LINE DEDENT def preorder ( root ) : NEW_LINE INDENT if root is not None : NEW_LINE INDENT print " key : ▁ % d " % ( root . key ) , NEW_LINE if root . left is not None : NEW_LINE INDENT print " | ▁ left ▁ child : ▁ % d " % ( root . left . key ) , NEW_LINE DEDENT if root . right is not None : NEW_LINE INDENT print " | ▁ right ▁ child ▁ % d " % ( root . right . key ) , NEW_LINE DEDENT print " " NEW_LINE preorder ( root . left ) NEW_LINE preorder ( root . right ) NEW_LINE DEDENT DEDENT root = Node ( 10 ) NEW_LINE root . left = Node ( 20 ) NEW_LINE root . right = Node ( 30 ) NEW_LINE root . left . left = Node ( 40 ) NEW_LINE root . left . right = Node ( 50 ) NEW_LINE root . right . right = Node ( 70 ) NEW_LINE print " Given ▁ Tree " NEW_LINE preorder ( root ) NEW_LINE struc = [ ] NEW_LINE data = [ ] NEW_LINE EncodeSuccint ( root , struc , data ) NEW_LINE print " NEW_LINE Encoded Tree " NEW_LINE print " Structure ▁ List " NEW_LINE for i in struc : NEW_LINE INDENT print i , NEW_LINE DEDENT print " NEW_LINE DataList " NEW_LINE for value in data : NEW_LINE INDENT print value , NEW_LINE DEDENT newroot = DecodeSuccinct ( struc , data ) NEW_LINE print " NEW_LINE Preorder Traversal of decoded tree " NEW_LINE preorder ( newroot ) NEW_LINE |
Binary Indexed Tree : Range Updates and Point Queries | Updates such that getElement ( ) gets an increased value when queried from l to r . ; Get the element indexed at i ; To get ith element sum of all the elements from 0 to i need to be computed ; Driver Code ; Find the element at Index 4 ; Find the element at Index 3 | def update ( arr , l , r , val ) : NEW_LINE INDENT arr [ l ] += val NEW_LINE if r + 1 < len ( arr ) : NEW_LINE INDENT arr [ r + 1 ] -= val NEW_LINE DEDENT DEDENT def getElement ( arr , i ) : NEW_LINE INDENT res = 0 NEW_LINE for j in range ( i + 1 ) : NEW_LINE INDENT res += arr [ j ] NEW_LINE DEDENT return res NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 0 , 0 , 0 , 0 , 0 ] NEW_LINE n = len ( arr ) NEW_LINE l = 2 NEW_LINE r = 4 NEW_LINE val = 2 NEW_LINE update ( arr , l , r , val ) NEW_LINE index = 4 NEW_LINE print ( " Element ▁ at ▁ index " , index , " is " , getElement ( arr , index ) ) NEW_LINE l = 0 NEW_LINE r = 3 NEW_LINE val = 4 NEW_LINE update ( arr , l , r , val ) NEW_LINE index = 3 NEW_LINE print ( " Element ▁ at ▁ index " , index , " is " , getElement ( arr , index ) ) NEW_LINE DEDENT |
Binary Indexed Tree : Range Updates and Point Queries | Updates a node in Binary Index Tree ( BITree ) at given index in BITree . The given value ' val ' is added to BITree [ i ] and all of its ancestors in tree . ; index in BITree [ ] is 1 more than the index in arr [ ] ; Traverse all ancestors and add 'val ; Add ' val ' to current node of BI Tree ; Update index to that of parent in update View ; Constructs and returns a Binary Indexed Tree for given array of size n . ; Create and initialize BITree [ ] as 0 ; Store the actual values in BITree [ ] using update ( ) ; SERVES THE PURPOSE OF getElement ( ) Returns sum of arr [ 0. . index ] . This function assumes that the array is preprocessed and partial sums of array elements are stored in BITree [ ] ; Iniialize result ; index in BITree [ ] is 1 more than the index in arr [ ] ; Traverse ancestors of BITree [ index ] ; Add current element of BITree to sum ; Move index to parent node in getSum View ; Return the sum ; Updates such that getElement ( ) gets an increased value when queried from l to r . ; Increase value at ' l ' by 'val ; Decrease value at ' r + 1' by 'val ; Driver code ; Add 2 to all the element from [ 2 , 4 ] ; Find the element at Index 4 ; Add 2 to all the element from [ 0 , 3 ] ; Find the element at Index 3 | def updateBIT ( BITree , n , index , val ) : NEW_LINE INDENT index = index + 1 NEW_LINE while ( index <= n ) : NEW_LINE INDENT BITree [ index ] += val NEW_LINE index += index & ( - index ) NEW_LINE DEDENT DEDENT def constructBITree ( arr , n ) : NEW_LINE INDENT BITree = [ 0 ] * ( n + 1 ) NEW_LINE for i in range ( n ) : NEW_LINE INDENT updateBIT ( BITree , n , i , arr [ i ] ) NEW_LINE DEDENT return BITree NEW_LINE DEDENT def getSum ( BITree , index ) : NEW_LINE INDENT sum = 0 NEW_LINE index = index + 1 NEW_LINE while ( index > 0 ) : NEW_LINE INDENT sum += BITree [ index ] NEW_LINE index -= index & ( - index ) NEW_LINE DEDENT return sum NEW_LINE DEDENT def update ( BITree , l , r , n , val ) : NEW_LINE INDENT updateBIT ( BITree , n , l , val ) NEW_LINE updateBIT ( BITree , n , r + 1 , - val ) NEW_LINE DEDENT arr = [ 0 , 0 , 0 , 0 , 0 ] NEW_LINE n = len ( arr ) NEW_LINE BITree = constructBITree ( arr , n ) NEW_LINE l = 2 NEW_LINE r = 4 NEW_LINE val = 2 NEW_LINE update ( BITree , l , r , n , val ) NEW_LINE index = 4 NEW_LINE print ( " Element ▁ at ▁ index " , index , " is " , getSum ( BITree , index ) ) NEW_LINE l = 0 NEW_LINE r = 3 NEW_LINE val = 4 NEW_LINE update ( BITree , l , r , n , val ) NEW_LINE index = 3 NEW_LINE print ( " Element ▁ at ▁ index " , index , " is " , getSum ( BITree , index ) ) NEW_LINE |
Print Postorder traversal from given Inorder and Preorder traversals | Python3 program to prPostorder traversal from given Inorder and Preorder traversals . ; Find index of next item in preorder traversal in inorder . ; traverse left tree ; traverse right tree ; prroot node at the end of traversal ; Driver code | def printPost ( inn , pre , inStrt , inEnd ) : NEW_LINE INDENT global preIndex , hm NEW_LINE if ( inStrt > inEnd ) : NEW_LINE INDENT return NEW_LINE DEDENT inIndex = hm [ pre [ preIndex ] ] NEW_LINE preIndex += 1 NEW_LINE printPost ( inn , pre , inStrt , inIndex - 1 ) NEW_LINE printPost ( inn , pre , inIndex + 1 , inEnd ) NEW_LINE print ( inn [ inIndex ] , end = " ▁ " ) NEW_LINE DEDENT def printPostMain ( inn , pre , n ) : NEW_LINE INDENT for i in range ( n ) : NEW_LINE INDENT hm [ inn [ i ] ] = i NEW_LINE DEDENT printPost ( inn , pre , 0 , n - 1 ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT hm = { } NEW_LINE preIndex = 0 NEW_LINE inn = [ 4 , 2 , 5 , 1 , 3 , 6 ] NEW_LINE pre = [ 1 , 2 , 4 , 5 , 3 , 6 ] NEW_LINE n = len ( pre ) NEW_LINE printPostMain ( inn , pre , n ) NEW_LINE DEDENT |
Coordinates of the last cell in a Matrix on which performing given operations exits from the Matrix | Function to check if the indices ( i , j ) are valid indices in a Matrix or not ; Cases for invalid cells ; Return true if valid ; Function to find indices of cells of a matrix from which traversal leads to out of the matrix ; Starting from cell ( 0 , 0 ) , traverse in right direction ; Stores direction changes ; Iterate until the current cell exceeds beyond the matrix ; Current index ; If the current cell is 1 ; Update arr [ i ] [ j ] = 0 ; Update indices according to the direction ; Otherwise ; Update indices according to the direction ; The exit cooridnates ; Number of rows ; Number of columns ; Given matrix arr [ ] [ ] | def issafe ( m , n , i , j ) : NEW_LINE INDENT if i < 0 : NEW_LINE INDENT return False NEW_LINE DEDENT if j < 0 : NEW_LINE INDENT return False NEW_LINE DEDENT if i >= m : NEW_LINE INDENT return False NEW_LINE DEDENT if j >= n : NEW_LINE INDENT return False NEW_LINE DEDENT return True NEW_LINE DEDENT def endpoints ( arr , m , n ) : NEW_LINE INDENT i = 0 NEW_LINE j = 0 NEW_LINE current_d = ' r ' NEW_LINE rcd = { ' l ' : ' u ' , ' u ' : ' r ' , ' r ' : ' d ' , ' d ' : ' l ' } NEW_LINE while issafe ( m , n , i , j ) : NEW_LINE INDENT current_i = i NEW_LINE current_j = j NEW_LINE if arr [ i ] [ j ] == 1 : NEW_LINE INDENT move_in = rcd [ current_d ] NEW_LINE arr [ i ] [ j ] = 0 NEW_LINE if move_in == ' u ' : NEW_LINE INDENT i -= 1 NEW_LINE DEDENT elif move_in == ' d ' : NEW_LINE INDENT i += 1 NEW_LINE DEDENT elif move_in == ' l ' : NEW_LINE INDENT j -= 1 NEW_LINE DEDENT elif move_in == ' r ' : NEW_LINE INDENT j += 1 NEW_LINE DEDENT current_d = move_in NEW_LINE DEDENT else : NEW_LINE INDENT if current_d == ' u ' : NEW_LINE INDENT i -= 1 NEW_LINE DEDENT elif current_d == ' d ' : NEW_LINE INDENT i += 1 NEW_LINE DEDENT elif current_d == ' l ' : NEW_LINE INDENT j -= 1 NEW_LINE DEDENT elif current_d == ' r ' : NEW_LINE INDENT j += 1 NEW_LINE DEDENT DEDENT DEDENT return ( current_i , current_j ) NEW_LINE DEDENT M = 3 NEW_LINE N = 5 NEW_LINE arr = [ [ 0 , 1 , 1 , 1 , 0 ] , [ 1 , 0 , 1 , 0 , 1 ] , [ 1 , 1 , 1 , 0 , 0 ] , ] NEW_LINE print ( endpoints ( arr , M , N ) ) NEW_LINE |
Check if a number can be represented as sum of two positive perfect cubes | Function to check if N can be represented as sum of two perfect cubes or not ; Stores the perfect cubes of first N natural numbers ; Traverse the map ; Stores first number ; Stores second number ; Search the pair for the first number to obtain sum N from the Map ; If N cannot be represented as sum of two positive perfect cubes ; Function call to check if N can be represented as sum of two perfect cubes or not | def sumOfTwoPerfectCubes ( N ) : NEW_LINE INDENT cubes = { } NEW_LINE i = 1 NEW_LINE while i * i * i <= N : NEW_LINE INDENT cubes [ i * i * i ] = i NEW_LINE i += 1 NEW_LINE DEDENT for itr in cubes : NEW_LINE INDENT firstNumber = itr NEW_LINE secondNumber = N - itr NEW_LINE if secondNumber in cubes : NEW_LINE INDENT print ( " True " , end = " " ) NEW_LINE return NEW_LINE DEDENT DEDENT print ( " False " , end = " " ) NEW_LINE DEDENT N = 28 NEW_LINE sumOfTwoPerfectCubes ( N ) NEW_LINE |
Count subsets consisting of each element as a factor of the next element in that subset | Function to find number of subsets satisfying the given condition ; Stores number of required sets ; Stores maximum element of arr [ ] that defines the size of sieve ; Iterate through the arr [ ] ; If current element > maxE , then update maxE ; Declare an array sieve of size N + 1 ; Mark all elements corresponding in the array , by one as there will always exists a singleton set ; Iterate from range [ 1 , N ] ; If element is present in array ; Traverse through all its multiples <= n ; Update them if they are present in array ; Iterate from the range [ 1 , N ] ; Update the value of cnt ; Prthe result ; Driver Code ; Function Call | def countSets ( arr , n ) : NEW_LINE INDENT cnt = 0 NEW_LINE maxE = - 1 NEW_LINE for i in range ( n ) : NEW_LINE INDENT if ( maxE < arr [ i ] ) : NEW_LINE INDENT maxE = arr [ i ] NEW_LINE DEDENT DEDENT sieve = [ 0 ] * ( maxE + 1 ) NEW_LINE for i in range ( n ) : NEW_LINE INDENT sieve [ arr [ i ] ] = 1 NEW_LINE DEDENT for i in range ( 1 , maxE + 1 ) : NEW_LINE INDENT if ( sieve [ i ] != 0 ) : NEW_LINE INDENT for j in range ( i * 2 , maxE + 1 , i ) : NEW_LINE INDENT if ( sieve [ j ] != 0 ) : NEW_LINE INDENT sieve [ j ] = ( sieve [ j ] + sieve [ i ] ) % 1000000007 NEW_LINE DEDENT DEDENT DEDENT DEDENT for i in range ( maxE + 1 ) : NEW_LINE INDENT cnt = ( cnt % 1000000007 + sieve [ i ] % 1000000007 ) % 1000000007 NEW_LINE DEDENT print ( cnt % 1000000007 ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 16 , 18 , 6 , 7 , 2 , 19 , 20 , 9 ] NEW_LINE N = len ( arr ) NEW_LINE countSets ( arr , N ) NEW_LINE DEDENT |
Find the first day of a given year from a base year having first day as Monday | Function to find the day of 1 st January of Y year ; Count years between years Y and B ; Count leap years ; Non leap years ; Total number of days in the years lying between the years Y and B ; Actual day ; Driver code | def findDay ( Y , B ) : NEW_LINE INDENT lyear , rest , totaldays , day = 0 , 0 , 0 , 0 ; NEW_LINE Y = ( Y - 1 ) - B ; NEW_LINE lyear = Y // 4 ; NEW_LINE rest = Y - lyear ; NEW_LINE totaldays = ( rest * 365 ) + ( lyear * 366 ) + 1 ; NEW_LINE day = ( totaldays % 7 ) ; NEW_LINE if ( day == 0 ) : NEW_LINE INDENT print ( " Monday " ) ; NEW_LINE DEDENT elif ( day == 1 ) : NEW_LINE INDENT print ( " Tuesday " ) ; NEW_LINE DEDENT elif ( day == 2 ) : NEW_LINE INDENT print ( " Wednesday " ) ; NEW_LINE DEDENT elif ( day == 3 ) : NEW_LINE INDENT print ( " Thursday " ) ; NEW_LINE DEDENT elif ( day == 4 ) : NEW_LINE INDENT print ( " Friday " ) ; NEW_LINE DEDENT elif ( day == 5 ) : NEW_LINE INDENT print ( " Saturday " ) ; NEW_LINE DEDENT elif ( day == 6 ) : NEW_LINE INDENT print ( " Sunday " ) ; NEW_LINE DEDENT else : NEW_LINE INDENT print ( " INPUT ▁ YEAR ▁ IS ▁ WRONG ! " ) ; NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT Y = 2020 ; B = 1900 ; NEW_LINE findDay ( Y , B ) ; NEW_LINE DEDENT |
Queries to update array elements in a range [ L , R ] to satisfy given conditions | Function to prthe array ; Function to perform the query in range [ L , R ] such that arr [ i ] += i - L + 1 ; Initialize array ; Traverse the query array ; Stores range in 1 - based index ; Update arr1 [ L ] ; Update arr1 [ R + 1 ] ; Update arr2 [ R + 1 ] ; Calculate prefix sum ; Traverse the array , arr2 [ ] ; Copy arr2 [ ] into arr [ ] ; Driver Code ; Given array ; Size of the array ; Stores count of query ; Function Call | def printArray ( arr , N ) : NEW_LINE INDENT print ( * arr ) NEW_LINE DEDENT def modifyArray ( arr , N , Q , cntQuery ) : NEW_LINE INDENT arr1 = [ 0 for i in range ( N + 2 ) ] NEW_LINE arr2 = [ 0 for i in range ( N + 2 ) ] NEW_LINE for i in range ( cntQuery ) : NEW_LINE INDENT L = Q [ i ] [ 0 ] + 1 NEW_LINE R = Q [ i ] [ 1 ] + 1 NEW_LINE arr1 [ L ] += 1 NEW_LINE arr1 [ R + 1 ] -= 1 NEW_LINE arr2 [ R + 1 ] -= R - L + 1 NEW_LINE DEDENT for i in range ( 1 , N + 1 ) : NEW_LINE INDENT arr1 [ i ] += arr1 [ i - 1 ] NEW_LINE DEDENT for i in range ( 1 , N + 1 ) : NEW_LINE INDENT arr2 [ i ] += arr2 [ i - 1 ] + arr1 [ i ] NEW_LINE DEDENT for i in range ( 1 , N + 1 ) : NEW_LINE INDENT arr [ i - 1 ] = arr2 [ i ] NEW_LINE DEDENT printArray ( arr , N ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 0 , 0 , 0 , 0 ] NEW_LINE N = len ( arr ) NEW_LINE Q = [ [ 1 , 3 ] , [ 0 , 1 ] ] NEW_LINE cntQuery = len ( Q ) NEW_LINE modifyArray ( arr , N , Q , cntQuery ) NEW_LINE DEDENT |
Maximize product obtained by taking one element from each array of a given list | Function to return the product of 2 numbers ; If any of the two numbers is None ; Otherwise , return the product ; Function to calculate maximum product by taking only one element from each array present in the list ; Find the maximum and minimum present in the current array ; If last index is reached , then return the highest ( positive ) and lowest ( negative ) values ; Store the positive and negative products returned by calculating for the remaining arrays ; Store highest positive product ; Store product of highest with negative ; Store product of lowest with positive ; Store lowest negative product ; Return the maximum positive and minimum negative product ; Count of given arrays ; Given list of N arrays ; Store the maximum positive and minimum negative product possible ; Print the maximum product | def findProduct ( number_1 , number_2 ) : NEW_LINE INDENT if ( number_1 == None or number_2 == None ) : NEW_LINE INDENT return 0 NEW_LINE DEDENT else : NEW_LINE INDENT return number_1 * number_2 NEW_LINE DEDENT DEDENT def calculateProduct ( List , index ) : NEW_LINE INDENT highest = max ( List [ index ] ) NEW_LINE lowest = min ( List [ index ] ) NEW_LINE if ( index + 1 == len ( List ) ) : NEW_LINE INDENT if ( lowest < 0 and highest >= 0 ) : NEW_LINE INDENT return [ highest , lowest ] NEW_LINE DEDENT elif ( lowest <= 0 and highest <= 0 ) : NEW_LINE INDENT return [ None , lowest ] NEW_LINE DEDENT elif ( lowest >= 0 and highest >= 0 ) : NEW_LINE INDENT return [ highest , None ] NEW_LINE DEDENT DEDENT [ positive , negative ] = calculateProduct ( List , index + 1 ) NEW_LINE highPos = findProduct ( highest , positive ) NEW_LINE highNeg = findProduct ( highest , negative ) NEW_LINE lowPos = findProduct ( lowest , positive ) NEW_LINE lowNeg = findProduct ( lowest , negative ) NEW_LINE if ( lowest < 0 and highest >= 0 ) : NEW_LINE INDENT return [ max ( highPos , lowNeg ) , min ( highNeg , lowPos ) ] NEW_LINE DEDENT elif ( lowest <= 0 and highest <= 0 ) : NEW_LINE INDENT return [ lowNeg , lowPos ] NEW_LINE DEDENT elif ( lowest >= 0 and highest >= 0 ) : NEW_LINE INDENT return [ max ( lowPos , highPos ) , min ( lowNeg , highNeg ) ] NEW_LINE DEDENT DEDENT N = 2 NEW_LINE arr = [ [ - 3 , - 4 ] , [ 1 , 2 , - 3 ] ] NEW_LINE positive , negative = calculateProduct ( arr , 0 ) NEW_LINE print ( positive ) NEW_LINE |
Reduce a number N by at most D to maximize count of trailing nines | Python3 program for the above approach ; Function to find a number with maximum count of trailing nine ; Stores count of digits in n ; Stores power of 10 ; If last i digits greater than or equal to d ; Update res ; Update p10 ; Driver Code ; Function Call | from math import log10 NEW_LINE def maxNumTrailNine ( n , d ) : NEW_LINE INDENT res = n NEW_LINE cntDigits = int ( log10 ( n ) + 1 ) NEW_LINE p10 = 10 NEW_LINE for i in range ( 1 , cntDigits + 1 ) : NEW_LINE INDENT if ( n % p10 >= d ) : NEW_LINE INDENT break NEW_LINE DEDENT else : NEW_LINE INDENT res = n - n % p10 - 1 NEW_LINE DEDENT p10 = p10 * 10 NEW_LINE DEDENT print ( res ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT n , d = 1025 , 6 NEW_LINE maxNumTrailNine ( n , d ) NEW_LINE DEDENT |
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once | Function to find minimum count of ways to split the array into two subset such that elements of each pair occurs in two different subset ; Stores minimum count of ways to split array into two subset such that elements of each pair occurs in two different subset ; if n is odd ; driver code | def MinimumNoOfWays ( arr , n ) : NEW_LINE INDENT min_no_of_ways = 0 NEW_LINE if ( n % 2 == 0 ) : NEW_LINE INDENT mini_no_of_ways = n // 2 NEW_LINE DEDENT else : NEW_LINE INDENT mini_no_of_ways = n // 2 + 1 NEW_LINE DEDENT return mini_no_of_ways NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 3 , 4 , 1 , 2 , 5 ] NEW_LINE n = len ( arr ) NEW_LINE print ( MinimumNoOfWays ( arr , n ) ) NEW_LINE DEDENT |
Chocolate Distribution Problem | Set 2 | Function to return minimum number of chocolates ; decreasing sequence ; add the chocolates received by that person ; end point of decreasing sequence ; val = 1 reset value at that index ; increasing sequence ; flat sequence ; add value of chocolates at position n - 1 ; Helper function to get sum of decreasing sequence ; value obtained from decreasing sequence also the count of values in the sequence ; assigning max of values obtained from increasing and decreasing sequences ; sum of count - 1 values & peak value sum of natural numbers : ( n * ( n + 1 ) ) / 2 ; Driver code | def minChocolates ( a , n ) : NEW_LINE INDENT i , j = 0 , 0 NEW_LINE val , res = 1 , 0 NEW_LINE while ( j < n - 1 ) : NEW_LINE INDENT if ( a [ j ] > a [ j + 1 ] ) : NEW_LINE INDENT j += 1 NEW_LINE continue NEW_LINE DEDENT if ( i == j ) : NEW_LINE INDENT res += val NEW_LINE DEDENT else : NEW_LINE INDENT res += get_sum ( val , i , j ) NEW_LINE DEDENT if ( a [ j ] < a [ j + 1 ] ) : NEW_LINE INDENT val += 1 NEW_LINE DEDENT else : NEW_LINE INDENT val = 1 NEW_LINE DEDENT j += 1 NEW_LINE i = j NEW_LINE DEDENT if ( i == j ) : NEW_LINE INDENT res += val NEW_LINE DEDENT else : NEW_LINE INDENT res += get_sum ( val , i , j ) NEW_LINE DEDENT return res NEW_LINE DEDENT def get_sum ( peak , start , end ) : NEW_LINE INDENT count = end - start + 1 NEW_LINE peak = max ( peak , count ) NEW_LINE s = peak + ( ( ( count - 1 ) * count ) >> 1 ) NEW_LINE return s NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT a = [ 5 , 5 , 4 , 3 , 2 , 1 ] NEW_LINE n = len ( a ) NEW_LINE print ( ' Minimum ▁ number ▁ of ▁ chocolates ▁ = ' , minChocolates ( a , n ) ) NEW_LINE DEDENT |
Remove array elements to reduce frequency of each array element to at most K | Function to remove array elements such that frequency of each distinct array element is at most K ; Base Case ; Stores index of array element by removing the array element such that the frequency of array elements is at most K ; Traverse the array ; If j < k or arr [ i ] > arr [ j - k ] ; Update arr [ j ] ; Remove array elements ; Function to print the array ; Traverse the array ; Utility Function to remove array elements such that frequency of each distinct array element is at most K ; Print updated array ; Driver Code | def RemoveElemArr ( arr , n , k ) : NEW_LINE INDENT if ( n == 0 or n == 1 ) : NEW_LINE INDENT return arr NEW_LINE DEDENT j = 0 NEW_LINE for i in range ( n ) : NEW_LINE INDENT if ( j < k or arr [ i ] > arr [ j - k ] ) : NEW_LINE INDENT arr [ j ] , j = arr [ i ] , j + 1 NEW_LINE DEDENT DEDENT while ( len ( arr ) > j ) : NEW_LINE INDENT del arr [ - 1 ] NEW_LINE DEDENT return arr NEW_LINE DEDENT def printArray ( arr ) : NEW_LINE INDENT for i in arr : NEW_LINE INDENT print ( i , end = " ▁ " ) NEW_LINE DEDENT DEDENT def UtilRemov ( arr , n , k ) : NEW_LINE INDENT arr = RemoveElemArr ( arr , n , k ) NEW_LINE printArray ( arr ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 1 , 2 , 2 , 3 , 4 , 4 , 4 , 5 , 5 ] NEW_LINE k = 2 NEW_LINE n = len ( arr ) NEW_LINE UtilRemov ( arr , n , k ) NEW_LINE DEDENT |
Count pairs of equal array elements remaining after every removal | Function to count pairs of equal elements by removing arr [ i ] from the array ; Stores total count of pairs of equal elements ; Store frequency of each distinct array element ; Traverse the array ; Update frequency of arr [ i ] ; Traverse the map ; Stores key of an element ; Traverse the array ; Stores count of pairs of equal element by removing arr [ i ] ; Driver Code ; Given Array | def pairs_after_removing ( arr , N ) : NEW_LINE INDENT cntPairs = 0 NEW_LINE mp = { } NEW_LINE for i in arr : NEW_LINE INDENT mp [ i ] = mp . get ( i , 0 ) + 1 NEW_LINE DEDENT for element in mp : NEW_LINE INDENT i = element NEW_LINE cntPairs += mp [ i ] * ( mp [ i ] - 1 ) // 2 NEW_LINE DEDENT for i in range ( N ) : NEW_LINE INDENT pairs_after_arr_i_removed = cntPairs + 1 - mp [ arr [ i ] ] NEW_LINE print ( pairs_after_arr_i_removed , end = ' ▁ ' ) NEW_LINE DEDENT return NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 2 , 3 , 4 , 3 , 2 ] NEW_LINE N = len ( arr ) NEW_LINE pairs_after_removing ( arr , N ) NEW_LINE DEDENT |
Modify N by adding its smallest positive divisor exactly K times | Function to find the smallest divisor of N greater than 1 ; If i is a divisor of N ; If N is a prime number ; Function to find the value of N by performing the operations K times ; If N is an even number ; Update N ; If N is an odd number ; Update N ; Driver Code | def smallestDivisorGr1 ( N ) : NEW_LINE INDENT for i in range ( sqrt ( N ) ) : NEW_LINE INDENT i += 1 NEW_LINE DEDENT if ( N % i == 0 ) : NEW_LINE INDENT return i NEW_LINE DEDENT return N NEW_LINE DEDENT def findValOfNWithOperat ( N , K ) : NEW_LINE INDENT if ( N % 2 == 0 ) : NEW_LINE INDENT N += K * 2 NEW_LINE DEDENT else : NEW_LINE INDENT N += smallestDivisorGr1 ( N ) + ( K - 1 ) * 2 NEW_LINE DEDENT return N NEW_LINE DEDENT N = 6 NEW_LINE K = 4 NEW_LINE print ( findValOfNWithOperat ( N , K ) ) NEW_LINE |
Partition array into minimum number of equal length subsets consisting of a single distinct value | Python3 program to implement the above approach ; Function to find the minimum count of subsets by partitioning the array with given conditions ; Store frequency of each distinct element of the array ; Traverse the array ; Update frequency of arr [ i ] ; Stores GCD of frequency of each distinct element of the array ; Update freqGCD ; Driver Code | from math import gcd NEW_LINE def CntOfSubsetsByPartitioning ( arr , N ) : NEW_LINE INDENT freq = { } NEW_LINE for i in range ( N ) : NEW_LINE INDENT freq [ arr [ i ] ] = freq . get ( arr [ i ] , 0 ) + 1 NEW_LINE DEDENT freqGCD = 0 NEW_LINE for i in freq : NEW_LINE INDENT freqGCD = gcd ( freqGCD , freq [ i ] ) NEW_LINE DEDENT return ( N ) // freqGCD NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 1 , 2 , 3 , 4 , 4 , 3 , 2 , 1 ] NEW_LINE N = len ( arr ) NEW_LINE print ( CntOfSubsetsByPartitioning ( arr , N ) ) NEW_LINE DEDENT |
Construct a Matrix such that each cell consists of sum of adjacent elements of respective cells in given Matrix | Initialize rows and columns ; Store all 8 directions ; Function to check if a cell ( i , j ) is valid or not ; Function to find sum of adjacent cells for cell ( i , j ) ; Initialize sum ; Visit all 8 directions ; Check if cell is valid ; Return sum ; Function to print sum of adjacent elements ; Stores the resultant matrix ; Iterate each elements of matrix ; Find adjacent sum ; Driver code ; Given matrix ; Size of matrix ; Function call | r , c = 0 , 0 ; NEW_LINE dir = [ [ 1 , 0 ] , [ - 1 , 0 ] , [ 0 , 1 ] , [ 0 , - 1 ] , [ - 1 , - 1 ] , [ - 1 , 1 ] , [ 1 , 1 ] , [ 1 , - 1 ] ] ; NEW_LINE def valid ( i , j ) : NEW_LINE INDENT if ( i >= 0 and j >= 0 and i < r and j < c ) : NEW_LINE INDENT return True ; NEW_LINE DEDENT return False ; NEW_LINE DEDENT def find ( i , j , v ) : NEW_LINE INDENT s = 0 ; NEW_LINE for k in range ( 8 ) : NEW_LINE INDENT ni = i + dir [ k ] [ 0 ] ; NEW_LINE nj = j + dir [ k ] [ 1 ] ; NEW_LINE if ( valid ( ni , nj ) ) : NEW_LINE INDENT s += v [ ni ] [ nj ] ; NEW_LINE DEDENT DEDENT return s ; NEW_LINE DEDENT def findsumofneighbors ( M ) : NEW_LINE INDENT v = [ [ 0 for i in range ( c ) ] for j in range ( r ) ] ; NEW_LINE for i in range ( r ) : NEW_LINE INDENT for j in range ( c ) : NEW_LINE INDENT v [ i ] [ j ] = find ( i , j , M ) ; NEW_LINE print ( v [ i ] [ j ] , end = " ▁ " ) ; NEW_LINE DEDENT print ( " " ) ; NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT M = [ [ 1 , 4 , 1 ] , [ 2 , 4 , 5 ] , [ 3 , 1 , 2 ] ] ; NEW_LINE r = len ( M [ 0 ] ) ; NEW_LINE c = len ( M [ 1 ] ) ; NEW_LINE findsumofneighbors ( M ) ; NEW_LINE DEDENT |
Nth term of a recurrence relation generated by two given arrays | Python3 program for the above approach ; Declare T [ ] [ ] as global matrix ; Result matrix ; Function to multiply two matrices ; Create an auxiliary matrix to store elements of the multiplication matrix ; Iterate over range [ 0 , K ] ; Update temp [ i ] [ j ] ; Update the final matrix ; Function to multiply two matrices ; Create an auxiliary matrix to store elements of the multiplication matrix ; Iterate over range [ 0 , K ] ; Update temp [ i ] [ j ] ; Update the final matrix ; Function to calculate matrix ^ n using binary exponentaion ; Initialize result matrix and unity matrix ; Function to calculate nth term of general recurrence ; Fill T [ ] [ ] with appropriate value ; Function Call to calculate T ^ n ; Calculate nth term as first element of F * ( T ^ n ) ; Print the result ; Driver Code ; Given Initial terms ; Given coefficients ; Given K ; Given N ; Function Call | mod = 1e9 + 7 NEW_LINE T = [ [ 0 for x in range ( 2000 ) ] for y in range ( 2000 ) ] NEW_LINE result = [ [ 0 for x in range ( 2000 ) ] for y in range ( 2000 ) ] NEW_LINE def mul_2 ( K ) : NEW_LINE INDENT temp = [ [ 0 for x in range ( K + 1 ) ] for y in range ( K + 1 ) ] NEW_LINE for i in range ( 1 , K + 1 ) : NEW_LINE INDENT for j in range ( 1 , K + 1 ) : NEW_LINE INDENT for k in range ( 1 , K + 1 ) : NEW_LINE INDENT temp [ i ] [ j ] = ( ( temp [ i ] [ j ] + ( T [ i ] [ k ] * T [ k ] [ j ] ) % mod ) % mod ) NEW_LINE DEDENT DEDENT DEDENT for i in range ( 1 , K + 1 ) : NEW_LINE INDENT for j in range ( 1 , K + 1 ) : NEW_LINE INDENT T [ i ] [ j ] = temp [ i ] [ j ] NEW_LINE DEDENT DEDENT DEDENT def mul_1 ( K ) : NEW_LINE INDENT temp = [ [ 0 for x in range ( K + 1 ) ] for y in range ( K + 1 ) ] NEW_LINE for i in range ( 1 , K + 1 ) : NEW_LINE INDENT for j in range ( 1 , K + 1 ) : NEW_LINE INDENT for k in range ( 1 , K + 1 ) : NEW_LINE INDENT temp [ i ] [ j ] = ( ( temp [ i ] [ j ] + ( result [ i ] [ k ] * T [ k ] [ j ] ) % mod ) % mod ) NEW_LINE DEDENT DEDENT DEDENT for i in range ( 1 , K + 1 ) : NEW_LINE INDENT for j in range ( 1 , K + 1 ) : NEW_LINE INDENT result [ i ] [ j ] = temp [ i ] [ j ] NEW_LINE DEDENT DEDENT DEDENT def matrix_pow ( K , n ) : NEW_LINE INDENT for i in range ( 1 , K + 1 ) : NEW_LINE INDENT for j in range ( 1 , K + 1 ) : NEW_LINE INDENT if ( i == j ) : NEW_LINE INDENT result [ i ] [ j ] = 1 NEW_LINE DEDENT DEDENT DEDENT while ( n > 0 ) : NEW_LINE INDENT if ( n % 2 == 1 ) : NEW_LINE INDENT mul_1 ( K ) NEW_LINE DEDENT mul_2 ( K ) NEW_LINE n //= 2 NEW_LINE DEDENT DEDENT def NthTerm ( F , C , K , n ) : NEW_LINE INDENT for i in range ( 1 , K + 1 ) : NEW_LINE INDENT T [ i ] [ K ] = C [ K - i ] NEW_LINE DEDENT for i in range ( 1 , K + 1 ) : NEW_LINE INDENT T [ i + 1 ] [ i ] = 1 NEW_LINE DEDENT matrix_pow ( K , n ) NEW_LINE answer = 0 NEW_LINE for i in range ( 1 , K + 1 ) : NEW_LINE INDENT answer += F [ i - 1 ] * result [ i ] [ 1 ] NEW_LINE DEDENT print ( int ( answer ) ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT F = [ 1 , 2 , 3 ] NEW_LINE C = [ 1 , 1 , 1 ] NEW_LINE K = 3 NEW_LINE N = 10 NEW_LINE NthTerm ( F , C , K , N ) NEW_LINE DEDENT |
Calculate Root Mean Kth power of all array elements | Python3 program for the above approach ; Function to find the Nth root ; Initially guessing random numberbetween 0 and 9 ; Smaller eps for more accuracy ; Initialize difference between the two roots by INT_MAX ; xK denotes current value of x ; Iterate until desired accuracy is reached ; Find the current value from previous value by newton 's method ; Function to calculate the Root Mean kth power of array elements ; Calculate sum of kth power ; Calculate Mean ; Calculate kth Root of mean ; Driver Code ; Function Call | import sys NEW_LINE import random NEW_LINE def nthRoot ( A , N ) : NEW_LINE INDENT xPre = random . random ( ) % 10 NEW_LINE eps = 1e-3 NEW_LINE delX = sys . maxsize NEW_LINE xK = 0 NEW_LINE while ( delX > eps ) : NEW_LINE INDENT xK = ( ( ( N - 1.0 ) * xPre + A / pow ( xPre , N - 1 ) ) / N ) NEW_LINE delX = abs ( xK - xPre ) NEW_LINE xPre = xK NEW_LINE DEDENT return xK NEW_LINE DEDENT def RMNValue ( arr , n , k ) : NEW_LINE INDENT Nth = 0 NEW_LINE mean = 0.0 NEW_LINE root = 0.0 NEW_LINE for i in range ( n ) : NEW_LINE INDENT Nth += pow ( arr [ i ] , k ) NEW_LINE DEDENT mean = ( Nth // ( n ) ) NEW_LINE root = nthRoot ( mean , k ) NEW_LINE return root NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT arr = [ 10 , 4 , 6 , 8 ] NEW_LINE N = len ( arr ) NEW_LINE K = 3 NEW_LINE print ( RMNValue ( arr , N , K ) ) NEW_LINE DEDENT |
Add two numbers represented by Stacks | Function to return the stack that contains the sum of two numbers ; Calculate the sum of the top elements of both the stacks ; Push the sum into the stack ; Store the carry ; Pop the top elements ; If N1 is not empty ; If N2 is not empty ; If carry remains ; Reverse the stack . so that most significant digit is at the bottom of the stack ; Function to display the resultamt stack ; Driver Code | def addStack ( N1 , N2 ) : NEW_LINE INDENT res = [ ] NEW_LINE s = 0 NEW_LINE rem = 0 NEW_LINE while ( len ( N1 ) != 0 and len ( N2 ) != 0 ) : NEW_LINE INDENT s = ( rem + N1 [ - 1 ] + N2 [ - 1 ] ) NEW_LINE res . append ( s % 10 ) NEW_LINE rem = s // 10 NEW_LINE N1 . pop ( - 1 ) NEW_LINE N2 . pop ( - 1 ) NEW_LINE DEDENT while ( len ( N1 ) != 0 ) : NEW_LINE INDENT s = rem + N1 [ - 1 ] NEW_LINE res . append ( s % 10 ) NEW_LINE rem = s // 10 NEW_LINE N1 . pop ( - 1 ) NEW_LINE DEDENT while ( len ( N2 ) != 0 ) : NEW_LINE INDENT s = rem + N2 [ - 1 ] NEW_LINE res . append ( s % 10 ) NEW_LINE rem = s // 10 NEW_LINE N2 . pop ( - 1 ) NEW_LINE DEDENT while ( rem > 0 ) : NEW_LINE INDENT res . append ( rem ) NEW_LINE rem //= 10 NEW_LINE DEDENT res = res [ : : - 1 ] NEW_LINE return res NEW_LINE DEDENT def display ( res ) : NEW_LINE INDENT s = " " NEW_LINE for i in res : NEW_LINE INDENT s += str ( i ) NEW_LINE DEDENT print ( s ) NEW_LINE DEDENT N1 = [ ] NEW_LINE N1 . append ( 5 ) NEW_LINE N1 . append ( 8 ) NEW_LINE N1 . append ( 7 ) NEW_LINE N1 . append ( 4 ) NEW_LINE N2 = [ ] NEW_LINE N2 . append ( 2 ) NEW_LINE N2 . append ( 1 ) NEW_LINE N2 . append ( 3 ) NEW_LINE res = addStack ( N1 , N2 ) NEW_LINE display ( res ) NEW_LINE |
Check if a number has an odd count of odd divisors and even count of even divisors | Python3 implementation of the above approach ; Function to check if the number is a perfect square ; Find floating povalue of square root of x . ; If square root is an integer ; Function to check if count of even divisors is even and count of odd divisors is odd ; Driver code | import math NEW_LINE def isPerfectSquare ( x ) : NEW_LINE INDENT sr = pow ( x , 1 / 2 ) ; NEW_LINE return ( ( sr - math . floor ( sr ) ) == 0 ) ; NEW_LINE DEDENT def checkFactors ( x ) : NEW_LINE INDENT if ( isPerfectSquare ( x ) ) : NEW_LINE INDENT print ( " Yes " ) ; NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) ; NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT N = 36 ; NEW_LINE checkFactors ( N ) ; NEW_LINE DEDENT |
Queries to find the XOR of an Array after replacing all occurrences of X by Y | Stores the bitwise XOR of array elements ; Function to find the total xor ; Loop to find the xor of all the elements ; Function to find the XOR after replacing all occurrences of X by Y for Q queries ; Remove contribution of X from total_xor ; Adding contribution of Y to total_xor ; Print total_xor ; Driver Code | global total_xor NEW_LINE total_xor = 0 NEW_LINE def initialize_xor ( arr , n ) : NEW_LINE INDENT global total_xor NEW_LINE for i in range ( n ) : NEW_LINE INDENT total_xor = total_xor ^ arr [ i ] NEW_LINE DEDENT DEDENT def find_xor ( X , Y ) : NEW_LINE INDENT global total_xor NEW_LINE total_xor = total_xor ^ X NEW_LINE total_xor = total_xor ^ Y NEW_LINE print ( total_xor ) NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT arr = [ 5 , 7 , 8 , 9 ] NEW_LINE n = len ( arr ) NEW_LINE initialize_xor ( arr , n ) NEW_LINE Q = [ [ 5 , 6 ] , [ 8 , 1 ] ] NEW_LINE for i in range ( len ( Q ) ) : NEW_LINE INDENT find_xor ( Q [ i ] [ 0 ] , Q [ i ] [ 1 ] ) NEW_LINE DEDENT DEDENT |
Check whether a given number is an ugly number or not | Function to check if a number is an ugly number or not ; Base Cases ; Condition to check if the number is divided by 2 , 3 , or 5 ; Driver Code | def isUgly ( n ) : NEW_LINE INDENT if ( n == 1 ) : NEW_LINE INDENT return 1 NEW_LINE DEDENT if ( n <= 0 ) : NEW_LINE INDENT return 0 NEW_LINE DEDENT if ( n % 2 == 0 ) : NEW_LINE INDENT return ( isUgly ( n // 2 ) ) NEW_LINE DEDENT if ( n % 3 == 0 ) : NEW_LINE INDENT return ( isUgly ( n // 3 ) ) NEW_LINE DEDENT if ( n % 5 == 0 ) : NEW_LINE INDENT return ( isUgly ( n // 5 ) ) NEW_LINE DEDENT return 0 NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT no = isUgly ( 14 ) NEW_LINE if ( no == 1 ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT DEDENT |
Maximum possible GCD for a pair of integers with sum N | Function to find the required GCD value ; If i is a factor of N ; Return the largest factor possible ; If N is a prime number ; Driver Code | def maxGCD ( N ) : NEW_LINE INDENT i = 2 NEW_LINE while ( i * i <= N ) : NEW_LINE INDENT if ( N % i == 0 ) : NEW_LINE INDENT return N // i NEW_LINE DEDENT i += 1 NEW_LINE DEDENT return 1 NEW_LINE DEDENT N = 33 NEW_LINE print ( " Maximum ▁ Possible ▁ GCD ▁ value ▁ is ▁ : ▁ " , maxGCD ( N ) ) NEW_LINE |
Minimize K whose XOR with given array elements leaves array unchanged | Function to find the minimum value of K in given range ; Declare a set ; Initialize count variable ; Iterate in range [ 1 , 1024 ] ; counter set as 0 ; Iterating through the Set ; Check if the XOR calculated is present in the Set ; If the value of Bitwise XOR inside the given set then increment count ; Check if the value of count is equal to the size of set ; Return minimum value of K ; If no such K is found ; Given array ; Function Call | def min_value ( arr , N ) : NEW_LINE INDENT x , X , K = 0 , 0 , 0 NEW_LINE S = set ( ) NEW_LINE for i in range ( N ) : NEW_LINE INDENT S . add ( arr [ i ] ) NEW_LINE DEDENT count = 0 NEW_LINE for i in range ( 1 , 1024 ) : NEW_LINE INDENT count = 0 NEW_LINE for it in S : NEW_LINE INDENT X = ( ( i it ) - ( i & it ) ) NEW_LINE if X in S : NEW_LINE INDENT count += 1 NEW_LINE DEDENT DEDENT if ( count == len ( S ) ) : NEW_LINE INDENT K = i NEW_LINE return K NEW_LINE DEDENT DEDENT return - 1 NEW_LINE DEDENT arr = [ 1 , 0 , 3 , 3 , 0 , 2 ] NEW_LINE N = len ( arr ) NEW_LINE print ( min_value ( arr , N ) ) NEW_LINE |
Junction Numbers | Python3 program for the above approach ; Function to find the sum Of digits of N ; To store sum of N and sumOfdigitsof ( N ) ; extracting digit ; Function to check Junction numbers ; To store count of ways n can be represented as i + SOD ( i ) ; Driver Code ; Function Call | import math NEW_LINE def sum1 ( n ) : NEW_LINE INDENT sum1 = 0 NEW_LINE while ( n != 0 ) : NEW_LINE INDENT r = n % 10 NEW_LINE sum1 = sum1 + r NEW_LINE n = n // 10 NEW_LINE DEDENT return sum1 NEW_LINE DEDENT def isJunction ( n ) : NEW_LINE INDENT count = 0 NEW_LINE for i in range ( 1 , n + 1 ) : NEW_LINE INDENT if ( i + sum1 ( i ) == n ) : NEW_LINE INDENT count = count + 1 NEW_LINE DEDENT DEDENT return count >= 2 NEW_LINE DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT n = 111 NEW_LINE if ( isJunction ( n ) == 1 ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT DEDENT |
Pointer | Function to find the product of digits of a number N ; 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 ; Function to check Pointer - Prime numbers ; Driver Code ; Given number N ; Function call | def digProduct ( n ) : NEW_LINE INDENT product = 1 NEW_LINE while ( n != 0 ) : NEW_LINE INDENT product = product * ( n % 10 ) NEW_LINE n = int ( n / 10 ) NEW_LINE DEDENT return product NEW_LINE DEDENT def isPrime ( n ) : NEW_LINE INDENT if ( n <= 1 ) : NEW_LINE INDENT return False NEW_LINE DEDENT if ( n <= 3 ) : NEW_LINE INDENT return True NEW_LINE DEDENT if ( n % 2 == 0 or n % 3 == 0 ) : NEW_LINE INDENT return False NEW_LINE DEDENT i = 5 NEW_LINE while ( i * i <= n ) : NEW_LINE INDENT if ( n % i == 0 or n % ( i + 2 ) == 0 ) : NEW_LINE INDENT return False NEW_LINE DEDENT i = i + 6 NEW_LINE DEDENT return True NEW_LINE DEDENT def nextPrime ( N ) : NEW_LINE INDENT if ( N <= 1 ) : NEW_LINE INDENT return 2 ; NEW_LINE DEDENT prime = N NEW_LINE found = False NEW_LINE while ( not found ) : NEW_LINE INDENT prime = prime + 1 NEW_LINE if ( isPrime ( prime ) ) : NEW_LINE INDENT found = True NEW_LINE DEDENT DEDENT return prime NEW_LINE DEDENT def isPointerPrime ( n ) : NEW_LINE INDENT if ( isPrime ( n ) and ( n + digProduct ( n ) == nextPrime ( n ) ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT else : NEW_LINE INDENT return False NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT N = 23 NEW_LINE if ( isPointerPrime ( N ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT DEDENT |
Perfect Digital Invariants number | Function to find the sum of divisors ; Function to check whether the given number is Perfect Digital Invariant number or not ; For each digit in temp ; If satisfies Perfect Digital Invariant condition ; If sum exceeds n , then not possible ; Given Number N ; Function Call | def power ( x , y ) : NEW_LINE INDENT if ( y == 0 ) : NEW_LINE INDENT return 1 NEW_LINE DEDENT if ( y % 2 == 0 ) : NEW_LINE INDENT return ( power ( x , y // 2 ) * power ( x , y // 2 ) ) NEW_LINE DEDENT return ( x * power ( x , y // 2 ) * power ( x , y // 2 ) ) NEW_LINE DEDENT def isPerfectDigitalInvariant ( x ) : NEW_LINE INDENT fixed_power = 0 NEW_LINE while True : NEW_LINE INDENT fixed_power += 1 NEW_LINE temp = x NEW_LINE summ = 0 NEW_LINE while ( temp ) : NEW_LINE INDENT r = temp % 10 NEW_LINE summ = summ + power ( r , fixed_power ) NEW_LINE temp = temp // 10 NEW_LINE DEDENT if ( summ == x ) : NEW_LINE INDENT return ( True ) NEW_LINE DEDENT if ( summ > x ) : NEW_LINE INDENT return ( False ) NEW_LINE DEDENT DEDENT DEDENT N = 4150 NEW_LINE if ( isPerfectDigitalInvariant ( N ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT |
Brilliant Numbers | Python3 program for the above approach ; Function to generate all prime numbers less than n ; Initialize all entries of boolean array as true . A value in isPrime [ i ] will finally be false if i is Not a prime ; If isPrime [ p ] is not changed , then it is a prime ; Update all multiples of p ; Function to return the number of digits in a number ; Function to check if N is a Brilliant number ; Generating primes using Sieve ; Traversing all numbers to find first pair ; Given Number ; Function Call | import math NEW_LINE def SieveOfEratosthenes ( n , isPrime ) : NEW_LINE INDENT isPrime [ 0 ] = isPrime [ 1 ] = False NEW_LINE for i in range ( 2 , n + 1 , 1 ) : NEW_LINE INDENT isPrime [ i ] = True NEW_LINE DEDENT p = 2 NEW_LINE while ( p * p <= n ) : NEW_LINE INDENT if ( isPrime [ p ] == True ) : NEW_LINE INDENT for i in range ( p * 2 , n + 1 , p ) : NEW_LINE INDENT isPrime [ i ] = False NEW_LINE DEDENT DEDENT p += 1 NEW_LINE DEDENT DEDENT def countDigit ( n ) : NEW_LINE INDENT return math . floor ( math . log10 ( n ) + 1 ) NEW_LINE DEDENT def isBrilliant ( n ) : NEW_LINE INDENT flag = 0 NEW_LINE isPrime = [ 0 ] * ( n + 1 ) NEW_LINE SieveOfEratosthenes ( n , isPrime ) NEW_LINE for i in range ( 2 , n , 1 ) : NEW_LINE INDENT x = n // i NEW_LINE if ( isPrime [ i ] and isPrime [ x ] and x * i == n ) : NEW_LINE INDENT if ( countDigit ( i ) == countDigit ( x ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT DEDENT DEDENT return False NEW_LINE DEDENT n = 1711 NEW_LINE if ( isBrilliant ( n ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT |
Icosikaienneagonal Number | Function to Find the Nth icosikaienneagonal Number ; Driver Code | def icosikaienneagonalNum ( n ) : NEW_LINE INDENT return ( 27 * n * n - 25 * n ) // 2 NEW_LINE DEDENT N = 3 NEW_LINE print ( icosikaienneagonalNum ( N ) ) NEW_LINE |
Find the largest contiguous pair sum in given Array | Python3 program to find the a contiguous pair from the which has the largest sum ; Function to find and return the largest sum contiguous pair ; Stores the contiguous pair ; Initialize maximum sum ; Compare sum of pair with max_sum ; Insert the pair ; Driver Code | import sys NEW_LINE def largestSumpair ( arr , n ) : NEW_LINE INDENT pair = [ ] NEW_LINE max_sum = - sys . maxsize - 1 NEW_LINE for i in range ( 1 , n ) : NEW_LINE INDENT if max_sum < ( arr [ i ] + arr [ i - 1 ] ) : NEW_LINE INDENT max_sum = arr [ i ] + arr [ i - 1 ] NEW_LINE if pair == [ ] : NEW_LINE INDENT pair . append ( arr [ i - 1 ] ) NEW_LINE pair . append ( arr [ i ] ) NEW_LINE DEDENT else : NEW_LINE INDENT pair [ 0 ] = arr [ i - 1 ] NEW_LINE pair [ 1 ] = arr [ i ] NEW_LINE DEDENT DEDENT DEDENT return pair NEW_LINE DEDENT arr = [ 11 , - 5 , 9 , - 3 , 2 ] NEW_LINE N = len ( arr ) NEW_LINE pair = largestSumpair ( arr , N ) NEW_LINE print ( pair [ 0 ] , end = " ▁ " ) NEW_LINE print ( pair [ 1 ] , end = " ▁ " ) NEW_LINE |
Sum of minimum value of x and y satisfying the equation ax + by = c | Python3 program for the above approach ; x and y store solution of equation ax + by = g ; Euclidean Algorithm ; store_gcd returns the gcd of a and b ; Function to find any possible solution ; Condition if solution does not exists ; Adjusting the sign of x0 and y0 ; Function to shift solution ; Shifting to obtain another solution ; Function to find minimum value of x and y ; g is the gcd of a and b ; Store sign of a and b ; If x is less than 0 , then shift solution ; If y is less than 0 , then shift solution ; Find intersection such that both x and y are positive ; miny is value of y corresponding to minx ; Returns minimum value of x + y ; Given a , b , and c ; Function call | x , y , x1 , y1 = 0 , 0 , 0 , 0 NEW_LINE x0 , y0 , g = 0 , 0 , 0 NEW_LINE def gcd ( a , b ) : NEW_LINE INDENT global x , y , x1 , y1 NEW_LINE if ( b == 0 ) : NEW_LINE INDENT x = 1 NEW_LINE y = 0 NEW_LINE return a NEW_LINE DEDENT store_gcd = gcd ( b , a % b ) NEW_LINE x = y1 NEW_LINE y = x1 - y1 * ( a // b ) NEW_LINE return store_gcd NEW_LINE DEDENT def possible_solution ( a , b , c ) : NEW_LINE INDENT global x0 , y0 , g NEW_LINE g = gcd ( abs ( a ) , abs ( b ) ) NEW_LINE if ( c % g != 0 ) : NEW_LINE INDENT return 0 NEW_LINE DEDENT x0 *= c // g NEW_LINE y0 *= c // g NEW_LINE if ( a < 0 ) : NEW_LINE INDENT x0 *= - 1 NEW_LINE DEDENT if ( b < 0 ) : NEW_LINE INDENT y0 *= - 1 NEW_LINE DEDENT return 1 NEW_LINE DEDENT def shift_solution ( a , b , shift_var ) : NEW_LINE INDENT global x , y NEW_LINE x += shift_var * b NEW_LINE y -= shift_var * a NEW_LINE DEDENT def find_min_sum ( a , b , c ) : NEW_LINE INDENT global x , y , g NEW_LINE x , y , g = 0 , 0 , 0 NEW_LINE if ( possible_solution ( a , b , c ) == 0 ) : NEW_LINE INDENT return - 1 NEW_LINE DEDENT if ( g != 0 ) : NEW_LINE INDENT a //= g NEW_LINE b //= g NEW_LINE DEDENT if a > 0 : NEW_LINE INDENT sign_a = 1 NEW_LINE DEDENT else : NEW_LINE INDENT sign_a = - 1 NEW_LINE DEDENT if b > 0 : NEW_LINE INDENT sign_b = 1 NEW_LINE DEDENT else : NEW_LINE INDENT sign_b = - 1 NEW_LINE DEDENT shift_solution ( a , b , - x // b ) NEW_LINE if ( x < 0 ) : NEW_LINE INDENT shift_solution ( a , b , sign_b ) NEW_LINE DEDENT minx1 = x NEW_LINE shift_solution ( a , b , y // a ) NEW_LINE if ( y < 0 ) : NEW_LINE INDENT shift_solution ( a , b , - sign_a ) NEW_LINE DEDENT minx2 = x NEW_LINE if ( minx2 > x ) : NEW_LINE INDENT temp = minx2 NEW_LINE minx2 = x NEW_LINE x = temp NEW_LINE DEDENT minx = max ( minx1 , minx2 ) NEW_LINE if ( minx > x ) : NEW_LINE INDENT return - 1 NEW_LINE DEDENT miny = ( c - a * x ) // b NEW_LINE return ( miny + minx ) NEW_LINE DEDENT a , b , c = 2 , 2 , 0 NEW_LINE print ( find_min_sum ( a , b , c ) ) NEW_LINE |
Super | Function to check if N is a super - d number ; Driver Code | def isSuperdNum ( n ) : NEW_LINE INDENT for d in range ( 2 , 10 ) : NEW_LINE INDENT substring = str ( d ) * d ; NEW_LINE if substring in str ( d * pow ( n , d ) ) : NEW_LINE INDENT return True NEW_LINE DEDENT DEDENT return False NEW_LINE DEDENT n = 261 NEW_LINE if isSuperdNum ( n ) == True : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT |
Second hexagonal numbers | Function to find N - th term in the series ; Driver code | def findNthTerm ( n ) : NEW_LINE INDENT print ( n * ( 2 * n + 1 ) ) NEW_LINE DEDENT N = 4 NEW_LINE findNthTerm ( N ) NEW_LINE |
Apocalyptic Number | Function to check if a number N is Apocalyptic ; Given Number N ; Function Call | def isApocalyptic ( n ) : NEW_LINE INDENT if '666' in str ( 2 ** n ) : NEW_LINE INDENT return True NEW_LINE DEDENT return False NEW_LINE DEDENT N = 157 NEW_LINE if ( isApocalyptic ( 157 ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT |
Kummer Numbers | Python3 program to find Kummer number upto n terms ; list to store all prime less than and equal to 10 ^ 6 ; Function for the Sieve of Sundaram . This function stores all prime numbers less than MAX in primes ; In general Sieve of Sundaram , produces primes smaller than ( 2 * x + 2 ) for a number given number x . Since we want primes smaller than MAX , we reduce MAX to half This list is used to separate numbers of the form i + j + 2 ij from others where 1 <= i <= j ; Main logic of Sundaram . Mark all numbers which do not generate prime number by doing 2 * i + 1 ; Since 2 is a prime number ; Print other primes . Remaining primes are of the form 2 * i + 1 such that marked [ i ] is false . ; Function to calculate nth Kummer number ; Multiply first n primes ; return nth Kummer number ; Driver code | import math NEW_LINE MAX = 1000000 NEW_LINE primes = [ ] NEW_LINE def sieveSundaram ( ) : NEW_LINE INDENT marked = [ 0 ] * int ( MAX / 2 + 1 ) NEW_LINE for i in range ( 1 , int ( ( math . sqrt ( MAX ) - 1 ) // 2 ) + 1 ) : NEW_LINE INDENT for j in range ( ( i * ( i + 1 ) ) << 1 , MAX // 2 + 1 , 2 * i + 1 ) : NEW_LINE INDENT marked [ j ] = True NEW_LINE DEDENT DEDENT primes . append ( 2 ) NEW_LINE for i in range ( 1 , MAX // 2 + 1 ) : NEW_LINE INDENT if ( marked [ i ] == False ) : NEW_LINE INDENT primes . append ( 2 * i + 1 ) NEW_LINE DEDENT DEDENT DEDENT def calculateKummer ( n ) : NEW_LINE INDENT result = 1 NEW_LINE for i in range ( n ) : NEW_LINE INDENT result = result * primes [ i ] NEW_LINE DEDENT return ( - 1 + result ) NEW_LINE DEDENT N = 5 NEW_LINE sieveSundaram ( ) NEW_LINE for i in range ( 1 , N + 1 ) : NEW_LINE INDENT print ( calculateKummer ( i ) , end = " , ▁ " ) NEW_LINE DEDENT |
Check if given number contains a digit which is the average of all other digits | Function which checks if a digits exists in n which is the average of all other digits ; Calculate sum of digits in n ; Store digits ; Increase the count of digits in n ; If average of all digits is integer ; Otherwise ; Driver code | def check ( n ) : NEW_LINE INDENT digits = set ( ) NEW_LINE temp = n NEW_LINE Sum = 0 NEW_LINE count = 0 NEW_LINE while ( temp > 0 ) : NEW_LINE INDENT Sum += temp % 10 NEW_LINE digits . add ( temp % 10 ) NEW_LINE count += 1 NEW_LINE temp = temp // 10 NEW_LINE DEDENT if ( ( Sum % count == 0 ) and ( ( int ) ( Sum / count ) in digits ) ) : NEW_LINE INDENT print ( " Yes " ) NEW_LINE DEDENT else : NEW_LINE INDENT print ( " No " ) NEW_LINE DEDENT DEDENT n = 42644 NEW_LINE check ( n ) NEW_LINE |
Count of lexicographically smaller characters on right | function to count the smaller characters at the right of index i ; store the length of String ; for each index initialize count as zero ; increment the count if characters are smaller than at ith index ; print the count of characters smaller than the index i ; Driver code ; input String | def countSmaller ( str ) : NEW_LINE INDENT n = len ( str ) ; NEW_LINE for i in range ( n ) : NEW_LINE INDENT cnt = 0 ; NEW_LINE for j in range ( i + 1 , n ) : NEW_LINE INDENT if ( str [ j ] < str [ i ] ) : NEW_LINE INDENT cnt += 1 ; NEW_LINE DEDENT DEDENT print ( cnt , end = " ▁ " ) ; NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT str = " edcba " ; NEW_LINE countSmaller ( str ) ; NEW_LINE DEDENT |
Find the smallest contiguous sum pair in an Array | Python3 program to find the smallest sum contiguous pair ; Function to find the smallest sum contiguous pair ; Contiguous pair ; isntialize minimum sum with maximum value ; checking for minimum value ; Add to pair ; Updating pair ; Driver code | import sys NEW_LINE def smallestSumpair ( arr , n ) : NEW_LINE INDENT pair = [ ] NEW_LINE min_sum = sys . maxsize NEW_LINE for i in range ( 1 , n ) : NEW_LINE INDENT if min_sum > ( arr [ i ] + arr [ i - 1 ] ) : NEW_LINE INDENT min_sum = arr [ i ] + arr [ i - 1 ] NEW_LINE if pair == [ ] : NEW_LINE INDENT pair . append ( arr [ i - 1 ] ) NEW_LINE pair . append ( arr [ i ] ) NEW_LINE DEDENT else : NEW_LINE INDENT pair [ 0 ] = arr [ i - 1 ] NEW_LINE pair [ 1 ] = arr [ i ] NEW_LINE DEDENT DEDENT DEDENT return pair NEW_LINE DEDENT arr = [ 4 , 9 , - 3 , 2 , 0 ] NEW_LINE n = len ( arr ) NEW_LINE pair = smallestSumpair ( arr , n ) NEW_LINE print ( pair [ 0 ] , pair [ 1 ] ) NEW_LINE |
Sum of the products of same placed digits of two numbers | Function to find the sum of the products of their corresponding digits ; Loop until one of the numbers have no digits remaining ; Driver Code | def sumOfProductOfDigits ( n1 , n2 ) : NEW_LINE INDENT sum1 = 0 ; NEW_LINE while ( n1 > 0 and n2 > 0 ) : NEW_LINE INDENT sum1 += ( ( n1 % 10 ) * ( n2 % 10 ) ) ; NEW_LINE n1 = n1 // 10 ; NEW_LINE n2 = n2 // 10 ; NEW_LINE DEDENT return sum1 ; NEW_LINE DEDENT n1 = 25 ; NEW_LINE n2 = 1548 ; NEW_LINE print ( sumOfProductOfDigits ( n1 , n2 ) ) ; NEW_LINE |
Count of ways to represent N as sum of a prime number and twice of a square | Python3 implementation to count the number of ways a number can be written as sum of prime number and twice a square ; Function to mark all the prime numbers using sieve ; Loop to mark the prime numbers upto the Square root of N ; Loop to store the prime numbers in an array ; Function to find the number ways to represent a number as the sum of prime number and square of a number ; Loop to iterate over all the possible prime numbers ; Increment the count if the given number is a valid number ; Driver Code ; Function call | import math NEW_LINE n = 500000 - 2 NEW_LINE v = [ ] NEW_LINE def sieveoferanthones ( ) : NEW_LINE INDENT prime = [ 1 ] * ( n + 1 ) NEW_LINE for i in range ( 2 , int ( math . sqrt ( n ) ) + 1 ) : NEW_LINE INDENT if ( prime [ i ] != 0 ) : NEW_LINE INDENT for j in range ( i * i , n + 1 , i ) : NEW_LINE INDENT prime [ j ] = False NEW_LINE DEDENT DEDENT DEDENT for i in range ( 2 , n ) : NEW_LINE INDENT if ( prime [ i ] != 0 ) : NEW_LINE INDENT v . append ( i ) NEW_LINE DEDENT DEDENT DEDENT def numberOfWays ( n ) : NEW_LINE INDENT count = 0 NEW_LINE j = 1 NEW_LINE while ( 2 * ( pow ( j , 2 ) ) < n ) : NEW_LINE INDENT i = 1 NEW_LINE while ( v [ i ] + 2 <= n ) : NEW_LINE INDENT if ( n == v [ i ] + ( 2 * ( math . pow ( j , 2 ) ) ) ) : NEW_LINE INDENT count += 1 NEW_LINE DEDENT i += 1 NEW_LINE DEDENT j += 1 NEW_LINE DEDENT print ( count ) NEW_LINE DEDENT sieveoferanthones ( ) NEW_LINE n = 9 NEW_LINE numberOfWays ( n ) NEW_LINE |
Program to convert Degree to Radian | Function for conversion ; Driver code | def Convert ( degree ) : NEW_LINE INDENT pi = 3.14159265359 ; NEW_LINE return ( degree * ( pi / 180 ) ) ; NEW_LINE DEDENT degree = 30 ; NEW_LINE radian = Convert ( degree ) ; NEW_LINE print ( radian ) ; NEW_LINE |
Program to convert a Binary Number to Hexa | Function to convert BCD to hexadecimal ; Iterating through the bits backwards ; Computing the hexadecimal number formed so far and storing it in a vector . ; Reinitializing all variables for next group . ; Printing the hexadecimal number formed so far . ; Driver Code ; Function Call | def bcdToHexaDecimal ( s ) : NEW_LINE INDENT len1 = len ( s ) NEW_LINE check = 0 NEW_LINE num = 0 NEW_LINE sum = 0 NEW_LINE mul = 1 NEW_LINE ans = [ ] NEW_LINE i = len1 - 1 NEW_LINE while ( i >= 0 ) : NEW_LINE INDENT sum += ( ord ( s [ i ] ) - ord ( '0' ) ) * mul NEW_LINE mul *= 2 NEW_LINE check += 1 NEW_LINE if ( check == 4 or i == 0 ) : NEW_LINE INDENT if ( sum <= 9 ) : NEW_LINE INDENT ans . append ( chr ( sum + ord ( '0' ) ) ) NEW_LINE DEDENT else : NEW_LINE INDENT ans . append ( chr ( sum + 55 ) ) ; NEW_LINE DEDENT check = 0 NEW_LINE sum = 0 NEW_LINE mul = 1 NEW_LINE DEDENT i -= 1 NEW_LINE DEDENT len1 = len ( ans ) NEW_LINE i = len1 - 1 NEW_LINE while ( i >= 0 ) : NEW_LINE INDENT print ( ans [ i ] , end = " " ) NEW_LINE i -= 1 NEW_LINE DEDENT DEDENT if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT s = "100000101111" NEW_LINE bcdToHexaDecimal ( s ) NEW_LINE DEDENT |
Subsets and Splits