# Final state of the string after modification

Given a string *S* of length n representing n boxes adjacent to each other.

- A character
*R*at index i represents that i-th box is being pushed towards the right. - On the other hand,
*L*at index i represents that i-th box is being pushed towards the left. - And a
*.*represents an empty space.

We start with initial configuration, at every time unit, a box being pushed toward right pushes next box toward right and same is true for a box being pushed toward left. The task is to print the final positions of all boxes when no more movements are possible. If there is a substring “R.L”, then middle box is being pushed from both directions and therefore not moved any more.

**Examples:**

Input:S = “RR.L”

Output:RR.L

The first and second boxes are being toward right. The middle dot is being pushed from both directions, so does not move.

Input:S = “R..R…L.”

Output:RRRRR.LL.

At time unit 1 :

The first box pushes second box.

Third box pushes fourth box.

Second last box pushes third last box, configuration becomes

“RR.RR.LL.”

At time unit 2 :

Second box pushes third box, string becomes

“RRRRR.LL.”

**Approach:** We can calculate the net force applied on every box. The forces we care about are how close a box is to a leftward *R* or to a rightward *L* i.e. the more closer we are, the stronger will be the force.

- Scanning from left to right, force decays by
*1*in every iteration, and resets to*N*if we meet an*R*again. - Similarly, from right to left direction, we can find the forces from the right (closeness to
*L*). - For some box result[i], if the forces are equal then the result is
*.*as both side apply same force to it. Otherwise, our result is implied by whichever force is stronger.

For string

S = “R..R…L.”

The forces going from left to right are[7, 6, 5, 7, 6, 5, 4, 0, 0].

The forces going from right to left are[0, 0, 0, 0, -4, -5, -6, -7, 0].

Combining them (taking their arithmetic addition at each index) givesresult = [7, 6, 5, 7, 2, 0, -2, -7, 0].

Thus, the final answer isRRRRR.LL.

Below is the implementation of above approach:

## Python3

`# Python3 implementation of above approach ` ` ` `# Function to return final ` `# positions of the boxes ` `def` `pushBoxes(S): ` ` ` ` ` `N ` `=` `len` `(S) ` ` ` `force ` `=` `[` `0` `] ` `*` `N ` ` ` ` ` `# Populate forces going from left to right ` ` ` `f ` `=` `0` ` ` `for` `i ` `in` `range` `(` `0` `, N): ` ` ` ` ` `if` `S[i] ` `=` `=` `'R'` `: ` ` ` `f ` `=` `N ` ` ` `elif` `S[i] ` `=` `=` `'L'` `: ` ` ` `f ` `=` `0` ` ` `else` `: ` ` ` `f ` `=` `max` `(f ` `-` `1` `, ` `0` `) ` ` ` `force[i] ` `+` `=` `f ` ` ` ` ` `# Populate forces going from right to left ` ` ` `f ` `=` `0` ` ` `for` `i ` `in` `range` `(N ` `-` `1` `, ` `-` `1` `, ` `-` `1` `): ` ` ` ` ` `if` `S[i] ` `=` `=` `'L'` `: ` ` ` `f ` `=` `N ` ` ` `elif` `S[i] ` `=` `=` `'R'` `: ` ` ` `f ` `=` `0` ` ` `else` `: ` ` ` `f ` `=` `max` `(f ` `-` `1` `, ` `0` `) ` ` ` `force[i] ` `-` `=` `f ` ` ` ` ` `# return final state of boxes ` ` ` `return` `"".join(` `'.'` `if` `f ` `=` `=` `0` `else` `'R'` `if` `f > ` `0` `else` `'L'` ` ` `for` `f ` `in` `force) ` ` ` ` ` `# Driver code ` `S ` `=` `".L.R...LR..L.."` ` ` `# Function call to print answer ` `print` `(pushBoxes(S)) ` |

*chevron_right*

*filter_none*

**Output:**

LL.RR.LLRRLL..

## Recommended Posts:

- Distinct state codes that appear in a string as contiguous sub-strings
- Final string after performing given operations
- Print the final string when minimum value strings get concatenated in every operation
- Finding the probability of a state at a given time in a Markov chain | Set 2
- Minimum time to return array to its original state after given modifications
- Find the final X and Y when they are Altering under given condition
- Final cell position in the matrix
- Minimum possible final health of the last monster in a game
- Find the final radiations of each Radiated Stations
- Find the final sequence of the array after performing given operations
- Lexicographically smallest string formed by appending a character from the first K characters of a given string
- Create a new string by alternately combining the characters of two halves of the string in reverse
- String slicing in Python to check if a string can become empty by recursive deletion
- Minimal moves to form a string by adding characters or appending string itself
- String Range Queries to find the number of subsets equal to a given String

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.