पुनरावर्ती प्रधान गुण खोजें

Question

पुनरावर्ती प्रधान गुण ऐसे अपराधों के अनुक्रम हैं

p(1) = 2
p(n) = the p(n-1)th prime

यहां एक उदाहरण दिया गया है कि कोई व्यक्ति 4 जी पुनरावर्ती प्रधानमंत्री की गणना कैसे कर सकता है।

p(4) = the p(3)th prime
p(3) = the p(2)th prime
p(2) = the p(1)th prime
p(1) = 2
p(2) = the 2nd prime
p(2) = 3
p(3) = the 3rd prime
p(3) = 5
p(4) = the 5th prime
p(4) = 11

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो कि n दिए जाने पर, nth को पुनरावर्ती रूप से प्रधान प्रधान मंत्री को आउटपुट करता है।

यदि आप अपने उत्तर में ऐसा संकेत देना चाहते हैं तो आप चाहें तो 0 आधारित अनुक्रमणिका का उपयोग करना चुन सकते हैं।

यह कोड-गोल्फ है इसलिए लक्ष्य आपके बाइट की संख्या को कम करना है।

---

परीक्षण के मामलों

1 -> 2
2 -> 3
3 -> 5
4 -> 11
5 -> 31
6 -> 127
7 -> 709
8 -> 5381
9 -> 52711

---

प्रासंगिक OEIS प्रविष्टि: OEIS A007097

Answer 1

ओएसिस , 3 बाइट्स

कार्यक्रम 0-अनुक्रमित है । कोड:

<q2

सूत्र का उपयोग करता है: a (n) = nth_prime (a (n-1) - 1) , बेस केस के साथ a (0) = 2 ।

कोड स्पष्टीकरण:

  2   = a(0)

<     # Decrement a(n - 1) to get a(n - 1) - 1
 q    # prime(a(n - 1) - 1)

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

Answer 2

दरअसल , 7 बाइट्स

1@⌠DP⌡n

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

स्पष्टीकरण:

1@⌠DP⌡n
1        push 1
 @       swap 1 with n
  ⌠DP⌡n  do the following n times:
   DP      decrement, prime at index

Answer 3

गणितज्ञ, 16 बाइट्स

Nest[Prime,1,#]&

अनाम फ़ंक्शन। नंबर को इनपुट के रूप में लेता है और आउटपुट के रूप में एक नंबर देता है।

Answer 4

जेली , 5 4 बाइट्स

1 बाइट @ डेनिस को धन्यवाद।

1ÆN¡

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

व्याख्या

1        Starting with n = 1,
 ÆN      replace n by the nth prime
   ¡     (input) times.

Comments

आप की जरूरत नहीं है ⁸।

— डेनिस

@ डेनिस तो ¡केवल पुनरावृत्ति के रूप में निलाड्स को स्वीकार करता है और इनपुट के लिए डिफ़ॉल्ट यदि कोई नहीं पाया जाता है?

— पुरकाकूदरी

<f><n>¡खुशी से के लिए monadic या dyadic परमाणुओं को स्वीकार करता है <n>। हालांकि, अगर <f>एक निलाद है, तो कुछ गलत होना चाहिए, इसलिए इसे <f>¡इसके बजाय पार्स किया जाता है और अंतिम इनपुट लेता है (अंतिम कमांड-लाइन तर्क, एसटीडीआईएन कोई नहीं है) <n>इसके बजाय।

— डेनिस

Answer 5

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

p=(n,x=1)=>n?p(n-1,(N=y=>x?N(++y,x-=(P=z=>y%--z?P(z):z==1)(y)):y)(1)):x

Ungolfed, आपके पास तीन अलग-अलग पुनरावर्ती कार्य हैं:

P=(n,x=n)=>n%--x?P(n,x):x==1
N=(n,x=1)=>n?N(n-P(++x),x):x
p=(n,x=1)=>n?p(n-1,N(x)):x

• Pनिर्धारित करता nहै कि क्या प्रधान है;
• Nnवें प्रधानमंत्री को पाता है ;
• pपुनरावर्ती Nइनपुट 1 nसमय पर चलता है ।

Answer 6

MATL , 6 बाइट्स

1i:"Yq

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

व्याख्या

1      % Push 1
i      % Input n
:      % Range [1 2 ... N]
"      % For each (that is, do the following N times)
  Yq   %   k-th prime, where k is the input
       % End for each (implicit)
       % Display stack (implicit)

Answer 7

आर, 98 93 बाइट्स

5 बाइट्स @smci को धन्यवाद

यहाँ एक भयानक अकुशल पुनरावर्ती समाधान है:

f<-function(m,n=1){j<-1;for(i in 1:n){j<-numbers::nextPrime(j)};a<-ifelse(m==0,j,f(m-1,j));a}

टेस्ट आउटपुट:

f(6)
[1] 127

f(10)        ### takes almost a minute... YIKES!!!
[1] 648391

Comments

आप थोड़ा सा दाढ़ी कर सकते हैंa<-ifelse(m==0,j,f(m-1,j))

— smx

74 बाइट्स

— ग्यूसेप

@Giuseppe, आपको उत्तर के रूप में पोस्ट करना चाहिए ... यह काफी कमी है !!! मैंने पहले कभी ऐसा ifप्रयोग नहीं देखा है ... बहुत अच्छा !!

— जोसेफ वुड

@ जोसेफवुड नाह, वे सिर्फ मानक गोल्फ हैं; कोर एल्गोरिथ्म नहीं बदला। मैं आपको कुछ और अच्छे गोल्फ टिप्स के लिए R में गोल्फिंग के लिए टिप्स पढ़ने का सुझाव दूंगा (हालाँकि आमतौर पर वे भयानक R शैली के होते हैं)।

— ग्यूसेप

Answer 8

बैश + आम उपयोगिताओं, 55

चूंकि हम पुनरावर्ती अपराध कर रहे हैं, यहाँ एक पुनरावर्ती उत्तर है:

((SHLVL-2<$1))&&primes 2|sed -n "`$0 $1`{p;q}"||echo 1

चूंकि रिकर्सन लेवल काउंटिंग $SHLVLबिल्ट-इन वैरिएबल पर आधारित है , इसलिए यदि आप पहले से ही कुछ शेल लेवल गहरे हैं, तो उत्तर बंद हो सकता है। शायद यही कारण है कि यह जवाब TIO पर काम नहीं करता है।

---

अगर यह अच्छा नहीं है, तो यहां एक अधिक पारंपरिक जवाब है:

बैश + आम उपयोगिताओं, 58

for((i=$1;i--;));{
n=`primes 2|sed -n "$n{p;q}"`
}
echo $n

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

Answer 9

हास्केल , 58 बाइट्स

1 अनुक्रमित

f 1=2;f n=[x|x<-[2..],all((>)2.gcd x)[2..x-1]]!!(f(n-1)-1)

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

स्पष्टीकरण:

अदनान के जवाब के रूप में समान 0-अनुक्रमित प्राइम-लिस्ट एक्सेस ट्रिक का उपयोग करता है ।
मूल रूप से सीधे-सीधे विनिर्देश का पालन होता है।

f 1=2; -- base case
f n= -- main case
    [x|x<-[2..],all((>)2.gcd x)[2..x-1]]             -- list of all primes
    [x|x<-[2..],                                     -- consider all numbers
                               [2..x-1]              -- consider all smaller numbers
                all((>)2.gcd x)                      -- is coprime with them?
                    (>)2.                            -- 2 is greater than
                         gcd x                       -- gcd(x,lambda input)
                                        !!(f(n-1)-1) -- access the
                                                     -- f(n-1)-th 1-indexed prime

Answer 10

05AB1E , 4 बाइट्स

ÎF<Ø

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

व्याख्या

ÎF<Ø
Î    # Push 0 and input
 F   # Do input times...
  <   # Decrement
   Ø  # Get the nth prime (0-indexed) with n being the top of the stack

Answer 11

आश्चर्य है , 23 बाइट्स

p\.{1\2@:^(- p -#0 1)1P

1 अनुक्रमित। उपयोग:

p\.{1\2@:^(- p -#0 1)1P}; p 3

व्याख्या

p\.{                #. Pattern matching syntax
  1\2               #. Base case p(1)=2
  @:^(- p -#0 1)1P  #. Other cases p(n)=nthprime(p(n-1)-1)
                    #. nthprime is 0-indexed
}                   #. Trailing bracket is optional in this case