Biorąc pod uwagę liczbę całkowitą większą niż 1, wypisz liczbę sposobów, które można wyrazić jako sumę jednego lub więcej kolejnych liczb pierwszych.

Kolejność summands nie ma znaczenia. Suma może składać się z pojedynczej liczby (więc wynik dla dowolnej liczby pierwszej będzie wynosił co najmniej 1.)

To jest golf golfowy . Obowiązują standardowe zasady.

Zobacz wiki OEIS, aby uzyskać informacje i sekwencje, w tym samą sekwencję OEIS A054845 .

Przypadki testowe

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

Galaretka ,  6  5 bajtów

-1 dzięki dylnan

ÆRẆ§ċ

Link monadyczny

Wypróbuj online! Lub zobacz pakiet testowy (zwróć uwagę, że końcowy przypadek testowy upłynąłby w TIO w latach 60.).

W jaki sposób?

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

R , 95 bajtów

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}

Wypróbuj online!

• -24 bajty dzięki @Giuseppe, który zasadniczo zrewolucjonizował również moje rozwiązanie obsługujące 34421!

05AB1E , 6 bajtów

Kod

ÅPŒOQO

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

JavaScript (ES6), 92 bajty

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)

Wypróbuj online!

Skomentował

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 bajtów

EZqPYTRYsG=z

Wypróbuj na MATL Online

Początkowy E(pomnóż przez 2) upewnia się, że w przypadku pierwszej liczby wejściowej wynik później Ys( cumsum) nie ma pierwszej liczby wejściowej powtarzającej się w zerowanej części macierzy (w ten sposób powodując bałagan w liczeniu).

Wyjaśnienie:

                % 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 bajtów

{⟦ṗˢs+?}ᶜ

Wypróbuj online!
Wiele przypadków testowych

(-5 pełnych bajtów, dzięki @Kroppeb!)

Wyjaśnienie:

{⟦ṗˢ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 bajtów

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

Wypróbuj online! Link zawiera szybsze przypadki testowe. Wyjaśnienie:

m)

Uruchom cały skrypt w trybie multilinii gdzie ^i $dopasuj w każdej linii.

.+
$*_$&$*

Konwertuj na unary dwa razy, najpierw używając _s, a następnie używając 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Usuń wszystkie liczby złożone w zakresie.

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

__1$n$

Łuska , 9 8 bajtów

^{-1 bajt dzięki Mr.Xcoder (użyj nazwanego argumentu ¹zamiast S)!}

#¹ṁ∫ṫ↑İp

Wypróbuj online!

Wyjaśnienie

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

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

Wypróbuj w MATL Online!

Wyjaśnienie

:"        % 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 bajtów

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

Wypróbuj online!

Czysty , 100 98 bajtów

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]

Wypróbuj online!

Definiuje funkcję, $ :: Int -> Intktóra działa jak wyjaśniono poniżej:

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

(Wyjaśnienie dotyczy starszej, ale logicznie identycznej wersji)

Perl 6 , 53 bajtów

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

Wypróbuj online!

Używa operatora redukcji trójkąta dwa razy. Ostatni przypadek testowy jest zbyt wolny dla TIO.

Wyjaśnienie

{                                                   } # 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 bajtów

Musi być krótsza droga!

Występuje w ostatnim przypadku testowym.

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

Wypróbuj lub uruchom wszystkie przypadki testowe

Wyjaśnienie

                      :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 bajtów

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 bajt dzięki @ceilingcat .
-10 bajtów dzięki @SaraJ .

Wypróbuj online.

Wyjaśnienie:

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

Jest w zasadzie podobny do odpowiedzi Jelly lub 05AB1E , tylko 190 bajtów więcej .. XD
Tutaj porównanie dla każdej części, dodane tylko dla zabawy (i żeby zobaczyć, dlaczego Java jest tak gadatliwa, a te języki gry w golfa są tak potężne):

1. Weź dane wejściowe: (galaretka: 0 bajtów) niejawnie ; (05AB1E: 0 bajtów) niejawnie ; (Java 10: 5 bajtów)n->{}
2. Utwórz listę liczb pierwszych w zakresie [2, n]: (Galaretka: 2 bajty) ÆR; (05AB1E: 2 bajty) ÅP; (Java 10: 95 bajtów)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. Zbierz wszystkie ciągłe listy podrzędne: (Galaretka: 1 bajt) Ẇ; (05AB1E: 1 bajt) Œ; (Java 10: 55 bajtów)for(x=L.size(),i=0;i<x;)for(k=i++;k<x;) i(int)L.get(k++);
4. Zsumuj każdą podlistę: (galaretka: 1 bajt) §; (05AB1E: 1 bajt) O; (Java 10: 9 bajtów) ,si,s=0 is+=
5. Policz te równe wejściowi: (Galaretka: 1 bajt) ċ; (05AB1E: 2 bajty) QO; (Java 10: 15 bajtów) ,r=0ir+=s==n?1:0
6. Wynik wynik: (Galaretka: 0 bajtów) niejawnie ; (05AB1E: 0 bajtów) niejawnie ; (Java 10: 9 bajtów)return r;

Physica , 41 bajtów

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

Wypróbuj online!

Jak to działa

->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 bajtów

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

Wypróbuj online!

Alternatywnie, 89 bajtów

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

Wypróbuj online!