decodeString: regex solution

Question

The prompt: Given an encoded string, return its corresponding decoded string. The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is repeated exactly k times. Note: k is guaranteed to be a positive integer.

For s = "4[ab]", the output should be decodeString(s) = "abababab" For s = "2[b3[a]]", the output should be decodeString(s) = "baaabaaa"

My answer:

let decodeString = function(s) {

  const replaced = s.replace((/(\d+)\[([a-z]*)\]/), (match, num, substr) => {
    return substr.repeat(num);
  })

  return replaced.indexOf('[') > -1 ? decodeString(replaced) : replaced; 

};

This solution works for smaller inputs like "3[a]2[bc]" but I get stack overflow for more complex inputs like "3[a]2[b4[F]c]". Is there a way to do this iteratively to avoid using the call stack? Is it possible to solve this question by only using regex? Any help is much appreciated!

This is a great exercise to write a basic lexer, parser, and evaluator. I highly recommend you try it. It will show you how to work through this problem without a highly sophisticated regexp engine. — Mulan, Jun 11 '18 at 19:51

Luis felipe De jesus Munoz · Accepted Answer · 2018-06-11T18:13:16.403

2

function decodeString(str){
 let regex = /(\d+)\[([a-z]*)\]/gi;
 let result = str.replace(regex, (match, num, substr) => substr.repeat(num));
 let recall = regex.test(result);
 if(recall){
  return decodeString(result);
 }
 return result;
}

console.log(
  decodeString("4[ab]"),
  decodeString("2[b3[a]]"),
  decodeString("3[a]2[b4[F]c]")
)

edited Jun 11 '18 at 18:13

answered Jun 11 '18 at 17:39

Luis felipe De jesus Munoz

7,454
2
33
53

Thanks for help. I think your solution has the same logic as mine. It also reaches max call stack for input `"3[a]2[b4[F]c]"`. Any way to avoid this? – Alec Davidson Jun 11 '18 at 18:10
1

Why do you even suggest golfed code as a solution to a SO question? Just remove the golfed part... – Olivier Grégoire Jun 11 '18 at 18:12
@AlecDavidson Sorry, I just figure out that the problem was a missing `i` in your regex to ignore case sensitivity – Luis felipe De jesus Munoz Jun 11 '18 at 18:14
@Luis Yes! Thank you! The problem was a missing i – Alec Davidson Jun 11 '18 at 18:26

score 0 · Answer 2 · answered Jun 11 '18 at 18:09

0

You can just replace your recursive call with a while loop, based on the same condition:

function decodeString(s) {
    while (s.includes("[")) {
        s = s.replace(/(\d+)\[([a-z]*)\]/, (match, num, substr) => substr.repeat(num));
    }
    return s;
}

console.log(decodeString("2[b3[a]]"));

answered Jun 11 '18 at 18:09

trincot

317,000
35
244
286

Yes. Thank you for this. This is the iterative solution I was looking for. The stack overflow was actually because of a missing i flag in the regex – Alec Davidson Jun 11 '18 at 18:27
Indeed, if you have capitals or more opening than closing braces, or missing digits before them, or characters that do not match with any of those, ... it will not stop. If the input is not guaranteed to match with the pattern, it would be better to compare the string before and after the replacement: if nothing changed: exit; – trincot Jun 11 '18 at 19:02

score 0 · Answer 3 · answered Aug 21 '18 at 06:13

It is interesting to see that a few elegant lines of regex code will reproduce the result that the approach of iterating through the string requires 60 or so lines of code to accomplish. However, I thought it would also be interesting to benchmark some of the various implementations I've encountered.

I find that the purely iterative approach, with recursive calls for nested brackets, is significantly faster than the other implementations. Here are the results:

Iterate string, call procedure recursively for nested brackets: 136,943 ops/sec
Iterate string without using recursive procedure: 85,775 ops/sec
Luis Felipe's regex: 81,197 ops/sec
trincot's regex, replacing recursive call with while loop: 80,784 ops/sec

Of course, there are other variables between 1 and 2 that could be significantly slowing down the latter. But on first look the hypothesis that recursion improves performance in this case appears reasonable.

Here's the jsperf.

Implementation 1 is here. Implementation 2 is here. Interestingly, implementation 1 is the only one that runs fast enough to pass the CodeSignal tests.

decodeString: regex solution

3 Answers3