# Final state of the string after modification

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

1. A character R at index i represents that i-th box is being pushed towards the right.
2. On the other hand, L at index i represents that i-th box is being pushed towards the left.
3. 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.”

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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) gives result = [7, 6, 5, 7, 2, 0, -2, -7, 0].
Thus, the final answer is RRRRR.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)) `

Output:

```LL.RR.LLRRLL..
```

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.