`x...(a and b)...y` 在有限长度内的正则表达式？

Question

是否可以在n 的有限长度内指定匹配x...(a and b)...y 的正则表达式？

更准确地说：

1. 匹配的x和y之间的字符长度最多为n。
2. 在匹配的x 和y 之间必须同时存在a 和b（不考虑顺序）。
3. x、a、b 和 y 这里可以代表多字符字符串 sn-p。

测试用例（假设n = 10）：

Match:
...x..a...b..y...
...x..b...a..y...
...x..a...b..y...a...
...x..a...b..y...b...
...x..a...b..y...y...
...x..a.x.b..y...
...x..a.y.b..y...
...xaabbaabbay...
...x..a...b..y... ...x..a...b..y... (2 matches)
...xaby...xaby... (2 matches)

Don't match:
...x..a...b......
...x......b..y...
...x..a......y...
...x..a...b......y...
...x......b..y...a...
...x..a......y...b...
...x..a.y.b......
...x..a.y.b......y...
...x..a.y.b.x....y...
.a.x......b..y...
.b.x..a......y...

P.S: 我知道这可以通过简单地匹配/x.{0,n}y/ 来完成，然后检查a 和b 是否都存在于许多编程语言的匹配字符串中。但是，此问题明确要求单一正则表达式方法，以便它可以在某些应用程序中用作查询，例如 Google Doc 和 Notepad++。

Answer 1

相信你可以使用

x(?:(?(1)(?!)|(a))|(?(2)(?!)|(b))|.){0,10}?y(?(1)|(?!))(?(2)|(?!))

请参阅regex demo。 详情：

• x - 左侧分隔符
• (?:(?(1)(?!)|(a))|(?(2)(?!)|(b))|.){0,10}? - 零到十次出现（但尽可能少）
  • (?(1)(?!)|(a)) - 如果 Group 1 为 null（如果 Group 1 之前没有匹配）匹配 a，否则无法立即触发回溯
  • | - 或
  • (?(2)(?!)|(b)) - 如果 Group 2 为 null（如果 Group 2 之前没有匹配）匹配 b，否则无法立即触发回溯
  • |. - 或任何一个字符（默认换行字符除外）
• y - 右手定界符
• (?(1)|(?!)) - 条件构造：如果第 1 组参加了比赛（如果第 1 组的值不为空），则继续，否则，比赛失败
• (?(2)|(?!)) - 条件构造：如果第 2 组参加了比赛（如果第 2 组的值不为空），则继续，否则，比赛失败。

最后两个条件确保匹配的文本中有a 和b。

注意：如果a 和b 可以是多字符串，n 必须减少到n-(a.length-b.length+2) 的长度。因此，如果a 是ac 并且b 是bmc，则需要将10 替换为10-(2-3+2) => 7。这也意味着您应该事先检查您的预期限制长度限制，它应该允许 a 和 b 组合的长度。

注意 2：在模式的开头添加 (?s) 以匹配换行符和 .。更多选项请参见How do I match any character across multiple lines in a regular expression?。

Answer 2

如果不为x 和a|b 之间、a 和b 之间以及a|b 和y 之间的部分生成所有有效的长度组合，我担心这是不可能的。

对于 n=5（即在 x 和 y 之间的 a 和 b 以外的 0-3 个字符：

x ( [^ab]{0} ( a ( [^b]{0} b .{0,3}
                 | [^b]{1} b .{0,2}
                 | [^b]{2} b .{0,1}
                 | [^b]{3} b .{0}   )
             | b ( [^b]{0} a .{0,3}
                 | [^b]{1} a .{0,2}
                 | [^b]{2} a .{0,1}
                 | [^b]{3} a .{0}   ) )
  | [^ab]{1} ( a ( [^b]{0} b .{0,2}
                 | [^b]{1} b .{0,1}
                 | [^b]{2} b .{0}   )
             | b ( [^b]{0} a .{0,2}
                 | [^b]{1} a .{0,1}
                 | [^b]{2} a .{0}   ) )
  | [^ab]{2} ( a ( [^b]{0} b .{0,1}
                 | [^b]{1} b .{0}   )
             | b ( [^b]{0} a .{0,1}
                 | [^b]{1} a .{0}   ) )
  | [^ab]{3} ( a ( [^b]{0} b .{0}   )
             | b ( [^b]{0} a .{0}   ) ) ) y

我使用[^…] 而不是. 来避免从错误的分支回溯太多，尽管它可能会进一步优化。