 GFG App
Open App Browser
Continue

# 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 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