Cho một số nguyên lớn hơn 1, xuất ra số cách có thể được biểu diễn dưới dạng tổng của một hoặc nhiều số nguyên tố liên tiếp.

Thứ tự triệu tập không thành vấn đề. Một tổng có thể bao gồm một số duy nhất (vì vậy đầu ra cho bất kỳ số nguyên tố nào sẽ có ít nhất là 1.)

Đây là mã golf . Quy tắc tiêu chuẩn áp dụng.

Xem wiki OEIS này để biết thông tin và trình tự liên quan, bao gồm cả trình tự OEIS A054845 .

Các trường hợp thử nghiệm

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

Thạch ,  6  5 byte

-1 cảm ơn dyl Nam

ÆRẆ§ċ

Một liên kết đơn âm

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm (lưu ý trường hợp thử nghiệm cuối cùng sẽ hết thời gian ở 60s tại TIO).

Làm sao?

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

R , 95 byte

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}

Hãy thử trực tuyến!

• -24 byte nhờ @Giuseppe, người về cơ bản đã cách mạng hóa giải pháp của tôi hỗ trợ 34421!

05AB1E , 6 byte

Mã

ÅPŒOQO

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

JavaScript (ES6), 92 byte

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)

Hãy thử trực tuyến!

Đã bình luậ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 byte

EZqPYTRYsG=z

Dùng thử trên MATL Online

Giá trị ban đầu E(nhân với 2) đảm bảo rằng, đối với đầu vào nguyên tố, kết quả của sau Ys( cumsum) không có số nguyên tố đầu vào lặp lại trong phần không của ma trận (do đó làm rối loạn số đếm).

Giải trình:

                % 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 byte

{⟦ṗˢs+?}ᶜ

Hãy thử trực tuyến!
Nhiều trường hợp kiểm tra

(-5 toàn bộ byte, nhờ @Kroppeb!)

Giải trình:

{⟦ṗˢ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

Võng mạc 0.8.2 , 68 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp kiểm tra nhanh hơn. Giải trình:

m)

Chạy toàn bộ tập lệnh ở chế độ đa dòng ở đâu ^và $khớp trên mỗi dòng.

.+
$*_$&$*

Chuyển đổi sang unary hai lần, lần đầu tiên sử dụng _s, sau đó sử dụng 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Xóa tất cả các số tổng hợp trong phạm vi.

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

__1$n$

Husk , 9 8 byte

^{-1 byte nhờ Mr.Xcoder (sử dụng đối số có tên ¹thay vì S)!}

#¹ṁ∫ṫ↑İp

Hãy thử trực tuyến!

Giải trình

#¹ṁ∫ṫ↑İ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 byte

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

Hãy thử nó tại MATL Online!

Giải trình

:"        % 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 byte

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

Hãy thử trực tuyến!

Sạch sẽ , 100 98 byte

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]

Hãy thử trực tuyến!

Xác định chức năng $ :: Int -> Inthoạt động như được giải thích dưới đây:

$ 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
    ]

(Giải thích cho phiên bản cũ hơn nhưng giống hệt logic)

Perl 6 , 53 byte

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

Hãy thử trực tuyến!

Sử dụng toán tử giảm tam giác hai lần. Trường hợp thử nghiệm cuối cùng là quá chậm đối với TIO.

Giải trình

{                                                   } # 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 byte

Phải có một cách ngắn hơn thế này!

Craps ra trên trường hợp thử nghiệm cuối cùng.

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

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

Giải trình

                      :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 byte

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 byte nhờ @ceilingcat .
-10 byte nhờ @SaraJ .

Hãy thử trực tuyến.

Giải trình:

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

Về cơ bản, nó tương tự như các câu trả lời của Jelly hoặc 05AB1E , chỉ hơn 190 byte .. XD
Ở đây một so sánh cho từng bộ phận, được thêm vào chỉ để giải trí (và để xem tại sao Java lại dài dòng và các ngôn ngữ chơi gôn này rất mạnh):

1. Lấy đầu vào: (Jelly: 0 byte) ngầm ; (05AB1E: 0 byte) ngầm ; (Java 10: 5 byte)n->{}
2. Tạo một danh sách các số nguyên tố trong phạm vi [2, n]: (Jelly: 2 byte) ÆR; (05AB1E: 2 byte)ÅP ; (Java 10: 95 byte)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. Nhận tất cả các danh sách phụ liên tục: (Jelly: 1 byte) Ẇ; (05AB1E: 1 byte) Œ; (Java 10: 55 byte)for(x=L.size(),i=0;i<x;)for(k=i++;k<x;) và(int)L.get(k++);
4. Tổng mỗi danh sách phụ: (Jelly: 1 byte) §; (05AB1E: 1 byte) O; (Java 10: 9 byte) ,svà,s=0 vàs+=
5. Đếm những cái đó bằng đầu vào: (Jelly: 1 byte) ċ; (05AB1E: 2 byte) QO; (Java 10: 15 byte),r=0 vàr+=s==n?1:0
6. Xuất kết quả: (Jelly: 0 byte) ngầm ; (05AB1E: 0 byte) ngầm ; (Java 10: 9 byte)return r;

Physica , 41 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

->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 byte

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

Hãy thử trực tuyến!

Thay thế, 89 byte

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

Hãy thử trực tuyến!