Question

The objective is to convert an array like a3b5c2 to aaabbbbbcc in-place.
I have a solution:

• Assuming that the array is of infinite size,
• I parse the array from the end.
• look for a number (say n)
• depending on how many digits I get, I look for the next character.
• When I get it, I move the elements from current position through end of array by n-1 positions.
• Fill the open positions with the encountered character.

The complexity of this solution will be O(n^2). Is there a solution with complexity less than O(n^2)?

Answer 1

If you parse the array once, you can know where the last element will be by summing all the numerical values.

Parse it once and find its final size.

Once you do that, start filling it from the “end” (from where its final value will be): 2 times c, then 5 times b…

This is a O(n) in-place solution.

EDIT:

As srbh.kmr said in comments, this won’t work if the array has a series of badly-placed characters repeated only one time. For instance, if we have the array a1b1c1d1e7, the answer above will erase the last letters.

The only number that causes issues is 1, and we can treat it in O(n):

Before treating the array as explained above, eliminate those ones. Starting from the beginning, parse the array and each time a 1 is found, erase it and move the remaining letters forward (not the whole remaining array, just the next characters). If several 1s are found in the array, the hole between the first and second parts of the array will get bigger. For the example array above, the steps look like this:

a1b1c1d1e7
// First parse gives length = 1+1+1+1+7

// Repair ones
a b1c1d1e7
ab 1c1d1e7
ab  c1d1e7
abc  1d1e7
abc   d1e7
abcd   1e7
abcd    e7
abcde    7
abcde7

Then, apply the algorithm above. If no number is found after a character, just copy the character to its position at the end of the array:

// Fill final array
abcde7    x
          ^ 11th position
abcde     e
abcde    ee
abcde   eee
abcde  eeee
abcde eeeee
abcdeeeeeee
abcdeeeeeee  // Here we overwrite the first "e"
abcdeeeeeee  // Then we see there are lone letters (4 times), so we leave them.