Wenn eine Ganzzahl größer als 1 ist, geben Sie die Anzahl der Möglichkeiten aus, die als Summe von einem oder mehreren aufeinanderfolgenden Primzahlen ausgedrückt werden können.

Reihenfolge der Summanden spielt keine Rolle. Eine Summe kann aus einer einzelnen Zahl bestehen (daher beträgt die Ausgabe für jede Primzahl mindestens 1).

Das ist Code-Golf . Es gelten Standardregeln.

In diesem OEIS-Wiki finden Sie verwandte Informationen und Sequenzen, einschließlich der Sequenz selbst, OEIS A054845 .

Testfälle

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

Gelee ,  6  5 Bytes

-1 danke an dylnan

ÆRẆ§ċ

Eine monadische Verbindung

Probieren Sie es online! Oder sehen Sie sich die Testsuite an (beachten Sie, dass der letzte Testfall bei TIO nach 60 Sekunden abläuft).

Wie?

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

R , 95 Bytes

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}

Probieren Sie es online!

• -24 Bytes dank @Giuseppe, der meine Lösung, die auch 34421 unterstützt, grundlegend revolutioniert hat!

05AB1E , 6 Bytes

Code

ÅPŒOQO

Verwendet die 05AB1E- Codierung. Probieren Sie es 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)

Probieren Sie es online!

Kommentiert

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 Bytes

EZqPYTRYsG=z

Probieren Sie es auf MATL Online aus

Die Initiale E(Multiplikation mit 2) stellt sicher, dass bei der Primzahl-Eingabe das Ergebnis der later Ys( cumsum) -Eingabe keine Primzahl hat, die sich im nullten Teil der Matrix wiederholt (und so mit der Zählung durcheinanderbringt).

Erläuterung:

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

{⟦ṗˢs+?}ᶜ

Probieren Sie es online!
Mehrere Testfälle

(-5 ganze Bytes, danke an @Kroppeb!)

Erläuterung:

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

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

Probieren Sie es online! Link enthält schnellere Testfälle. Erläuterung:

m)

Führen Sie das gesamte Skript im mehrzeiligen Modus aus, ^und $passen Sie es in jeder Zeile an.

.+
$*_$&$*

Konvertiere zweimal nach unary, zuerst mit _s, dann mit 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Löschen Sie alle zusammengesetzten Nummern im Bereich.

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

__1$n$

Schale , 9 8 Bytes

^{-1 byte dank Mr.Xcoder (benutze benanntes Argument ¹statt S)!}

#¹ṁ∫ṫ↑İp

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es bei MATL Online!

Erläuterung

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

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

Probieren Sie es online!

Sauber , 100 98 Bytes

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]

Probieren Sie es online!

Definiert die Funktion, $ :: Int -> Intdie wie folgt funktioniert :

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

(Erklärung gilt für eine ältere, aber logisch identische Version)

Perl 6 , 53 Bytes

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

Probieren Sie es online!

Verwendet den Dreiecksverkleinerungsoperator zweimal. Der letzte Testfall ist für TIO zu langsam.

Erläuterung

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

Es muss einen kürzeren Weg geben!

Scheißt auf den letzten Testfall.

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

Probieren Sie es aus oder führen Sie alle Testfälle aus

Erläuterung

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

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 dank @ceilingcat .
-10 Bytes dank @SaraJ .

Probieren Sie es online aus.

Erläuterung:

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

Es ist im Grunde ähnlich wie die Gelee oder 05AB1E Antworten, nur 190 Bytes mehr .. XD
Hier ein Vergleich für jeden der Teile, hinzugefügt nur zum Spaß (und zu sehen , warum Java so ausführlich ist, und diese Golf - Sprachen sind so mächtig):

1. Nehmen Sie die Eingabe: (Jelly: 0 Bytes) implizit ; (05AB1E: 0 Byte) implizit ; (Java 10: 5 Bytes)n->{}
2. Erstellen Sie eine Liste von Primzahlen im Bereich [2, n]: (Jelly: 2 Bytes) ÆR; (05AB1E: 2 Bytes) ÅP; (Java 10: 95 Bytes)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. Holen Sie sich alle fortlaufenden Unterlisten: (Jelly: 1 Byte) Ẇ; (05AB1E: 1 Byte) Œ; (Java 10: 55 Bytes) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)und(int)L.get(k++);
4. Summiere jede Unterliste: (Gelee: 1 Byte) §; (05AB1E: 1 Byte) O; (Java 10: 9 Bytes) ,sund ,s=0unds+=
5. Zählen Sie die Werte, die der Eingabe entsprechen: (Gelee: 1 Byte) ċ; (05AB1E: 2 Bytes) QO; (Java 10: 15 Bytes) ,r=0undr+=s==n?1:0
6. Das Ergebnis ausgeben: (Jelly: 0 Bytes) implizit ; (05AB1E: 0 Byte) implizit ; (Java 10: 9 Bytes)return r;

Physica , 41 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Alternative 89 Bytes

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

Probieren Sie es online!