Skip to content
Related Articles

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] = 0 and A[0] (= 3) > A[1] (= 2) 
S[1] = 0 and A[1] (= 2) > A[2] (= 0) 
S[2] = 1 and A[2] (= 0) > A[3] (= 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 <bits/stdc++.h>
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
Recommended Articles
Page :