Reconstruct original string from resultant string based on given encoding technique

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-X exists 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>

Output:

01100

Time Complexity: O(N)
Auxiliary Space: O(N)