Dengan bilangan bulat lebih besar dari 1, hasilkan jumlah cara yang dapat dinyatakan sebagai jumlah dari satu atau lebih bilangan prima berturut-turut.

Urutan musim panas tidak masalah. Jumlah dapat terdiri dari satu angka (sehingga output untuk prime apa pun akan setidaknya 1.)

Ini adalah kode-golf . Aturan standar berlaku.

Lihat wiki OEIS ini untuk informasi dan urutan terkait, termasuk urutan itu sendiri OEIS A054845 .

Uji kasus

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

Jelly ,  6  5 byte

-1 Terima kasih kepada dylnan

ÆRẆ§ċ

Tautan monadik

Cobalah online! Atau lihat test-suite (perhatikan kasus tes akhir akan habis pada 60-an di TIO).

Bagaimana?

Æ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}

Cobalah online!

• -24 byte terima kasih kepada @Giuseppe yang pada dasarnya merevolusi solusi saya yang mendukung 34421 juga!

05AB1E , 6 byte

Kode

ÅPŒOQO

Menggunakan penyandian 05AB1E . Cobalah online!

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)

Cobalah online!

Berkomentar

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

Cobalah di MATL Online

Inisial E(dikalikan dengan 2) memastikan bahwa, untuk input prima, hasil nanti Ys( cumsum) tidak memiliki input prima yang berulang di bagian nol dari matriks (sehingga mengacaukan penghitungan).

Penjelasan:

                % 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+?}ᶜ

Cobalah online!
Berbagai kasus uji

(-5 seluruh byte, terima kasih kepada @ Kalpeb!)

Penjelasan:

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

Retina 0.8.2 , 68 byte

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

Cobalah online! Tautan mencakup test case yang lebih cepat. Penjelasan:

m)

Jalankan seluruh skrip dalam mode multiline di mana ^dan $cocokkan di setiap baris.

.+
$*_$&$*

Konversikan ke unary dua kali, pertama menggunakan _s, lalu menggunakan 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Hapus semua angka komposit dalam rentang.

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

__1$n$

Sekam , 9 8 byte

^{-1 byte terima kasih kepada Mr.Xcoder (gunakan argumen bernama ¹alih-alih S)!}

#¹ṁ∫ṫ↑İp

Cobalah online!

Penjelasan

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

Cobalah di MATL Online!

Penjelasan

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

Cobalah online!

Bersih , 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]

Cobalah online!

Menentukan fungsi $ :: Int -> Intyang berfungsi seperti yang dijelaskan di bawah ini:

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

(Penjelasan untuk versi yang lebih lama tetapi identik secara logis)

Perl 6 , 53 byte

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

Cobalah online!

Menggunakan operator reduksi segitiga dua kali. Kasing tes terakhir terlalu lambat untuk TIO.

Penjelasan

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

Pasti ada cara yang lebih singkat dari ini!

Craps pada test case terakhir.

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

Cobalah atau jalankan semua test case

Penjelasan

                      :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 terima kasih kepada @ceilingcat .
-10 byte terima kasih kepada @SaraJ .

Cobalah online.

Penjelasan:

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

Ini pada dasarnya mirip dengan jawaban Jelly atau 05AB1E , hanya 190 byte lebih .. XD
Di sini perbandingan untuk masing-masing bagian, ditambahkan hanya untuk bersenang-senang (dan untuk melihat mengapa Java sangat bertele-tele, dan bahasa-bahasa golf ini sangat kuat):

1. Ambil input: (Jelly: 0 byte) secara implisit ; (05AB1E: 0 byte) secara implisit ; (Java 10: 5 byte)n->{}
2. Buat daftar bilangan prima dalam kisaran [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. Dapatkan semua sub-daftar berkelanjutan: (Jelly: 1 byte) Ẇ; (05AB1E: 1 byte) Œ; (Java 10: 55 byte) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)dan(int)L.get(k++);
4. Jumlahkan setiap sub-daftar: (Jelly: 1 byte) §; (05AB1E: 1 byte) O; (Java 10: 9 bytes) ,sdan ,s=0dans+=
5. Hitung yang sama dengan input: (Jelly: 1 byte) ċ; (05AB1E: 2 byte) QO; (Java 10: 15 byte) ,r=0danr+=s==n?1:0
6. Keluarkan hasilnya: (Jelly: 0 byte) secara implisit ; (05AB1E: 0 byte) secara implisit ; (Java 10: 9 bytes)return r;

Physica , 41 byte

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

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Alternatif, 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]]

Cobalah online!