Open in App
Not now

# Generate a Sequence by inserting positions into Array based on corresponding String value

• Difficulty Level : Hard
• Last Updated : 24 Mar, 2022

Given a string S of length N. The string consists only of letters ‘F’ and ‘B’. The task is to generate a sequence performing some operations such that:

• Consider an integer sequence A that consists of only a 0, i.e. A = (0).
• Now, for each index(i) of the string (1 to N), if S[i] is ‘F’ add i to the immediate front (i.e. left side) of i-1 in sequence A
• Else if S[i] is ‘B’ add i to the immediate back (i.e. right side) of i-1 sequence A.
• Print the resultant sequence A.

Examples :

Input: N = 5, S = “FBBFB”
Output: 1 2 4 5 3 0
Explanation: Initially, A = {0}.
S[1] is ‘F’ , sequence becomes {1, 0}
S[2] is ‘B’ , sequence becomes {1, 2, 0}
S[3] is ‘B’ , sequence becomes {1, 2, 3, 0}
S[4] is ‘F’ , sequence becomes {1, 2, 4, 3, 0}
S[5] is ‘B’ , sequence becomes {1, 2, 4, 5, 3, 0}

Input : N = 6 , S = “BBBBBB”
Output : 0 1 2 3 4 5 6

Approach: The idea to solve the problem is based on the concept dequeue.

As at each iteration, it is possible that insertion of i may occur from any end of (i-1), therefore deque can be used as in dequeue insertion is possible from any end.

Follow the steps for the solution:

• The observation in the approach is that the problem becomes more simple after inverting all the operations.
• The problem now modifies to, a given sequence that consists of only (N), and after each iteration from the end of the string,
• If S[i] is ‘F’, push i to the right of i-1,
• If S[i] is ‘B’, push i to the left of i-1 in the dequeue.
• Return the elements of dequeue in the order from the front end.

Below is the implementation of the above approach.

## C++

 `// C++ program for above approach`   `#include ` `using` `namespace` `std;`   `// Function to find sequence` `// from given string ` `// according to given rule` `void` `findSequence(``int` `N, string S)` `{`   `    ``// Creating a deque` `    ``deque<``int``> v;`   `    ``// Inserting N (size of string) into deque` `    ``v.push_back(N);`   `    ``// Iterating string from behind and` `    ``// pushing the indices into the deque` `    ``for` `(``int` `i = N - 1; i >= 0; i--) {`   `        ``// If letter at current index is 'F',` `        ``// push i to the right of i-1` `        ``if` `(S[i] == ``'F'``) {` `            ``v.push_back(i);` `        ``}`   `        ``// If letter at current index is 'B',` `        ``// push i to the left of i-1` `        ``else` `{` `            ``v.push_front(i);` `        ``}` `    ``}`   `    ``// Printing resultant sequence` `    ``for` `(``int` `i = 0; i <= N; i++)` `        ``cout << v[i] << ``" "``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5;` `    ``string S = ``"FBBFB"``;`   `    ``// Printing the sequence` `    ``findSequence(N, S);` `    ``return` `0;` `}`

## Java

 `// JAVA program for above approach` `import` `java.util.*;` `class` `GFG` `{`   `  ``// Function to find sequence` `  ``// from given string` `  ``// according to given rule` `  ``public` `static` `void` `findSequence(``int` `N, String S)` `  ``{`   `    ``// Creating a deque` `    ``Deque v = ``new` `ArrayDeque();`   `    ``// Inserting N (size of string) into deque` `    ``v.addLast(N);`   `    ``// Iterating string from behind and` `    ``// pushing the indices into the deque` `    ``for` `(``int` `i = N - ``1``; i >= ``0``; i--) {`   `      ``// If letter at current index is 'F',` `      ``// push i to the right of i-1` `      ``if` `(S.charAt(i) == ``'F'``) {` `        ``v.addLast(i);` `      ``}`   `      ``// If letter at current index is 'B',` `      ``// push i to the left of i-1` `      ``else` `{` `        ``v.addFirst(i);` `      ``}` `    ``}`   `    ``// Printing resultant sequence` `    ``for` `(Iterator itr = v.iterator(); itr.hasNext();) {` `      ``System.out.print(itr.next() + ``" "``);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``5``;` `    ``String S = ``"FBBFB"``;`   `    ``// Printing the sequence` `    ``findSequence(N, S);` `  ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python program for above approach` `from` `collections ``import` `deque`   `# Function to find sequence` `# from given string` `# according to given rule` `def` `findSequence(N, S):`   `    ``# Creating a deque` `    ``v ``=` `deque()`   `    ``# Inserting N (size of string) into deque` `    ``v.append(N)`   `    ``# Iterating string from behind and` `    ``# pushing the indices into the deque` `    ``i ``=` `N ``-` `1` `    ``while``(i >``=` `0``):`   `        ``# If letter at current index is 'F',` `        ``# push i to the right of i-1` `        ``if` `(S[i] ``=``=` `'F'``):` `            ``v.append(i)`   `        ``# If letter at current index is 'B',` `        ``# push i to the left of i-1` `        ``else``:` `            ``v.appendleft(i)`   `        ``i ``-``=` `1`   `    ``# Printing resultant sequence` `    ``print``(``*``v)`   `# Driver Code` `N ``=` `5` `S ``=` `"FBBFB"`   `# Printing the sequence` `findSequence(N, S)`   `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# program for above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `  ``// Function to find sequence` `  ``// from given string` `  ``// according to given rule` `  ``public` `static` `void` `findSequence(``int` `N, String S)` `  ``{`   `    ``// Creating a deque` `    ``List<``int``> v = ``new` `List<``int``>();`   `    ``// Inserting N (size of string) into deque` `    ``v.Add(N);`   `    ``// Iterating string from behind and` `    ``// pushing the indices into the deque` `    ``for` `(``int` `i = N - 1; i >= 0; i--) {`   `      ``// If letter at current index is 'F',` `      ``// push i to the right of i-1` `      ``if` `(S[i] == ``'F'``) {` `        ``v.Add(i);` `      ``}`   `      ``// If letter at current index is 'B',` `      ``// push i to the left of i-1` `      ``else` `{` `        ``v.Insert(0,i);` `      ``}` `    ``}`   `    ``// Printing resultant sequence` `    ``foreach` `(``int` `itr ``in` `v) {` `      ``Console.Write(itr + ``" "``);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `N = 5;` `    ``String S = ``"FBBFB"``;`   `    ``// Printing the sequence` `    ``findSequence(N, S);` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`1 2 4 5 3 0 `

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

My Personal Notes arrow_drop_up
Related Articles