Specific regex not working in R

Question

I'm trying to find whether a string pattern; (<double num><space><an operator><space><double num>) e.g. (14.0 + 46.0) exists in a given string using a regex in R. There can be 4 operators +,-,* and /.

There are two main patterns. Regex for the 1st pattern identifies that the pattern exists in the string "s"

#Pattern 1
s = "(14.0 + 46.0)"

#Regex
grep("^\\(-?\\d*\\.\\d{1}\\s[\\+\\-\\*\\/]\\s-?\\d*\\.\\d{1}\\)$", s)

I'm trying to find the same pattern in a different string s1 and s2. I modified the first regex by adding .* (any character) to the beginning and end of the string ("^.* .*$"). I have checked the regex in this online checker and it works. But it doesn't work in R studio.

#Pattern 2
s1 = "((5.0 - 50.0) - 15.0)"
s2 = "(15.0 - (5.0 - 50.0))"

#Regex
grep("^.*\\(-?\\d*\\.\\d{1}\\s[\\+\\-\\*\\/]\\s-?\\d*\\.\\d{1}\\).*$", s1)

Answer 1

Brief

Just to explain why I made so many changes to your regex (I actually just rewrote it).

1. You use {1}. While this is valid, it is redundant, so the {1} can be removed.
2. You don't need to escape every character in a list, only specific ones (i.e. slash and hyphen, but only hyphen when it's not at the start/end of the set or after a range - so I moved it to the start of the set).
3. Your regex allows .1 to be valid, not sure if that was intentional, and if it was you can edit my regex to your liking. I just felt that a more correct solution would force a number before the . such that .1 is invalid, but 0.1 is valid.
4. You have repeating parts in your pattern so I changed these to named capture groups. This allows the pattern to be very easily manipulated to your liking. It also allows you to define pattern parts in one location instead of multiple spots. - Recursion
5. Recursion is the only way (or balancing groups in C#) that I know of that you can properly determine matched open/closing tags (in this case left and right parentheses). The g group in my pattern handles the recursion.

---

Code

See regex in use here

(?(DEFINE)
  (?<n>[-+]?\d+(?:\.\d+)?)
  (?<a>\s*[-+*\/]\s*)
  (?<g>\((?:(?&n)|(?&g))(?&a)(?:(?&n)|(?&g))\))
)
^(?&g)$

Flags: gmx

Usage

See the code in use here

r <- "(?(DEFINE)(?<n>[-+]?\\d+(?:\\.\\d+)?)(?<a>\\s*[-+*\\/]\\s*)(?<g>\\((?:(?&n)|(?&g))(?&a)(?:(?&n)|(?&g))\\)))^(?&g)$"
x <- c("(14.0 + 46.0)", "((5.0 - 50.0) - 15.0)", "(15.0 - (5.0 - 50.0))", "(15.0 - (5.0 - 50.0)")
grep(r, x, perl=TRUE)

---

Results

Input

(14.0 + 46.0)
((5.0 - 50.0) - 15.0)
(15.0 - (5.0 - 50.0))

Output

Only matches shown below.

(14.0 + 46.0)
((5.0 - 50.0) - 15.0)
(15.0 - (5.0 - 50.0))

---

Explanation

• (?(DEFINE)) Subpattern definition construct. This is completely ignored by regex. It gets treated as a var name="value", whereas you can recall the specific pattern for use via its name.
• (?<n>[-+]?\d+(?:\.\d+)?) Subpattern n defines a valid number as follows
  • [-+]? Match zero or one of any character in the set -+
  • \d+ Match any digit one or more times
  • (?:\.\d+)? Match zero or one of a literal dot . followed by one or more digits
• (?<a>\s*[-+*\/]\s*) Subpattern a defines all valid arithmetic symbols
  • \s* Match any number of whitespace characters
  • [-+*\/] Match a character in the set -+*/
  • \s* Match any number of whitespace characters
• (?<g>\((?:(?&n)|(?&g))(?&a)(?:(?&n)|(?&g))\)) Match the following
  • \( Match a literal left parenthesis (
  • (?:(?&n)|(?&g)) Match either the n or g patterns (recursion)
  • (?&a) Match the a pattern (recursion)
  • (?:(?&n)|(?&g)) Match either the n or g patterns (recursion)
  • \) Match a literal right parenthesis )
• ^(?&g)$ Match the following
  • ^ Assert position at the end of the line
  • (?&g) Match the g pattern (recursion)
  • $ Assert position at the end of the line

Answer 2

Note that adding .* at both ends of the regex is dangerous, since .* is greedy and will match any character. You can either attach ? (which makes .* lazy) or remove .* altogether since grep searches for any match in any parts of the string. To answer your question, it seems that you have to turn on perl to enable grep to match correctly:

#Pattern 2
s1 = "((5.0 - 50.0) - 15.0)"
s2 = "(15.0 - (5.0 - 50.0))"

grep("^.*?\\(-?\\d*\\.\\d{1}\\s[\\+\\-\\*\\/]\\s-?\\d*\\.\\d{1}\\).*?$", s1)
# integer(0)

grep("\\(-?\\d+\\.\\d\\s[\\+\\-\\*\\/]\\s-?\\d+\\.\\d\\)", s1)
# integer(0)

grep("^.*?\\(-?\\d*\\.\\d{1}\\s[\\+\\-\\*\\/]\\s-?\\d*\\.\\d{1}\\).*?$", s1, perl = TRUE)
# [1] 1

grep("\\(-?\\d+\\.\\d\\s[\\+\\-\\*\\/]\\s-?\\d+\\.\\d\\)", s1, perl = TRUE)
# [1] 1

As pointed out by @ctwheels, this will match any string that has the pattern (<double num><space><an operator><space><double num>) in any position of the string. So this does not serve to validate whether the string contains only valid characters. See @ctwheels's answer for the latter case.