可能重复:
如何确定一个数字是否是正则表达式的素数？

此页面声称此正则表达式发现非素数(并通过反例:素数):

/^1?$|^(11+?)\1+$/

这怎么找到素数？

这是什么？

这是常见问答的集合.这也是社区Wiki,因此每个人都被邀请参与维护.

为什么是这样？

正则表达式患的是给我泽码型的问题和答案不佳,没有解释.此参考旨在提供质量问答的链接.

范围是什么？

此引用适用于以下语言:php,perl,javascript,python,ruby,java,.net.

这可能过于宽泛,但这些语言共享相同的语法.对于特定功能,它背后的语言标签,例如:

• 什么是正则表达式平衡组？.净

这是周日,一轮代码高尔夫的时间!

挑战

通过字符计数写出最短的源代码,以确定输入数字是"幸福素数","悲伤素数","快乐非素数"还是"悲伤非素数".

输入

输入应该是来自命令行参数或stdin的整数.不要担心处理大数字,但如果可以/想要这样做.对于小于1的输入值,行为将是未定义的,但是1具有明确的结果.

产量

输出应该打印数字的类型:"快乐素数","悲伤素数","快乐非素数"或"悲伤的非素数".尾随换行符是可选的.

例子

$ happyprime 139
happy prime
$ happyprime 2
sad prime
$ happyprime 440
happy non-prime
$ happyprime 78
sad non-prime

定义

以防你的大脑需要复习.

快乐的号码

来自维基百科,

甲快乐数由下面的过程来定义.从任何正整数开始,将数字替换为其数字的平方和,并重复该过程,直到数字等于1(它将保持不变),或者在一个不包括1的循环中无休止地循环.这些数字这个过程在1结束的是快乐的数字,而那些不以1结尾的是不愉快的数字(或悲伤的数字).

例如,

• 139
• 1 ^ 2 + 3 ^ 2 + 9 ^ 2 = 91
• 9 ^ 2 + 1 ^ 2 = 82
• 8 ^ 2 + 2 ^ 2 = 68
• 6 ^ 2 + 8 ^ 2 = 100
• 1 ^ 2 …

_{这是一系列教育正则表达式文章的一部分,这是对嵌套引用概念的温和介绍.}

前几个三角形数字是:

 1 = 1
 3 = 1 + 2
 6 = 1 + 2 + 3
10 = 1 + 2 + 3 + 4
15 = 1 + 2 + 3 + 4 + 5

有很多方法可以检查数字是否为三角形.有一种有趣的技术使用正则表达式如下:

• 给定n,我们首先创建一个长度为n的字符串,其中填充相同的字符
• 然后我们将此字符串与模式匹配 ^(\1.|^.)+$
  • 当且仅当此模式与字符串匹配时,n为三角形

以下是一些片段,表明它适用于多种语言:

PHP(在ideone.com上)

$r = '/^(\1.|^.)+$/';

foreach (range(0,50) as $n) {
  if (preg_match($r, str_repeat('o', $n))) {
     print("$n ");
  }
}

Java(在ideone.com上)

for (int n = 0; n <= 50; …

^{这是一系列教育正则表达式文章的第三部分.它遵循这个正则表达式如何找到三角形数字？(首先介绍嵌套引用)和如何将^ nb ^ n与Java正则表达式匹配？ (前瞻性"计数"机制进一步详述).这部分介绍了一种特定形式的嵌套断言,当与嵌套引用结合使用时,Java正则表达式可以匹配大多数人认为"不可能"的东西:回文!}

回文的语言是非常规的 ; 它实际上是无上下文的(对于给定的字母表).也就是说,现代正则表达式实现不仅仅识别常规语言,Perl/PCRE的递归模式和.NET的平衡组可以很容易地识别回文(参见:相关问题).

但是,Java的正则表达式引擎既不支持这些"高级"功能.然而"某人" ^(*wink*)成功编写了以下正则表达式,这似乎做得很好(参见ideone.com):

public class Palindrome {
    // asserts that the entirety of the string matches the given pattern
    static String assertEntirety(String pattern) {
        return "(?<=(?=^pattern$).*)".replace("pattern", pattern);
    }

    public static void main(String[] args) {
        final String PALINDROME =
            "(?x) | (?:(.) add)+ chk"
                .replace("add", assertEntirety(".*? (\\1 \\2?)"))
                .replace("chk", assertEntirety("\\2"));

        System.out.println(PALINDROME);
        // (?x) | (?:(.) (?<=(?=^.*? (\1 \2?)$).*))+ (?<=(?=^\2$).*)

        String[] tests …

我主要关心的是Java风格,但我也很欣赏有关其他人的信息.

假设你有一个像这样的子模式:

(.*)(.*)

虽然不是很有用,但是让我们说这两个捕获组(比如说,\1和\2)是一个更大的模式的一部分,它与这些组的反向引用相匹配,等等.

所以两者都是贪婪的,因为他们尽可能地捕捉,只在必要时减少.

我的问题是:谁更贪婪？是否\1优先考虑,\2仅在必要时给予其份额？

关于什么:

(.*)(.*)(.*)

让我们假设\1确实是第一优先.让我们说它过于贪婪,然后吐出一个角色.谁先得到它？它总是\2或可以\3吗？

让我们假设这\2是被\1拒绝的.如果这仍然不起作用,谁现在吐出来？是\2吐\3,还是先\1吐出另一个\2？

奖金问题

如果你写这样的东西会发生什么:

(.*)(.*?)(.*)

现在\2不情愿.这是否意味着\1吐出来\3,\2只是不情愿地接受了\3拒绝？

例

也许我没有给出具体的例子来说明我是如何使用这些模式的,这可能是一个错误,但这里有一些:

System.out.println(
    "OhMyGod=MyMyMyOhGodOhGodOhGod"
    .replaceAll("^(.*)(.*)(.*)=(\\1|\\2|\\3)+$", "<$1><$2><$3>")
); // prints "<Oh><My><God>"

// same pattern, different input string
System.out.println(
    "OhMyGod=OhMyGodOhOhOh"
    .replaceAll("^(.*)(.*)(.*)=(\\1|\\2|\\3)+$", "<$1><$2><$3>")
); // prints "<Oh><MyGod><>"

// now \2 is reluctant
System.out.println( …

这是功能:

var isPrime = function(x) {
    return (!(/^,?$|^(,,+?)\1+$/.test(Array(++x))));
};

它适用于小数字,但是当数字很大时,会抛出一个异常,表示数组长度无效.我无法理解这里发生了什么.RegEx测试的作用是什么？为什么这段代码有效？

相关问题/材料:

• 我们如何匹配^ nb ^ n与Java正则表达式？

• 如何确定一个数字是否是正则表达式的素数？(它涉及一元素数匹配,而我正在寻找≥2的基数;不过是一个很好的伎俩,是什么让我思考这个)

• http://nikic.github.io/2012/06/15/The-true-power-of-regular-expressions.html

众所周知,由各种编程语言支持的"正则表达式"生成在形式意义上非常规的语言,并且如上述材料所示,能够识别至少一些上下文敏感语言.

语言L = {x | x是基数10中的素数.}是一种上下文敏感语言,因为素数可以通过线性有界自动机来测试(但它不是通过泵浦引理参数的无上下文语言).

那么,是否可以编写一个Perl或Java正则表达式,它恰好接受基数为10的所有素数？如果感觉更容易,可以随意替换≥2的任何其他基础或精确识别所有复合数字.

例如,使用转义来运行任意Perl代码被视为作弊.重复替换(很容易图灵完成)也超出了范围; 整个工作应该在正则表达式内完成.这个问题更多的是关于正则表达式实际有多强大的界限.

这对 Google 来说是一件特别困难的事情，因为大多数问题都是关于如何编写正则表达式来匹配单个字符，这不是我的问题。

我的问题是：如果我有一个 JavaScript / TypeScript API，它允许用户提供任何给定的正则表达式，但它们的正则表达式应该只匹配 0-1 个字符，如果用户编写的正则表达式可以，我将如何抛出错误匹配多个字符？

例如：

/[a-z]/        // valid
/[a-z][A-Z]/   // invalid
/[a-z]{1}/     // valid
/[a-z]{2}/     // invalid
/[a-z]*/       // invalid
/[a-z]+/       // invalid

...ETC

感觉考虑某人可以指定正则表达式来匹配多个字符的所有方式可能会变得乏味。关于如何实现这一点有什么想法吗？

给定一个输入字符串，其中包含任意数量的 'x' 个字符（x, xx, xxxxx,xxxxxxxxxxxxx等等），只有当输入字符串具有质数的 'x' 个字符时，如何才能编写与输入字符串匹配的正则表达式？不应匹配长度为 1 的字符串。

例如：

匹配这些： xx xxx xxxxx xxxxxxx

但不是这些： x xxxx xxxxxxxxx

这是我找到的一个解决方案 - ^(?!(xx+)\1+$)（这里，作为这个问题的答案）。但是，我想知道它为什么有效。请分享任何替代解决方案。

我正在使用 PCRE 引擎。

我意识到人们通常不会将正则表达式用于此类事情。我只是对如何做到这一点很好奇。