给定一个正整数作为输入，确定它是否是一个海数。

大量数字是指这样的数字，即+以10为底的任意两个数字之间的任何符号插入都会产生质数整数。

例如40427是宽容的，因为

4+0427  = 431  is prime
40+427  = 467  is prime
404+27  = 431  is prime
4042+7  = 4049 is prime

输出量

您应该输出两个不同的值，一个输入是海量值时一个，而另一个输入则不是。

计分

竞赛的目的是使为解决此任务而编写的源代码的大小（以字节为单位）尽可能小。

测试用例

1       -> True
2       -> True
4       -> True
10      -> False
98      -> True
101     -> True
109     -> False
819     -> False
4063    -> True
40427   -> True
2000221 -> True

OEIS 253996

05AB1E，10个字节

码

η¨¹.s¨R+pP

使用05AB1E编码。在线尝试！或验证所有测试用例！

说明

η¨             # Take the prefixes of the input and remove the last element
  ¹.s¨         # Take the suffixes of the input and remove the last element
      R        # Reverse the array of suffixes
       +       # Vectorized addition
        p      # Check if each element is prime
         P     # Product of the array

C（gcc），8384 85 83 84 86 75 111 个字节

所有优化均已关闭，仅在32位GCC上。

-1字节感谢@ceilingcat

+一些1大小写的字节。

+一些字节可重用的功能。

i,j,r,s;f(a){for(i=10,r=1;a/i;i*=10)for(s=a%i+a/i,r*=s-1,j=2;j<s;)r*=s%j++>0;a=!r;}

将输入作为整数。对于错误的情况，返回1，对于真实的情况，返回0。

在线尝试！

请参阅我关于Mathematica代码（55字节）的另一个答案。

视网膜，38字节

\B
$`$*_$'$*_
S`\d
G`^_$|^(__+)\1+$
^$

在线尝试！

打印1大量数字，0否则显示。

说明

\B
$`$*_$'$*_

我们首先匹配两个数字之间的每个位置（不是单词边界的位置），然后将匹配的前缀和后缀都插入一进制，并_用作一进制数字。因此+，我们不直接插入s，而是直接将和的一元结果插入那里。

S`\d

现在，我们将数字前后的字符串分开，以便每个总和都占一行，而我们摆脱了这些数字（也将有一条空的开头和结尾行，但这并不重要）。

G`^_$|^(__+)\1+$

这是标准的正则表达式，用于匹配一元数中的非素数。G在这里使用rep阶段意味着我们只保留所有包含正非质数的行（丢弃空行）。

^$

最后，我们检查字符串是否为空。如果输入的内容很宽泛，那么上一阶段将丢弃所有行（因为它们都是素数），这给了我们1。否则，如果任何行不是素数，它将保留在字符串中，而regex失败，给出0。

Python 2中，82个 79 78字节

f=lambda n,d=10:n<d or d/n<all((n/d+n%d)%k*f(n,10*d)for k in range(2,n/d+n%d))

这很慢，并且只能通过备忘来处理测试用例。

在线尝试！

替代版本，79字节

f=lambda n,d=10:n<d or f(n,10*d)>d/n<all((n/d+n%d)%k for k in range(2,n/d+n%d))

加快一字节的速度。

在线尝试！

果冻，12字节

DJ⁵*⁸dṖS€ÆPẠ

在线尝试！

验证所有测试用例。

Java 8，175 171 94 88字节

n->{long d=10,r=0,i,t;for(;d<=n;d*=10,r|=t-i)for(t=n/d+n%d,i=1;t%++i%t>0;);return r==0;}

-77感谢@PeterTaylor通过使用算术方法（而不是带有String的String .substring）并摆脱了单独的方法来检查整数是否为质数。
使用@SaraJ的素数检查方法 -6个字节，因此请确保对她投票！

在这里尝试。

说明：

n->{                  // Method with long as both parameter and return-type
  long d=10,r=0,i,t;  //  Some temp longs
  for(;d<=n           //  Loop as long as `d` is below or equal to input `n`
                      //  (inclusive instead of exclusive due to special case 10)
      ;               //    After every iteration:
       d*=10,         //     Multiple `d` by 10
       r|=t-i)        //     and Bitwise-OR `r` with `t-i`
    for(t=n/d+n%d,    //   Set `t` to `n` integer-divided by `d` plus `n` modulo-`d`
        i=1;          //   Set `i` to 1
        t%++i%t>0;);  //   Inner oop as long as `t` modulo `i+1` modulo `t` is not 0 yet
                      //   (after we've first increased `i` by 1 with `++i`)
                      //   (if `t` equals `i` afterwards, it means `t` is a prime)
  return r==0;}       //  Return if `r` is still 0

Pyth，14个字节

.AmP_ssMcQ]dtU

在线尝试！True如果数字很大，将显示，False否则显示。将数字作为字符串。

说明

.AmP_ssMcQ]dtU

              Q    # Implicit input Q
            tU     # Generate the range [1, 2, ..., len(Q)-1]
  m                # For each index d in the above range...
        cQ]d       # Split Q at index d
      sM           # Convert the two parts to integers
     s             # Sum
   P_              # Check it is a prime
.A                 # ...end for. Check all elements are True

Python 2中，104 102 98 96 103字节

• 感谢@Wheat向导2个字节： i完全匿名，因为它仅被调用一次。
• 感谢@Hyperneutrino提供4个字节：从主数获取数字而不是切片的更智能方法
• @Hyperneutrino保存了另外2个字节： x-1只是x为了进行主要检查。
• 修复了大小写失败的问题x=10，因此增加了7个字节，这要归功于@Dennis和@Wheat Wizard的发现：我的早期版本考虑了1为质数

lambda x:all((lambda x:x>1and all(x%j for j in range(2,x)))(x/10**j+x%10**j)for j in range(1,len(`x`)))

在线尝试！

杰普特（24） 16字节

这几乎是@ Shaggy，@ ETHproduction和我之间的协作。

¬£[YîU UtY]xÃÅej

在线尝试！

将输入作为字符串。

点，25 24字节

$&0N_%,_=1M$+(a^@_)M1,#a

在线尝试！

说明

a是第一个命令行参数。1,#a产生包含数字的范围1通过len(a)-1。为此，我们映射了一个lambda函数：

$+(a^@_)
   a^@_   Split a at this index
$+(    )  Fold the resulting 2-element list on +

接下来，我们映射另一个lambda函数0N_%,_=1，用于测试素数。我从这个答案中得到了 ; 您可以在那里阅读说明。最后，我们将列表折叠在逻辑AND（$&）上。结果是1如果所有的和都是素数，0则。

示例，输入为4063：

                    1,#a   [1; 2; 3]
           $+(a^@_)M       [67; 103; 409]
  0N_%,_=1M                [1; 1; 1]
$&                         1

CJam，22个字节

r:L,({)_L<i\L>i+mp!},!

在线尝试！

为真打印正整数，对于虚假打印零。

-1感谢Peter Taylor的巧妙trick 俩。
-3感谢Peter Taylor的另一个建议。

杰普特，23个字节

将输入作为字符串。

该死的; 在我正在研究的更短的替代方案上受到打击。

£i+Ýe@OxXr"%+0+"'+)j

测试一下

Mathematica，75个字节

And@@Table[PrimeQ@ToExpression@StringInsert[#,"+",n],{n,2,StringLength@#}]&

Function期望一个String。PrimeQ@ToExpression@StringInsert[#,"+",n]返回是否+在n第一个数字后插入a 给出质数。Table[...,{n,2,StringLength@#}]给出这些值的列表，n范围从2到字符串的长度。然后And，我们采用该列表的每个元素。方便地，如果StringLength@#<2，Table[...]则为空列表，为此And@@{}==True

Mathematica，55岁 50 45 49 50 54 62 个字节

看来我应该分开张贴。

重新测量了代码长度的+6个字节。

+5个字节，感谢ngenisis。

And@@(qPrimeQ[#~Mod~q+⌊#/q⌋])@Rest@PowerRange@#&

将输入作为整数并返回regular True和False。将在两者之间是unicode 0xF4A1，简称Function[,]。代码长度取决于文件大小（不带BOM的UTF-8），如果不正确，请添加注释。

PowerRange[x]返回1，10，100 ...不大于x，在Mathematica 10中引入。

简明英语 4204 341 315 251 241 240字节

通过将3,863字节移入普通英语的库中，（重新）将素数测试合并到普通英语的库中。删除了26个字节的空白。通过缩写局部变量节省了64个字节。通过缩写接口节省了10个字节。根据RosLuP的建议，通过更改m的初始化和递增方式节省了1个字节。

To decide if a n number is g:
Put 1 in a m number.
Loop.
Multiply the m by 10.
If the m is greater than the n, say yes.
Divide the n by the m giving a q quotient and a r remainder.
Add the q to the r.
If the r is not prime, say no.
Repeat.

最终代码的未发布版本：

To decide if a number is magnanimous:
  Put 1 in another number.
  Loop.
    Multiply the other number by 10.
    If the other number is greater than the number, say yes.
    Divide the number by the other number giving a quotient and a remainder.
    Add the quotient to the remainder.
    If the remainder is not prime, say no.
  Repeat.

注意：可以在github.com/Folds/english上找到Plain English IDE 。IDE在Windows上运行。它编译为32位x86代码。

该Osmosian令普通英语的动态叉已经有了质数在4700版的测试，但它（通过2017年6月的1月）用了一个很低效的算法。GitHub站点的动态fork的版本4001-4011省略了素性测试。GitHub站点的动态派生版本4013包括素数测试。执行该素性测试的代码是此答案先前修订版的一部分。

Perl 6、58字节

{?(10,10* *...^*>$_).map({$_ div$^a+$_%$^a}).all.is-prime}

在线尝试！

10, 10 * * ...^ * > $_是10的倍数的几何序列，直到超出输入参数的元素之前的1为止$_。然后，我们只需检查每10次幂，输入参数div和mod的乘积之和就是幂。

哈斯克尔， 114 110字节

p x=[x]==[i|i<-[2..x],x`mod`i<1]
i!x|i<1=0<1|0<1=p(uncurry(+)$divMod x$10^i)&&(i-1)!x
f x=(length(show x)-1)!x

不带解释：

-- Check if x is a prime number
p x = [x] == [i | i<-[2..x], x`mod`i < 1]
-- Checks all pairs of numbers a '+' can be put in between
i ! x | i<1 = 0<1                                -- Single-digit numbers are always truthy
      | 0<1 = p (uncurry (+) $ divMod x $ 10^i)  -- Does x split at i digits from right sum up to a prime?
           && (i-1) ! x                          -- If so, check next pair
-- Start (!) with the number of digits in x minus one
f x = (length (show x)-1) ! x

公理，88字节

f(n:PI):Boolean==(i:=10;repeat(q:=n quo i;q=0 or ~prime?(q+n rem i)=>break;i:=i*10);q=0)

测试与结果

(10) -> [[i,f(i)]  for i in [1,2,4,10,98,101,109,819,4063,40427,2000221,999999999999999999999999999999999999999999999]]
   (10)
   [[1,true], [2,true], [4,true], [10,false], [98,true], [101,true],
    [109,false], [819,false], [4063,true], [40427,true], [2000221,true],
    [999999999999999999999999999999999999999999999 ,false]]

Brachylog，11个字节

{~cĊℕᵐ+}ᶠṗᵐ

在线尝试！

{      }ᶠ      Find every
      +        sum of
   Ċ           two
    ℕᵐ         whole numbers
 ~c            which concatenate to the input,
          ᵐ    and assert that all of them
         ṗ     are prime.

Perl 6、35个字节

{m:ex/^(.+)(.+)$/.all.sum.is-prime}

在线尝试！

说明：

{                                 }     # Anonymous code block that
 m:ex/^        $/                         # Match all
       (.+)(.+)                           # Splits of the input number
                 .all                     # Are all of them
                     .sum                   # When summed
                         .is-prime          # Prime?

堆叠，51字节

[tostr:#'1-~>splitat tr['+',' '#`#~prime]map 1,all]

在线尝试！

这是一个功能。它的工作原理是将其参数转换为字符串（tostr），将其复制并获得其长度（:#'），然后减去1（1-），范围从1到该数字（~>）。堆栈看起来像这样，用于输入40427：

('40427' (1 2 3 4))

我们执行vectorized splitat，导致以下数组位于堆栈的顶部：

(('4' '40' '404' '4042') ('0427' '427' '27' '7'))

用换位tr，得到：

(('4' '0427') ('40' '427') ('404' '27') ('4042' '7'))

然后，我们映射函数['+',' '#＃(with〜prime ] map`）。该功能可以：

['+',' '#`#~prime]
 '+',                concatenate a plus sign (string)    `('4' '0427' '+')
     ' '#`           join by spaces                      `'4 0427 +'`
          #~         evaluate                            `431`
            prime    check primality                     `1`

然后，在地图之后，我们进行连接1。这是因为all返回undef空列表。

JavaScript（ES6），70个字节

P=(n,x=2)=>n%x?P(n,x+1):n==x
f=(n,i=10)=>i>n||P((n/i|0)+n%i)&f(n,i*10)

由于计算时出现“太多递归”错误，导致我的浏览器中的最后一种情况失败P(200023)。希望这不会使它无效。

QBIC，38个字节

_L;|[a-1|q=q*µ!_sA,b|!+!_sA,b+1,a|!}?q

说明

_L |     Create a variable a and set it to the length of
  ;      the input string (A$)
[a-1|    FOR b = 1 to a-1
q=q*     multiply q by
 µ       -1 if prime, 0 if not, of
  !        a cast of 
   _s       a substring of
     A,       A$
     b        from index 1 to index b (only one index is given, so that is assumed to be the req. length from 1)
      |!   to number
 +         plus
 !         a cast of
  _s         a substring of
    A,         A$
    b+1        from index b+1
    ,a         for the length of a (does not error if it exceeds the end of the string)
      |!   to number
 }       NEXT 
 ?q      PRINT q, which is eitrher -1 or 1 for all-prime sums, or 0 otherwise

CJam（21字节）

r:R,({RiA@)#md+mp!},!

在线演示，在线测试套件

解剖

r:R       e# Take a token of input and assign it to R
,(        e# Take the length of R minus one
{         e# Filter i = 0 to (length of R minus two)
  Ri      e#   Push R as an integer value
  A@)#    e#   Push 10 to the power of (i + 1)
  md      e#   divmod
  +mp!    e#   Add, primality test, negate result
},        e# The result of the filter is a list of splits which give a non-prime
!         e# Negate result, giving 0 for false and 1 for true

Pyth，15个 14字节

.AmP_svcz]dtUz

测试套件

使用Pyth的最新更改保存了一个字节。

APL（NARS），字符35，字节70

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}

测试：

  f←{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
  f¨1 2 4 10 98 101 109 819 4063 40427 2000221
1 1 1 0 1 1 0 0 1 1 1 

这将是来自Axiom post algo的APL中的翻译...

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
 0≥k←¯1+≢⍕⍵:1⋄  assign to k the length as array of argument return 1 if that is <=0
 ∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k
              m←10*⍳k  m is the array pow(10,1..k)
           ⌊⍵÷m       the array of quotient of argumet with m
          +           sum 
     (m∣⍵)            with array of remander
   0π                 build the binary array of "are prime each"
 ∧/                   and that array

PHP，100字节

for(;++$k<strlen($a=$argn);$x+=$i==1)for($i=$n=substr($a,$k)+$b.=$a[$k-1];--$i&&$n%$i;);echo$x+2>$k;

1如果输入为大量，则打印，否则为空。与管道一起运行-nR或在线尝试。

Perl -p 5，42个字节

$\=1;s//map$\&&=($`+$')%$_,2..$`+$'-1/ge}{

在线尝试！