Given a HexaDecimal Number N, the task is to convert the number to its equivalent Binary Coded Decimal.
Examples:
Input: 11F
Output: 0001 0001 1111
Explanation:
Binary of 1 – 0001
Binary of F – 1111
Thus, Equivalent BCD is 0001 0001 1111
Input: A D
Output: 1010 1101
Explanation:
Binary of A – 1010
Binary of D – 1101
Thus, Equivalent BCD is 1010 1101
Approach: The idea is to iterate over each digit of the given Hexa-Decimal number and find the four digit Binary Equivalent of that digit. Finally, print all the converted digits one by one.
Below is the implementation of the above approach:
C++
// C++ implementation to convert the given // HexaDecimal number to its equivalent BCD. #include <bits/stdc++.h> using namespace std; // Function to convert // HexaDecimal to its BCD void HexaDecimaltoBCD(string s) { int len = s.length(), check = 0; int num = 0, sum = 0, mul = 1; // Iterating through the digits for ( int i = 0; i <= len - 1; i++) { // check whether s[i] is a character // or a integer between 0 to 9 // and compute its equivalent BCD if (s[i] >= 47 && s[i] <= 52) cout << bitset<4>(s[i]) << " " ; else cout << bitset<4>(s[i] - 55) << " " ; } } // Driver Code int main() { string s = "11F" ; // Function Call HexaDecimaltoBCD(s); return 0; } |
Java
// Java implementation to convert the given // HexaDecimal number to its equivalent BCD. public class Main { // Function to convert // HexaDecimal to its BCD public static void HexaDecimaltoBCD(String s) { int len = s.length(), check = 0 ; int num = 0 , sum = 0 , mul = 1 ; // Iterating through the digits for ( int i = 0 ; i <= len - 1 ; i++) { // check whether s[i] is a character // or a integer between 0 to 9 // and compute its equivalent BCD if (s.charAt(i) >= 47 && s.charAt(i) <= 52 ) { String result = Integer.toBinaryString(( int )s.charAt(i)); System.out.print(result.substring(result.length() - 4 ) + " " ); } else { String result = Integer.toBinaryString(( int )s.charAt(i) - 55 ); System.out.print(result.substring(result.length() - 4 ) + " " ); } } } public static void main(String[] args) { String s = "11F" ; // Function Call HexaDecimaltoBCD(s); } } // This code is contributed by divyesh072019 |
Python3
# Python3 program to convert the given # HexaDecimal number to its equivalent BCD # Function to convert # Haxadecimal to BCD def HexaDecimaltoBCD( str ): # Iterating through the digits for i in range ( len ( str )): # Conversion into equivalent BCD print ( "{0:04b}" . format ( int ( str [i], 16 )), end = " " ) # Driver code str = "11F" # Function call HexaDecimaltoBCD( str ) # This code is contributed by himanshu77 |
C#
// C# implementation to convert the given // HexaDecimal number to its equivalent BCD. using System; class GFG { // Function to convert // HexaDecimal to its BCD static void HexaDecimaltoBCD( string s) { int len = s.Length; // Iterating through the digits for ( int i = 0; i <= len - 1; i++) { // check whether s[i] is a character // or a integer between 0 to 9 // and compute its equivalent BCD if (s[i] >= 47 && s[i] <= 52) { string result = Convert.ToString(( int )s[i], 2); Console.Write(result.Substring(result.Length - 4) + " " ); } else { string result = Convert.ToString(( int )s[i] - 55, 2); Console.Write(result.Substring(result.Length - 4) + " " ); } } } static void Main() { string s = "11F" ; // Function Call HexaDecimaltoBCD(s); } } // This code is contributed by diyeshrabadiya07 |
Javascript
// JavaScript implementation to convert the given // HexaDecimal number to its equivalent BCD. // Function to convert // HexaDecimal to its BCD function HexaDecimaltoBCD(s) { var len = s.length; var check = 0; var num = 0; var sum = 0; var mul = 1; // Iterating through the digits for ( var i = 0; i < len; i++) { // check whether s[i] is a character // or a integer between 0 to 9 // and compute its equivalent BCD if (s[i] >= '0' && s[i] <= '9' ) { var result = parseInt(s[i]).toString(2).padStart(4, "0" ); process.stdout.write(result.substr(-4) + " " ); } else { var result = (s[i].charCodeAt() - 55) .toString(2) .padStart(4, "0" ); process.stdout.write(result.substr(-4) + " " ); } } } // Driver Code var s = "11F" ; // Function Call HexaDecimaltoBCD(s); // This code is contributed by phasing17 |
0001 0001 1111
Method 2:
1. Initialize an empty string variable bcd to store the binary coded decimal representation.
2. Iterate through each character in the input hexadecimal number using a for loop.
3. Convert the character to its equivalent integer value using the int() function with base 16.
4. Convert the integer value to its binary representation using the bin() function, which returns a string of binary digits prefixed with “0b”.
5. Remove the “0b” prefix from the binary string using string slicing ([2:]).
6. Ensure that the binary string has 4 digits by zero-padding it using the zfill() method.
7. Append the zero-padded binary string to the bcd variable.
8. After iterating through all characters in the input hexadecimal number, return the final bcd string.
C++
#include <bitset> #include <iostream> #include <string> using namespace std; string hex_to_bcd(string hex_num) { string bcd = "" ; for ( char c : hex_num) { bcd += bitset<4>(stoi(string(1, c), nullptr, 16)) .to_string(); } return bcd; } int main() { string hex_num = "2A" ; string bcd_num = hex_to_bcd(hex_num); cout << "Hexadecimal number: " << hex_num << endl; cout << "BCD number: " << bcd_num << endl; return 0; } |
Java
import java.util.*; public class HexToBCD { public static String hexToBCD(String hexNum) { String bcd = "" ; for ( int i = 0 ; i < hexNum.length(); i++) { char c = hexNum.charAt(i); int num = Character.digit(c, 16 ); String bits = String.format( "%04d" , Integer.parseInt( Integer.toBinaryString(num))); bcd += bits; } return bcd; } public static void main(String[] args) { String hexNum = "2A" ; String bcdNum = hexToBCD(hexNum); System.out.println( "Hexadecimal number: " + hexNum); System.out.println( "BCD number: " + bcdNum); } } |
Python3
def hex_to_bcd(hex_num): bcd = "" for char in hex_num: bcd + = bin ( int (char, 16 ))[ 2 :].zfill( 4 ) return bcd hex_num = "2A" bcd_num = hex_to_bcd(hex_num) print ( "Hexadecimal number:" , hex_num) print ( "BCD number:" , bcd_num) |
C#
using System; class Program { // Function to convert HEX to BCD static string HexToBcd( string hexNum) { string bcd = "" ; foreach ( char c in hexNum) { bcd += Convert .ToString(Convert.ToInt32( c.ToString(), 16), 2) .PadLeft(4, '0' ); } // Return the BCD return bcd; } // Driver Code static void Main( string [] args) { string hexNum = "2A" ; string bcdNum = HexToBcd(hexNum); Console.WriteLine( "Hexadecimal number: {0}" , hexNum); Console.WriteLine( "BCD number: {0}" , bcdNum); } } |
Javascript
function hex_to_bcd(hex_num) { let bcd = "" ; for (let c of hex_num) { bcd += parseInt(c, 16).toString(2).padStart(4, '0' ); } return bcd; } let hex_num = "2A" ; let bcd_num = hex_to_bcd(hex_num); console.log( "Hexadecimal number: " + hex_num); console.log( "BCD number: " + bcd_num); |
Hexadecimal number: 2A BCD number: 00101010
Time complexity:
The time complexity of the hex_to_bcd function is O(n), where n is the length of the input hexadecimal string. This is because the function iterates through each character in the string and performs a constant amount of work for each character.
Auxiliary Space:
The space auxiliary complexity of the function is also O(n), since it creates a new string variable bcd to store the binary coded decimal representation of the input hexadecimal number, which can be as long as 2n digits (since each hexadecimal digit corresponds to 4 binary digits in BCD representation).
Method: Using look up table method
First, the program defines an unordered map named lookup which maps each hexadecimal character to its BCD representation. For example, the hexadecimal character ‘0’ maps to “0000” and the character ‘A’ maps to “1010”.
Then, the hex_to_bcd function takes a hexadecimal number as a string and initializes an empty string bcd to store the BCD representation. The function iterates over each character in the input string using a range-based for loop. For each character, it looks up its corresponding BCD representation in the lookup map and appends it to the bcd string.
Finally, the main function calls hex_to_bcd with an example hexadecimal number “2A” and stores the result in bcd_num. It then prints both the original hexadecimal number and the resulting BCD number to the console.
C++
#include <iostream> #include <string> #include <unordered_map> using namespace std; string hex_to_bcd(string hex_num) { unordered_map< char , string> lookup { { '0' , "0000" }, { '1' , "0001" }, { '2' , "0010" }, { '3' , "0011" }, { '4' , "0100" }, { '5' , "0101" }, { '6' , "0110" }, { '7' , "0111" }, { '8' , "1000" }, { '9' , "1001" }, { 'A' , "1010" }, { 'B' , "1011" }, { 'C' , "1100" }, { 'D' , "1101" }, { 'E' , "1110" }, { 'F' , "1111" } }; string bcd = "" ; for ( char c : hex_num) { bcd += lookup; } return bcd; } int main() { string hex_num = "2A" ; string bcd_num = hex_to_bcd(hex_num); cout << "Hexadecimal number: " << hex_num << endl; cout << "BCD number: " << bcd_num << endl; return 0; } |
Java
import java.util.HashMap; public class HexToBCD { public static String hexToBCD(String hexNum) { HashMap<Character, String> lookup = new HashMap<>(); lookup.put( '0' , "0000" ); lookup.put( '1' , "0001" ); lookup.put( '2' , "0010" ); lookup.put( '3' , "0011" ); lookup.put( '4' , "0100" ); lookup.put( '5' , "0101" ); lookup.put( '6' , "0110" ); lookup.put( '7' , "0111" ); lookup.put( '8' , "1000" ); lookup.put( '9' , "1001" ); lookup.put( 'A' , "1010" ); lookup.put( 'B' , "1011" ); lookup.put( 'C' , "1100" ); lookup.put( 'D' , "1101" ); lookup.put( 'E' , "1110" ); lookup.put( 'F' , "1111" ); StringBuilder bcd = new StringBuilder(); for ( char c : hexNum.toCharArray()) { bcd.append(lookup.get(c)); } return bcd.toString(); } public static void main(String[] args) { String hexNum = "2A" ; String bcdNum = hexToBCD(hexNum); System.out.println( "Hexadecimal number: " + hexNum); System.out.println( "BCD number: " + bcdNum); } } |
Python3
def hex_to_bcd(hex_num): lookup = { '0' : "0000" , '1' : "0001" , '2' : "0010" , '3' : "0011" , '4' : "0100" , '5' : "0101" , '6' : "0110" , '7' : "0111" , '8' : "1000" , '9' : "1001" , 'A' : "1010" , 'B' : "1011" , 'C' : "1100" , 'D' : "1101" , 'E' : "1110" , 'F' : "1111" } bcd = "" for c in hex_num: bcd + = lookup return bcd hex_num = "2A" bcd_num = hex_to_bcd(hex_num) print ( "Hexadecimal number:" , hex_num) print ( "BCD number:" , bcd_num) |
C#
using System; using System.Collections.Generic; class GFG { // Function to convert a hexadecimal number to its BCD representation static string HexToBcd( string hexNum) { // Define a dictionary to map each hexadecimal digit to its corresponding BCD representation. Dictionary< char , string > lookup = new Dictionary< char , string > { { '0' , "0000" }, { '1' , "0001" }, { '2' , "0010" }, { '3' , "0011" }, { '4' , "0100" }, { '5' , "0101" }, { '6' , "0110" }, { '7' , "0111" }, { '8' , "1000" }, { '9' , "1001" }, { 'A' , "1010" }, { 'B' , "1011" }, { 'C' , "1100" }, { 'D' , "1101" }, { 'E' , "1110" }, { 'F' , "1111" } }; string bcd = "" ; // Iterate through each character in the hexadecimal number. foreach ( char c in hexNum) { // Convert each hexadecimal digit to its BCD representation and append it to the result. bcd += lookup; } return bcd; } static void Main() { string hexNum = "2A" ; // Call the HexToBcd function to convert the hexadecimal number to its BCD representation. string bcdNum = HexToBcd(hexNum); // Display the original hexadecimal number and its BCD representation. Console.WriteLine( "Hexadecimal number: " + hexNum); Console.WriteLine( "BCD number: " + bcdNum); } } |
Javascript
// Define a dictionary to map each hexadecimal digit to its corresponding BCD representation. const lookup = { '0' : "0000" , '1' : "0001" , '2' : "0010" , '3' : "0011" , '4' : "0100" , '5' : "0101" , '6' : "0110" , '7' : "0111" , '8' : "1000" , '9' : "1001" , 'A' : "1010" , 'B' : "1011" , 'C' : "1100" , 'D' : "1101" , 'E' : "1110" , 'F' : "1111" }; // Function to convert a hexadecimal number to its BCD representation function hex_to_bcd(hex_num) { let bcd = "" ; // Iterate through each character in the hexadecimal number. for (let c of hex_num) { // Convert each hexadecimal digit to its BCD representation and append it to the result. bcd += lookup; } return bcd; } const hex_num = "2A" ; // Call the HexToBcd function to convert the hexadecimal number to its BCD representation. const bcd_num = hex_to_bcd(hex_num); // Display the original hexadecimal number and its BCD representation. console.log( "Hexadecimal number: " + hex_num); console.log( "BCD number: " + bcd_num); |
Hexadecimal number: 2A BCD number: 00101010
The time complexity of this algorithm is O(n), where n is the length of the input hex_num.
The auxiliary space complexity is also O(n), since we need to store the BCD representation as a string.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!