C++ Program To Convert Binary To (septenary)

In this article, you will learn how to convert a binary number to its septenary equivalent using C++. We will break down the process into logical steps, providing a clear understanding of number base conversions and their implementation.

Problem Statement

The problem is to take a number represented in binary (base 2) and convert it into its equivalent representation in septenary (base 7). This conversion is fundamental in understanding how different numbering systems work and is a common task in various computing and mathematical contexts. For instance, a binary input like 1011 needs to be correctly translated into its base 7 form.

Example

Let's consider the binary number 1011.

• Binary 1011 is equivalent to decimal 11.
• Decimal 11 is equivalent to septenary 14.

Thus, the conversion of binary 1011 to septenary should yield 14.

Background & Knowledge Prerequisites

To understand this conversion process, readers should be familiar with:

• Number Bases: Basic understanding of different number systems like binary (base 2), decimal (base 10), and the concept of septenary (base 7).
• Binary to Decimal Conversion: How to convert a binary number to its decimal equivalent (e.g., summing digit * 2^position).
• Decimal to Other Base Conversion: The method of repeatedly dividing a decimal number by the target base and collecting remainders in reverse order.
• C++ Basics:
• Functions and their definitions.
• Loops (e.g., while loops).
• Arithmetic operations (modulo %, division /, multiplication *).
• Input/output operations (cin, cout).

Use Cases or Case Studies

Understanding and implementing number base conversions is valuable in several areas:

• Computer Science Education: Essential for grasping how computers store and process data, which primarily uses binary.
• Low-Level Programming: In scenarios where direct manipulation of bit patterns or specific base representations is required.
• Algorithm Development: When designing algorithms that operate on or require output in non-standard bases.
• Data Representation: Converting data between systems that might use different internal number representations.
• Mathematical Puzzles and Theory: Exploring properties of numbers across various bases can be a part of recreational mathematics or number theory research.

Solution Approaches

The most straightforward and common approach to convert a number from an arbitrary base (like binary) to another arbitrary base (like septenary) is to first convert the number to its decimal (base 10) equivalent, and then convert that decimal number to the target base.

Convert Binary to Decimal, then Decimal to Septenary

This method involves two sequential conversions: first from binary to its decimal equivalent, and then from the decimal value to septenary.

Code Example:

// Binary to Septenary Converter
#include <iostream>
#include <string>
#include <algorithm> // Required for std::reverse

// Function to convert binary to decimal
long long binaryToDecimal(long long binaryNumber) {
    long long decimalNumber = 0;
    long long base = 1; // Represents powers of 2 (2^0, 2^1, 2^2, ...)

    while (binaryNumber > 0) {
        int lastDigit = binaryNumber % 10; // Get the last digit (either 0 or 1)
        binaryNumber = binaryNumber / 10;  // Remove the last digit
        decimalNumber += lastDigit * base; // Add the product of digit and power of 2
        base *= 2;                         // Move to the next power of 2
    }
    return decimalNumber;
}

// Function to convert decimal to septenary
long long decimalToSeptenary(long long decimalNumber) {
    if (decimalNumber == 0) {
        return 0; // Special case for input 0
    }

    std::string septenaryString = "";
    while (decimalNumber > 0) {
        int remainder = decimalNumber % 7; // Get the remainder when divided by 7
        septenaryString += std::to_string(remainder); // Append remainder to string
        decimalNumber /= 7;                          // Update decimal number
    }
    std::reverse(septenaryString.begin(), septenaryString.end()); // Reverse the string
    return std::stoll(septenaryString); // Convert string back to long long
}

int main() {
    // Step 1: Declare a variable to store the binary input
    long long binaryInput;

    // Step 2: Prompt the user to enter a binary number
    std::cout << "Enter a binary number: ";
    std::cin >> binaryInput;

    // Step 3: Convert the binary number to its decimal equivalent
    long long decimalValue = binaryToDecimal(binaryInput);

    // Step 4: Convert the decimal value to its septenary equivalent
    long long septenaryValue = decimalToSeptenary(decimalValue);

    // Step 5: Display the result
    std::cout << "Binary " << binaryInput << " = Septenary " << septenaryValue << std::endl;

    return 0;
}

Run

Sample Output:

Enter a binary number: 1011
Binary 1011 = Septenary 14

Enter a binary number: 11101
Binary 11101 = Septenary 56

Stepwise Explanation:

1. binaryToDecimal(long long binaryNumber) Function:
   • Initializes decimalNumber to 0 and base (power of 2) to 1.

It iterates as long as binaryNumber is greater than 0.

In each iteration:

It extracts the lastDigit of the binaryNumber (e.g., binaryNumber % 10). For binary, this will be either 0 or 1.

The binaryNumber is then reduced by its last digit (e.g., binaryNumber / 10).

The lastDigit is multiplied by the current base (which represents 2^0, 2^1, 2^2, ...) and added to decimalNumber.

The base is doubled for the next iteration (base *= 2), moving to the next power of 2.

Once all digits are processed, the function returns the calculated decimalNumber.

1. decimalToSeptenary(long long decimalNumber) Function:
   • Handles the edge case where decimalNumber is 0, returning 0 directly.

Initializes an empty string septenaryString to build the septenary representation.

It iterates as long as decimalNumber is greater than 0.

In each iteration:

It calculates the remainder when decimalNumber is divided by 7. This remainder is a digit in base 7.

The remainder is converted to a string and appended to septenaryString.

The decimalNumber is then updated by dividing it by 7 (decimalNumber /= 7).

After the loop, the septenaryString contains the septenary digits in reverse order (e.g., for decimal 11, it would be "41").

std::reverse is used to reverse the string to get the correct order (e.g., "14").

Finally, std::stoll converts the resulting string back into a long long and returns it.

1. main() Function:
   • Prompts the user to enter a binary number.

Calls binaryToDecimal to perform the first conversion.

Calls decimalToSeptenary to perform the second conversion on the result.

Prints the original binary number and its septenary equivalent.

Conclusion

Converting between different number bases is a foundational skill in computing. By first converting a binary number to its decimal equivalent and then converting that decimal value to septenary, we establish a robust and easily understandable method. This two-step approach is versatile for conversions between any two bases, provided an intermediate decimal conversion.

Summary

• Binary to septenary conversion involves a two-step process: binary to decimal, then decimal to septenary.
• Binary to Decimal: Sum each binary digit multiplied by its corresponding power of 2.
• Decimal to Septenary: Repeatedly divide the decimal number by 7, collecting the remainders. The septenary number is formed by these remainders in reverse order.
• C++ functions can encapsulate each conversion step for modularity and clarity.
• This method is applicable to converting between any two arbitrary bases through an intermediate decimal representation.