Convertir un número decimal dado a su representación BCD

Dado un número decimal N , la tarea es convertir N a su forma decimal codificada en binario (BCD) .
Ejemplos: 
 

Entrada: N = 12 
Salida: 0001 0000 
Explicación: 
Considerando el concepto de 4 bits: 
1 en binario es 0001 y 2 en binario es 0010 . 
Entonces, su BCD equivalente es 0001 0010.
Entrada: N = 10 
Salida: 0001 0000 
Explicación: 
considerando el concepto de 4 bits: 
1 en binario es 0001 y 0 en binario es 0000 . 
Entonces su BCD equivalente es 0001 0000. 
 

Acercarse: 
 

1. Invierta los dígitos del número dado N usando el enfoque discutido en este artículo y almacene el número en Rev.
2. Extraiga los dígitos de Rev e imprima la forma binaria del dígito usando el conjunto de bits .
3. Repita los pasos anteriores para cada dígito en Rev.

A continuación se muestra la implementación del enfoque anterior:
 

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to convert Decimal to BCD
void BCDConversion(int n)
{
    // Base Case
    if (n == 0) {
        cout << "0000";
        return;
    }
 
    // To store the reverse of n
    int rev = 0;
 
    // Reversing the digits
    while (n > 0) {
        rev = rev * 10 + (n % 10);
        n /= 10;
    }
 
    // Iterate through all digits in rev
    while (rev > 0) {
 
        // Find Binary for each digit
        // using bitset
        bitset<4> b(rev % 10);
 
        // Print the Binary conversion
        // for current digit
        cout << b << ' ';
 
        // Divide rev by 10 for next digit
        rev /= 10;
    }
}
 
// Driver Code
int main()
{
    // Given Number
    int N = 12;
 
    // Function Call
    BCDConversion(N);
    return 0;
}

// Java program for the above approach
import java.util.*;
 
class Gfg
{
   
    // Function to convert Decimal to BCD
    public static void BCDConversion(int n)
    {
       
        // Base Case
        if(n == 0)
        {
            System.out.print("0000");
        }
       
        // To store the reverse of n
        int rev = 0;
       
        // Reversing the digits
        while (n > 0)
        {
            rev = rev * 10 + (n % 10);
            n /= 10;
        }
         
        // Iterate through all digits in rev
        while(rev > 0)
        {
           
            // Find Binary for each digit
            // using bitset
            String b = Integer.toBinaryString(rev % 10);
             
            b = String.format("%04d", Integer.parseInt(b));
             
              // Print the Binary conversion
            // for current digit
            System.out.print(b + " ");
           
            // Divide rev by 10 for next digit
            rev /= 10;
        }
    }
   
  // Driver code
  public static void main(String []args)
  {
     
    // Given Number
    int N = 12;
     
    // Function Call
    BCDConversion(N);
  }
}
 
// This code is contributed by avanitrachhadiya2155

# Python3 program for the above approach
 
# Function to convert Decimal to BCD
def BCDConversion(n) :
 
    # Base Case
    if (n == 0) :
        print("0000")
        return
 
    # To store the reverse of n
    rev = 0
 
    # Reversing the digits
    while (n > 0) :
        rev = rev * 10 + (n % 10)
        n = n // 10
 
    # Iterate through all digits in rev
    while (rev > 0) :
 
        # Find Binary for each digit
        # using bitset
        b = str(rev % 10)
         
        # Print the Binary conversion
        # for current digit
        print("{0:04b}".format(int(b, 16)), end = " ")
 
        # Divide rev by 10 for next digit
        rev = rev // 10
 
# Given Number
N = 12
 
# Function Call
BCDConversion(N)
 
# This code is contributed by divyeshrabadiya07

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to convert Decimal to BCD
    static void BCDConversion(int n)
    {
        // Base Case
        if (n == 0) {
            Console.Write("0000");
            return;
        }
      
        // To store the reverse of n
        int rev = 0;
      
        // Reversing the digits
        while (n > 0) {
            rev = rev * 10 + (n % 10);
            n /= 10;
        }
      
        // Iterate through all digits in rev
        while (rev > 0) {
      
            // Find Binary for each digit
            // using bitset
            string b = Convert.ToString(rev % 10, 2).PadLeft(4, '0');
      
            // Print the Binary conversion
            // for current digit
            Console.Write(b + " ");
      
            // Divide rev by 10 for next digit
            rev /= 10;
        }
    }
 
  static void Main() {
       
    // Given Number
    int N = 12;
  
    // Function Call
    BCDConversion(N);
  }
}
 
// This code is contributed divyesh072019

<script>
 
    //JavaScript for the above approach
 
    // Function to convert Decimal to BCD
    function BCDConversion(n)
    {
        // Base Case
        if (n == 0) {
            document.write("0000");
            return;
        }
 
        // To store the reverse of n
        let rev = 0;
 
        // Reversing the digits
        while (n > 0) {
            rev = rev * 10 + (n % 10);
            n = parseInt(n / 10, 10);
        }
 
        // Iterate through all digits in rev
        while (rev > 0) {
 
            // Find Binary for each digit
            // using bitset
            let b = (rev % 10).toString(2);
            while(b.length != 4)
            {
                b = "0" + b;
            }
 
            // Print the Binary conversion
            // for current digit
            document.write(b + " ");
 
            // Divide rev by 10 for next digit
            rev = parseInt(rev / 10, 10);
        }
    }
 
    // Driver Code
    // Given Number
    let N = 12;
 
    // Function Call
    BCDConversion(N);
 
</script>

0001 0010

Complejidad de tiempo: O(log ₁₀ N) , donde N es el número dado.