 GFG App
Open App Browser
Continue

# Generate a sequence determined by the characters of a given string

Given a binary string S of length N (1 ≤ N ≤ 105), the task is to print a permutation A consisting of integers 0 to N satisfying the following conditions:

• If S[i] = 1, then A[i] < A[i + 1].
• If S[i] = 0, then A[i] > A[i + 1].

Examples:

Input: S = “001”
Output: [3, 2, 0, 1]
Explanation:
S = 0 and A (= 3) > A (= 2)
S = 0 and A (= 2) > A (= 0)
S = 1 and A (= 0) > A (= 1)

Input: S = “1010”
Output: [0, 4, 1, 3, 2]

Approach: Follow the steps below to solve the problem:

• Assign the lowest number possible if the character encountered in the string is ‘1’.
• Assign the highest number possible if the character encountered in the string is ‘0’.
• Set two pointers lo (= 0), storing the current lowest possible, and hi (= N), storing the current highest possible.
• Traverse the string and append the values to the resultant array, say res, from the range using the two pointers accordingly.
• After complete traversal of the string, only one value is remaining to be appended. Append lo to the last index.
• Print the array res as the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to print the` `// required sequence` `void` `StringPattern(string S)` `{` `    ``// Length of the string` `    ``int` `n = (``int``)S.size();`   `    ``// Pointers to store lowest and` `    ``// highest possible values` `    ``int` `l = 0, r = n;`   `    ``// Stores the required answer` `    ``vector<``int``> res(n + 1, 0);`   `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``switch` `(S[i]) {`   `        ``// If current character is '1'` `        ``case` `'1'``:`   `            ``// Assign smallest` `            ``// possible value` `            ``res[i] = l++;` `            ``break``;`   `        ``// If current character is '0'` `        ``case` `'0'``:`   `            ``// Assign largest` `            ``// possible value` `            ``res[i] = r--;` `            ``break``;` `        ``}` `    ``}`   `    ``// At this point, l == r ，` `    ``// only one value is not assigned yet.` `    ``res[n] = l;` `    ``for` `(``int` `el : res) {` `        ``cout << el << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``string s = ``"001"``;` `    ``StringPattern(s);`   `    ``return` `0;` `}`

## Java

 `// Java Implementation of above approach ` `import` `java.util.*; ` `class` `GFG ` `{ `   `// function to find minimum required permutation ` `static` `void` `StringPattern(String s) ` `{ ` `    ``int` `n = s.length();` `    ``int` `l = ``0``, r = n;  ` `    ``int` `[] res = ``new` `int``[n + ``1``]; ` `    ``for` `(``int` `x = ``0``; x < n; x++) ` `    ``{ ` `        ``if` `(s.charAt(x) == ``'1'``) ` `        ``{ ` `            ``res[x] = l++;` `        ``} ` `        ``else` `if``(s.charAt(x) == ``'0'``)` `        ``{ ` `            ``res[x] = r--;` `        ``} ` `    ``}     ` `    ``res[n] = l;` `    ``for``(``int` `i = ``0``; i < n+``1``; i++) ` `    ``{ ` `        ``System.out.print(res[i]+``" "``); ` `    ``}` `} `   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String s = ``"001"``;` `    ``StringPattern(s); ` `} ` `} `   `// This code is contributed by mohit kumar 29.`

## Python3

 `# Python program to implement` `# the above approach`   `# Function to print the` `# required sequence` `def` `StringPattern(S):`   `    ``# Stores the lowest, highest` `    ``# possible values that can be` `    ``# appended, size of the string` `    ``lo, hi ``=` `0``, ``len``(S)`   `    ``# Stores the required result` `    ``ans ``=` `[]`   `    ``# Traverse the string` `    ``for` `x ``in` `S:`   `        ``# If current character is '1'` `        ``if` `x ``=``=` `'1'``:`   `            ``# Append lowest` `            ``# possible value` `            ``ans.append(lo)`   `            ``lo ``+``=` `1`   `        ``# If current character is '0'` `        ``else``:`   `            ``# Append highest` `            ``# possible value` `            ``ans.append(hi)`   `            ``hi ``-``=` `1`   `    ``return` `ans ``+` `[lo]`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `        ``# Input` `    ``s ``=` `'001'` `    ``print``(StringPattern(s))`

## C#

 `// C# Implementation of above approach ` `using` `System;` `class` `GFG ` `{ `   `// function to find minimum required permutation ` `static` `void` `StringPattern(String s) ` `{ ` `    ``int` `n = s.Length;` `    ``int` `l = 0, r = n;  ` `    ``int` `[] res = ``new` `int``[n + 1]; ` `    ``for` `(``int` `x = 0; x < n; x++) ` `    ``{ ` `        ``if` `(s[x] == ``'1'``) ` `        ``{ ` `            ``res[x] = l++;` `        ``} ` `        ``else` `if``(s[x] == ``'0'``)` `        ``{ ` `            ``res[x] = r--;` `        ``} ` `    ``}     ` `    ``res[n] = l;` `    ``for``(``int` `i = 0; i < n + 1; i++) ` `    ``{ ` `        ``Console.Write(res[i] + ``" "``); ` `    ``}` `} `   `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``String s = ``"001"``;` `    ``StringPattern(s); ` `} ` `} `   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`3 2 0 1`

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

My Personal Notes arrow_drop_up