In "aa67bc54c9", is there any way to print "aa" 67 times, "bc" 54 times and so on, using regular expressions?

Question

I was asked this question in an interview for an internship, and probably the first solution I suggested was to try and use a regular expression (I usually am a little stumped in interviews). Something like this

(?P<str>[a-zA-Z]+)(?P<n>[0-9]+)

I thought it would match the strings and store them in the variable "str" and the numbers in the variable "n". How, I was not sure of. :-(

So it matches strings of type "a1b2c3", but a problem here is that it also matches strings of type "a1b". Could anyone suggest a solution to deal with this problem?

Also, is there any other regular expression that could solve this problem?

Answer 1

how about:

while ($line =~ s/^([a-z]+)(\d+)//i)
{
    print $1 x $2;
}

Answer 2

Answering your question directly:

• No, regular expressions match text and don't print anything, so there is no way to do it solely using regular expressions.

The regular expression you gave will match one string/number pair; you can then print that repeatedly using an appropriate mechanism. The Perl solution from @tster is about as compact as it gets. (It doesn't use the names that you applied in your regex; I'm pretty sure that doesn't matter.)

The remaining details depend on your implementation language.

Answer 3

Nope, this is your basic 'trick question' - no matter how you answer it that answer is wrong unless you have exactly the answer the interviewer was trained to parrot. See the workup of the issue given by Pavel Shved - note that all invocations have 'not' as a common condition, the tool just keeps sliding: Even when it changes state there is no counter in that state

I have a rather advanced book by Kenneth C Louden who is a college prof on the matter, in which it is stated that the issue at hand is codified as "Regex's can't count." The obvious answer to the question seems to me at the moment to be using the lookahead feature of Regex's ...

Probably depends on what build of what brand of regex the interviewer is using, which probably depends of flight-dynamics of Golf Balls.

Answer 4

Nice answers so far. Regular expressions alone are generally thought of as a way to match patterns, not generate output in the manner you mentioned.

Having said that, there is a way to use regex as part of the solution. @Jonathan Leffler made a good point in his comment to tster's reply: "... maybe you need a better regex library in your language."

Depending on your language of choice and the library available, it is possible to pull this off. Using C# and .NET, for example, this could be achieved via the Regex.Replace method. However, the solution is not 100% regex since it still relies on other classes and methods (StringBuilder, String.Join, and Enumerable.Repeat) as shown below:

string input = "aa67bc54c9";
string pattern = @"([a-z]+)(\d+)";
string result = Regex.Replace(input, pattern, m =>
        // can be achieved using StringBuilder or String.Join/Enumerable.Repeat
        // don't use both
        //new StringBuilder().Insert(0, m.Groups[1].Value, Int32.Parse(m.Groups[2].Value)).ToString()
        String.Join("", Enumerable.Repeat(m.Groups[1].Value, Int32.Parse(m.Groups[2].Value)).ToArray())
         + Environment.NewLine // comment out to prevent line breaks
        );
Console.WriteLine(result);

A clearer solution would be to identify the matches, loop over them and insert them using the StringBuilder rather than rely on Regex.Replace. Other languages may have compact idioms to handle the string multiplication that doesn't rely on other library classes.

To answer the interview question, I would reply with, "it's possible, however the solution would not be a stand-alone 100% regex approach and would rely on other language features and/or libraries to handle the generation aspect of the question since the regex alone is helpful in matching patterns, not generating them."

And based on the other responses here you could beef up that answer further if needed.