यह एक प्रमुख है ... लगभग

Question

यदि आपने कभी गणित वर्ग में होने वाले अपराधों के बारे में सीखा है, तो आपको शायद एक बिंदु पर, यह निर्धारित करना होगा कि क्या संख्या प्रमुख है। आप शायद गड़बड़ कर चुके हैं, जबकि आप अभी भी उन्हें सीख रहे थे, उदाहरण के लिए, एक प्रधानमंत्री के लिए 39 की गलती। खैर, चिंता की बात नहीं है, क्योंकि 39 एक अर्धवृत्त है, अर्थात यह दो अपराधों का उत्पाद है।

इसी तरह, हम एक परिभाषित कर सकते हैं कश्मीर के उत्पाद होने के रूप में प्रधानमंत्री -Almost कश्मीर रूढ़ अंक। उदाहरण के लिए, 40 वां 4-4-प्राइम है; 40 = 5 * 2 * 2 * 2, 4 कारकों का उत्पाद।

आपका कार्य एक प्रोग्राम / फ़ंक्शन लिखना है जो दो पूर्णांकों n और k को इनपुट और आउटपुट के रूप में स्वीकार करता है / n th k -alal अभाज्य संख्या लौटाता है । यह एक कोड-गोल्फ है, इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

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

n, k => output
n, 1 => the nth prime number
1, 1 => 2
3, 1 => 5
1, 2 => 4
3, 2 => 9
5, 3 => 27

कई तरह का

आपको किसी बंद माध्यम के अलावा किसी भी तरह से खुद को उत्पन्न करना होगा, अगर ऐसा कोई बंद रूप मौजूद है।

Comments

अपने पहले उदाहरण में अपने गणित की जाँच करें: 40 5 * 2 * 2 * 2 * 2 के बराबर नहीं है।

— GamrCorps

@GamrCorps आह, हाँ, धन्यवाद।

— कॉनर ओ'ब्रायन

आप n के-के-प्राइम को कैसे परिभाषित करते हैं ? क्या निर्धारित करता है कि k- लगभग प्राइम किस क्रम में हैं?

— GamrCorps

मैं नहीं करने के लिए अपने अभिव्यक्ति लगता कि fमामले में की f[n,1]सही है, के बाद से लगभग-अभाज्य संख्या की सूची विषम संख्या में होते हैं (उदाहरण के लिए पिछले दो उदाहरण है, जो दो के एक शक्ति और एक प्रमुख के उत्पाद के रूप में व्यक्त नहीं हैं)। (और यह भी कहता है कि f[n,1] == 2*f[n,1]।)

— 2012rcampion

एक साधारण बंद फॉर्म पर प्रतिबंध क्यों लगाया गया है?

— कैलक्यूलेटर

Answer 1

अजगर, 9 बाइट्स

e.fqlPZQE

व्याख्या

          - autoassign Q = eval(input())
     PZ   -      prime_factors(Z) 
    l     -     len(^)
   q   Q  -    ^ == Q
 .f     E -  first eval(input()) of (^ for Z in range(inf))
e         - ^[-1]

यहाँ कोशिश करो!

या एक परीक्षण सूट की कोशिश करो!

Answer 2

ब्रेकीलॉग , 9 बाइट्स

आधी बाइट का इस्तेमाल करके @sundar को हराया

{~l~ḋ}ᶠ⁽t

व्याख्या

                    --  Input like [n,k]
{    }ᶠ⁽            --      Find the first n values which
   ~ḋ               --          have a prime decomposition
 ~l                 --          of length k
        t           --      and take the last one

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

Answer 3

पाइके (कमिट 29), 8 बाइट्स (नॉन-कंपेटिटिव)

.fPlQq)e

स्पष्टीकरण:

         - autoassign Q = eval_or_not(input())
.f    )  - First eval_or_not(input) of (^ for i in range(inf))
  P      -    prime_factors(i)
   l     -   len(^)
     q   -  ^==V
    Q    -   Q
       e - ^[-1]

Answer 4

जूलिया, 84 78 59 57 बाइट्स

f(n,k,i=1)=n>0?f(n-(sum(values(factor(i)))==k),k,i+1):i-1

यह एक पुनरावर्ती कार्य है जो दो पूर्णांकों को स्वीकार करता है और एक पूर्णांक देता है। यहाँ दृष्टिकोण प्रधान कारक के खिलाफ घातांक के योग की जाँच करना है k।

Ungolfed:

function f(n, k, i=1)
    # We initialize a counter i as a function argument.

    # Recurse while we've encountered fewer than n k-almost primes
    if n > 0
        # If the sum of the exponents in the prime factorization of i is
        # equal to k, there are k prime factors of i. We subtract a boolean
        # from n, which is implicitly cast to an integer, which will
        # decrement n if i is k-almost prime and leave it as is otherwise.
        return f(n - (sum(values(factor(i))) == k), k, i + 1)
    else
        # Otherwise we return i-1 (i will have been incremented one too
        # many times, hence the -1)
        return i - 1
    end
end

Answer 5

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

ÆfL=³
ç#Ṫ

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

यह काम किस प्रकार करता है

Ç#Ṫ    Main link. Left input: k. Right input: n.

Ç      Apply the helper link to k, k + 1, k + 2, ... until...
 #       n matches are found.
  Ṫ    Retrieve the last match.


ÆfL=³  Helper link. Left argument: k (iterator)

Æf     Yield the prime factors of k.
  L    Compute the length of the list, i.e., the number of prime factors.
   =³  Compare the result with k (left input).

Comments

मैं किसी भी एन्कोडिंग के बारे में नहीं जानता जो इन 9 पात्रों को 9 बाइट्स के रूप में बचा सकता है।

— Oleh Prypin

जेली एक कस्टम एन्कोडिंग का उपयोग करती है जो एकल बाइट्स के साथ समझने वाले 256 वर्ण का प्रतिनिधित्व करती है।

— डेनिस

Answer 6

ब्रेकीलॉग , 18 बाइट्स

,1{hH&t<NḋlH;N}ⁱ⁽t

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

                      Implicit input, say [5, 3]
,1                    Append 1 to the input list. [5, 3, 1]
  {           }ⁱ⁽     Repeat this predicate the number of times given by
                        the first element of the list (5),
                        on the rest of the list [3, 1]
   hH&                Let's call the first element H
      t<N             There is a number N greater than the second element
         ḋ            Whose prime factorization's
          l           length
           H          is equal to H
            ;N        Then, pair that N with H and let that be input for
                      the next iteration
                 t    At the end of iterations, take the last N
                      This is implicitly the output

Answer 7

गणितज्ञ, ५६ ५१ बाइट्स

Last@Select[Range[2^##],PrimeOmega@#==n&/.n->#2,#]&

चेतावनी: यह सैद्धांतिक है। किसी भी मान> 4 के लिए न चलें। एक अधिक कुशल अभिव्यक्ति के साथ 2 ^ ## बदलें।

Comments

यह काम नहीं करता है n=1।

— IPoiler

इसके अलावा PrimeOmega[1]मूल्यांकन करने के लिए 0, &&#>1निरर्थक है।

— IPoiler

Answer 8

गणितज्ञ, ५३ ४ ९ बाइट्स

Cases[Range[2^(#2+#)],x_/;PrimeOmega@x==#2][[#]]&

एक ढीली ऊपरी सीमा के आधार पर पूर्णांक की एक सूची बनाता है। PrimeOmegaमायने रखता है multiplicities साथ प्रधानमंत्री कारकों, कश्मीर प्रधानमंत्री -Almost Casesसूची से लिया जाता है, और n है कि उप-समूह की वें सदस्य लौटाया जाता है।

Comments

2 ^ (0 + ##), या सिर्फ 2 ^ ## काम करता है।

— कैलक्यूलेटर

@CatsAreFluffy 2^Sequence[1,2]यह देखने की कोशिश करें कि उत्तरार्द्ध विफल क्यों होता है।

— IPoiler

Answer 9

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

शायद बहुत अधिक गोल्फ हो सकता है, क्योंकि मैं अभी भी हास्केल के लिए एक नौसिखिया हूं। फ़ंक्शन qअपने तर्क के कारकों की संख्या लौटाता है, और इसका fउपयोग उन nthसभी नंबरों से बनाई गई सूची के तत्व को लेने के लिए करता है जिनमें kकारक हैं।

q n|n<2=0|1>0=1+q(div n ([x|x<-[2..],mod n x<1]!!0))
f n k=filter(\m->q m==k)[1..]!!n-1

Answer 10

MATL, 14 बाइट्स

:YqiZ^!XpSu1G)

इसे MATL ऑनलाइन पर आज़माएं

:               % Take first input n implicitly, make range 1 to n
 Yq             % Get corresponding prime numbers (1st prime to nth prime)
   i            % Take the second input k
    Z^          % Take the k-th cartesian power of the primes list 
                % (Getting all combinations of k primes)
      !Xp       % Multiply each combination (2*2*2, 2*2*3, 2*2*5, ...)
         Su     % Sort and unique
           1G)  % Take the n-th element of the result

Answer 11

पायथन 3, 100 बाइट्स

यह एक बहुत ही सरल जानवर बल कार्य है। यह 2 से साथ शुरू हर संख्या की जाँच करता है sympyकी factorintजब तक यह पाया गया है समारोह n k-Almost अभाज्य संख्या है, जो बिंदु पर, फ़ंक्शन nइनमें से वें।

import sympy
def a(n,k):
 z=1;c=0
 while c<n:z+=1;c+=(sum(sympy.factorint(z).values())==k)
 return z

Ungolfed:

मैं उपयोग करता हूं sum(factorint(a).values())क्योंकि जोड़े factorintका एक शब्दकोश देता है factor: exponent। शब्दकोश (घातांक) के मानों को हथियाना और उन्हें संक्षेप में बताना कि कितने प्रमुख कारक हैं और इस प्रकार kयह kसबसे प्रमुख प्रधानमंत्री है।

from sympy import factorint
def almost(n, k):
    z = 1
    count = 0
    while count < n: 
        z += 1
        if sum(factorint(a).values()) == k:
            count += 1
    return z

Answer 12

पायथन 2 , 76 बाइट्स

f=lambda n,k,p=2,c=0:c==k if p>n else f(n,k,p+1,c)if n%p else f(n/p,k,p,c+1)

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