Враховуючи ціле число, що перевищує 1, виведіть кількість способів, яке воно може бути виражене сумою одного або декількох послідовних простих чисел.

Порядок суми не має значення. Сума може складатися з одного числа (тому вихід для будь-якого простого числа буде не менше 1.)

Це код-гольф . Діють стандартні правила.

Дивіться у цій вікі OEIS для пов'язаної інформації та послідовностей, включаючи саму послідовність OEIS A054845 .

Тестові справи

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

Желе ,  6  5 байт

-1 завдяки ділнан

ÆRẆ§ċ

Монадійне посилання

Спробуйте в Інтернеті! Або подивіться набір тестів (врахуйте, що остаточний тестовий випадок закінчився б у 60-х у TIO).

Як?

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

R , 95 байт

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}

Спробуйте в Інтернеті!

• -24 байти завдяки @Giuseppe, який в основному змінив моє рішення, підтримуючи 34421!

05AB1E , 6 байт

Код

ÅPŒOQO

Використовує кодування 05AB1E . Спробуйте в Інтернеті!

JavaScript (ES6), 92 байти

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)

Спробуйте в Інтернеті!

Прокоментував

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 байт

EZqPYTRYsG=z

Спробуйте це на MATL Online

Початковий E(помножити на 2) гарантує, що для основного введення результат пізнього Ys( cumsum) не має вхідної простір, що повторюється в нульовій частині матриці (таким чином, псується з рахунком).

Пояснення:

                % 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

Брахілог , 14 9 байт

{⟦ṗˢs+?}ᶜ

Спробуйте в Інтернеті!
Кілька тестових випадків

(-5 цілих байтів, завдяки @Kroppeb!)

Пояснення:

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

Сітківка 0,8,2 , 68 байт

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

Спробуйте в Інтернеті! Посилання включає більш швидкі тестові випадки. Пояснення:

m)

Запустити весь сценарій у багаторядковому режимі, де ^і $відповідати у кожному рядку.

.+
$*_$&$*

Перетворити в одинарний двічі, спочатку використовуючи _s, потім використовуючи 1s.

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

Видаліть усі складені числа в діапазоні.

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

__1$n$

Лушпиння , 9 8 байт

^{-1 байт завдяки Mr.Xcoder (використовуйте названий аргумент ¹замість S)!}

#¹ṁ∫ṫ↑İp

Спробуйте в Інтернеті!

Пояснення

#¹ṁ∫ṫ↑İ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 байт

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

Спробуйте в MATL Online!

Пояснення

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

Пітон 2 , 106 104 байт

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

Спробуйте в Інтернеті!

Чисто , 100 98 байт

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]

Спробуйте в Інтернеті!

Визначає функцію, $ :: Int -> Intяка працює, як пояснено нижче:

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

(Пояснення для старшої, але логічно ідентичної версії)

Perl 6 , 53 байти

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

Спробуйте в Інтернеті!

Використовує оператор скорочення трикутника двічі. Останній тестовий випадок занадто повільний для TIO.

Пояснення

{                                                   } # 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 байт

Повинен бути коротший шлях, ніж цей!

Виймає останній тестовий випадок.

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

Спробуйте або запустіть усі тестові приклади

Пояснення

                      :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 байти

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 байт завдяки @ceilingcat .
-10 байт завдяки @SaraJ .

Спробуйте в Інтернеті.

Пояснення:

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

Це в основному схоже на відповіді Jelly або 05AB1E , лише 190 байт більше .. XD
Ось порівняння для кожної з частин, додане просто заради задоволення (і щоб зрозуміти, чому Java настільки багатослівний, і ці мови для гри в гольф настільки потужні):

1. Візьміть вхід: (Jelly: 0 байт) неявно ; (05AB1E: 0 байт) неявно ; (Java 10: 5 байт)n->{}
2. Створіть список простих ліній у діапазоні [2, n]: (Желе: 2 байти) ÆR; (05AB1E: 2 байти) ÅP; (Java 10: 95 байт)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. Отримайте всі суцільні підсписи: (Jelly: 1 байт) Ẇ; (05AB1E: 1 байт) Œ; (Java 10: 55 байт) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)і(int)L.get(k++);
4. Підсумовуйте кожен підперелік: (желе: 1 байт) §; (05AB1E: 1 байт) O; (Java 10: 9 байт) ,sі ,s=0іs+=
5. Порахуйте ті, що дорівнюють вводу: (желе: 1 байт) ċ; (05AB1E: 2 байти) QO; (Java 10: 15 байт) ,r=0іr+=s==n?1:0
6. Виведіть результат: (Jelly: 0 байт) неявно ; (05AB1E: 0 байт) неявно ; (Java 10: 9 байт)return r;

Фізика , 41 байт

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

Спробуйте в Інтернеті!

Як це працює

->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 байт

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

Спробуйте в Інтернеті!

Альтернативно, 89 байт

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

Спробуйте в Інтернеті!