How to write a regex to match ((11 3) (96 15) (2 3) )

Question

I am trying to make a regular expression that will match:

((11 3) (96 15) (2 3) )

So far I have:

([^(|^)| |[A-Za-z])+

But it only captures the 11 and not the rest. Also the string is a lot longer I just used a small piece of it so it repeats with the same format but different numbers. This what I have thus far for the program at least part of it:

regex expression("([^(|^)| |[A-Za-z])+");
string line2 = "((11 3) (96 15) (2 3) )";
if(regex_match(line2, expression))
    cout << "yes";
else
    cout << "no";

Answer 1

You have numbers in your example string, but are using letters in your regex, was that intended? I suppose I would use a regex something like this:

\((\([0-9]+ [0-9]+\) )+\)

If we break it down, here's my thought process:

\(     // start with a literal "("
(      // create a group
\(     // another literal "("
[0-9]+ // one or more digits
       // a space (hard to spell out here
[0-9]+ // one or more digits
       // a space (hard to spell out here
\)     // a litteral ")" to match the opening
)      // close the group
+      // group must repeat one or more times
\)     // final closing ")"

EDIT: OK, since you say that sometimes the second numbers aren't numbers, then we can easily adjust the regex to look something like this:

\((\([0-9]+ [A-Za-z0-9]+\) )+\)

if you need to avoid mixing letters and numbers, you can do this:

\((\[0-9]+ ([A-Za-z]+|[0-9]+)\) )+\)

Answer 2

Let's build your expression "from the ground up".

Keeping in mind your final goal to match ((11 3) (96 15) (2 3) ), we shall start with matching a much simpler pattern, and advance one step at a time:

\d        matches "1"
\d+       matches "11", or "3", or "96"
\d+ *\d+  matches "11 3" or "96 15"
\(\d+ *\d+\)           matches "(11 3)" or "(96 15)"
(\(\d+ *\d+\) *)*      matches "(11 3)(96 15) (2 3)"
\((\(\d+ *\d+\) *)*\)  matches "((11 3) (96 15) (2 3) )"

Note: I have not tested this answer. I relied upon the Boost.Regex documentation to develop this answer.

Answer 3

I solved this recently when trying to match syntax similar to 1-4,5,9,20-25. The resulting regular expression is, admittedly, not simple:

/\G([0-9]++)(?:-([0-9]++))?+(?:,(?=[-0-9,]+$))?+/

This expression allowed me to collect all of the matches in the string, incrementally.

We can apply the same approach to your problem, but it's extremely difficult to both validate and match your given input. (I don't know how to do it. If someone else does, I'd like to see!) But you can validate the input separately:

/\(\s*(\s*((\s*\d+\s+\d+\s*)\)\s*)+\s*\)/

See Evan's answer for how it works. \d is equivalent to [0-9] and \s is equivalent to [\r\n\t ].

This is an incremental match to extract the numbers:

/\G\(?\s*(?:\(\s*(\d+)\s+(\d+)\s*\))(?:(?=\s*\(\s*\d+\s+\d+\s*\))|\s*\))/

It breaks down like so:

/\G     # matches incrementally. \G marks the beginning of the string or the beginning of the next match.
 \(?\s* # matches first open paren; safely ignores it and following whiespace if this is not the first match.
 (?:    # begins a new grouping - it does not save matches.
   \(\s* # first subgroup open paren and optional whitespace.
   (\d+) # matches first number in the pair and stores it in a match variable.
   \s+   # separating whitespace
   (\d+) # matches second number in the pair and stores it in a match variable.
   \s*\) # ending whitespace and close paren
 )      # ends subgroup
 (?:    # new subgroup
   (?=  # positive lookahead - this is optional and checks that subsequent matches will work.
     \s*\(\s*\d+\s+\d+\s*\)  # look familiar?
   )    # end positive lookahead
   |    # if positive lookahead fails, try another match
   \s*\)\s* # optional ending whitespace, close paren
 )/     # ... and end subgroup.

I haven't tested this, but I'm confident it'd work. Each time you apply the expression to a given string, it'll extract each subsequent pair of numbers until it sees the last closing paren, and it'll consume the whole string, or stop if there's an input error. You may need to finesse it for Boost::regex. This is a Perl-compatible regular expression.