需要正则表达式来匹配特殊情况

我想这是你想要的。

对于交替字符:

(?=(.)(?!\1)(.))(?:\1\2){2,}

\0 整个交替序列, \1 和 \2 是两个(不同的)交替出现的字符。

N 和 M 此处有数字):

(?=(.))\1{N}.*?(?=(?!\1)(.))\2{M}

\0 将是整场比赛,包括中缀。 \1 字符是否重复(至少) \2 字符是否重复(至少) M 次。

下面是Java中的测试工具。

import java.util.regex.*;

public class Regex3 {
    static String runNrunM(int N, int M) {
        return "(?=(.))\\1{N}.*?(?=(?!\\1)(.))\\2{M}"
            .replace("N", String.valueOf(N))
            .replace("M", String.valueOf(M));
    }
    static void dumpMatches(String text, String pattern) {
        Matcher m = Pattern.compile(pattern).matcher(text);
        System.out.println(text + " <- " + pattern);
        while (m.find()) {
            System.out.println("  match");
            for (int g = 0; g <= m.groupCount(); g++) {
                System.out.format("    %d: [%s]%n", g, m.group(g));
            }
        }
    }
    public static void main(String[] args) {
        String[] tests = {
            "foobababababaf foobaafoobaaaooo",
            "xxyyyy axxayyyya zzzzzzzzzzzzzz"
        };
        for (String test : tests) {
            dumpMatches(test, "(?=(.)(?!\\1)(.))(?:\\1\\2){2,}");
        }
        for (String test : tests) {
            dumpMatches(test, runNrunM(3, 3));
        }
        for (String test : tests) {
            dumpMatches(test, runNrunM(2, 4));
        }
    }
}

这将产生以下输出:

foobababababaf foobaafoobaaaooo <- (?=(.)(?!\1)(.))(?:\1\2){2,}
  match
    0: [bababababa]
    1: [b]
    2: [a]
xxyyyy axxayyyya zzzzzzzzzzzzzz <- (?=(.)(?!\1)(.))(?:\1\2){2,}
foobababababaf foobaafoobaaaooo <- (?=(.))\1{3}.*?(?=(?!\1)(.))\2{3}
  match
    0: [aaaooo]
    1: [a]
    2: [o]
xxyyyy axxayyyya zzzzzzzzzzzzzz <- (?=(.))\1{3}.*?(?=(?!\1)(.))\2{3}
  match
    0: [yyyy axxayyyya zzz]
    1: [y]
    2: [z]
foobababababaf foobaafoobaaaooo <- (?=(.))\1{2}.*?(?=(?!\1)(.))\2{4}
xxyyyy axxayyyya zzzzzzzzzzzzzz <- (?=(.))\1{2}.*?(?=(?!\1)(.))\2{4}
  match
    0: [xxyyyy]
    1: [x]
    2: [y]
  match
    0: [xxayyyy]
    1: [x]
    2: [y]

• (?=(.)(?!\1)(.))(?:\1\2){2,} 有两部分
  • (?=(.)(?!\1)(.)) 建立 和 使用前瞻
    • \1
    • 使用lookahead捕获let \0 拥有整个比赛(而不仅仅是“尾”端)
  • (?:\1\2){2,} \1\2 序列,必须至少重复两次。
• (?=(.))\1{N}.*?(?=(?!\1)(.))\2{M}
  • (?=(.))\1{N} 捕获 N 次
    • 使用lookahead来捕获意味着可以 而不是 N-1
  • .*?
  • (?=(?!\1)(.))\2{M}
    • 与第一部分类似
    • 嵌套的负前瞻确保 \1 != \2

run regex将匹配较长的运行,例如。 run(2,2) 比赛 "xxxyyy"

xxxyyy <- (?=(.))\1{2}.*?(?=(?!\1)(.))\2{2}
  match
    0: [xxxyy]
    1: [x]
    2: [y]

而且,它不允许重叠匹配。也就是说,只有一个 run(2,3) "xx11yyy222" .

xx11yyy222 <- (?=(.))\1{2}.*?(?=(?!\1)(.))\2{3}
  match
    0: [xx11yyy]
    1: [x]
    2: [y]

假设您使用perl/PCRE:

1. (.{2})\1+ ((.)(?!\2)(.))\1+ . 第二个regex阻止匹配 oooo .

((.)\2{N}).*?((?!\2)(.)\4{M}) . 删除 (?!\2) oooaoooo

好吧,这对第一个有效。。。

((.)(.))(\2\3)+

a = "This is my foobababababaf string"

console.log(a.replace(/(.)(.)(\1\2)+/, "<<$&>>"))

a = "This is my foobaafoobaaaooo string"

console.log(a.replace(/(.)\1+(.)\2+/, "<<$&>>"))