# Reconstruct original string from resultant string based on given encoding technique

• Last Updated : 27 Jan, 2022

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 Pi-X exists and is equal to 1, then Si is 1
• if the character Pi+X exists and is equal to 1, then Si is 1
• if both of the aforementioned conditions are false, then Si 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 ``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

 ``

Output:
`01100`

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

My Personal Notes arrow_drop_up