असीम रूप से कई primes

Question

यूक्लिड के बाद से, हमने जाना है कि असीम रूप से कई अपराध हैं। तर्क विरोधाभास से है: यदि केवल सीमित कई हैं, मान लें कि $p_1,p_2,...,p_n$ , तो निश्चित रूप से $m:=p_1\cdot p_2\cdot...\cdot p_n+1$ इनमें से किसी भी प्राइम से विभाज्य नहीं है, इसलिए इसके अभाज्यकरण को एक नया प्राइम प्राप्त करना होगा जो सूची में नहीं था। तो यह धारणा कि केवल सूक्ष्म रूप से मौजूद प्रचलित मिथ्या है।

अब मान लेते हैं कि $2$ एकमात्र प्रधान है। ऊपर से विधि को एक नए (संभव) अभाज्य के रूप में देती है। विधि को फिर से लागू करने से , और फिर , फिर , तो दोनों और नए प्राइम हैं, आदि ऐसे मामले में जहां हमें एक समग्र संख्या मिलती है, हम सिर्फ कम से कम नए प्राइम लेते हैं। इसका परिणाम A000945 है ।$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$

चुनौती

प्राइम और पूर्णांक को देखते हुए, इस प्रकार परिभाषित अनुक्रम के टर्म की गणना करें :$p_1$$n$$n$$p_n$

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

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

Answer 1

जावास्क्रिप्ट (ईएस 6),  45  44 बाइट्स

इनपुट के रूप में लेता है (n)(p1), जहां 0-अनुक्रमित है।$n$

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

Answer 2

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न्यूनतम प्रमुख कारक को पुनर्प्राप्त करता है।

Answer 3

जे , 15 बाइट्स

-10 बाइट मील के लिए धन्यवाद!

N (शून्य-अनुक्रमित) तक अनुक्रम लौटाते हुए - @ मीलों तक धन्यवाद

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

इसे ऑनलाइन आज़माएं!

जे , 25 बाइट्स

nवें आइटम को लौटाता है

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

इसे ऑनलाइन आज़माएं!

Comments

(,0({q:)1+*/)^:15 बाइट्स के लिए, अनुक्रम n(शून्य-अनुक्रमित) तक लौटते हुए

— मीलों

@ मीलों धन्यवाद!

— गैलेन इवानोव

बहुत अच्छा। @ मीलों क्या वास्तव में वहाँ व्याकरणिक रूप से हो रहा है? हम एक क्रिया और एक संयोजन को एक साथ रखते हैं और एक डाईएडिक क्रिया को वापस लाते हैं। मैंने सोचा कि verb conj एक क्रिया विशेषण का निर्माण किया ।

— योना

@ जोनाह यह एक चाल है जिसे मैंने गोल्फ से सीखा है। मुझे लगता है कि यह पुराने पार्सिंग नियमों में से एक है जो अभी भी मान्य है

— मील

@ मीलों मैंने महसूस किया कि यह एक क्रिया विशेषण (या अदनौन) है। यह संज्ञा को उसके बायीं ओर संशोधित करता है, जो दाईं ओर "संलग्न" होता है ^:, और फिर यह एक क्रिया बन जाती है जो दाएं arg पर लागू होती है। मुझे लगता है कि यह व्याकरणिक रूप से क्या हो रहा है।

— योना

Answer 4

पायथन 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

इसे ऑनलाइन आज़माएं!

Comments

मैं सिर्फ अजगर के साथ शुरू किया है, लेकिन आप की जरूरत है int(input())अन्यथा iएक है str?

— एंथनी

पायथन 3 में यह सच होगा क्योंकि input()हमेशा स्ट्रिंग्स लौटता है। पायथन 2 input()में इनपुट का मूल्यांकन करने की कोशिश करता है। मैं इस मामले में पायथन 2 का उपयोग कर रहा हूं क्योंकि परिणामी कोड थोड़ा कम है। के लिए वास्तविक कोड आप अजगर 3 उपयोग करने के लिए के रूप में यह अजगर के नए और अधिक समर्थित संस्करण है प्रयास करना चाहिए।

— अंडा

N चरणों के बाद यह कैसे समाप्त होता है?

— सिंटेक्स

@ सिंटैक्स यह किसी दिए गए p1 के लिए अनुक्रम को अनिश्चित काल के लिए आउटपुट करता है, जैसा कि डिफ़ॉल्ट अनुक्रम नियमों द्वारा अनुमत है ।

— अंडा

Answer 5

जेली , 8 बाइट्स

P‘ÆfṂṭµ¡

एक पूर्ण कार्यक्रम (शून्य अनुक्रमण का उपयोग करके) $P_0$ और $n$ स्वीकार करना जो पी 0 की सूची का एक जेली प्रतिनिधित्व दर्शाता है$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

Answer 6

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)

Comments

λλP>fWλ£λP>fW$n$$n^{\text{th}}$£

@ Mr.Xcoder " यदि केवल हम जैसे एक झंडा था £लेकिन पिछले तत्व के लिए! ", की तरह .£? ;) संपादित करें: वास्तव में, यह वास्तव में की तरह काम नहीं करता है £सूचियों के लिए .. की तरह एक सूची का उपयोग कर [1,2]के साथ .£पिछले 1 और 2 आइटम के साथ दो ढीला मदों में परिणाम (यानी 12345हो जाता है [5,45]के बजाय [45,3]या [3,45]साथ, 12S.£) ..

— केविन Cruijssen

उम्म, नहीं, मैं नहीं देखता कि कैसे λ.£काम करना चाहिए। मैंने ध्वज का उपयोग अतिरिक्त कार्य से जुड़ा है λ( अदनान के साथ इस वार्तालाप को देखें )। मैं मूल रूप से कुछ ध्वज चाहता हूं èजैसे कि जब λè...}यह चल रहा है तो अनंत धारा के बजाय एन-वें तत्व उत्पन्न करेगा (जैसे λ£पहले एन तत्वों को उत्पन्न करने के लिए काम करेगा)।

— श्री एक्सकोडर

@ Mr.Xcoder आह क्षमा करें, आपने £पुनरावर्ती वातावरण के लिए उपयोग किया है। हाँ, तो λ.£वास्तव में काम करने वाला नहीं है, मेरा बुरा। 6-बायटर की परवाह किए बिना। अब आपको बस @flawr की प्रतिक्रिया का इंतजार करना होगा कि इसकी अनुमति है या नहीं (यह शायद है)।

— केविन क्रूज़सेन

Answer 7

जाप , १२ 11 बाइट्स

यह एक सही पाने के लिए संघर्ष किया है ताकि कुछ है कि गोल्फ हो सकता है याद किया।

nपहले इनपुट के रूप में लेता है और p1, दूसरे के रूप में एक सिंगलटन सरणी के रूप में। पहला nपद लौटाता है । इसके बजाय वें 0-अनुक्रमित शब्द को वापस hकरने के gलिए बदलें n।

@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

Answer 8

रेटिना , 56 बाइट्स

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

\*
,

इसे ऑनलाइन आज़माएं! पहली पंक्ति में जोड़ने के लिए नई शर्तों की संख्या के रूप में इनपुट लेता है और दूसरी पंक्ति पर बीज शब्द। ध्यान दें: बहुत धीमी गति से हो जाता है क्योंकि यह एकात्मक कारक का उपयोग करता है इसलिए इसे प्रासंगिक लंबाई का एक स्ट्रिंग बनाने की आवश्यकता होती है। स्पष्टीकरण:

,|$
$*

बीज शब्दों में अल्पविराम को *एस के साथ बदलें और संलग्न करें *। यह मानों के उत्पाद की लंबाई के लिए एक रेटिना अभिव्यक्ति बनाता है।

"$&"{
)`

पहले इनपुट द्वारा दिए गए समय की संख्या को लूप दोहराएं।

~`.+¶
$$¶_

अस्थायी रूप से संख्या को पहली पंक्ति पर एक के साथ बदलें $और _दूसरी पंक्ति के लिए प्रीपेन्ड करें , फिर रेटिना प्रोग्राम के रूप में परिणाम का मूल्यांकन करें, इस प्रकार _मानों के उत्पाद की तुलना में लंबाई 1 की स्ट्रिंग को जोड़ना ।

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

दशमलव में संख्या का सबसे छोटा nontrivial कारक ढूंढें और *अगले लूप के लिए तैयार संलग्न करें ।

1A`

पुनरावृति इनपुट हटाएं।

.$

आखिरी को हटा दें *।

\*
,

शेष *s को ,s से बदलें ।

Answer 9

जावास्क्रिप्ट (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

Answer 10

बैश + जीएनयू कोरुटिल्स, 89 बाइट्स

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

TIO

Answer 11

रूबी 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।

Comments

आपको शायद उल्लेख करना चाहिए कि आप शून्य-अनुक्रमित कर रहे हैं; मैंने TIO पर काम करने की अनुमति देने के लिए (सिर्फ 1 बाइट लंबा) के (2..)साथ प्रतिस्थापित किया 2.stepऔर सब कुछ एक-एक करके बंद हो गया। इसे ऑनलाइन आज़माएं!

— मूल्य इंक

Answer 12

APL (Dyalog Extended) , 15 बाइट्स

यह, एल्गोरिथ्म जो विस्तारित की बहुत मददगार प्रधानमंत्री कारकों का उपयोग करके निर्मित की एक काफी सरल कार्यान्वयन है ⍭। इसे ऑनलाइन आज़माएं!

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

Answer 13

परी / जीपी , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

स्टैक्स , 9 बाइट्स

é|G╝╓c£¼_

इसे चलाएं और डीबग करें

इनपुट के लिए लेता है और (शून्य-अनुक्रमित) । पैदा करता है ।p0npn

Answer 15

सी (जीसीसी) , 54 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सीटिंग के लिए -1 बाइट धन्यवाद

Answer 16

पर्ल 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

Comments

-+^[*](@_)एक बाइट बचाता है।

— nwellnhof

Answer 17

हास्केल , 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