Dado um número inteiro maior que 1, imprima o número de maneiras pelas quais ele pode ser expresso como a soma de um ou mais números primos consecutivos.

A ordem dos summands não importa. Uma soma pode consistir em um único número (portanto, a saída para qualquer primo será pelo menos 1.)

Isso é código-golfe . Aplicam-se regras padrão.

Consulte este wiki da OEIS para obter informações e sequências relacionadas, incluindo a própria sequência OEIS A054845 .

Casos de teste

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

Geléia ,  6  5 bytes

-1 graças a dylnan

ÆRẆ§ċ

Um link monádico

Experimente online! Ou consulte o conjunto de testes (observe que o caso de teste final atingia o limite de 60 anos no TIO).

Quão?

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

Experimente online!

• -24 bytes graças a @ Giuseppe, que basicamente revolucionou minha solução, suportando 34421 também!

05AB1E , 6 bytes

Código

ÅPŒOQO

Usa a codificação 05AB1E . Experimente online!

JavaScript (ES6), 92 bytes

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)

Experimente online!

Comentado

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

Experimente no MATL Online

A inicial E (multiplicar por 2) garante que, para entrada principal, o resultado da entrada posterior Ys( cumsum) não faça com que a entrada principal se repita na parte zerada da matriz (mexendo com a contagem).

Explicação:

                % 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

Braquilog , 14 9 bytes

{⟦ṗˢs+?}ᶜ

Experimente online!
Vários casos de teste

(-5 bytes inteiros, graças a @Kroppeb!)

Explicação:

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

Experimente online! O link inclui casos de teste mais rápidos. Explicação:

m)

Execute o script inteiro no modo multilinha em que ^e $combine em todas as linhas.

.+
$*_$&$*

Converta em unário duas vezes, primeiro usando _s, depois usando 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Exclua todos os números compostos no intervalo.

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

__1$n$

Casca , 9 8 bytes

^{-1 byte graças ao Mr.Xcoder (use o argumento nomeado em ¹vez de S)!}

#¹ṁ∫ṫ↑İp

Experimente online!

Explicação

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

Experimente no MATL Online!

Explicação

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

Experimente online!

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

Experimente online!

Define a função $ :: Int -> Intque funciona como explicado abaixo:

$ 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 explicação é para uma versão mais antiga, mas logicamente idêntica)

Perl 6 , 53 bytes

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

Experimente online!

Usa o operador de redução de triângulo duas vezes. O último caso de teste é muito lento para o TIO.

Explicação

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

Japonês, 17 bytes

Tem que haver uma maneira mais curta do que isso!

Dados no último caso de teste.

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

Experimente ou execute todos os casos de teste

Explicação

                      :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 graças a @ceilingcat .
-10 bytes graças a @SaraJ .

Experimente online.

Explicação:

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

É basicamente semelhante às respostas Jelly ou 05AB1E , apenas 190 bytes a mais. XD
Aqui uma comparação para cada uma das partes, adicionada apenas por diversão (e para ver por que Java é tão detalhado e essas linguagens de golfe são tão poderosas):

1. Pegue a entrada: (geléia: 0 bytes) implicitamente ; (05AB1E: 0 bytes) implicitamente ; (Java 10: 5 bytes)n->{}
2. Crie uma lista de números primos no intervalo [2, n]: (Geléia: 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. Obter todas as sub-listas contínuas: (Jelly: 1 byte) Ẇ; (05AB1E: 1 byte) Œ; (Java 10: 55 bytes) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)e(int)L.get(k++);
4. Soma cada sub-lista: (Geléia: 1 byte) §; (05AB1E: 1 byte) O; (Java 10: 9 bytes) ,se ,s=0es+=
5. Contar aqueles iguais à entrada: (Geléia: 1 byte) ċ; (05AB1E: 2 bytes) QO; (Java 10: 15 bytes) ,r=0er+=s==n?1:0
6. Saída do resultado: (Geléia: 0 bytes) implicitamente ; (05AB1E: 0 bytes) implicitamente ; (Java 10: 9 bytes)return r;

Physica , 41 bytes

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

Experimente online!

Como funciona

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

Experimente online!

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

Experimente online!