Regex 正则表达式，仅允许2个或3个字符A和H出现

以我最少的正则表达式经验，我正在努力想出一个将这两个规则结合起来的正则表达式

语言：Scala

规则：

A和H不得在一行中以3的顺序出现，例如AHHHA无效

在5的序列中，必须有2个a和3个H或3个H和2个a

有效：

ahahahahahahahahahahahahahahahahahahahahahahahahaha

无效规则1:

ahahahahahahahahahahahahahahahahahahahahahaha

有效的规则1，无效的规则2:

hhahaahahahahahahahahahahahahahah

这符合规则1，但我不确定如何满足规则2

---

感谢您的帮助或建议。

对3个相同的问题使用否定的前瞻：

^(?!.*(AAA|HHH|AAHAA|HHAHH))[AH]*$

---

“规则2”还需要在前瞻中添加两个特殊情况。

虽然第一个规则将消除规则2中大多数有问题的组合，但它不会阻止外部字符成对出现的情况，例如

AAHAA

和

hhah

。因此，必须考虑第二条规则

排除这些成对外部字符的最简单方法是在负前瞻中显式指定它们：

/(?!.*(A{3}|H{3}|AAHAA|HHAHH))[AH]{5}/

从以下几点可以看出：

var regex=/（？！.*（A{3}H{3}AAHAA{124; hhah））[AH]{5}/；
日志（“应该是有效的：”）；
log（“AAHHA:”，regex.test（“AAHHA”）；
console.log（“AHHAA:”，regex.test（“AHHAA”）；
console.log（“AHAHA:”，regex.test（“AHAHA”）；
console.log（“HAHAH:”，regex.test（“HAHAH”）；
控制台日志（“”）；
日志（“由于规则1:”，应该无效）；
console.log（“AAAAA:”，regex.test（'AAAAA'）；
console.log（“aaah:”，regex.test（“aaah”）；
console.log（“aaah:”，regex.test（“aaah”）；
console.log（“aahh:”，regex.test（“aahh”）；
console.log（“ahhh:”，regex.test（“ahhh”）；
log（“hhhh:”，regex.test（'HHHHH'）；
控制台日志（“”）；
日志（“由于规则2:”，应该无效）；
console.log（“AAHAA:”，regex.test（“AAHAA”）；
console.log（“HHAHH:”，regex.test（“HHAHH”）基本思想是利用负前瞻，以确保某些模式不会出现在字符串中

对于规则1，我们有
A{3}
和
H{3}
，这是直接的，您不希望出现3个连续的A/H

对于规则2，唯一不违反规则1的情况是
AAHAA
和
HHAHH

结合所有这些，你有

^(?!.*(A{3}|H{3}|AAHAA|HHAHH))[AH]*$

解释

^                                     start of string
 (?!                         )        negative-look-ahead group, i.e. not followed by
    .*                                any occurrence of any char
      (A{3}|H{3}|AAHAA|HHAHH)         followed by the 4 cases I described above
                               [AH]*  (actual matching of the string) any occurrence of A/H
                                    $  end of string

您可以使用替代选项来检查字符串是否包含无效匹配项，如果包含，则检查字符串是否无效

它首先检查三重变型。对于5的组合，您就剩下了
使用
AAHAA
或
HHAHH
，因为其他无效组合将由匹配三重变量的第一条规则匹配


您想用什么语言来做这件事？使用一些内置函数可能比专门使用正则表达式更容易。很抱歉，忘了使用Scala添加它。对于规则2的参数，这是错误的。反例是“AAHAA”，它没有3个连续的值，但仍然不符合规则2@Adrian正是如此（我在我的负面展望中添加了这些例外）。我认为应该是
[AH]{5}
，而不是
[AH]*
，或者至少是
[AH]{5，}
相反，我同意将文本“分组”为5组的理论。我不确定是否允许团队重叠，但如果允许重叠，这肯定是一个很好的方法：）我不认为OP要求“5人一组”。如果这是他的意图，他的“无效规则1”样本不会失败，因为3个连续的
H
s被分成两组
val pattern = "(?:AAA|HHH|AAHAA|HHAHH)".r
val s = "AHAHAHAHHAHAAHHAAHHAAHAHHAHAHAHAHAHAHA"

pattern.findFirstIn(s) match {
  case None => println(s"OK for: $s")
  case _ => println(s"Not OK for: $s")
}