# Program to convert Hexa-Decimal Number to its equivalent BCD

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 ` `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`

Output

```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 ` `#include ` `#include `   `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);`

Output

```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 ` `#include ` `#include `   `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 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);`

Output

```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.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next