Количество способов, которым число является суммой последовательных простых чисел


15

Если целое число больше 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

Ответы:


9

Желе ,  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

2æRтак же, какÆR
Dylnan

@dylnan хороший, спасибо!
Джонатан Аллан

8

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!

1
это умный способ придумать простые числа до x!
Джузеппе


1
@ Джузеппе: это здорово !! Сегодня я болен, и я бы никогда не подумал, что ... (может быть, никогда: P) Я плохо себя чувствую при использовании вашего кода ... Я вернулся к предыдущему, если вы отправите новый ответ, я " ll upvote;)
digEmAll

1
@ngm каково значение 34421 ..? И @digEmAll, я не против; Я действительно понятия не имел об использовании cumsumи настройке первых нескольких элементов 0для получения последовательных простых сумм. Главный гольф был только мной, пытающимся заставить последний тестовый случай работать, и я просто повезло, что это было короче outer! У меня более чем достаточно представителей (по крайней мере, до тех пор, пока мы не получим надлежащие требования к представителям), и я всегда рад помочь большему количеству игроков в гольф R получить больше видимости!
Джузеппе

1
@Giuseppe 34421 - это наименьшее число, представляющее собой сумму последовательных простых чисел ровно 6 способами (см. Oeis.org/A054859 ). У большинства решений, опубликованных для этой задачи, не хватает времени (на TIO) или памяти для этого теста. Хотя ответ Java даже получил следующее целое число в последовательности (для 7), но не для 8.
НГМ


4

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

4

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

1
Теплица матрица простых чисел и треугольной части, очень приятно!
Луис Мендо

4

Брахилог , 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

Вы можете сыграть в гольф, рассчитав ⟦ṗˢвнутри цикла. Я получил этот {⟦ṗˢs+;?=}ᶜнабор тестов: попробуйте онлайн!
Kroppeb

Я понял , можно заменить ;?=на ?и получить {⟦ṗˢs+?}ᶜ(9 байт)
Kroppeb

@Kroppeb Конечно! Это гораздо более элегантный ответ тоже. Спасибо.
sundar - Восстановить Монику

3

Сетчатка 0.8.2 , 68 байт

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

Попробуйте онлайн! Ссылка включает в себя более быстрые тестовые случаи. Объяснение:

m)

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

.+
$*_$&$*

Конвертировать в унарный дважды, сначала используя _s, затем используя 1s.

_
$`__¶

_2N+1

A`^(__+)\1+$

Удалить все составные числа в диапазоне.

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

__1N


3

Шелуха , 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

Как полная программа, #¹ṁ∫ṫ↑İpследует сохранить 1 байт.
г-н Xcoder

3

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

Чисто , 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
    ]

(Объяснение для более старой, но логически идентичной версии)


1
Специальная благодарность за получение результата для 34421.
НГМ

2

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

2

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

2

Ява 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;

1
Особая благодарность за получение продукции за 34421.
НГМ

@ngm :) Ява может быть плохой во многих вещах, но с точки зрения производительности это обычно довольно хорошо.
Кевин Круйссен

1
Даже работает на 218918. Тайм-аут с 3634531.
НГМ

1
@ngm Я на самом деле удивлен, что он все еще достаточно быстр, чтобы выполнить операцию за 21891812,5 секунды, учитывая, что он будет выполнять 218918-2 = 218,916итерации с внутренним циклом: nитерации для каждого простого числа; 1 итерация для каждого четного числа; и где-то между [2,p/2)итерациями для каждого нечетного числа (около двух миллиардов итераций), после чего он добавляет 19518простые числа в список в памяти. И затем он будет зацикливаться на дополнительное sum([0,19518]) = 190,485,921время во втором вложенном цикле .. Всего 2223 570 640 итераций, если быть точным .
Кевин Круйссен

@ceilingcat Спасибо. Мы смогли сыграть еще 12 байтов с альтернативной первичной проверкой @SaraJ , минус трейлинг, %iтак как мы проверяем диапазон[2, n] , поэтому мне не нужно проверять i=1. :)
Кевин Круйссен

1

Физика , 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.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.