Dato un numero intero maggiore di 1, genera il numero di modi in cui può essere espresso come la somma di uno o più numeri primi consecutivi.

L'ordine delle sintesi non ha importanza. Una somma può essere costituita da un singolo numero (quindi l'output per qualsiasi numero primo sarà almeno 1)

Questo è code-golf . Si applicano le regole standard.

Vedi questo wiki OEIS per informazioni e sequenze correlate, inclusa la sequenza stessa OEIS A054845 .

Casi test

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

Gelatina ,  6  5 byte

-1 grazie a dylnan

ÆRẆ§ċ

Un collegamento monadico

Provalo online! Oppure guarda la suite di test (nota che il caso di test finale sarebbe scaduto a 60 anni al TIO).

Come?

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

Provalo online!

• -24 byte grazie a @Giuseppe che ha sostanzialmente rivoluzionato la mia soluzione supportando anche 34421!

05AB1E , 6 byte

Codice

ÅPŒOQO

Utilizza la codifica 05AB1E . Provalo 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)

Provalo online!

Commentate

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

Provalo su MATL online

L'iniziale E(moltiplicare per 2) si assicura che, per l'input primo, il risultato di later Ys( cumsum) non abbia l'input primo che si ripete nella parte azzerata della matrice (facendo confusione con il conteggio).

Spiegazione:

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

Provalo online!
Casi di test multipli

(-5 byte interi, grazie a @Kroppeb!)

Spiegazione:

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

Provalo online! Il collegamento include casi di test più veloci. Spiegazione:

m)

Esegui l'intero script in modalità multilinea dove ^e trova $corrispondenza su ogni riga.

.+
$*_$&$*

Converti in unario due volte, prima usando _s, poi usando 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Elimina tutti i numeri compositi nell'intervallo.

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

__1$n$

Husk , 9 8 byte

^{-1 byte grazie a Mr.Xcoder (usa l'argomento denominato ¹invece di S)!}

#¹ṁ∫ṫ↑İp

Provalo online!

Spiegazione

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

Provalo su MATL Online!

Spiegazione

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

Provalo online!

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

Provalo online!

Definisce la funzione $ :: Int -> Intche funziona come spiegato di seguito:

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

(La spiegazione è per una versione precedente ma logicamente identica)

Perl 6 , 53 byte

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

Provalo online!

Utilizza due volte l'operatore di riduzione del triangolo. L'ultimo caso di test è troppo lento per TIO.

Spiegazione

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

Deve esserci un modo più breve di questo!

Craps sull'ultimo caso di test.

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

Provalo o esegui tutti i casi di test

Spiegazione

                      :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 grazie a @ceilingcat .
-10 byte grazie a @SaraJ .

Provalo online.

Spiegazione:

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

È sostanzialmente simile alla risposta di Jelly o 05AB1E , solo 190 byte in più .. XD
Ecco un confronto per ciascuna delle parti, aggiunto solo per divertimento (e per capire perché Java è così prolisso e questi linguaggi del golf sono così potenti):

1. Prendi l'input: (Jelly: 0 byte) implicitamente ; (05AB1E: 0 byte) implicitamente ; (Java 10: 5 byte)n->{}
2. Crea un elenco di numeri primi nell'intervallo [2, n]: (Gelatina: 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. Ottieni tutti gli elenchi continui: (Jelly: 1 byte) Ẇ; (05AB1E: 1 byte) Œ; (Java 10: 55 byte)for(x=L.size(),i=0;i<x;)for(k=i++;k<x;) e(int)L.get(k++);
4. Somma ogni sotto-elenco: (Jelly: 1 byte) §; (05AB1E: 1 byte) O; (Java 10: 9 byte) ,sed ,s=0es+=
5. Contare quelli uguali all'input: (Jelly: 1 byte) ċ; (05AB1E: 2 byte) QO; (Java 10: 15 byte) ,r=0er+=s==n?1:0
6. Emette il risultato: (Jelly: 0 byte) implicitamente ; (05AB1E: 0 byte) implicitamente ; (Java 10: 9 byte)return r;

Physica , 41 byte

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

Provalo online!

Come funziona

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

Provalo online!

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

Provalo online!