Kể từ Euclid, chúng ta đã biết rằng có vô số số nguyên tố. Đối số là do mâu thuẫn: Nếu chỉ có nhiều số hữu hạn, giả sử , thì chắc chắn không chia hết cho bất kỳ các số nguyên tố này, vì vậy hệ số nguyên tố của nó phải mang lại một số nguyên tố mới không có trong danh sách. Vì vậy, giả định rằng chỉ tồn tại các số nguyên tố hữu hạn là sai. $p_1,p_2,...,p_n$ $m:=p_1\cdot p_2\cdot...\cdot p_n+1$

Bây giờ hãy giả sử rằng là số nguyên tố duy nhất. Phương pháp từ trên mang lại dưới dạng một số nguyên tố mới (có thể). Áp dụng phương pháp một lần nữa mang lại , và sau đó , sau đó , vì vậy cả và là các số nguyên tố mới, v.v ... Trong trường hợp chúng ta có được một số tổng hợp, chúng ta chỉ lấy số nguyên tố mới ít nhất. Điều này dẫn đến A000945 . $2$ $2+1=3$ $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$

Thử thách

Cho một số nguyên tố và một số nguyên tính toán số hạng thứ của chuỗi được xác định như sau: $p_1$ $n$ $n$ $p_n$

p_{n} : = tối thiểu (thừa số nguyên tố (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))$

Các trình tự này được gọi là hậu quả Euclid-Mullin .

Ví dụ

Đối với $p_1 = 2$ :

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

Với $p_1 = 5$ ( A051308 ):

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

Với $p_1 = 97$ ( A051330 )

— lỗ hổng
nguồn

10

JavaScript (ES6), 45 44 byte

Lấy đầu vào là (n)(p1), trong đó được lập chỉ mục 0. $n$

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

Hãy thử trực tuyến!

Đã bình luận

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
nguồn

9

05AB1E , 6 byte

Điều này tạo ra và dòng đầu ra vô hạn.

λλP>fW

Hãy thử trực tuyến! (liên kết bao gồm một phiên bản sửa đổi một chút λ£λP>fW, thay vào đó xuất ra các điều khoản đầu tiên ) $n$

Giải trình

Rất đơn giản. Cho và , chương trình thực hiện như sau: $p_1$ $n$

Bắt đầu với làm tham số ban đầu cho luồng vô hạn (được tạo bằng cách sử dụng đầu tiên ) và bắt đầu một môi trường đệ quy tạo ra một thuật ngữ mới sau mỗi lần xen kẽ và nối nó vào luồng. $p_1$ λ
Thứ hai λ, hiện đang được sử dụng trong môi trường đệ quy, thay đổi chức năng của nó: Bây giờ, nó lấy tất cả các phần tử được tạo trước đó (ví dụ: danh sách ), Trong đó đại diện cho số lần lặp hiện tại. $[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$ $n$
Phần còn lại là tầm thường: Plấy sản phẩm ( ), thêm một sản phẩm vào sản phẩm này và truy xuất hệ số nguyên tố tối thiểu. $\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$ >fW

— Ông Xcoder
nguồn

6

J , 15 byte

-10 bytes nhờ dặm!

Trả lại chuỗi lên tới n (không có chỉ mục) - nhờ @miles

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

Hãy thử trực tuyến!

J , 25 byte

Trả về nmục thứ

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

Hãy thử trực tuyến!

— Galen Ivanov
nguồn

1

(,0({q:)1+*/)^:15 byte, trả lại chuỗi lên đến n(zero-lập chỉ mục)

— dặm

@miles Cảm ơn bạn!

— Galen Ivanov

Rất đẹp. @miles chính xác những gì đang xảy ra ở đó về mặt ngữ pháp? chúng tôi đặt một động từ và kết hợp với nhau và lấy lại một động từ dyadic. Tôi nghĩ đã verb conj tạo ra một trạng từ .

— Giô-na

1

@Jonah đó là một mẹo tôi học được từ việc chơi golf. Tôi nghĩ đó là một trong những quy tắc phân tích cú pháp cũ vẫn còn hiệu lực

— dặm

@miles Tôi mới nhận ra đó là trạng từ (hay adnoun). Nó sửa đổi danh từ bên trái của nó, "gắn" bên phải của ^:, và sau đó trở thành một động từ áp dụng cho arg bên phải. Tôi nghĩ đó là những gì đang xảy ra về mặt ngữ pháp.

— Giô-na

5

Python 2 , 56 byte

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

Hãy thử trực tuyến!

Đã bình luận

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

Hãy thử trực tuyến!

— lò nướng
nguồn

Tôi chỉ mới bắt đầu với Python, nhưng bạn cần int(input())bằng cách khác ilà một str?

— Anthony

2

Trong Python 3, điều này đúng khi input()luôn trả về chuỗi. Trong Python 2 input()cố gắng đánh giá đầu vào. Tôi đang sử dụng Python 2 trong trường hợp này vì mã kết quả ngắn hơn một chút. Đối với mã thực, bạn nên thử sử dụng Python 3 vì đây là phiên bản Python mới hơn và được hỗ trợ nhiều hơn.

— trứng

Làm thế nào để điều này chấm dứt sau n bước?

— sintax

@sintax nó xuất ra chuỗi cho p1 nhất định vô thời hạn, như được cho phép bởi các quy tắc trình tự mặc định .

— trứng

4

Thạch , 8 byte

P‘ÆfṂṭµ¡

$P_0$ $n$ $P_0$ $P_n$ n=0

Hãy thử trực tuyến!

Làm sao?

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

— Jonathan Allan
nguồn

3

05AB1E , 8 byte

GDˆ¯P>fß

$n$ $p$

$n\geq9$ $p=2$ $p=5$ f

Giải trình:

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)

— Kevin Cruijssen
nguồn

λλP>fWλ£λP>fW

n

$n$

n^{th}

$n^{\text{th}}$ £

@ Mr.Xcoder "Giá như chúng ta có một lá cờ như thế £nhưng cho phần tử cuối cùng! ", Như thế .£nào? ;) EDIT: Trên thực tế, nó không hoạt động chính xác như £đối với danh sách .. sử dụng một danh sách như [1,2]với .£kết quả trong hai mục lỏng lẻo với 1 và 2 mục cuối cùng (tức là 12345trở nên [5,45]thay vì [45,3]hay [3,45], với 12S.£) ..

— Kevin Cruijssen

Umm, không, tôi không thấy λ.£nên làm việc như thế nào . Tôi đã sử dụng cờ như trong chức năng bổ sung được liên kết với λ(xem cuộc hội thoại này với Adnan ). Về cơ bản tôi muốn một số cờ èsao cho khi chạy λè...}nó sẽ tạo ra phần tử thứ n chứ không phải là luồng vô hạn (giống như λ£sẽ hoạt động để tạo ra n phần tử đầu tiên).

— Ông Xcoder

@ Mr.Xcoder Xin lỗi, bạn đã sử dụng £môi trường đệ quy. Vâng, sau đó λ.£thực sự sẽ không làm việc, xấu của tôi. Đẹp 6 -terter bất kể. Bây giờ bạn chỉ cần chờ phản hồi của @flawr cho dù điều đó có được phép hay không (có lẽ là như vậy).

— Kevin Cruijssen

3

Japt , 12 11 byte

Đấu tranh để có được điều này đúng vì vậy có thể đã bỏ lỡ một cái gì đó có thể được chơi golf.

Lấy nlàm đầu vào đầu tiên và p1, như một mảng đơn, là thứ hai. Trả về các nđiều khoản đầu tiên . Thay đổi hđể gtrả về nthuật ngữ 0 được lập chỉ mục thay thế.

@Z×Ä k Î}hV

Thử nó

@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

— Xù xì
nguồn

3

Võng mạc , 56 byte

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

\*
,

Hãy thử trực tuyến! Lấy đầu vào là số lượng thuật ngữ mới để thêm vào dòng đầu tiên và (các) thuật ngữ hạt giống trên dòng thứ hai. Lưu ý: Nhận rất chậm vì nó sử dụng hệ số đơn nguyên nên nó cần tạo một chuỗi có độ dài liên quan. Giải trình:

,|$
$*

Thay thế dấu phẩy trong các điều khoản hạt giống bằng *s và nối thêm a *. Điều này tạo ra biểu thức Retina cho một chuỗi độ dài của sản phẩm của các giá trị.

"$&"{
)`

Lặp lại vòng lặp số lần được đưa ra bởi đầu vào đầu tiên.

~`.+¶
$$¶_

Thay thế tạm thời số trên dòng đầu tiên bằng a $và thêm một _dòng vào dòng thứ hai, sau đó đánh giá kết quả dưới dạng chương trình Retina, do đó nối thêm một chuỗi _có độ dài 1 nhiều hơn sản phẩm của các giá trị.

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

Tìm hệ số không nhỏ nhất của số ở dạng thập phân và nối thêm *sẵn sàng cho vòng lặp tiếp theo.

1A`

Xóa đầu vào lặp.

.$

Xóa cái cuối cùng *.

\*
,

Thay *s còn lại bằng ,s.

— Neil
nguồn

2

JavaScript (Node.js) , 54 byte

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

Hãy thử trực tuyến!

Bị đánh cắp

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

— Herman L
nguồn

2

bash + GNU coreutils, 89 byte

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

TIO

— Nahuel Fouilleul
nguồn

2

Ruby 2.6, 51 byte

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

(2..), phạm vi vô hạn bắt đầu từ 2, chưa được hỗ trợ trên TIO.

Đây là hàm đệ quy lấy giá trị bắt đầu s(có thể là số nguyên tố hoặc tổng hợp), trả về nó khi n = 0 (chỉnh sửa: lưu ý rằng điều này có nghĩa là nó được lập chỉ mục bằng 0), trả về số nhỏ nhất llớn hơn 1 và chia -(s+1)khi n = 1, và nếu không thì đệ quy với s=l*svà n=n-1.

— lịch sử
nguồn

1

Bạn có lẽ nên đề cập rằng bạn đang làm chỉ số không; Tôi đã thay thế (2..)bằng 2.step(chỉ dài hơn 1 byte) để cho phép nó hoạt động trên TIO và mọi thứ đều bị tắt. Hãy thử trực tuyến!

— Mực giá trị

2

APL (Dyalog mở rộng) , 15 byte

Đây là một triển khai thuật toán khá đơn giản, sử dụng các yếu tố chính rất hữu ích của Extended ⍭. Hãy thử trực tuyến!

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

Giải trình

{⍵,⊃⍭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.

— Sherlock9
nguồn

1

Pari / GP , 47 byte

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

Hãy thử trực tuyến!

— alephalpha
nguồn

1

Stax , 9 byte

é|G╝╓c£¼_

Chạy và gỡ lỗi nó

Mất và (không có chỉ mục) cho đầu vào. Sản xuất .p₀np_n

— đệ quy
nguồn

1

C (gcc) , 54 53 byte

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

Hãy thử trực tuyến!

-1 byte nhờ trần

— lãng phí
nguồn

1

Perl 6 , 33 32 byte

-1 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Khối mã ẩn danh lấy một số và trả về một danh sách lười biếng.

Giải trình:

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

— Jo vua
nguồn

1

-+^[*](@_)tiết kiệm một byte.

— nwellnhof

0

Haskell , 49 byte

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

Hãy thử trực tuyến!

Trả về chuỗi vô hạn như một danh sách lười biếng.

Giải trình:

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

— Jo vua
nguồn

Vô số số nguyên tố

Thử thách

Ví dụ

JavaScript (ES6), 45 44 byte

Đã bình luận

05AB1E , 6 byte

Giải trình

J , 15 byte

J , 25 byte

Python 2 , 56 byte

Đã bình luận

Thạch , 8 byte

Làm sao?

05AB1E , 8 byte

Japt , 12 11 byte

Võng mạc , 56 byte

JavaScript (Node.js) , 54 byte

bash + GNU coreutils, 89 byte

Ruby 2.6, 51 byte

APL (Dyalog mở rộng) , 15 byte

Pari / GP , 47 byte

Stax , 9 byte

C (gcc) , 54 53 byte

Perl 6 , 33 32 byte

Giải trình:

Haskell , 49 byte

Giải trình: