Program to convert given Binary to its equivalent ASCII character string

Given a binary string str, the task is to find its equivalent ASCII (American Standard Code for Information Interchange) character string.

Examples: 

Input: str = “0110000101100010”
Output: ab
Explanation: Dividing str into set of 8 bits as follows: 

• 01100001 = 97, ASCII value of 97 is ‘a’.
• 01100010 = 98, ASCII value of 98 is ‘b’.

Therefore, the required ASCII character string is “ab”.

Input: str = “10000101100”
Output: Not Possible
Explanation: The given binary string is not a valid string as the number of characters is not a multiple of 8.

Approach: This problem is implementation-based problem. Follow the steps below to solve the given problem. 

• At first, check if s is divisible by 8 or not
  • If not divisible by 8 print “Not Possible”
  • Otherwise, move to the next step
• Declare an empty string to store all the ASCII character string.
• Traverses in a jump of 8 characters and in each step find the decimal equivalent value of the current set of 8 bits.
• Convert the decimal value to its equivalent ASCII character and append it to the res string.
• Return the res string.

Below is the implementation of the above approach:

C++14

// C++ implementation for above approach
#include <bits/stdc++.h>
using namespace std;

// Function to convert binary to decimal
int binaryToDecimal(string n)
{
    string num = n;

    // Stores the decimal value
    int dec_value = 0;

    // Initializing base value to 1
    int base = 1;

    int len = num.length();
    for (int i = len - 1; i >= 0; i--) {

        // If the current bit is 1
        if (num[i] == '1')
            dec_value += base;
        base = base * 2;
    }

    // Return answer
    return dec_value;
}

// Function to convert binary to ASCII
string setStringtoASCII(string str)
{
    // To store size of s
    int N = int(str.size());

    // If given string is not a
    // valid string
    if (N % 8 != 0) {
        return "Not Possible!";
    }

    // To store final answer
    string res = "";

    // Loop to iterate through string
    for (int i = 0; i < N; i += 8) {
        int decimal_value
            = binaryToDecimal((str.substr(i, 8)));

        // Apprend the ASCII character
        // equivalent to current value
        res += char(decimal_value);
    }

    // Return Answer
    return res;
}

// Driver Code
int main()
{
    string s = "0110000101100010";
    cout << setStringtoASCII(s);

    return 0;
}

Java

// Java implementation for above approach
import java.util.*;

class GFG
{

// Function to convert binary to decimal
static int binaryToDecimal(String n)
{
    String num = n;

    // Stores the decimal value
    int dec_value = 0;

    // Initializing base value to 1
    int base = 1;

    int len = num.length();
    for (int i = len - 1; i >= 0; i--) {

        // If the current bit is 1
        if (num.charAt(i) == '1')
            dec_value += base;
        base = base * 2;
    }

    // Return answer
    return dec_value;
}

// Function to convert binary to ASCII
static String setStringtoASCII(String str)
{

    // To store size of s
    int N = (str.length());

    // If given String is not a
    // valid String
    if (N % 8 != 0) {
        return "Not Possible!";
    }

    // To store final answer
    String res = "";

    // Loop to iterate through String
    for (int i = 0; i < N; i += 8) {
        int decimal_value
            = binaryToDecimal((str.substring(i, 8+i)));

        // Apprend the ASCII character
        // equivalent to current value
        res += (char)(decimal_value);
    }

    // Return Answer
    return res;
}

// Driver Code
public static void main(String[] args)
{
    String s = "0110000101100010";
    System.out.print(setStringtoASCII(s));

}
}

// This code is contributed by 29AjayKumar

Python3

# python implementation for above approach

# Function to convert binary to decimal
def binaryToDecimal(n):
    num = n

    # Stores the decimal value
    dec_value = 0

    # Initializing base value to 1
    base = 1

    le = len(num)
    for i in range(le - 1, -1, -1):

        # If the current bit is 1
        if (num[i] == '1'):
            dec_value += base
        base = base * 2

    # Return answer
    return dec_value

# Function to convert binary to ASCII
def setStringtoASCII(str):

    # To store size of s
    N = int(len(str))

    # If given string is not a
    # valid string
    if (N % 8 != 0):
        return "Not Possible!"

        # To store final answer
    res = ""

    # Loop to iterate through string
    for i in range(0, N, 8):
        decimal_value = binaryToDecimal(str[i: i + 8])

        # Apprend the ASCII character
        # equivalent to current value
        res += chr(decimal_value)

        # Return Answer
    return res

# Driver Code
if __name__ == "__main__":

    s = "0110000101100010"
    print(setStringtoASCII(s))

    # This code is contributed by rakeshsahni

C#

// C# implementation for above approach
using System;

class GFG {

    // Function to convert binary to decimal
    static int binaryToDecimal(string n)
    {
        string num = n;

        // Stores the decimal value
        int dec_value = 0;

        // Initializing base value to 1
        int base1 = 1;

        int len = num.Length;
        for (int i = len - 1; i >= 0; i--) {

            // If the current bit is 1
            if (num[i] == '1')
                dec_value += base1;
            base1 = base1 * 2;
        }

        // Return answer
        return dec_value;
    }

    // Function to convert binary to ASCII
    static string setStringtoASCII(string str)
    {

        // To store size of s
        int N = (str.Length);

        // If given String is not a
        // valid String
        if (N % 8 != 0) {
            return "Not Possible!";
        }

        // To store final answer
        string res = "";

        // Loop to iterate through String
        for (int i = 0; i < N; i += 8) {
            int decimal_value
                = binaryToDecimal((str.Substring(i, 8)));

            // Apprend the ASCII character
            // equivalent to current value
            res += (char)(decimal_value);
        }

        // Return Answer
        return res;
    }

    // Driver Code
    public static void Main(string[] args)
    {
        string s = "0110000101100010";
        Console.WriteLine(setStringtoASCII(s));
    }
}

// This code is contributed by ukasp.

Javascript

<script>

// JavaScript implementation for above approach

// Function to convert binary to decimal
function binaryToDecimal(n)
{
    let num = n;

    // Stores the decimal value
    let dec_value = 0;

    // Initializing base value to 1
    let base = 1;

    let len = n.length;
    for(let i = len - 1; i >= 0; i--)
    {

        // If the current bit is 1
        if (n[i] == '1')
            dec_value += base;

        base = base * 2;
    }

    // Return answer
    return dec_value;
}

// Function to convert binary to ASCII
function setStringtoASCII(str)
{

    // To store size of s
    let N = str.length;

    // If given string is not a
    // valid string
    if (N % 8 != 0)
    {
        return "Not Possible!";
    }

    // To store final answer
    let res = "";

    // Loop to iterate through string
    for(let i = 0; i < N; i = i + 8)
    {
        let decimal_value = binaryToDecimal(
            (str.slice(i, i + 8)));

        // Apprend the ASCII character
        // equivalent to current value
        res = res + String.fromCharCode(decimal_value);
    }

    // Return Answer
    return res;
}

// Driver Code
let s = "0110000101100010";
document.write(setStringtoASCII(s));

// This code is contributed by Potta Lokesh

</script>

Output

ab

Time Complexity: O(N), as we are using a loop to traverse N times so it will cost us O(N) time.
Auxiliary Space: O(N)

Approach 2: bit shifting:

In this approach, we loop through the binary string in chunks of 8 characters. For each chunk, we create an integer variable asciiValue and loop through the 8 characters in the chunk. For each character, we shift asciiValue one bit to the left and add the value of the character (‘0’ or ‘1’) to the rightmost bit using the bitwise OR operator. Once we’ve processed all 8 characters in the chunk, we convert asciiValue to a character using a cast and append it to asciiString. Finally, we print asciiString to the console.

Note that we’re using static_cast<char> to convert the integer asciiValue to a character. This is safer than using a C-style cast or a regular cast because it performs compile-time checks and produces a compile error if the conversion is not allowed.

here is the code of above approach:

C++

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string binaryString = "0110000101100010";
    string asciiString = "";

    for (size_t i = 0; i < binaryString.size(); i += 8) {
        int asciiValue = 0;
        for (size_t j = 0; j < 8; j++) {
            asciiValue <<= 1;
            asciiValue |= (binaryString[i + j] - '0');
        }
        asciiString += static_cast<char>(asciiValue);
    }

    cout << asciiString << endl;

    return 0;
}

Java

import java.util.*;

public class Main {
    public static void main(String[] args)
    {
        String binaryString = "0110000101100010";
        String asciiString = "";

        for (int i = 0; i < binaryString.length(); i += 8) {
            int asciiValue = 0;
            for (int j = 0; j < 8; j++) {
                asciiValue <<= 1;
                asciiValue
                    |= (binaryString.charAt(i + j) - '0');
            }
            asciiString += (char)asciiValue;
        }

        System.out.println(asciiString);
    }
}

Python3

binary_string = "0110000101100010"
ascii_string = ""

for i in range(0, len(binary_string), 8):
    ascii_value = 0
    for j in range(8):
        ascii_value <<= 1
        ascii_value |= int(binary_string[i+j])
    ascii_string += chr(ascii_value)

print(ascii_string)

C#

using System;

class Program {
    static void Main(string[] args)
    {
        // Initialize a binary string
        string binaryString = "0110000101100010";

        // Initialize an empty string to store the ASCII
        // characters
        string asciiString = "";

        // Loop through the binary string in chunks of 8
        // bits (1 byte)
        for (int i = 0; i < binaryString.Length; i += 8) {
            // Initialize an integer to store the ASCII
            // value of each byte
            int asciiValue = 0;
            // Loop through each bit in the byte and
            // calculate its ASCII value
            for (int j = 0; j < 8; j++) {
                // Shift the bits of asciiValue to the left
                // by one position
                asciiValue <<= 1;
                // OR the last bit of asciiValue with the
                // current bit of binaryString
                asciiValue |= (binaryString[i + j] - '0');
            }
            // Convert the ASCII value to its corresponding
            // character and add it to asciiString
            asciiString += Convert.ToChar(asciiValue);
        }

        // Print out the resulting ASCII string
        Console.WriteLine(asciiString);
    }
}

Javascript

const binaryString = "0110000101100010";
let asciiString = "";

for (let i = 0; i < binaryString.length; i += 8) {
  let asciiValue = 0;
  for (let j = 0; j < 8; j++) {
    asciiValue <<= 1;
    asciiValue |= parseInt(binaryString[i+j], 10);
  }
  asciiString += String.fromCharCode(asciiValue);
}

console.log(asciiString);

Output

ab

Time Complexity:  O(N), where n is the number of elements in the input array.
Auxiliary Space: O(N)