For Java:

Quantifiers documentation

X, exactly n times: X{n}
X, at least n times: X{n,}
X, at least n but not more than m times: X{n,m}

Put the regEx block in () and add * or +.

* 0 to any number of times.

+ 1 to any number of times.

{n} 'n' times.

{n,} at-least 'n' times.

(?: ... ) is called non-capturing group

Non-capturing parentheses group the regex so that you can apply regex operators, but do not capture anything.

Eg:

[0-9]{1} this means 1 digit(0-9)

[0-9]+ this means at-least one digit(0-9).

[0-9]* no digits or any number of digits(0-9).

Since you wanted "(.+?)",.+?},\s.+?:\s"(.+?)",.+?},\s.+?:\s"(.+?)",.+?},\s.+?:\s,

you may do it like this : ("(.+?)",.+?},\s.+?:\s){3}.

There's two different regex features that would be helpful. First off, you can use capturing groups. If you put something in parentheses, you can refer to whatever matched inside. So

/\(.\)\1

Will match any character (\(.\)) followed by that same character (Group 1, \1). You can also refer to groups in the replacement part of a substitute command.

The other feature is quantifiers.

• \{n,m} matches from n to m of the preceding characters...

• \{n} matches exactly n times of the preceding characters...

• \{,m} matches at most m (from 0 to m) of the preceding characters...

• \{n,} matches at least n of of the preceding characters...

putting it all together, you want to use:

/\(.\)\1\{6}

Or as the way I'd prefer it,

/\v(.)\1{6}

I'd recommend reading through vimregex.com. It's a good tutorial on vim regex features.

I believe I've improved on your pattern slightly:

/(\/\w{30,})(?:.+?\1){3,}?/s

Demo link: https://regex101.com/r/aNdURv/1

Key changes:
1. Why stop at 50 characters? Shouldn't matter how long the word is as long as it is at least 30. So I removed "50" from the first group.
2. You don't need to capture each repeat, just to count it towards the total you are aiming for (3 or more), so I added "?:" to the second group.
3. You don't need it to find all matching repeats, meaning it can be lazy and stop as long as it finds at least 3. So I added "?" to the end.

There is a simple solution, if you're matching the entire input string:

(?:pattern(?:\|(?!$)|$)){3}

Which means: match your pattern followed by:

• either \|(?!$): a pipe not followed by the end of the string
• or $ the end of the string

3 times.

For your specific pattern, this would be:

^(?:(?:((\*)|(\[[\w+ ]\-[\w+ ]\])|(\d+)))(?:\|(?!$)|$)){3}

I also prefixed the pattern with ^, since this solution works only if you match the entire input anyway.

With standard grep syntax and BRE:

$ grep -x '\(.*[^r]\)\{0,1\}rr\([^r].*\)\{0,1\}' < file
rr
abcrr d
rarrrrrr aaa rrqq
kdhdrraa rrzaza

^{(replace rr with r\{42\} for 42 rs)}

That is match exactly (that is the whole line) on rr optionally (\{0,1\} being 0 or 1, equivalent of ERE ?) preceded by a sequence of characters that ends in a character other than r ([^r]) and optionally followed by a sequence of characters starting with a character other than r.

With ERE:

$ grep -E '(^|[^r])rr([^r]|$)' < file
rr
abcrr d
rarrrrrr aaa rrqq
kdhdrraa rrzaza

^{(replace rr with r{42} for 42 rs)}

That is rr preceded by either the start of the line or a character other than r and followed by either the end of the line or a character other than r.

With PCRE (non-standard):

$ grep -P '(?<!r)rr(?!r)' < file
rr
abcrr d
rarrrrrr aaa rrqq
kdhdrraa rrzaza

^{(replace rr with r{42} for 42 rs)}

That is, rr not preceded nor followed by r.

With Augmented RE (ast-open grep):

$ grep -xX '(.*r)!rr(r.*)!' < file
rr
abcrr d
rarrrrrr aaa rrqq
kdhdrraa rrzaza

^{(replace rr with r{42} for 42 rs)}

(\s+(\w*\.*\w*);){12}

The {n} is a "repeat n times"

if you want "12 - 13" times,

(\s+(\w*\.*\w*);){12,13}

if you want "12+" times,

(\s+(\w*\.*\w*);){12,}

You need to use a back-reference to your capture group. Here is an example regex:

(.)\1{2}

Regex explained:

• (.) is a capture group that captures literally anything a single time
• \1 is a back-reference to the group you just captured (that single character)
• {2} is a quantifier, which matches the previous token (the \1) exactly twice.

Note that, to capture a single character n times, you have to specify {n - 1} as the quantifier because the first match was already captured by (.).

The full pcre that will match the strings you listed (and those that start with a ,) might be:

grep -P '^([0-9]+(-[0-9]+)?(,|$))+$'

How have we got there?

The most basic element to match is a digit, lets assume that [0-9], or the simpler \d in PCRE, is a correct regex for a English (ASCII) digit. Which might as well not be. It could match Devanagari numerals, for example. Then you would need to write: [0123456789] to be precise.

Then, a run of digits would be matched by [0-9]+.

After a number (1 or 3 or 26) ther could be a dash '-' followed by one or several digits ( a number again ):

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

Where the ? makes the dash-number sequence optional.

Then, each of those numbers: 3 (or number ranges: 4-9) should be followed by a comma , (several times):

([0-9]+(-[0-9]+)?,)+

Except that the last comma might be missing:

([0-9]+(-[0-9]+)?(,|$))+

And, if required, a leading comma might be present:

(^|,)([0-9]+(-[0-9]+)?(,|$))+

It is a very good idea to anchor the regex to the beginning and end of the text tested:

^((^|,)([0-9]+(-[0-9]+)?(,|$))+)$

You may test and edit the PCRE regex in this site

If the leading comma should be rejected, use:

^(([0-9]+(-[0-9]+)?(,|$))+)$

That leaves no optional interpretations to the regex machine. All must be matched, and anything that is not matched gets rejected.

It may be written as an (GNU) extended regex:

grep -E '^(([0-9]+(-[0-9]+)?(,|$))+)$'

As a Basic Regular Expression (BRE):

grep '^\(\([0-9]\{1,\}\(-[0-9]\{1,\}\)\{0,1\},\{0,1\}\)\{1,\}\)$'

Where the comma , is optional {0,1}, the regex engine might take some decisions about what to match.

Descriptive Regex?

A more descriptive regex, with spaces and comments might be had by starting it with (?x) in pcregrep

pcregrep '(?x)                  # tell the regex engine to allow
                                 # white space and comments.
           (?(DEFINE)            # subroutines that will be used. 
             (?<nrun> [0-9]+)    # run of digits (n-run).

              # define a range pair. A number run followed by
              # an optional ( dash and another number run )
             (?<range> (?&nrun)  (-(?&nrun))? )    # range pair.
             
             (?<sep> ,)          # separator used.
           )                     # end of definitions.

         # Actual regex to use:
         # (range) that ends in a (sep) 
         # or is at the end of the line,
         # several times (+).

         ^(  (?&range)  ((?&sep)|$)  )+$

        ' file

This regex (once compiled) is exactly equivalent to the original one and will run equally fast. Of course, there is an (negligible) additional time used to compile the regex.

Test example is here

Try following regex:

^[abc]{3}(,[abc]{3})*$

^...$ from the start till the end of the string
[...] one of the given character
...{3} three time of the phrase before
(...)* 0 till n times of the characters in the brackets