Match same number of repetitions as previous group

As others have commented, I don't think it's possible to accomplish this in a single regex. If you can't guarantee the strings are well-formed then you'd have to validate them with the regex, capture each group, and then compare the group lengths to verify they are of equal repetitions. However, if it's guaranteed all strings will be well-formed then you don't even need to use regex to implement this check:

fn matching_reps(string: &str, group1: &str, group2: &str) -> bool {
    let group2_start = string.find(group2).unwrap();
    let group1_reps = (string.len() - group2_start) / group1.len();
    let group2_reps = group2_start / group2.len();
    group1_reps == group2_reps
}

fn main() {
    assert_eq!(matching_reps("abc123", "abc", "123"), true);
    assert_eq!(matching_reps("abcabc123", "abc", "123"), false);
    assert_eq!(matching_reps("abcabc123123", "abc", "123"), true);
    assert_eq!(matching_reps("abcabc123123123", "abc", "123"), false);
}

playground

Pure regular expressions are not able to represent that.

There may be some way to define back references, but I am not familiar with regexp syntax in Rust, and this would technically be a way to represent something more than a pure regular expression.

There is however a simple way to compute it :

• use a regexp to make sure your string is a ^((abc)*)((123)*)$
• if your string matches, take the two captured substrings, and compare their lengths

Building a pattern dynamically is also an option. Matching one, two or three nested abc and 123 is possible with

abc(?:abc(?:abc(?:)?123)?123)?123

See proof. (?:)? is redundant, it matches no text, (?:...)? matches an optional pattern.

Rust snippet:

let a = "abc"; // Prefix
let b = "123"; // Suffix
let level = 3; // Recursion (repetition) level

let mut result = "".to_string();
for _n in 0..level {
    result = format!("{}(?:{})?{}", a, result, b);
}
println!("{}", result);
// abc(?:abc(?:abc(?:)?123)?123)?123

There's an extension to the regexp libraries, that is implemented from the old times unix and that allows to match (literally) an already scanned group literally after the group has been matched.

For example... let's say you have a number, and that number must be equal to another (e.g. the score of a soccer game, and you are interested only in draws between the two teams) You can use the following regexp:

([0-9][0-9]*) - \1

and suppose we feed it with "123-123" (it will match) but if we use "123-12" that will not match, as the \1 is not the same string as what was matched in the first group. When the first group is matched, the actual regular expression converts the \1 into the literal sequence of characters that was matched in the first group.

But there's a problem with your sample... is that there's no way to end the first group if you try:

([0-9][0-9]*)\1

to match 123123, because the automaton cannot close the first group (you need at least a nondigit character to make the first group to finalize)

But for example, this means that you can use:

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

and this will match phone numbers in the form

+(358)358-358-358

or

+(1)1-1-1-1-1-1-1

(the number in between the parenthesys is catched as a sample, and then you use the group to build a sequence of that number separated by dashes. You can se the expression working in this demo.)