Étant donné un entier supérieur à 1, affichez le nombre de façons dont il peut être exprimé comme la somme d'un ou plusieurs nombres premiers consécutifs.

L'ordre des sommations n'a pas d'importance. Une somme peut consister en un seul nombre (donc la sortie pour tout nombre premier sera au moins 1.)

C'est du code-golf . Des règles standard s'appliquent.

Voir ce wiki OEIS pour les informations et séquences connexes, y compris la séquence elle-même OEIS A054845 .

Cas de 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

Gelée ,  6  5 octets

-1 merci à dylnan

ÆRẆ§ċ

Un lien monadique

Essayez-le en ligne! Ou voir la suite de tests (notez que le cas de test final expirerait à 60 ans chez TIO).

Comment?

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

R , 95 octets

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}

Essayez-le en ligne!

• -24 octets grâce à @Giuseppe qui a fondamentalement révolutionné ma solution prenant également en charge 34421!

05AB1E , 6 octets

Code

ÅPŒOQO

Utilise l' encodage 05AB1E . Essayez-le en ligne!

JavaScript (ES6), 92 octets

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)

Essayez-le en ligne!

Commenté

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 octets

EZqPYTRYsG=z

Essayez-le sur MATL Online

L'initiale E(multipliée par 2) garantit que, pour une entrée principale, le résultat de la dernière Ys( cumsum) n'a pas le premier d'entrée se répétant dans la partie mise à zéro de la matrice (jouant ainsi avec le compte).

Explication:

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

{⟦ṗˢs+?}ᶜ

Essayez-le en ligne!
Plusieurs cas de test

(-5 octets entiers, grâce à @Kroppeb!)

Explication:

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

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

Essayez-le en ligne! Le lien inclut des cas de test plus rapides. Explication:

m)

Exécutez le script entier en mode multiligne où ^et $correspondez sur chaque ligne.

.+
$*_$&$*

Convertissez deux fois en unaire, en utilisant d'abord _s, puis en utilisant 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Supprimez tous les nombres composites de la plage.

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

__1$n$

Husk , 9 8 octets

^{-1 octet grâce à Mr.Xcoder (utilisez l'argument nommé ¹au lieu de S)!}

#¹ṁ∫ṫ↑İp

Essayez-le en ligne!

Explication

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

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

Essayez-le sur MATL Online!

Explication

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

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

Essayez-le en ligne!

Nettoyer , 100 98 octets

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]

Essayez-le en ligne!

Définit la fonction $ :: Int -> Intqui fonctionne comme expliqué ci-dessous:

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

(L'explication concerne une version plus ancienne mais logiquement identique)

Perl 6 , 53 octets

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

Essayez-le en ligne!

Utilise l'opérateur de réduction de triangle deux fois. Le dernier cas de test est trop lent pour TIO.

Explication

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

Il doit y avoir un moyen plus court que ça!

Craps sur le dernier cas de test.

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

Essayez-le ou exécutez tous les cas de test

Explication

                      :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 182 octets

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 octet grâce à @ceilingcat .
-10 octets grâce à @SaraJ .

Essayez-le en ligne.

Explication:

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

C'est fondamentalement similaire à la réponse de Jelly ou 05AB1E , juste 190 octets de plus .. XD
Voici une comparaison pour chacune des parties, ajoutée juste pour le plaisir (et pour voir pourquoi Java est si verbeux, et ces langages de golf sont si puissants):

1. Prenez l'entrée: (Jelly: 0 octets) implicitement ; (05AB1E: 0 octet) implicitement ; (Java 10: 5 octets)n->{}
2. Créez une liste de nombres premiers dans la plage [2, n]: (Gelée: 2 octets) ÆR; (05AB1E: 2 octets) ÅP; (Java 10: 95 octets)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. Obtenez toutes les sous-listes continues: (Gelée: 1 octet) Ẇ; (05AB1E: 1 octet) Œ; (Java 10: 55 octets) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)et(int)L.get(k++);
4. Additionnez chaque sous-liste: (Gelée: 1 octet) §; (05AB1E: 1 octet) O; (Java 10: 9 octets) ,set ,s=0ets+=
5. Comptez ceux égaux à l'entrée: (Gelée: 1 octet) ċ; (05AB1E: 2 octets) QO; (Java 10: 15 octets) ,r=0etr+=s==n?1:0
6. Afficher le résultat: (Jelly: 0 octets) implicitement ; (05AB1E: 0 octet) implicitement ; (Java 10: 9 octets)return r;

Physica , 41 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

Alternative, 89 octets

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

Essayez-le en ligne!