Reconstruct original string from resultant string based on given encoding technique

Read

Discuss

A binary string S of length N is constructed from a string P of N characters and an integer X. The choice of the ith character of S is as follows:

If the character P_i-_Xexists and is equal to 1, then S_i is 1
if the character P_i+_X exists and is equal to 1, then S_i is 1
if both of the aforementioned conditions are false, then S_i is 0.

Given the resulting string S and the integer X, reconstruct the original string P. If no string P can produce the string S, output -1.

Examples:

Input: S = “10011”, X = 2
Output: “01100”
Explanation: The input string S = “10011” can be constructed from the output string P = “01100”.

Input: S = “11101100111”, X = 3
Output: -1
Explanation: The input string S = “11101100111” cannot be constructed from any output string P.

Approach: The task can be solved by taking an auxiliary string with all 1s. Follow the below steps to solve the problem:

Initialize the string P with all the characters as ‘1’.
Now traverse the string S using a loop and put zeroes at the correct positions in P according to the given conditions:
- If S[i] is equal to ‘0’ and P[i-X] exists, i, e, (i-X)>=0, then put P[i-X] = ‘0’.
- If S[i] is equal to ‘0’ and P[i+X] exists, i.e, (i+X)<N, then put P[i+X] = ‘0’.
Initialize a variable flag = 1 to determine whether the string P exists or not.
To check for the correctness of the constructed string P, traverse the string S using a for loop:
- If S[i]==’1′ and either P[i-X] or P[i+X] exists and is equal to ‘1’, then the string P is so far correct and the traversal can continue.
- If S[i]==’1′ and either P[i-X] or P[i+X] does not exist or is not equal to 1, then set flag = 0, output -1 and break from the loop.
If the flag is equal to 0 after the traversal of the string S, then output the original string P.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to find the original string P
void findString(string S, int X)
{
    // Stores the size of string S
    int N = S.size();
 
    // Each character of string 
    // P is set to '1'
    string P(N, '1');
 
    // Loop to put zeroes at
    // the correct positions in P
    for (int i = 0; i < N; ++i) {
 
        // If the character is '0'
        if (S[i] == '0') {
 
            // If P[i-X] exists
            if (i - X >= 0) {
 
                // Set P[i-X] to '0'
                P[i - X] = '0';
            }
 
            // If P[i+X] exists
            if (i + X < N) {
 
                // Set P[i+X] to '0'
                P[i + X] = '0';
            }
        }
    }
 
    // Set flag to 1
    int flag = 1;
 
    // Loop to cross check
    // if P exists or not
    for (int i = 0; i < N; ++i) {
 
        // If the character is '1'
        if (S[i] == '1') {
 
            // If P[i-X] exists and
            // is equal to '1' or if
            // P[i+X] exists and
            // is equal to '1'
            if ((i - X >= 0
                 && P[i - X] == '1')
                || (i + X < N
                    && P[i + X] == '1')) {
                continue;
            }
            else {
 
                // Set flag to 0
                flag = 0;
 
                // Output -1
                cout << -1;
 
                // Break from the loop
                break;
            }
        }
    }
 
    // If flag is equal to 1
    if (flag == 1) {
 
        // Output string P
        cout << P;
    }
}
 
// Driver Code
int main()
{
    // Given input
    string S = "10011";
    int X = 2;
 
    // Function Call
    findString(S, X);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
public class GFG 
{
 
  // Function to find the original string P
  static void findString(String S, int X)
  {
 
    // Stores the size of string S
    int N = S.length();
 
    // Each character of string
    // converted to char Array P
    // is set to '1'
    char[] P = new char[N];
    for (int i = 0; i < N; ++i) {
      P[i] = '1';
    }
 
    // Loop to put zeroes at
    // the correct positions in P
    for (int i = 0; i < N; ++i) {
 
      // If the character is '0'
      if (S.charAt(i) == '0') {
 
        // If P[i-X] exists
        if (i - X >= 0) {
 
          // Set P[i-X] to '0'
          P[i - X] = '0';
        }
 
        // If P[i+X] exists
        if (i + X < N) {
 
          // Set P[i+X] to '0'
          P[i + X] = '0';
        }
      }
    }
 
    // Set flag to 1
    int flag = 1;
 
    // Loop to cross check
    // if P exists or not
    for (int i = 0; i < N; ++i) {
 
      // If the character is '1'
      if (S.charAt(i) == '1') {
 
        // If P[i-X] exists and
        // is equal to '1' or if
        // P[i+X] exists and
        // is equal to '1'
        if ((i - X >= 0 && P[i - X] == '1')
            || (i + X < N && P[i + X] == '1')) {
          continue;
        }
        else {
 
          // Set flag to 0
          flag = 0;
 
          // Output -1
          System.out.print(-1);
 
          // Break from the loop
          break;
        }
      }
    }
 
    // If flag is equal to 1
    if (flag == 1) {
 
      // Output string P
      String p = new String(P);
      System.out.print(p);
    }
  }
 
  // Driver Code
  public static void main(String args[])
  {
 
    // Given input
    String S = "10011";
    int X = 2;
 
    // Function Call
    findString(S, X);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Python3

# Python program for the above approach
 
# Function to find the original string P
def findString(S, X):
 
    # Stores the size of string S
    N = len(S)
 
    # Each character of string
    # P is set to '1'
    P = ['1'] * N
 
    # Loop to put zeroes at
    # the correct positions in P
    for i in range(N):
 
        # If the character is '0'
        if (S[i] == '0'):
 
            # If P[i-X] exists
            if (i - X >= 0):
 
                # Set P[i-X] to '0'
                P[i - X] = '0';
 
            # If P[i+X] exists
            if (i + X < N):
 
                # Set P[i+X] to '0'
                P[i + X] = '0';
 
    # Set flag to 1
    flag = 1;
 
    # Loop to cross check
    # if P exists or not
    for i in range(N):
 
        # If the character is '1'
        if (S[i] == '1'):
 
            # If P[i-X] exists and
            # is equal to '1' or if
            # P[i+X] exists and
            # is equal to '1'
            if ((i - X >= 0 and P[i - X] == '1') or (i + X < N and P[i + X] == '1')):
                continue;
            else:
 
                # Set flag to 0
                flag = 0;
 
                # Output -1
                print(-1);
 
                # Break from the loop
                break;
 
    # If flag is equal to 1
    if (flag == 1):
 
        # Output string P
        print("".join(P));
 
# Driver Code
 
# Given input
S = "10011";
X = 2;
 
# Function Call
findString(S, X);
 
# This code is contributed by gfgking

C#

// C# program for the above approach
using System;
using System.Collections;
class GFG 
{
 
  // Function to find the original string P
  static void findString(string S, int X)
  {
 
    // Stores the size of string S
    int N = S.Length;
 
    // Each character of string
    // converted to char Array P
    // is set to '1'
    char[] P = new char[N];
    for (int i = 0; i < N; ++i) {
      P[i] = '1';
    }
 
    // Loop to put zeroes at
    // the correct positions in P
    for (int i = 0; i < N; ++i) {
 
      // If the character is '0'
      if (S[i] == '0') {
 
        // If P[i-X] exists
        if (i - X >= 0) {
 
          // Set P[i-X] to '0'
          P[i - X] = '0';
        }
 
        // If P[i+X] exists
        if (i + X < N) {
 
          // Set P[i+X] to '0'
          P[i + X] = '0';
        }
      }
    }
 
    // Set flag to 1
    int flag = 1;
 
    // Loop to cross check
    // if P exists or not
    for (int i = 0; i < N; ++i) {
 
      // If the character is '1'
      if (S[i] == '1') {
 
        // If P[i-X] exists and
        // is equal to '1' or if
        // P[i+X] exists and
        // is equal to '1'
        if ((i - X >= 0 && P[i - X] == '1')
            || (i + X < N && P[i + X] == '1')) {
          continue;
        }
        else {
 
          // Set flag to 0
          flag = 0;
 
          // Output -1
          Console.Write(-1);
 
          // Break from the loop
          break;
        }
      }
    }
 
    // If flag is equal to 1
    if (flag == 1) {
 
      // Output string P
      string p = new string(P);
      Console.Write(p);
    }
  }
 
  // Driver Code
  public static void Main()
  {
    // Given input
    string S = "10011";
    int X = 2;
 
    // Function Call
    findString(S, X);
  }
}
 
// This code is contributed by Taranpreet

Javascript

<script>
    // JavaScript program for the above approach
 
    // Function to find the original string P
    const findString = (S, X) => {
     
        // Stores the size of string S
        let N = S.length;
 
        // Each character of string
        // P is set to '1'
        let P = new Array(N).fill('1');
 
        // Loop to put zeroes at
        // the correct positions in P
        for (let i = 0; i < N; ++i) {
 
            // If the character is '0'
            if (S[i] == '0') {
 
                // If P[i-X] exists
                if (i - X >= 0) {
 
                    // Set P[i-X] to '0'
                    P[i - X] = '0';
                }
 
                // If P[i+X] exists
                if (i + X < N) {
 
                    // Set P[i+X] to '0'
                    P[i + X] = '0';
                }
            }
        }
 
        // Set flag to 1
        let flag = 1;
 
        // Loop to cross check
        // if P exists or not
        for (let i = 0; i < N; ++i) {
 
            // If the character is '1'
            if (S[i] == '1') {
 
                // If P[i-X] exists and
                // is equal to '1' or if
                // P[i+X] exists and
                // is equal to '1'
                if ((i - X >= 0
                    && P[i - X] == '1')
                    || (i + X < N
                        && P[i + X] == '1')) {
                    continue;
                }
                else {
 
                    // Set flag to 0
                    flag = 0;
 
                    // Output -1
                    document.write(-1);
 
                    // Break from the loop
                    break;
                }
            }
        }
 
        // If flag is equal to 1
        if (flag == 1) {
 
            // Output string P
            document.write(P.join(""));
        }
    }
 
    // Driver Code
 
    // Given input
    let S = "10011";
    let X = 2;
 
    // Function Call
    findString(S, X);
 
// This code is contributed by rakeshsahni
 
</script>