给定一个大于1的整数，输出将其表示为一个或多个连续素数之和的方式数。

补数的顺序无关紧要。一个和可以包含一个数字（因此任何质数的输出至少为1。）

这是代码高尔夫球。适用标准规则。

有关相关信息和序列，包括序列本身的OEIS A054845，请参阅此OEIS Wiki。

测试用例

2 => 1
3 => 1
4 => 0
5 => 2
6 => 0
7 => 1
8 => 1
10 => 1
36 => 2
41 => 3
42 => 1
43 => 1
44 => 0
311 => 5
1151 => 4
34421 => 6

果冻， 6  5 字节

-1感谢dylnan

ÆRẆ§ċ

一元链接

在线尝试！或查看测试套件（请注意，最终测试用例将在TIO上于60s超时）。

怎么样？

ÆRẆ§ċ - Link: integer, n
ÆR    - primes from 2 to n inclusive
  Ẇ   - all contiguous substrings
   §  - sum each
    ċ - count occurrences of n

R，95字节

function(x,P=2){for(i in 2:x)P=c(P,i[all(i%%P)])
for(i in 1:x){F=F+sum(cumsum(P)==x)
P[i]=0}
F}

在线尝试！

• -24个字节感谢@Giuseppe，他从根本上革新了我的解决方案，同时也支持34421！

05AB1E，6个字节

码

ÅPŒOQO

使用05AB1E编码。在线尝试！

JavaScript（ES6），92个字节

n=>(a=[],k=1,g=s=>k>n?0:!s+g(s>0?s-(p=d=>k%--d?p(d):d<2&&a.push(k)&&k)(++k):s+a.shift()))(n)

在线尝试！

已评论

n => (                          // n = input
  a = [],                       // a[] = array holding the list of consecutive primes
  k = 1,                        // k = current number to test
  g = s =>                      // g = recursive function taking s = n - sum(a)
    k > n ?                     //   if k is greater than n:
      0                         //     stop recursion
    :                           //   else:
      !s +                      //     increment the final result if s = 0
      g(                        //     add the result of a recursive call to g():
        s > 0 ?                 //       if s is positive:
          s - (                 //         subtract from s the result of p():
            p = d => k % --d ?  //           p() = recursive helper function looking
              p(d)              //                 for the highest divisor d of k,
            :                   //                 starting with d = k - 1
              d < 2 &&          //           if d is less than 2 (i.e. k is prime):
              a.push(k) &&      //             append k to a[]
              k                 //             and return k (else: return false)
          )(++k)                //         increment k and call p(k)
        :                       //       else:
          s + a.shift()         //         remove the first entry from a[]
                                //         and add it to s
      )                         //     end of recursive call
  )(n)                          // initial call to g() with s = n

MATL，15 12字节

EZqPYTRYsG=z

在MATL Online上尝试

初始值E（乘以2）可确保对于素数输入，后一个Ys（cumsum）的结果不会使输入素数在矩阵的归零部分中重复自身（因此会弄乱计数）。

说明：

                % Implicit input, say 5
E               % Double the input
 Zq             % Get list of primes upto (and including) that
                %  Stack: [2 3 5 7]
   P            % Reverse that list
    YT          % Toeplitz matrix of that
                %  Stack: [7 5 3 2
                           5 7 5 3
                           3 5 7 5
                           2 3 5 7]
      R         % `triu` - upper triangular portion of matrix
                %  Stack: [7 5 3 2
                           0 7 5 3
                           0 0 7 5
                           0 0 0 7]
       Ys       % Cumulative sum along each column
                %  Stack: [7  5  3  2
                           7 12  8  5
                           7 12 15 10
                           7 12 15 17]


         G=     % Compare against input - 1s where equal, 0s where not
           z    % Count the number of non-zeros

Brachylog，14 9字节

{⟦ṗˢs+?}ᶜ

在线尝试！
多个测试案例

（-5个完整字节，多亏@Kroppeb！）

说明：

{⟦ṗˢs+?}ᶜ
{      }ᶜ     Count the number of ways this predicate can succeed:
 ⟦            Range from 0 to input
  ṗˢ          Select only the prime numbers
    s         The list of prime numbers has a substring (contiguous subset)
     +        Whose sum
      ?       Is the input

视网膜0.8.2，68字节

.+
$*_$&$*
_
$`__¶
A`^(__+)\1+$
m)&`^((_)|¶)+¶[_¶]*(?<-2>1)+$(?(2)1)

在线尝试！链接包括更快的测试用例。说明：

m)

在多行模式下运行整个脚本，^并$在每行上进行匹配。

.+
$*_$&$*

两次转换为一元，首先使用_s，然后使用1s。

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

删除范围内的所有复合数字。

&`^((_)|¶)+¶[_¶]*(?<-2>1)+$(?(2)1)

__1$n$

外壳，9 8字节

^{-1字节感谢Mr.Xcoder（使用命名参数¹代替S）！}

#¹ṁ∫ṫ↑İp

在线尝试！

说明

#¹ṁ∫ṫ↑İp  -- example input: 3
#¹        -- count the occurrences of 3 in
      İp  -- | primes: [2,3,5,7..]
     ↑    -- | take 3: [2,3,5]
    ṫ     -- | tails: [[2,3,5],[3,5],[5]]
  ṁ       -- | map and flatten
   ∫      -- | | cumulative sums
          -- | : [2,5,10,3,8,5]
          -- : 1

MATL，16字节

:"GZq@:g2&Y+G=vs

在MATL在线上尝试一下！

说明

:"        % Input (implicit): n. For each k in [1 2 ... n]
  G       %   Push n
  Zq      %   Primes up to that
  @:g     %   Push vector of k ones
  2&Y+    %   Convolution, removing the edges
  G=      %   True for entries that equal n
  v       %   Concatenate vertically with previous results
  s       %   Sum
          % End (implicit). Display (implicit)

Python 2中，106个 104字节

P=k=o=1
p=[]
i=input()
exec'o+=P%k*sum(p)==i;P*=k*k;k+=1;p+=P%k*[k];exec"p=p[i<sum(p):];"*k;'*i
print~-o

在线尝试！

干净，100 98字节

import StdEnv,StdLib
$n=sum[1\\z<-inits[i\\i<-[2..n]|all(\j=i/j*j<i)[2..i-1]],s<-tails z|sum s==n]

在线尝试！

定义功能$ :: Int -> Int，如下所述：

$ n                              // the function $ of n is
    = sum [                      // the sum of
        1                        // 1, for every 
        \\ z <- inits [          // prefix z of 
            i                    // i, for every
            \\ i <- [2..n]       // integer i between 2 and n
            | and [              // where every
                i/j*j < i        // j does not divide i
                \\ j <- [2..i-1] // for every j between 2 and i-1
            ]
        ]
        , s <- tails z           // ... and suffix s of the prefix z
        | sum s == n             // where the sum of the suffix is equal to n
    ]

（说明适用于较旧但逻辑上相同的版本）

Perl 6、53字节

{+grep $_,map {|[\+] $_},[\R,] grep *.is-prime,2..$_}

在线尝试！

两次使用三角形归约运算符。对于TIO，最后一个测试用例太慢了。

说明

{                                                   } # Anonymous block
                               grep *.is-prime,2..$_  # List of primes up to n
                         [\R,]  # All sublists (2) (3 2) (5 3 2) (7 5 3 2) ...
          map {|[\+] $_},  # Partial sums for each, flattened
 +grep $_,  # Count number of occurrences

Japt，17个字节

有比这更短的方法！

掌握最后一个测试用例。

õ fj x@ZãYÄ x@¶Xx

尝试或运行所有测试用例

说明

                      :Implicit input of integer U
õ                     :Range [1,U]
  fj                  :Filter primes
      @               :Map each integer at 0-based index Y in array Z
         YÄ           :  Y+1
       Zã             :  Subsections of Z of that length
             @        :  Map each array X
               Xx     :    Reduce by addition
              ¶       :    Check for equality with U
            x         :  Reduce by addition
     x                :Reduce by addition

Java的10，195个 194 184 182字节

n->{var L=new java.util.Stack();int i=1,k,x,s,r=0;for(;i++<n;){for(k=1;i%++k>0;);if(k==i)L.add(i);}for(x=L.size(),i=0;i<x;)for(k=i++,s=0;k<x;r+=s==n?1:0)s+=(int)L.get(k++);return r;}

-1个字节感谢@ceilingcat。
-10个字节感谢@SaraJ。

在线尝试。

说明：

n->{                // Method with integer as both parameter and return-type
  var L=new java.util.Stack();
                    //  List of primes, starting empty
  int i=1,k,x,s,    //  Temp integers
      r=0;          //  Result-counter, starting at 0
  for(;i++<n;){     //  Loop `i` in the range [2, `n`]
    for(k=1;        //   Set `k` to 1
        i%++k>0;);  //   Inner loop which increases `k` by 1 before every iteration,
                    //   and continues as long as `i` is not divisible by `k`
    if(k==i)        //   If `k` is now still the same as `i`; a.k.a. if `i` is a prime:
      L.add(i);}    //    Add the prime to the List
  for(x=L.size(),   //  Get the amount of primes in the List
      i=0;i<x;)     //  Loop `i` in the range [0, amount_of_primes)
    for(s=0,        //   (Re)set the sum to 0
        k=i++;k<x;  //   Inner loop `k` in the range [`i`, amount_of_primes)
        r+=s==n?    //     After every iteration, if the sum is equal to the input:
            1       //      Increase the result-counter by 1
           :        //     Else:
            0)      //      Leave the result-counter the same by adding 0
      s+=(int)L.get(k++);
                    //    Add the next prime (at index `k`) to the sum
  return r;}        //  And finally return the result-counter

它基本上与Jelly或05AB1E的答案类似，仅相差 190字节。
这里，每个部位的比较，增加只是为了好玩（和明白为什么Java是如此冗长，而这些高尔夫球场的语言都是那么强大）：

1. 隐式地输入：（果冻：0字节）；（05AB1E：0个字节）隐式 ; （Java 10：5个字节）n->{}
2. 创建以下范围内的素数列表[2, n]：（果冻：2个字节）ÆR；（05AB1E：2个字节）ÅP; （Java 10：95个字节）var L=new java.util.Stack();int i=1,k,x,s,r=0;for(;i++<n;){for(k=1;i%++k>0;);if(k==i)L.add(i);}
3. 获取所有连续子列表：（果冻：1个字节）Ẇ；（05AB1E：1个字节）Œ; （爪哇10：55个字节）for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)和(int)L.get(k++);
4. 汇总每个子列表：（果冻：1个字节）§；（05AB1E：1个字节）O; （爪哇10：9字节）,s和,s=0与s+=
5. 计数等于输入的那些值：（Jelly：1个字节）ċ；（05AB1E：2个字节）QO; （Java 10：15个字节）,r=0和r+=s==n?1:0
6. 隐式输出结果：（果冻：0字节）；（05AB1E：0个字节）隐式 ; （Java 10：9个字节）return r;

物理，41字节

->x:Count[Sum@Sublists[PrimeQ$$[…x]];x]

在线尝试！

怎么运行的

->x:Count[Sum@Sublists[PrimeQ$$[…x]];x] // Full program.
->x:            // Define an anonymous function with parameter x.
    […x]        // Range [0 ... x] (inclusive).
        $$      // Filter-keep those that...
  PrimeQ        // Are prime.
 Sublists[...]  // Get all their sublists.
Sum@            // Then sum each sublist.
Count[...;x]    // Count the number of times x occurs in the result.

Haskell，89个字节

g n=sum[1|a<-[0..n],_<-filter(n==).scanl1(+)$drop a[p|p<-[2..n],all((>0).mod p)[2..p-1]]]

在线尝试！

备用，89字节

f n=length$do a<-[0..n];filter(n==).scanl1(+)$drop a[p|p<-[2..n],all((>0).mod p)[2..p-1]]

在线尝试！