एक प्रमुख शक्ति एक धनात्मक पूर्णांक n है जिसे n n = p ^k के रूप में लिखा जा सकता है जहाँ p एक अभाज्य है और k एक धनात्मक पूर्णांक है। उदाहरण के लिए, कुछ प्रमुख शक्तियाँ हैं [2, 3, 5, 4, 9, 25, 8, 27, 125]।

इसके बाद, 2 की प्रधान शक्तियों पर विचार करें। ये हैं [2, 4, 8, 16, ...]और इन्हें 2 ^k के रूप में लिखा जा सकता है । 20 के नीचे की प्रमुख शक्तियों पर विचार करते समय उन्हें सभी शामिल किया जाएगा। हालांकि, 16 उस सीमा में 2 के आधार प्राइम के साथ अधिकतम प्रमुख शक्ति है। एक प्रमुख शक्ति पी ^{कश्मीर} है अधिक से अधिक है, तो इसके बारे में सर्वोच्च शक्ति है एक श्रेणी में पी उस श्रेणी में। हम केवल प्रत्येक रेंज में अधिकतम प्राइम पावर में रुचि रखते हैं, इसलिए सभी कम प्राइम पॉवर को बाहर रखा जाना चाहिए।

आपका लक्ष्य एक फ़ंक्शन या प्रोग्राम लिखना है जो एक सकारात्मक पूर्णांक n लेता है और सीमा में अधिकतम प्रमुख शक्तियों को आउटपुट करता है [2, 3, 4, ..., n]।

@ मैक्सिमम प्राइम पॉवर की परिभाषा और अधिक स्पष्ट करने के लिए @ पीटर टेलर का धन्यवाद ।

नियम

यह कोड-गोल्फ है इसलिए अपने कोड को यथासंभव छोटा बनाएं।
अधिक से अधिक प्रधानमंत्री शक्तियां किसी भी क्रम में उत्पादन किया जा सकता है लेकिन कोई डुप्लिकेट होना चाहिए।

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

n      result
1      []
2      [2]
3      [2, 3]
4      [3, 4]
5      [3, 4, 5]
6      [3, 4, 5]
7      [3, 4, 5, 7]
20     [5, 7, 9, 11, 13, 16, 17, 19]
50     [11, 13, 17, 19, 23, 25, 27, 29, 31, 32, 37, 41, 43, 47, 49]
100    [11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97]
10000  <1229 results>
       [101, 103, 107, 109, 113, 127, 131, 137, 139, 149, ..., 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973]

10000 के लिए अधिकतम प्रमुख शक्तियों की पूरी सूची यहां पाई जा सकती है ।

code-golf math primes

— मील की दूरी पर
स्रोत

16

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

æḟÆR

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

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

æḟÆR  Main link. Argument: n

  ÆR  Prime range; yield all primes in [1, ..., n].
æḟ    Power floor; round n down to the nearest power of each prime in the range.

— डेनिस
स्रोत

ओह इतना स्पष्ट है कि एक बार कोई इसे देख ले!

— जोनाथन एलन

15

Power floorक्या बिल्ली

— जंगवान मिन

1

इस पोस्ट ने मुझे आधिकारिक रूप से जेली सीखने के लिए मना लिया।

— चैंडलर वॉटसन

10

गणितज्ञ, ४४ 43 40 बाइट्स

मीलों और मार्टिन एंडर के लिए धन्यवाद 4 बाइट्स बचाए

~~n#^⌊#~Log~n⌋&/@Select[Range@n,PrimeQ]~~

(x=Prime@Range@PrimePi@#)^⌊x~Log~#⌋&

⌊और ⌋कर रहे हैं 3बाइट वर्णों के U+230Aऔर U+230Bका प्रतिनिधित्व\[LeftFloor] और \[RightFloor], क्रमशः।

स्पष्टीकरण:

शुद्ध कार्य। #वह छोटा है Slot[1]जिसके लिए पहले तर्क का प्रतिनिधित्व करता है Function। PrimePi@#गिने जाने वाले या उससे कम के बराबर की संख्या को गिना जाता है #, Range@PrimePi@#पहले PrimePi[#]सकारात्मक पूर्णांकों Prime@Range@PrimePi@#की सूची है , और इसी प्रकार #(कम से कम एक बाइट से कम Select[Range@#,PrimeQ]) के समान है। प्रतीक xहै Setइस सूची के बराबर है, तो करने के लिए उठाया Power ⌊x~Log~#⌋है, जो की सूची है Floor[Log[n,#]]प्रत्येक के लिए nमें x। मैथेमेटिका में, एक Powerही लंबाई की एक और सूची की सूची बनाने से उनके संबंधित तत्वों की शक्तियों की सूची बन जाती है।

— ngenisis
स्रोत

मैंने सोचा था कि Range@#~Select~PrimeQइससे छोटा होगा Prime@Range@PrimePi@#... लेकिन यह एक टाई है

— ग्रेग मार्टिन

यह एक अच्छा आंकड़ा है। क्या यह एक बिलिन का उपयोग करके उत्पन्न किया गया था या मैन्युअल रूप से बनाया गया था?

— मील

@ मील्स इसे TreeForm

— ngenisis

धन्यवाद। मुझे यह देखकर कभी याद नहीं रहा, लेकिन जाहिर है कि यह हमेशा के लिए हो गया।

— मील

7

MATL, 13 बाइट्स

ZqG:!^tG>~*X>

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

व्याख्या

        % Implicitly grab the input as a number (N)
Zq      % Get an array of all primes below N
G:!     % Create an array from [1...N]
^       % Raise each prime to each power in this array which creates a 2D matrix
        % where the powers of each prime are down the columns
tG>~    % Create a logical matrix that is TRUE where the values are less than N
*       % Perform element-wise multiplication to force values > N to zero
X>      % Compute the maximum value of each column
        % Implicitly display the resulting array

— Suever
स्रोत

7

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

ÆR*ÆE€»/

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

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

ÆR*ÆE€»/  Main link. Argument: n

ÆR        Prime range; yield all primes in [1, ..., n].
   ÆE€    Prime exponents each; yield the exponents of 2, 3, 5, ... of the prime
          factorization of each k in [1, ..., n].
          For example, 28 = 2² × 3⁰ × 5⁰ × 7¹ yields [2, 0, 0, 1].
  *       Exponentiation; raise the elements of the prime range to the powers
          of each of the exponents arrays.
      »/  Reduce the columns by maximum.

— डेनिस
स्रोत

6

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

RÆEz0iṀ$€

इसे ऑनलाइन आज़माएं! (विधि 10000 मामले के लिए बहुत धीमी है)।

कैसे?

की सूची बनाता पी ^{कश्मीर} के क्रम में पी ।

RÆEz0iṀ$€ - Main link: n                      e.g. 7
R         - range(n)                          [1 ,2  ,3    ,4  ,5      ,6    ,7]
 ÆE       - prime factor vector (vectorises)  [[],[1],[0,1],[2],[0,0,1],[1,1],[0,0,0,1]]
   z0     - transpose with filler 0           [[0,1,0,2,0,1,0],[0,0,1,0,0,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,1]]
       $€ - la$t two links as a monad, for €ach       ^             ^                   ^                   ^
     i    -     first index of                        4             3                   5                   7
      Ṁ   -     maximum                       [4,3,5,7]

— जोनाथन एलन
स्रोत

5

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

m^ds.lQdfP_TS

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

        f   S -  filter(v, range(1, input))
         P_T  -   is_prime(T)
m             - map(v, ^)
    .lQd      -    log(input, d)
   s          -   int(^)
 ^d           -  d ** ^

मैंने थोड़ी देर में अजगर के साथ नहीं खेला है इसलिए किसी भी गोल्फिंग टिप्स की सराहना की जाती है।

— नीला
स्रोत

5

मुझे नेगीसिस के समाधान की तुलना में एक छोटा गणितज्ञ समाधान नहीं मिल सका है , लेकिन मुझे लगा कि मैं कुछ (वैकल्पिक रूप से दिलचस्प) वैकल्पिक तरीकों की पेशकश करूंगा।

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

#/#2&@@@({#,#}&/@Range@#~Select~PrimeQ//.{a_,b_}/;a<=#:>{b a,b})&

पहले हम {#,#}&/@Range@#~Select~PrimeQसभी प्राइमों की सूची को उचित सीमा में बनाने के लिए उपयोग करते हैं , लेकिन प्रत्येक प्राइम के जोड़े के साथ, जैसे { {2,2}, {3,3}, ...}। फिर हम प्रतिस्थापन नियम के साथ उस सूची पर बार-बार काम करते हैं {a_,b_}/;a<=#:>{b a,b}, जो आदेशित जोड़े के पहले तत्व को तब तक गुणा करता है जब तक कि पहला तत्व इनपुट से अधिक न हो जाए। फिर हम #/#2&@@@आउटपुट पर लागू होते हैं , प्रत्येक ऑर्डर किए गए जोड़े के लिए, दूसरा द्वारा विभाजित पहला तत्व। (वे अंत में प्राइम द्वारा सॉर्ट किए गए हैं: एक उदाहरण आउटपुट है{16, 9, 5, 7, 11, 13, 17, 19} ।)

मैथेमेटिका, 44 बाइट्स

Values@Rest@<|MangoldtLambda@#->#&~Array~#|>&

वॉन मंगलॉल्ड फ़ंक्शन Λ(n)एक दिलचस्प संख्या सिद्धांत फ़ंक्शन है: यह 0 के बराबर है जब तक nकि एक प्रमुख पावर पी ^{कश्मीर नहीं है} , जिस स्थिति में यह बराबर log p(नहीं log n) है। (ये प्राकृतिक लॉग हैं, लेकिन इससे कोई फर्क नहीं पड़ेगा।) इस प्रकार MangoldtLambda@#->#&~Array~#उन नियमों की एक सरणी बनाता है { 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... }जिनकी लंबाई इनपुट पूर्णांक है।

हम फिर नियमों की इस सूची को "एसोसिएशन" का उपयोग करके बदल देते हैं <|...|>। यह किसी भी बाएं हाथ के मूल्य के साथ केवल अंतिम नियम को बनाए रखने का प्रभाव है। दूसरे शब्दों में, इसे फेंक होगा Log[2]->2और Log[2]->4और Log[2]->8और केवल रखने के Log[2]->16(यह मानते हुए कि इनपुट इस उदाहरण के लिए 16 और 31 के बीच है)। इसलिए केवल शेष दाहिने हाथ में अधिकतम प्रधान शक्तियां हैं - एक शेष नियम को छोड़कर 0->n, जहां nइनपुट पूर्णांक तक सबसे बड़ी गैर-प्राइम-पावर है। लेकिन Restउस अवांछनीय नियम को दूर फेंकता है, और Valuesएसोसिएशन में नियमों से दाहिने हाथ के किनारों को निकालता है। (वे अंत में ऊपर के अनुसार क्रमबद्ध हैं।)

थोड़ा लंबा (46 बाइट्स) संस्करण, जो प्रत्येक के दिखावे की संख्या को गिनता है log pऔर फिर अधिकतम प्रधान शक्तियों में बदलने के लिए एक्सपोनेंटिअट्स:

E^(1##)&@@@Rest@Tally[MangoldtLambda~Array~#]&

— ग्रेग मार्टिन
स्रोत

1

संघों का शुद्ध उपयोग। वे 2014 से बाहर हैं, लेकिन मुझे नहीं लगता कि उन्होंने गोल्फ में ज्यादा इस्तेमाल किया है। यह जानने के लिए बहुत उपयोगी है कि यह समान कुंजियों को मान से बाएँ से दाएँ बदलता है।

— मील

4

सीजाम , 21 20 बाइट्स

मार्टिन एंडर को 1 बाइट धन्यवाद दिया

ri_){mp},f{\1$mLi#}p

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

व्याख्या

ri                    e# Read an integer from input (let's call it n)
  _                   e# Duplicate it
   ){mp},             e# Push the array of all prime numbers up to and including n
         f{           e# Map the following block to each prime p:
           \          e#   Swap the top two elements of the stack
            1$        e#   Copy the second element down in the stack. Stack is now [p n p]
              mL      e#   Take the base-p logatithm of n
                i     e#   Cast to int (floor)
                 #    e#   Raise p to that power
                  }   e# (end of map block)
                   p  e# Print

— बिजनेस कैट
स्रोत

4

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

⟧{ḋ=}ˢ⊇Xhᵐ≠∧X×ᵐ

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

यह सबसे बड़ी से लेकर छोटी से छोटी शक्तियों का उत्पादन करता है।

यह बहुत अक्षम है।

व्याख्या

⟧                   The Range [Input, Input - 1, ..., 1, 0]
 {  }ˢ              Select:
  ḋ=                  The elements of that range whose prime decompositions are lists of the
                      same element (e.g. [3,3,3]); output is those prime decompositions
      ⊇X            X is an ordered subset of that list of prime decompositions
       Xhᵐ≠         All first elements of the prime decompositions are different (that is,
                      X contains prime decompositions with different primes each times)
           ∧
            X×ᵐ     Output is the result of mapping multiplication to each element of X

यह ⊇काम करने के तरीके के कारण सबसे पहले प्रत्येक अभाज्य के लिए सबसे बड़ा प्राइम डिकम्पोजिशन मिलेगा : बाएं से दाएं और सबसे बड़े से सबसे छोटे सबसेट तक।

— Fatalize
स्रोत

4

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

3 + 2 बाइट्स ने घातक परिणाम के लिए धन्यवाद बचाया!

यह मेरा पहली बार Brachylog का उपयोग कर रहा है, और मुझे पता है कि कुछ चीजें छोटे तरीकों से की जा सकती थीं, लेकिन मुझे खुशी है कि यह भी काम करती है: D

{≥.~^ℕ₁ᵐhṗ:.≜×>?∧}ᶠ

इसे ऑनलाइन आज़माएं! (रिटर्न मान उनके आधार प्राइम द्वारा दिए गए हैं)

स्पष्टीकरण:

{................}ᶠ           #Find all possible results of what's inside.
 ≥.                           #Input is >= than the output.
  .~^ℕ₁ᵐ                      #Output can be calculated as A^B, where A and B are
                              #Natural numbers >=1.
        hṗ                    #The first of those numbers (A) is prime
          :.≜×>?              #That same element (A), multiplied by the output
                              #is greater than the input - This means 
                              #that B is the maximal exponent for A.
                ∧             #No more restrictions on the output.

— सिंह
स्रोत

1

महान! आप विशिष्ट चर नामों ?और .इनपुट और आउटपुट के लिए दो बाइट्स बचा सकते हैं , Iऔर इसके बजाय X, जैसे:{≥N~^.hṗ:N×>?∧0<~t}ᶠ^ᵐ

— Fatalize

1

आप किसी अन्य बाइट को हटाकर यह भी 0<~tबता सकते हैं कि आउटपुट .का प्रत्येक तत्व ℕ₁ = [1, ..., +inf)इस प्रकार है:{≥N~^.ℕ₁ᵐhṗ:N×>?∧}ᶠ^ᵐ

— घातक

@ धन्यवाद धन्यवाद! मैं आपके सुझावों के साथ समाधान को अपडेट करूंगा :) वैसे, क्या आप जानते हैं कि समाधान {≥.~^ℕ₁ᵐhṗ:.×>?∧}ᶠ(आउटपुट के रूप में सीधे एन का उपयोग करके) काम क्यों नहीं करता है? मैंने पहले ऐसा कुछ करने की कोशिश की, लेकिन फिर एक्स का उपयोग करने और उस पर ^ लागू करने का सहारा लेना पड़ा

— लियो

2

मैं वास्तव में एक ही बात सोच रहा था; यह संभवतः अंतर्निहित लेबलिंग कदम के कारण होता है {...}ᶠजो कि विधेय के अंत में होता है जिसमें अजीब व्यवहार होता है। मैं इसे बदलने का इरादा रखता हूं और मैं विशेष रूप से इस बात पर ध्यान दूंगा कि यह कार्यक्रम उसी तरह काम नहीं करता है जैसे ऊपर वाला करता है।

— घातक

1

यह वास्तव में काम करता है यदि आप इसे इस तरह से करते हैं: {≥.~^ℕ₁ᵐhṗ:.≜×>?∧}ᶠइस तरह से आपको सही लेबलिंग मिलती है। (इस बीच ऐनक के लिए एक बदलाव किया गया था, लेकिन वास्तव में इस विशेष कार्यक्रम के व्यवहार को नहीं बदलता है, इसलिए यह इसे गैर-प्रतिस्पर्धात्मक नहीं बनाता है)। यह 2 बाइट बचाता है

— घातक

3

05AB1E , 15 12 बाइट्स

ƒNpiN¹N.nïm,

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

व्याख्या

ƒ             # for N in [0 ... input]
 Npi          # if N is prime
    N         # push N
     ¹N.n     # push log_N(input)
         ï    # convert to int
          m   # raise N to this power
           ,  # print

— Emigna
स्रोत

3

दे घुमा के + जीएनयू उपयोगिताओं, 74 बाइट्स

seq $1|factor|sed "s@.*: \(\w*\)\$@\1;l($1);l(\1);print \"/^p\"@"|bc -l|dc

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

इनपुट नंबर को एक तर्क के रूप में पारित किया जाता है। आउटपुट को stdout में प्रिंट किया जाता है। (जैसा कि प्रथागत है, stderr को अनदेखा किया जाता है।)

नमूना उत्पादन:

./maximalprimepowers 100 2>/dev/null
64
81
25
49
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

./maximalprimepowers 10000 2>/dev/null | wc -l
1229

यहां देखिए यह कैसे काम करता है:

तर्क एन को बुलाओ।

seq1 से एन तक सभी संख्याएं उत्पन्न करता है, और factorउन सभी को कारक बनाता है ।

कॉल में रेगीक्स सेड को उन पंक्तियों की पहचान करता है जहां संख्या एक प्राइम पी है, और उन लाइनों को उन लाइनों के साथ बदल देता है जो फॉर्म `के हैं।

P;l(N);l(P);print "/^p"

(जहां पी और एन को उनके वास्तविक संख्यात्मक मानों द्वारा बदल दिया जाता है, और बाकी सब कुछ शाब्दिक रूप से कॉपी किया जाता है, यहां तक कि उद्धरण और अर्धविराम और स्ट्रिंग भी print)।

इन लाइनों को इनपुट के रूप में खिलाया जाता है bc -l ; bc तीन संकेतित संख्याओं के मानों को प्रिंट करता है, प्रत्येक के बाद एक नई रेखा, और फिर वर्णों को प्रिंट करता है /^p। (ई.पू. में, l (x) x के प्राकृतिक लघुगणक को दर्शाता है।) JK K

तार जो bc प्रिंट करता है, उसे dc के इनपुट के रूप में खिलाया जाता है; dc पूर्णांक अंकगणितीय (छंटनी) का उपयोग करके प्रत्येक P ^ (लॉग (N) / लॉग (P)) के मान को प्रिंट करता है; P की सबसे बड़ी शक्ति वह <= N है।

एक चीज जो ऊपर से चमकती है, वह है कि उन रेखाओं के साथ क्या होता है जो उन कारकों से उत्पन्न होती हैं जो कि अपराधों के अनुरूप नहीं हैं। कॉल करने के लिए उन पंक्तियों में रेगेक्स का मिलान नहीं होता है, इसलिए उन पर कोई प्रतिस्थापन नहीं किया जाता है। नतीजतन, उन पंक्तियों की शुरुआत एक संख्या के साथ होती है जिसके बाद एक कॉलन होता है, जो इनपुट के रूप में खिलाए जाने पर एक त्रुटि उत्पन्न करता है bc। लेकिन bc केवल प्रिंटर्स को फिर से छापने के लिए, जिसे हम अनदेखा करते हैं; यह stdout के लिए कुछ भी प्रिंट नहीं करता है। डिफ़ॉल्ट रूप से, Stderr को PPCG पर ध्यान नहीं दिया जाता है ।

— मिशेल स्पेक्टर
स्रोत

3

हास्केल , 73 67 66 बाइट्स

p n=[last[x^i|i<-[1..n],x^i<=n]|x<-[2..n],all((>0).mod x)[2..x-1]]

इसे ऑनलाइन आज़माएं! उपयोग:

Prelude> p 50
[32,27,25,49,11,13,17,19,23,29,31,37,41,43,47]

संपादित करें: 6 बाइट्स ज़गरब के लिए धन्यवाद!

स्पष्टीकरण:

p n=[... x|x<-[2..n]                         ] -- list of all x in the range 2 to n
p n=[... x|x<-[2..n],        mod x<$>[2..x-1]] -- where the remainders of x mod the numbers 2 to x-1
p n=[... x|x<-[2..n],all(>0)$mod x<$>[2..x-1]] -- are all greater 0. This yields all primes in the range.

p n=[    [x^i|i<-[1..n]       ]|...] -- for each of those x generate the list of all x^i with i in the range 1 to n
p n=[last[x^i|i<-[1..n],x^i<=n]|...] -- where x^i is smaller or equal to n
p n=[last[x^i|i<-[1..n],x^i<=n]|...] -- and take the last (that is the largest) element

— Laikoni
स्रोत

1

मुझे लगता है कि बाईं ओर हो सकता है last[x^i|i<-[1..n],x^i<=n]।

— जर्ग्बेल

@Zgarb धन्यवाद! यह हमेशा सूची की समझ है, है ना ...

— Laikoni

2

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

Ræl/ÆF*/€

मेरे अन्य उत्तर की तुलना में एक बाइट , लेकिन इनपुट 10,000 के लिए खत्म सेकंड के एक जोड़े है।

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

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

Ræl/ÆF*/€  Main link. Argument: n

R          Range; yield [1, ..., n].
 æl/       Reduce by least common multiple.
    ÆF     Factor the LCM into [prime, exponent] pairs.
      */€  Reduce each pair by exponentiation.

— डेनिस
स्रोत

जेली में एक 7 बाइट संस्करण भी है जो जल्दी खत्म होता है।

— मील

मैं आपका 7 देखूंगा और आपको

— डेनिस

वाह, मुझे नहीं पता था कि एक बिल्डिन भी था। की काके ले लेता है।

— मील

2

जावास्क्रिप्ट (ईएस 6), 118 120 119 114 112 105 बाइट्स

(n,r)=>(r=k=>[...Array(k-1)].map((_,i)=>i+2),r(n).filter(q=>r(q).every(d=>q%d|!(d%(q/d)*(q/d)%d)&q*d>n)))

सुझाव का स्वागत करते हैं। यह एक तरह से लंबा है, लेकिन यह पोस्ट करने लायक लग रहा था क्योंकि यह बिल्ट-इन प्राइम्स का उपयोग करने के बजाय स्पष्ट रूप से सभी विभाज्यता परीक्षण करता है।

टिप्पणियाँ:

एक प्राकृतिक संख्या q एक प्रमुख शक्ति है <=> q के सभी भाजक एक ही प्रधानमंत्री की शक्तियां हैं <=> किसी भी d के लिए जो q को विभाजित करता है, d और q / d में से एक दूसरे का भाजक है।
यदि q p की एक शक्ति है, तो q हर nontrivial विभाजक d के लिए q </> q * p> n <=> q * d> n है।

— मीका
स्रोत

2

ऋषि, 43 बाइट्स

lambda i:[x^int(ln(i,x))for x in primes(i)]

रेंज में प्रत्येक प्राइम primes(i)को अपनी अधिकतम प्राइम पावर में मैप करता है। lnसिर्फ एक उपनाम है logइसलिए यह वैकल्पिक आधार स्वीकार करता है, हालांकि इसका नाम बताता है कि यह केवल आधार का उपयोग कर सकता है e।

— busukxuan
स्रोत

सोचा कि यह पहले अजगर था, primesसमारोह को देखा और वास्तव में उत्साहित हो गया। कभी भी स्टैकओवरफ्लो पर भरोसा नहीं करना चाहिए।

— sagiksp

@sagiksp मुझे नहीं मिला, इसका स्टैकऑवरफ्लो से क्या लेना-देना है?

— बुसुकुआन

2

हास्केल, 110 90 बाइट्स

s[]=[];s(x:t)=x:s[y|y<-t,y`rem`x>0];f n=[last.fst.span(<=n).scanl1(*)$repeat x|x<-s[2..n]]

- लकोनी की प्रतिक्रिया के अनुसार प्रतिरूप

— ब्रांडर
स्रोत

यह एक और के Exception: Prelude.last: empty listलिए फेंकता है । f 2f 3

— लकोनी

1

इसके बजाय f 4रिटर्न , मुझे लगता है कि आपकी जरूरत है । हालांकि इसके बजाय एक बाइट का उपयोग करना कम है। [2,3][4,3]takeWhile(<n)takeWhile(<=n)fst.spantakeWhile

— लकोनी

2

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

f n=[k|k<-[2..n],p:q<-[[d|d<-[2..k],mod k d<1]],k==p*p^length q,p*k>n]

एक कार्य को परिभाषित करता है f। इसे ऑनलाइन आज़माएं!

व्याख्या

विचार [2..n]उन नंबरों के लिए सीमा को फ़िल्टर करना है kजो संतुष्ट करते हैं k == p^length(divisors k)और p*k > n, जहां pका सबसे छोटा प्रधान भाजक है k।

f n=                -- Define f n as
 [k|                -- the list of numbers k, where
  k<-[2..n],        -- k is drawn from [2..n],
  p:q<-[            -- the list p:q is drawn from
   [d|              -- those lists of numbers d where
    d<-[2..k],      -- d is drawn from [2..k] and
    mod k d<1]      -- d divides k
   ],               -- (so p:q are the divisors of k except 1, and p is the smallest one),
  k==p*p^length q,  -- k equals p to the power of the divisor list's length
                    -- (so it's in particular a prime power), and
  p*k>n]            -- p*k, the next power of p, is not in the range [2..n].

— Zgarb
स्रोत

1

PHP, 101 93 91 88 बाइट्स

बस थोड़ा सा असली गणित ...

for($n=$argv[$i=1];$n>$j=$i++;$j?:$r[$p=$i**~~log($n,$i)]=$p)for(;$i%$j--;);print_r($r);

टूट - फूट

for($n=$argv[$i=1];     // loop $i from 2 to $n
    $n>$j=$i++;             // 0.: init $j to $i-1
    $j?:                    // 2. if $i is prime
        $r[$p=$i**~~log($n,$i)]=$p) // 3. add maximum power to results
    for(;$i%$j--;);         // 1. prime check (if $i is prime, $j will be 0)
print_r($r);            // print results

— टाइटस
स्रोत

1

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

पुनरावर्ती पुनरावृति i0 से लेकर और तक शामिल है n। यदि iप्रधान इसे उच्चतम फ्लोर्ड एक्सपोनेंट के लिए बढ़ाता है जो इसे बनाता है <= n( i ^ floor(log(n) / log(i)))

F=(n,i=n)=>i?[...((P=j=>i%--j?P(j):1==j)(i)?[i**((l=Math.log)(n)/l(i)|0)]:[]),...F(n,--i)]:[]

— जॉर्ज रीथ
स्रोत

मैक्सिमल प्राइम पॉवर्स का पता लगाएं

नियम

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

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

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

गणितज्ञ, ४४ 43 40 बाइट्स

स्पष्टीकरण:

MATL, 13 बाइट्स

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

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

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

कैसे?

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

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

मैथेमेटिका, 44 बाइट्स

सीजाम , 21 20 बाइट्स

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

व्याख्या

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

स्पष्टीकरण:

05AB1E , 15 12 बाइट्स

दे घुमा के + जीएनयू उपयोगिताओं, 74 बाइट्स

हास्केल , 73 67 66 बाइट्स

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

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

जावास्क्रिप्ट (ईएस 6), 118 120 119 114 112 105 बाइट्स

ऋषि, 43 बाइट्स

हास्केल, 110 90 बाइट्स

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

व्याख्या

PHP, 101 93 91 88 बाइट्स

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