34

एक द्वितीयक संख्या एक धनात्मक पूर्णांक होती है जिसके प्रमुख कारक (गुणन के बिना) सभी इसकी वर्गमूल से कम या बराबर होते हैं। 4एक द्वितीयक संख्या है, क्योंकि इसका एकमात्र मुख्य कारक है 2, जो इसकी वर्गमूल के बराबर है। हालांकि, 15यह एक माध्यमिक संख्या नहीं है, क्योंकि इसमें 5एक प्रमुख कारक है, जो इसकी वर्गमूल ( ~ 3.9) से बड़ी है । क्योंकि सभी अभाज्य संख्याओं के अभाज्य गुणनखंड होते हैं, कोई भी अभाज्य संख्या एक गौण संख्या होती है। पहले कुछ माध्यमिक संख्याएँ इस प्रकार हैं:

1, 4, 8, 9, 12, 16, 18, 24, 25, 27, 30, 32, 36, 40, 45, 48, 49, 50, 54, 56

तृतीयक संख्या को समान रूप से परिभाषित किया गया है, सिवाय इसके कि सभी प्रमुख कारक इसके घनमूल से कम या बराबर होने चाहिए। पहले कुछ तृतीयक संख्याएँ इस प्रकार हैं:

1, 8, 16, 27, 32, 36, 48, 54, 64, 72, 81, 96, 108, 125, 128, 135, 144, 150, 160, 162

सामान्य तौर पर, एक n-ary संख्या वह होती है जिसके मुख्य कारक इसकी n-th जड़ से कम या बराबर होते हैं। इस प्रकार, एक धनात्मक पूर्णांक $x$ एक naary -ary संख्या है यदि इसका प्रत्येक प्रधान कारक $p$ सन्तुष्टि $p^n ≤ x$ । इस प्रकार, प्राथमिक संख्याएं सभी सकारात्मक पूर्णांक हैं (सभी प्रमुख कारक जो स्वयं से कम या बराबर हैं), चतुर्थांश संख्या में उनके सभी प्रमुख कारक उनकी चौथी जड़ से कम या बराबर हैं, और इसी तरह।

चुनौती

पूर्णांकों को देखते हुए kऔर nइनपुट के रूप में, kth n-ary संख्या का उत्पादन करते हैं । kया तो शून्य हो सकता है या एक-अनुक्रमित (आपकी पसंद), और nहमेशा सकारात्मक होगा।

उदाहरण

10-आर्य संख्या तक प्रत्येक अनुक्रम में ये पहले 20 तत्व हैं:

Primary: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20
Secondary: 1, 4, 8, 9, 12, 16, 18, 24, 25, 27, 30, 32, 36, 40, 45, 48, 49, 50, 54, 56
Tertiary: 1, 8, 16, 27, 32, 36, 48, 54, 64, 72, 81, 96, 108, 125, 128, 135, 144, 150, 160, 162
Quarternary: 1, 16, 32, 64, 81, 96, 108, 128, 144, 162, 192, 216, 243, 256, 288, 324, 384, 432, 486, 512
5-ary: 1, 32, 64, 128, 243, 256, 288, 324, 384, 432, 486, 512, 576, 648, 729, 768, 864, 972, 1024, 1152
6-ary: 1, 64, 128, 256, 512, 729, 768, 864, 972, 1024, 1152, 1296, 1458, 1536, 1728, 1944, 2048, 2187, 2304, 2592
7-ary: 1, 128, 256, 512, 1024, 2048, 2187, 2304, 2592, 2916, 3072, 3456, 3888, 4096, 4374, 4608, 5184, 5832, 6144, 6561
8-ary: 1, 256, 512, 1024, 2048, 4096, 6561, 6912, 7776, 8192, 8748, 9216, 10368, 11664, 12288, 13122, 13824, 15552, 16384, 17496
9-ary: 1, 512, 1024, 2048, 4096, 8192, 16384, 19683, 20736, 23328, 24576, 26244, 27648, 31104, 32768, 34992, 36864, 39366, 41472, 46656
10-ary: 1, 1024, 2048, 4096, 8192, 16384, 32768, 59049, 62208, 65536, 69984, 73728, 78732, 82944, 93312, 98304, 104976, 110592, 118098, 124416

— मेगो
स्रोत

10

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

Æf*³<‘Ạ
1Ç#Ṫ

कमांड लाइन तर्क के रूप में n और k (एक-अनुक्रमित) लेता है।

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

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

1Ç#Ṫ     Main link. Left argument: n. Right argument: k

1        Set the return value to 1.
 Ç#      Execute the helper link above for r = 1, 2, 3, ... until k of them return
         a truthy value. Yield the list of all k matches.
   Ṫ     Tail; extract the last match.


Æf*³<‘Ạ  Helper link. Argument: r

Æf       Compute all prime factors of r.
  *³     Elevate them to the n-th power.
    <‘   Compare all powers with r + 1.
      Ạ  All; return 1 if all comparisons were true, 0 if one or more were not.

— डेनिस
स्रोत

यहाँ कोई बाइट सेविंग नहीं है, लेकिन मैं तब भी यही सोचता ÆfṪ*³<‘हूँ क्योंकि हम जानते हैं कि अगर कोई भी फैक्टर Ạसही इच्छाशक्ति पर भरोसा करता है।

— जोनाथन एलन

6

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

:[1]cyt
,1|,.$ph:?^<=

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

यह उत्तर एक-अनुक्रमित है।

व्याख्या

Input: [N:K]

:[1]cy              Retrieve the first K valid outputs of the predicate below with N as input
      t             Output is the last one

,1                  Output = 1
  |                 Or
   ,.$ph            Take the biggest prime factor of the Output
        :?^<=       Its Nth power is less than the Output

— Fatalize
स्रोत

6

जावास्क्रिप्ट (ईएस 7), 95 90 बाइट्स

यथोचित रूप से तेज़ लेकिन दुखद रूप से अधिकतम संख्या में पुनरावृत्ति द्वारा सीमित है।

f=(k,n,i=1)=>(F=(i,d)=>i-1?d>1?i%d?F(i,d-1):F(i/d,x):1:--k)(i,x=++i**(1/n)|0)?f(k,n,i):i-1

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

एक पूर्णांक i को फैक्टर करने और यह सत्यापित करने के बजाय कि इसके सभी प्रमुख कारक x = मंजिल (i ^{1 / n} ) से कम या बराबर हैं , हम बाद की धारणा को सीधे मान्य करने का प्रयास करते हैं। यही आंतरिक कार्य F () का उद्देश्य है :

F = (i, d) =>         // given an integer i and a divisor d:
  i - 1 ?             //   if the initial integer is not yet fully factored
    d > 1 ?           //     if d is still a valid candidate
      i % d ?         //       if d is not a divisor of i
        F(i, d - 1)   //         try again with d-1 
      :               //       else
        F(i / d, x)   //         try to factor i/d
    :                 //     else
      1               //       failed: yield 1
  :                   //   else
    --k               //     success: decrement k

हम जाँच करता है, तो किसी भी पूर्णांक घ में [2 ... मैं ^{1 / एन} ] विभाजित मैं । यदि नहीं, तो धारणा मान्य नहीं है और हम 1 लौटाते हैं । यदि हाँ, तो हम i = i / d पर प्रक्रिया को पुन: दोहराते हैं जब तक कि यह विफल नहीं हो जाता है या प्रारंभिक पूर्णांक पूरी तरह से फैक्टर हो जाता है ( i == 1 ), जिस स्थिति में हम k को घटाते हैं । बदले में, बाहरी फ़ंक्शन f () को k == 0 तक पुनरावर्ती कहा जाता है ।

नोट: कारण अस्थायी जैसे त्रुटियों गोलाई बात करने के लिए 125**(1/3) == 4.9999…, के लिए वास्तविक परिकलित मान एक्स है मंजिल ((i + 1) ^{1 / एन} ) ।

डेमो

(यहां बेहतर संगतता के लिए 97-बाइट ES6 संस्करण के साथ।)

कोड स्निपेट दिखाएं

f=(k,n,i=1)=>(F=(i,d)=>i-1?d>1?i%d?F(i,d-1):F(i/d,x):1:--k)(i,x=Math.pow(++i,1/n)|0)?f(k,n,i):i-1

console.log(f(17, 3)); // 144
console.log(f(13, 4)); // 243
console.log(f(4, 10)); // 4096

स्निपेट का विस्तार करें

— Arnauld
स्रोत

6

जावास्क्रिप्ट (ईएस 7), 93 79 बाइट्स

f=(k,n,g=(i,j=2)=>i<2?--k?g(++m):m:j**n>m?g(++m):i%j?g(i,j+1):g(i/j,j))=>g(m=1)

मैं अरनॉल्ड के उत्तर को समझ नहीं सका इसलिए मैंने अपना लिखा और सुविधापूर्वक दो बाइट्स छोटी आई। संपादित करें: @ETHproductions की सहायता से 14 बाइट्स सहेजे गए। Ungolfed:

function ary(k, n) {
    for (var c = 1;; c++) {
        var m = c;
        for (var i = 2; m > 1 && i ** n <= c; i++)
            while (m % i == 0) m /= i;
        if (m == 1 && --k == 0) return c;
    }
}

— नील
स्रोत

दिलचस्प बात यह है कि मेरा एक बाइट देखने से ठीक पहले 93 बाइट्स का था और फ्लोटिंग पॉइंट राउंडिंग एरर जैसे कि ++i**(1/n)बजाय मूल्यांकन करने का फैसला i**(1/n)किया 125**(1/3) == 4.999...। (जिस तरह से यह लिखा गया है, मुझे लगता है कि आपका कोड इससे प्रभावित नहीं है।)

— अरनौलड

@ETHproductions वास्तव में, मुझे याद है कि इसे बाइट काउंट में शामिल किया गया था, मैं इसे उत्तर में शामिल करना भूल गया ...

— नील

@ETHproductions काम करने लगता है, लेकिन मैंने mएक और दो बाइट्स से दाढ़ी बनाने के लिए असाइनमेंट को स्थानांतरित किया ।

— नील

5

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

m#n=(0:1:filter(\k->last[n|n<-[2..k],all((>0).rem n)[2..n-1],k`rem`n<1]^n<=k)[2..])!!m

स्पष्टीकरण:

( %%%%ऊपर लाइन से कोड को दर्शाता है)

    [n|n<-[2..k],all((>0).rem n)[2..n-1],k`rem`n<1]  -- generates all prime factors of k
    last%%%%^n<=k                                    -- checks whether k is n-ary
    (0:1:filter(\k->%%%%)[2..])!!m                   -- generates all n-ary nubmers and picks the m-th
     m#n=%%%%                                        -- assignment to the function #

— flawr
स्रोत

filterएक मेमने के साथ शायद ही कभी भुगतान किया जाता है, एक सूची समझ आमतौर पर कम होती है: m#n=(0:1:[k|k<-[2..],last[n|n<-[2..k],all((>0).rem n)[2..n-1],kरेम n<1]^n<=k])!!m।

— nimi

ओह, आप भी छोड़ सकते हैं 0:, क्योंकि अनुक्रमण 0-आधारित हो सकता है।

— नीमी

... और भी बेहतर: m#n=[k|k<-[1..],last[n|n<-[1..k],all((>0).rem n)[2..n-1],kरेमn<1]^n<=k]!!m

— नीमी

3

पायथ, 13 बाइट्स

e.f.AgL@ZQPZE

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

वास्तव में जेली समाधान की तरह काम करता है।

e.f.AgL@ZQPZE
                 Implicit: read n into Q.
            E    Read k.
 .f              Find the first k integers >= 1 for which
   .A            all
          P      prime factors of
           Z     the number
     gL          are at most
         Q       the n'th
       @         root of
        Z        the number.
e                Take the last one.

— PurkkaKoodari
स्रोत

3

पर्ल 6, 88 बाइट्स

->\k,\n{sub f(\n,\d){n-1??n%%d??f n/d,d!!f n,d+1!!d};(1,|grep {$_>=f($_,2)**n},2..*)[k]}

मेरी आकस्मिक अंतर्दृष्टि यह है कि आपको प्रत्येक कारक को देखने की आवश्यकता नहीं है n, बस सबसे बड़ा एक है, जो कि आंतरिक फ़ंक्शन की fगणना करता है। दुर्भाग्य से, यह बड़े इनपुट के साथ स्टैक को उड़ा देता है।

is-primeकई अधिक वर्णों की कीमत पर, अंतर्निर्मित पर निर्मित विधि का उपयोग करके, एक मौलिकता परीक्षण जोड़कर मजबूत किया जा सकता है ।

— शॉन
स्रोत

3

भूसी , 10 बाइट्स

!fS≤ȯ^⁰→pN

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

व्याख्या

मुझे →खाली सूची रिटर्न का उपयोग करने का पता लगाने के लिए कुछ समय दिया , जिसके 1बजाय सूची में छोड़ देता है (अन्यथा इसे फिर से शुरू करने के लिए 2 बाइट खर्च होंगे):-Inf▲1

!fS≤(^⁰→p)N  -- input n as ⁰ and k implicit, for example: 4 3
!f        N  -- filter the natural numbers by the following predicate (example on 16):
  S≤(    )   --   is the following less than the element (16) itself?
        p    --   ..prime factors (in increasing order): [2]
       →     --   ..last element/maximum: 2
     ^⁰      --   ..to the power of n: 16
             --   16 ≤ 16: yes
             -- [1,16,32,64,81..
!            -- get the k'th element: 32

— ბიმო
स्रोत

2

आर, 93 बाइट्स

f=function(k,n){x='if'(k,f(k-1,n)+1,1);while(!all(numbers::primeFactors(x)<=x^(1/n)))x=x+1;x}

शून्य अनुक्रमित।

यह एक पुनरावर्ती कार्य है जो बस तब तक चलता रहता है जब तक कि यह अगली संख्या को पंक्ति में न मिल जाए। numbersमुख्य कारकों को खोजने के लिए पैकेज का उपयोग करता है।

— JAD
स्रोत

2

MATL, 21 बाइट्स

x~`@YflG^@>~A+t2G<}x@

यह समाधान एक-आधारित अनुक्रमण का उपयोग करता है और इनपुट होते हैं n और kक्रमश:।

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

व्याख्या

x       % Implicitly grab the first input and delete it
~       % Implicitly grab the second input and make it FALSE (0) (this is the counter)
`       % Beginning of the do-while loop
  @Yf   % Compute the prime factors of the current loop index
  1G^   % Raise them to the power of the first input
  @>    % Determine if each value in the array is greater than the current index
  ~A    % Yield a 0 if any of them were and a 1 if they weren't
  +     % Add this to the counter (increments only for positive cases)
  t2G<  % Determine if we have reached a length specified by the second input
}       % After we exit the loop (finally), ...
x@      % Delete the counter and push the current loop index to the stack
        % Implicitly display the result

— Suever
स्रोत

~ दूसरे इनपुट :-) का पुन: उपयोग करने में अच्छा लगा :-)

— लुइस मेंडो

1

Brachylog v2 , 16 बाइट्स

{∧.ḋ,1⌉;?^≤}ᶠ⁽t

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

डेनिस के जेली समाधान का श्रेयमुझे सही दिशा में सोचने के ।

व्याख्या

यहाँ थोड़ा असम्बद्ध संस्करण है जो पार्स करना आसान है:

↰₁ᶠ⁽t
∧.ḋ,1⌉;?^≤

हेल्पर विधेय (लाइन 2): इनपुट एक्सपोनेंट n है , आउटपुट अप्रतिबंधित है:

∧           Break implicit unification
 .ḋ         Get the prime factors of the output
   ,1       Append 1 (necessary because 1 has no prime factors and you can't take
            the max of an empty list)
     ⌉      Max (largest prime factor, or 1 if the output is 1)
      ;?    Pair that factor with the input (n)
        ^   Take factor to the power of n
         ≤  Verify that the result is less than or equal to the output

मुख्य विधेय (पंक्ति 1): इनपुट एक सूची है जिसमें सूचकांक k (1-आधारित) और घातांक n ; उत्पादन असंबंधित है:

  ᶠ⁽   Find the first k outputs of
↰₁     calling the helper predicate with n as input
    t  Get the last (i.e. kth) one

— DLosc
स्रोत

0

एपीएल (एनएआरएस), 53 चार्ट, 106 बाइट्स

r←a f w;c
c←0⋄r←1
→3×⍳∼∧/(πr)≤a√r⋄→0×⍳w≤c+←1
r+←1⋄→2

परीक्षा:

  1 f¨1..20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 
  2 f¨1..20
1 4 8 9 12 16 18 24 25 27 30 32 36 40 45 48 49 50 54 56 
  3 f¨1..20
1 8 16 27 32 36 48 54 64 72 81 96 108 125 128 135 144 150 160 162 
  4 f¨1..20
1 16 32 64 81 96 108 128 144 162 192 216 243 256 288 324 384 432 486 512 
  10 f¨1..20
1 1024 2048 4096 8192 16384 32768 59049 62208 65536 69984 73728 78732 82944 93312 98304 104976 110592 118098 124416

— RosLuP
स्रोत

0

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

f=lambda K,n,i=1:K and f(K-all(j**n<=i for j in range(1,i+1)if i%j==0and all(j%k for k in range(2,j))),n,i+1)or~-i

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

1-अनुक्रमित फ़ंक्शन।

— चास ब्राउन
स्रोत

0

Japt , 14 बाइट्स

nपहले इनपुट के रूप में लेता है और kदूसरे के रूप में (1-अनुक्रमित)।

@_k e§Vq}aXÄ}g

कोशिश करो

— झबरा
स्रोत

एन-आर्य संख्या उत्पन्न करें

चुनौती

उदाहरण

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

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

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

व्याख्या

जावास्क्रिप्ट (ईएस 7), 95 90 बाइट्स

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

डेमो

जावास्क्रिप्ट (ईएस 7), 93 79 बाइट्स

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

पायथ, 13 बाइट्स

पर्ल 6, 88 बाइट्स

भूसी , 10 बाइट्स

व्याख्या

आर, 93 बाइट्स

MATL, 21 बाइट्स

Brachylog v2 , 16 बाइट्स

व्याख्या

एपीएल (एनएआरएस), 53 चार्ट, 106 बाइट्स

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

Japt , 14 बाइट्स