Со времен Евклида мы знали, что простых чисел бесконечно много. Аргумент от противного: если существует лишь конечное число, скажем , $p_1,p_2,...,p_n$ , то обязательно $m:=p_1\cdot p_2\cdot...\cdot p_n+1$ не делится на любой из этих простых чисел, поэтому его простые множители должны дать новое простое число , которое не было в списке. Таким образом, предположение, что существуют только конечно простые числа, неверно.

Теперь давайте предположим, что $2$ является единственным простым числом. Метод сверху дает $2+1=3$ как новое (возможное) простое число. Повторное применение метода дает , а затем , затем , так что и являются новыми простые числа и т. д. В случае, когда мы получаем составное число, мы просто берем наименьшее новое простое число. Это приводит к A000945 . $2\cdot 3+1=7$ $2\cdot 3\cdot 7+1=43$ $2\cdot 3\cdot 7\cdot 43+1=13\cdot 139$ $13$ $139$

Вызов

Учитывая простой $p_1$ и целое число $n$ вычислить $n$ -го термина $p_n$ о последовательности , определенной следующим образом :

p_{n} := min (primefactors (p_{1} \cdot p_{2} \cdot . . . \cdot p_{n - 1} + 1))

$p_n := \min(\operatorname{primefactors}(p_1\cdot p_2\cdot ... \cdot p_{n-1} + 1))$

Эти последовательности известны как последовательности Евклида-Маллина .

Примеры

Для $p_1 = 2$ :

1 2
2 3
3 7
4 43
5 13
6 53
7 5
8 6221671
9 38709183810571

Для $p_1 = 5$ ( A051308 ):

1 5
2 2
3 11
4 3
5 331
6 19
7 199
8 53
9 21888927391

Для $p_1 = 97$ ( A051330 )

— flawr
источник

10

JavaScript (ES6), 45 44 байта

Принимает ввод как (n)(p1), где $n$ индексируется 0.

n=>g=(p,d=2)=>n?~p%d?g(p,d+1):--n?g(p*d):d:p

Попробуйте онлайн!

n =>                // n = 0-based index of the requested term
  g = (             // g is a recursive function taking:
    p,              //   p = current prime product
    d = 2           //   d = current divisor
  ) =>              //
    n ?             // if n is not equal to 0:
      ~p % d ?      //   if d is not a divisor of ~p (i.e. not a divisor of p + 1):
        g(p, d + 1) //     increment d until it is
      :             //   else:
        --n ?       //     decrement n; if it's still not equal to 0:
          g(p * d)  //       do a recursive call with the updated prime product
        :           //     else:
          d         //       stop recursion and return d
    :               // else:
      p             //   don't do any recursion and return p right away

— Arnauld
источник

9

05AB1E , 6 байтов

Это производит и бесконечный поток вывода.

λλP>fW

Попробуйте онлайн! (ссылка содержит слегка измененную версию λ£λP>fW, которая вместо этого выводит первые $n$ терминов)

объяснение

Очень просто. Учитывая $p_1$ и $n$ , программа делает следующее:

Начинается с $p_1$ в качестве начального параметра для бесконечного потока (который генерируется с использованием первого λ) и начинает рекурсивную среду, которая генерирует новый термин после каждого взаимодействия и добавляет его в поток.
Второй λ, теперь используемый внутри рекурсивной среды, меняет свою функциональность: теперь он извлекает все ранее сгенерированные элементы (то есть список $[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$ ), где $n$ представляет текущий номер итерации.
Остальное тривиально: Pберется произведение ( $\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$ ), >добавляется единица к этому произведению и fWизвлекается минимальный простой множитель.

— Мистер Xcoder
источник

6

J 15 байт

-10 байт благодаря милям!

Возврат последовательности до n (с нулевым индексом) - благодаря @miles

(,0({q:)1+*/)^:

Попробуйте онлайн!

J , 25 байт

Возвращает nэлемент

_2{((],0{[:q:1+*/@])^:[])

Попробуйте онлайн!

— Гален Иванов
источник

1

(,0({q:)1+*/)^:для 15 байтов, возвращая последовательность до n(с нулевым индексированием)

— миль

@Miles Спасибо!

— Гален Иванов

Очень хорошо. @ миль, что именно там происходит грамматически? мы соединяем глагол и соединение вместе и получаем двоичный глагол обратно. Я думал, verb conj произвел наречие .

— Иона

1

@ Джона, это трюк, который я узнал из игры в гольф. Я думаю , что это один из самых старых правил разбора , что по - прежнему действительны

— миль

@ Мили Я только что понял, что это наречие (или adnoun). Она изменяет существительное слева от нее , который «атташе» к справа от ^:, а затем , что становится глаголом , который относится к правой арг. Я думаю, что это происходит грамматически.

— Иона

5

Python 2 , 56 байт

i=input();k=1
while 1:
 k*=i;print i;i=2
 while~k%i:i+=1

Попробуйте онлайн!

i=input() # the initial prime
k=1       # the product of all previous primes
while 1:  # infinite loop
 k*=i     # update the product of primes
 print i  # output the last prime
 i=2      # starting at two ...
 while~k%i: # find the lowest number that divides k+1
  i+=1
            # this our new prime

Попробуйте онлайн!

— овс
источник

Я только начал с Python, но вам нужно в int(input())противном случае iэто str?

— Энтони

2

В Python 3 это было бы верно, так как input()всегда возвращает строки. В Python 2 input()пытается оценить вход. Я использую Python 2 в этом случае, потому что полученный код немного короче. Для реального кода вы должны попытаться использовать Python 3, так как это более новая и поддерживаемая версия Python.

— овс

Как это заканчивается после n шагов?

— Синтаксис

@sintax выводит последовательность для заданного p1 бесконечно, как это разрешено правилами последовательности по умолчанию .

— Ов

4

Желе , 8 байт

P‘ÆfṂṭµ¡

Полная программа (с нулевым индексированием), принимающая $P_0$ а также $n$ который печатает желе представление списка $P_0$ в $P_n$ включительно. (Как диадическая ссылка, n=0нам будет возвращено целое число, а не список.)

Попробуйте онлайн!

Как?

P‘ÆfṂṭµ¡ - Link: integer, p0; integer n
      µ¡ - repeat the monadic chain to the left n times, starting with x=p0:
P        -   product of x (p0->p0 or [p0,...,pm]->pm*...*p0)
 ‘       -   increment
  Æf     -   prime factors
    Ṃ    -   minimum
     ṭ   -   tack
         - implicit print

— Джонатан Аллан
источник

3

05AB1E , 8 байтов

GDˆ¯P>fß

Первый вход $n$ второе простое $p$ ,

Попробуйте онлайн или еще несколько тестов (в тестовом наборе отсутствуют тесты для $n\geq9$ , потому что для $p=2$ а также $p=5$ встроенный fзанимает слишком много времени).

Объяснение:

G         # Loop (implicit input) n-1 amount of times:
 Dˆ       #  Add a copy of the number at the top of the stack to the global array
          #  (which will take the second input p implicitly the first iteration)
   ¯      #  Push the entire global array
    P     #  Take the product of this list
     >    #  Increase it by 1
      f   #  Get the prime factors of this number (without counting duplicates)
       ß  #  Pop and only leave the smallest prime factor
          # (after the loop: implicitly output the top of the stack as result)

— Кевин Круйссен
источник

У меня было λλP>fW(6 байт) с выводом в виде бесконечного списка и λ£λP>fW(7 байт) для первого

n

$n$ условия. Однако получить

n^{th}

$n^{\text{th}}$ должно быть 9 байтов ... Если бы только у нас был флаг, как, £но для последнего элемента!

— г-н Xcoder

@ Mr.Xcoder « Если бы только у нас был флаг, £но для последнего элемента! », Как .£? ;) РЕДАКТИРОВАТЬ: На самом деле, это не работает точно так же, как £для списков .. используя список, как [1,2]с .£результатами в двух свободных элементах с последними 1 и 2 элементами (то есть 12345становится [5,45]вместо [45,3]или [3,45], с 12S.£) ..

— Кевин Круйссен

Хм, нет, я не понимаю, как λ.£должно работать. Я использовал флаг как в дополнительной функции, связанной с λ(см. Этот разговор с Аднаном ). Я в основном хочу некоторый флаг, èтакой, чтобы при запуске λè...}он генерировал n-й элемент, а не бесконечный поток (точно так же, как λ£работал бы для генерации первых n элементов).

— г-н Xcoder

@ Mr.Xcoder А, прости, ты использовал £рекурсивную среду. Да, тогда λ.£действительно не сработает, мой плохой. Хороший 6-байтовый независимо. Теперь вам просто нужно дождаться ответа @flawr , разрешено это или нет (возможно, так и есть).

— Кевин Круйссен

3

Japt , 12 11 байт

Изо всех сил пытался сделать это правильно, поэтому, возможно, пропустил что-то, что можно сыграть в гольф.

Принимает nв качестве первого ввода и p1, в качестве одноэлементного массива, в качестве второго. Возвращает первые nусловия. Измените hна, gчтобы nвместо этого возвращать th-индексированный термин.

@Z×Ä k Î}hV

Попытайся

@Z×Ä k Î}hV     :Implicit input of integer U=n & array V=[p1]
@               :Function taking an array as an argument via parameter Z
 Z×             :  Reduce Z by multiplication
   Ä            :  Add 1
     k          :  Prime factors
       Î        :  First element
        }       :End function
         hV     :Run that function, passing V as Z, and
                : push the result to V.
                : Repeat until V is of length U

— мохнатый
источник

3

Сетчатка , 56 байт

,|$
$*
"$&"{~`.+¶
$$¶_
)`\b(__+?)\1*$
$.1$*
1A`
.$

\*
,

Попробуйте онлайн! Принимает входные данные как число новых терминов, добавляемых в первой строке, и начальный (ие) термин (ы) во второй строке. Примечание: становится очень медленным, так как использует унарную факторизацию, поэтому ему нужно создать строку соответствующей длины. Объяснение:

,|$
$*

Замените запятые в начальных терминах на *s и добавьте a *. Это создает выражение Retina для строки длины произведения значений.

"$&"{
)`

Повторите цикл количество раз, данное первым входом.

~`.+¶
$$¶_

Временно замените число в первой строке на a $и добавьте a _ко второй строке, затем оцените результат как программу Retina, добавив, таким образом, строку _s длиной на 1 больше, чем произведение значений.

\b(__+?)\1*$
$.1$*

Найдите наименьший нетривиальный множитель числа в десятичном виде и добавьте *готовый к следующему циклу.

1A`

Удалить итерацию.

.$

Удалить последнее *.

\*
,

Заменить оставшиеся *s на ,s.

— Нил
источник

2

JavaScript (Node.js) , 54 байта

f=(p,n,P=p,F=n=>-~P%n?F(n+1):n)=>--n?f(p=F(2),n,P*p):p

Попробуйте онлайн!

Ungolfed

F=(p,n=2)=>            // Helper function F for finding the smallest prime factor
  p%n                  //   If n (starting at 2) doesn't divide p:
    ?F(n+1)            //     Test n+1 instead
    :n                 //   Otherwise, return n
f=(p,n,P=p)=>          // Main function f:
  --n                  //   Repeat n - 1 times:
    ?f(p=F(P+1),n,P*p) //     Find the next prime factor and update the product
    :p                 //   Return the last prime

— Герман Л
источник

2

bash + GNU coreutils, 89 байт

IFS=\*;n=$1;shift;for((;++i<n;));{ set $@ `factor $["$*+1"]|cut -d\  -f2`;};echo ${@: -1}

TIO

— Науэль Фуйе
источник

2

Ruby 2.6, 51 байт

f=->s,n{[s,l=(2..).find{|d|~s%d<1}][n]||f[l*s,n-1]}

(2..)бесконечный диапазон, начинающийся с 2, пока не поддерживается в TIO.

Это рекурсивная функция, которая принимает начальное значение s(может быть простым или составным), возвращает его, когда n = 0 (правка: обратите внимание, что это означает, что оно имеет нулевой индекс), возвращает наименьшее число, lкоторое больше 1, и делит, -(s+1)когда n = 1, а в противном случае рекурсивно с s=l*sи n=n-1.

— гистократ
источник

1

Вы, вероятно, должны упомянуть, что вы делаете нулевую индексацию; Я заменил (2..)на 2.step(всего на 1 байт больше), чтобы он работал на TIO, и все было выключено одним. Попробуйте онлайн!

— Value Ink

2

APL (Dyalog Extended) , 15 байт

Это довольно простая реализация алгоритма, использующая встроенные очень полезные простые факторы Extended ⍭. Попробуйте онлайн!

{⍵,⊃⍭1+×/⍵}⍣⎕⊢⎕

объяснение

{⍵,⊃⍭1+×/⍵}⍣⎕⊢⎕

             ⊢⎕  First get the first prime of the sequence S from input.
{         }⍣⎕    Then we repeat the code another input number of times.
     1+×/⍵       We take the product of S and add 1.
    ⍭            Get the prime factors of product(S)+1.
   ⊃             Get the first element, the smallest prime factor of prod(S)+1.
 ⍵,              And append it to S.

— Шерлок9
источник

1

Pari / GP , 47 байт

(p,n)->s=1;for(i=2,n,s*=p;p=divisors(s+1)[2]);p

Попробуйте онлайн!

— alephalpha
источник

1

Stax , 9 байт

é|G╝╓c£¼_

Запустите и отладьте его

Берет и (с нулевым индексом) для ввода. Производит .p₀np_n

— рекурсивный
источник

1

C (gcc) , 54 53 байта

p;f(x,n){for(p=x;--n;p*=x)for(x=1;~p%++x;);return x;}

Попробуйте онлайн!

-1 байт благодаря возрастанию

— Wastl
источник

1

Perl 6 , 33 32 байта

-1 байт благодаря nwellnhof

{$_,{1+(2...-+^[*](@_)%%*)}...*}

Попробуйте онлайн!

Блок анонимного кода, который принимает число и возвращает ленивый список.

Объяснение:

{                              }  # Anonymous codeblock
                           ...*   # That returns an infinite list
 $_,                              # Starting with the input
    {                     }       # Where each element is
     1+(2...             )          # The first number above 2
                      %%*           # That cleanly divides
               [*](@_)                # The product of all numbers so far
            -+^                       # Plus one

— Джо Кинг
источник

1

-+^[*](@_) сохраняет байт.

— nwellnhof

0

Haskell , 49 байтов

g 1
g a b=b:g(a*b)([c|c<-[2..],1>mod(a*b+1)c]!!0)

Попробуйте онлайн!

Возвращает бесконечную последовательность в виде отложенного списка.

Объяснение:

g 1                                            -- Initialise the product as 1
g a b=                                         -- Given the product and the current number
       b:                                      -- Return the current number, followed by
         g                                     -- Recursively calliong the function with
          (a*b)                                -- The new product
               (                             ) -- And get the next number as
                [c|c<-[2..],             ]!!0  -- The first number above 2
                            1>mod       c      -- That cleanly divides
                                 (a*b+1)       -- The product plus one

— Джо Кинг
источник

Бесконечно много простых чисел

Вызов

Примеры

JavaScript (ES6), 45 44 байта

комментарии

05AB1E , 6 байтов

объяснение

J 15 байт

J , 25 байт

Python 2 , 56 байт

комментарии

Желе , 8 байт

Как?

05AB1E , 8 байтов

Japt , 12 11 байт

Сетчатка , 56 байт

JavaScript (Node.js) , 54 байта

bash + GNU coreutils, 89 байт

Ruby 2.6, 51 байт

APL (Dyalog Extended) , 15 байт

Pari / GP , 47 байт

Stax , 9 байт

C (gcc) , 54 53 байта

Perl 6 , 33 32 байта

Объяснение:

Haskell , 49 байтов

Объяснение: