1'den büyük bir tam sayı verildiğinde, bir veya daha fazla ardışık primerin toplamı olarak ifade edilebileceği yolların sayısını çıktılayın.

Summandların sırası önemli değil. Toplam, tek bir sayıdan oluşabilir (bu nedenle, herhangi bir asal için çıktı en az 1 olacaktır).

Bu kod golfü . Standart kurallar geçerlidir.

Bkz Bu OEIS wiki'yi sekansının kendisinin de dahil olmak üzere ilgili bilgileri ve dizileri için OEIS A054845 .

Test senaryoları

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

Jöle ,  6  5 bayt

-1 dylnan sayesinde

ÆRẆ§ċ

Monadik bir bağlantı

Çevrimiçi deneyin! Veya test takımına bakın (son test senaryosunun TIO'da 60'larda zaman aşımına uğradığını unutmayın).

Nasıl?

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

R , 95 bayt

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}

Çevrimiçi deneyin!

• 34421'i destekleyen çözümümde devrim yaratan @Giuseppe sayesinde -24 bayt!

05AB1E , 6 bayt

kod

ÅPŒOQO

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

JavaScript (ES6), 92 bayt

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)

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

EZqPYTRYsG=z

MATL Online'da deneyin

İlk E(2 ile çarp), birincil giriş için, later Ys( cumsum) sonucunun , matrisin sıfırlanmış bölümünde (böylece sayımla karışıklık) kendini tekrarlayan giriş asalının olmamasını sağlar.

Açıklama:

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

{⟦ṗˢs+?}ᶜ

Çevrimiçi deneyin!
Çoklu test örnekleri

(@Kroppeb sayesinde -5 tam bayt!)

Açıklama:

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

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

Çevrimiçi deneyin! Bağlantı daha hızlı test senaryoları içerir. Açıklama:

m)

Satırlı modda nerede bütün komut dosyasını çalıştırın ^ve $her satırda maç.

.+
$*_$&$*

Önce _s'yi sonra s'yi kullanarak iki kez tekliye dönüştürün 1.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Aralıktaki tüm bileşik sayıları silin.

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

__1$n$

Kabuk , 9 8 bayt

^{Mr.Xcoder sayesinde -1 bayt ( ¹bunun yerine adlandırılmış argüman kullanın S)!}

#¹ṁ∫ṫ↑İp

Çevrimiçi deneyin!

açıklama

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

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

MATL Online'da deneyin!

açıklama

:"        % 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 , 106104 bayt

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

Çevrimiçi deneyin!

Temiz , 100 98 bayt

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]

Çevrimiçi deneyin!

$ :: Int -> IntAşağıda açıklandığı gibi çalışan işlevi tanımlar :

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

(Açıklama daha eski ancak mantıksal olarak aynı sürüm içindir)

Perl 6 , 53 bayt

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

Çevrimiçi deneyin!

Üçgen azaltma işlecini iki kez kullanır. Son test durumu TIO için çok yavaş.

açıklama

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

Bundan daha kısa bir yol olmalı!

Son test durumunda ortaya çıkar.

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

Deneyin veya tüm test senaryolarını çalıştırın

açıklama

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

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

@Ceilingcat sayesinde -1 bayt . @SaraJ
sayesinde -10 bayt .

Çevrimiçi deneyin.

Açıklama:

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

Temel olarak Jelly veya 05AB1E cevaplarına benzer , sadece 190 bayt daha fazla .. XD
Burada, her parça için bir karşılaştırma, sadece eğlence için eklendi (ve Java'nın neden bu kadar ayrıntılı olduğunu ve bu golf dillerinin bu kadar güçlü olduğunu görmek için):

1. Girdiyi alın: (Jelly: 0 bayt) üstü kapalı ; (05AB1E: 0 bayt) dolaylı olarak ; (Java 10: 5 bayt)n->{}
2. Aralıkta bir primer listesi oluşturun [2, n]: (Jelly: 2 bayt) ÆR; (05AB1E: 2 bayt) ÅP; (Java 10: 95 bayt)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. Tüm sürekli alt listeleri alın: (Jelly: 1 byte) Ẇ; (05AB1E: 1 bayt) Œ; (Java 10: 55 bayt) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)ve(int)L.get(k++);
4. Her alt listeyi toplayın: (Jöle: 1 bayt) §; (05AB1E: 1 bayt) O; (Java 10: 9 bayt) ,sve ,s=0ves+=
5. Girdiye eşit olanları sayın: (Jelly: 1 byte) ċ; (05AB1E: 2 bayt) QO; (Java 10: 15 bayt) ,r=0ver+=s==n?1:0
6. Sonuç çıktısı: (Jöle: 0 bayt) dolaylı olarak ; (05AB1E: 0 bayt) dolaylı olarak ; (Java 10: 9 bayt)return r;

Physica , 41 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Alternatif, 89 bayt

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

Çevrimiçi deneyin!