Related Articles
Generate a sequence determined by the characters of a given string
• Last Updated : 27 Jan, 2021

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`
Output:
`3 2 0 1`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up