ตั้งแต่ยูคลิดเรารู้ว่ามีช่วงเวลามากมาย อาร์กิวเมนต์เป็นความขัดแย้งโดย: ถ้ามีเพียงขอบเขตหลายสมมติว่า$p_1,p_2,...,p_n$แล้วแน่นอน$m:=p_1\cdot p_2\cdot...\cdot p_n+1$ไม่หารด้วยใด ๆ ของช่วงเวลาเหล่านี้ดังนั้นตัวประกอบที่สำคัญที่จะต้องให้ผลผลิตที่สำคัญใหม่ที่ไม่ได้อยู่ในรายการ ดังนั้นการสันนิษฐานว่ามีเฉพาะช่วงเวลาที่ จำกัด เท่านั้นจึงเป็นเท็จ

ทีนี้สมมติว่า$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$เป็นช่วงเวลาใหม่ ฯลฯ ในกรณีที่เราได้รับหมายเลขคอมโพสิตเราก็จะเลือกนายกคนใหม่อย่างน้อยที่สุด ผลนี้ในA000945

ท้าทาย

รับค่าเฉพาะ$p_1$และจำนวนเต็ม$n$คำนวณคำ$n$ -th $p_n$ของลำดับที่กำหนดไว้ดังต่อไปนี้:

ลำดับเหล่านี้รู้จักกันในชื่อEuclid-Mullin -sequences

ตัวอย่าง

สำหรับ$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 )

1 97
2 2
3 3
4 11
5 19
6 7
7 461
8 719
9 5

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

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ดึงปัจจัยสำคัญขั้นต่ำ

J , 15 ไบต์

-10 ไบต์ขอบคุณไมล์!

ส่งคืนลำดับสูงสุด n (ดัชนีเป็นศูนย์) - ขอบคุณ@miles

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

ลองออนไลน์!

J , 25 ไบต์

ส่งคืนnรายการ th

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

ลองออนไลน์!

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

ลองออนไลน์!

เยลลี่ขนาด 8 ไบต์

P‘ÆfṂṭµ¡

ยอมรับโปรแกรมแบบเต็ม (ใช้การทำดัชนีเป็นศูนย์) $P_0$ และ $n$ ซึ่งจะพิมพ์ตัวแทน Jelly ของรายการ $P_0$ ไปยัง $P_n$รวมทั้ง (ในฐานะลิงก์แบบ dyadic 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

05AB1E , 8 ไบต์

GDˆ¯P>fß

อินพุตแรกคือ $n$ที่สองคือนายก $p$.

ลองใช้แบบออนไลน์หรือแบบทดสอบอื่น ๆ อีกมาก (ชุดการทดสอบไม่มีกรณีทดสอบสำหรับ$n\geq9$เพราะสำหรับ $p=2$ และ $p=5$builtin 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)

Japt , 12 11 ไบต์

พยายามดิ้นรนเพื่อให้ถูกต้องดังนั้นอาจพลาดบางสิ่งที่สามารถเล่นกอล์ฟได้

ใช้nเป็นอินพุตแรกและp1เป็นอาร์เรย์เดี่ยวเป็นวินาที ส่งคืนnคำศัพท์แรก เปลี่ยนhเป็นgเพื่อคืนค่าnเทอมที่ 0 ที่จัดทำดัชนีแทน

@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

เรติน่า 56 ไบต์

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

\*
,

ลองออนไลน์! ใช้อินพุตเป็นจำนวนของคำศัพท์ใหม่เพื่อเพิ่มในบรรทัดแรกและคำที่เป็นเมล็ดในบรรทัดที่สอง หมายเหตุ: ได้รับช้ามากเนื่องจากใช้การแยกตัวประกอบดังนั้นจึงจำเป็นต้องสร้างสตริงที่มีความยาวที่เกี่ยวข้อง คำอธิบาย:

,|$
$*

แทนที่เครื่องหมายจุลภาคในแง่ของเมล็ดพันธุ์ที่มีและผนวก* *สิ่งนี้จะสร้างนิพจน์ Retina สำหรับสตริงที่มีความยาวของผลิตภัณฑ์ของค่า

"$&"{
)`

วนซ้ำจำนวนครั้งที่กำหนดโดยอินพุตแรก

~`.+¶
$$¶_

แทนที่หมายเลขในบรรทัดแรกชั่วคราวด้วย$และเติม a_ไปยังบรรทัดที่สองจากนั้นประเมินผลลัพธ์เป็นโปรแกรม Retina ดังนั้นจึงต่อท้ายสตริง_ของความยาว 1 มากกว่าผลิตภัณฑ์ของค่า

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

ค้นหาปัจจัยที่เล็กที่สุดของตัวเลขเป็นทศนิยมและผนวก a *พร้อมสำหรับลูปถัดไป

1A`

ลบอินพุตการวนซ้ำ

.$

ลบรายการสุดท้าย *ลบสุดท้าย

\*
,

แทนที่*s ที่เหลือด้วย,s

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

bash + GNU coreutils 89 ไบต์

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

TIO

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ซ้ำกับและ

APL (ขยาย Dyalog) 15 ไบต์

นี่คือการดำเนินงานอย่างเป็นธรรมที่เรียบง่ายของอัลกอริทึมที่ใช้ขยายปัจจัยสำคัญที่เป็นประโยชน์มาก ⍭builtin, ลองออนไลน์!

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

Pari / GP , 47 ไบต์

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

ลองออนไลน์!

Stax , 9 ไบต์

é|G╝╓c£¼_

เรียกใช้และแก้ไขข้อบกพร่อง

ใช้และ (ไม่มีการทำดัชนี) สำหรับอินพุต ผลิตp0npn

C (gcc) , 54 53 ไบต์

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

ลองออนไลน์!

-1 ไบต์ขอบคุณไปที่catcat

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

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