कम फैक्टराइजेशन लीडर परिवर्तन

Question

tl; dr: उन मानों का आउटपुट करें जहाँ कम किए गए प्रधान कारक का परिवर्तन होता है।

प्रत्येक सकारात्मक पूर्णांक में एक अद्वितीय अभाज्य गुणनखंडन होता है। आइए घटे हुए अभाज्य गुणनखंड को कारकों के आकार द्वारा आदेशित अभाज्य कारकों की बहुलता की सूची कहते हैं। उदाहरण के लिए, कम अभाज्य गुणनखंडन 1980है [2, 2, 1, 1], क्योंकि 1980 = 2 * 2 * 3 * 3 * 5 * 11।

इसके बाद, पूर्णांक में, प्रत्येक घटाए गए अभाज्य गुणनखंड को कितनी बार दर्ज करते हैं, यह रिकॉर्ड करते हैं [1, 2, ..., n]। उदाहरण के लिए, [1, 2, ..., 10]निम्न में , निम्नांकित निम्नांकित मुख्य कारक होते हैं:

[1]: 4 (2, 3, 5, 7)
[2]: 2 (4, 9)
[1, 1]: 2 (6, 10)
[]: 1 (1)
[3]: 1 (8)

हम नेता nको कम अभाज्य गुणनखंड तक बुलाएंगे जो सबसे अधिक बार होता है [1, 2, ..., n]। इसलिए, के लिए कम प्रधान कारक n = 10है [1]। nछोटे से छोटे सबसे बड़े पूर्णांक के बेहतर होने के साथ, सबसे कम पूर्णांक के बराबर या उससे कम के बराबर सबसे बड़े पूर्णांक के आकार से संबंध टूट जाएंगे । उदाहरण के लिए, अप करने n = 60के लिए कम अभाज्य कारक [1]और [1, 1]प्रत्येक में 17 गुना होते हैं। उस सीमा देने में अधिकतम पूर्णांक होता [1, 1]है 58, जबकि अधिकतम पूर्णांक देने वाला [1]होता है 59। इसलिए, n = 60कम प्रधान कारक के साथ नेता है [1, 1]।

मैं उन मूल्यों में दिलचस्पी रखता हूँ nजहाँ कम प्रधान कारक परिवर्तन होता है। वे मान हैं nजहाँ कम किए गए प्रधान गुणन लीडर को कम किए गए प्रधान कारक के नेता से भिन्न होता है n-1। एक किनारे के मामले के रूप में, हम कहेंगे कि नेतृत्व में परिवर्तन होता है n = 1, क्योंकि एक नेता के लिए मौजूद नहीं है n = 0।

आपकी चुनौती आउटपुट के लिए है।

वांछित आउटपुट का प्रारंभिक अनुक्रम है:

1, 3, 58, 61, 65, 73, 77, 1279789, 1280057, 1280066, 1280073, 1280437, 1280441, 1281155, 1281161, 1281165, 1281179, 1281190, 1281243, 1281247, 1281262, 1281271, 1281313, 1281365

अनुमति आउटपुट शैली हैं:

• अनंत उत्पादन।
• पहला kनेता बदलता है, kइनपुट कहां है।
• kवें नेता परिवर्तन, जहां kइनपुट है।

k शून्य या एक अनुक्रमित हो सकता है।

यह कोड-गोल्फ है। यदि आप किसी चीज़ के बारे में निश्चित नहीं हैं, तो टिप्पणियों में पूछें। सौभाग्य!

Comments

क्या नेता के बारे में सबसे अधिक / k से कम मूल्य के साथ बदलता है?

— user202729

@ user202729 मैं यह कहने जा रहा हूं कि - यह चुनौती थोड़ी अलग है।

— isaacg

जब से तुम धनात्मक पूर्णांक के लिए विचार को परिभाषित किया है आप लोगों को या तो 1 या 3. (या परिवर्तन "जो के मूल्यों हैं पर अनुक्रम शुरू करने के लिए अनुमति देने के लिए चाहते हो सकता है n, जहां कम प्रधानमंत्री गुणन नेता करने के लिए कम प्रधानमंत्री गुणन नेता ऊपर से अलग है n-1")

— जोनाथन एलन

@JonathanAllan मैं चीजें नहीं बदल रहा हूं, लेकिन मैंने चुनौती के प्रासंगिक हिस्से को स्पष्ट कर दिया है।

— isaacg

Answer 1

हस्क , 18 बाइट्स

m←ġ(←►Lk=mȯmLgpṫ)N

इसे ऑनलाइन आज़माएं! यह अनंत सूची को प्रिंट करता है। लिंक पहले 7 मानों को परिणामित करता है, क्योंकि कार्यक्रम काफी अक्षम है और उसके बाद TIO पर।

कोष्ठक कुरूप हैं, लेकिन मुझे नहीं पता कि उनसे कैसे छुटकारा पाया जाए।

व्याख्या

m←ġ(←►Lk=mȯmLgpṫ)N  No input.
                 N  The list of natural numbers [1,2,3,4,..
  ġ(            )   Group into slices according to this function.
                    Each slice corresponds to a run of numbers with equal return values.
    ←►Lk=mȯmLgpṫ    Function: from n, compute the reduced factorization leader in [1..n].
                     As an example, take n = 12.
               ṫ     Reversed range: [12,11,10,9,8,7,6,5,4,3,2,1]
         m           Map over this range:
              p       Prime factorization: [[2,2,3],[11],[2,5],[3,3],[2,2,2],[7],[2,3],[5],[2,2],[3],[2],[]]
             g        Group equal elements: [[[2,2],[3]],[[11]],[[2],[5]],[[3,3]],[[2,2,2]],[[7]],[[2],[3]],[[5]],[[2,2]],[[3]],[[2]],[]]
          ȯmL         Take length of each run: [[2,1],[1],[1,1],[2],[3],[1],[1,1],[1],[2],[1],[1],[]]
       k=            Classify by equality: [[[2,1]],[[1],[1],[1],[1],[1]],[[1,1],[1,1]],[[2],[2]],[[3]],[[]]]
                     The classes are ordered by first occurrence.
     ►L              Take the class of maximal length: [[1],[1],[1],[1],[1]]
                     In case of a tie, ► prefers elements that occur later.
    ←                Take first element, which is the reduced factorization leader: [1]
                    The result of this grouping is [[1,2],[3,4,..,57],[58,59,60],[61,62,63,64],..
m←                  Get the first element of each group: [1,3,58,61,65,73,77,..

Comments

►=काम क्यों नहीं करता maxByबाद के तत्वों को पसंद नहीं करता है ?

— H.PWiz

@ H.PWiz समस्या यह है कि एक टाई के मामले में, मुझे अधिकतम तत्व को वरीयता देने की आवश्यकता है, जिसकी उलटी सीमा में पहली घटना नवीनतम संभव है, या समकक्ष है, जिसकी बढ़ती सीमा में अंतिम घटना जल्द से जल्द संभव है। ►=न तो करता है।

— ज़गर्ब

Answer 2

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

एन-वें नेता परिवर्तन लौटाता है, 1-अनुक्रमित।

N=>(F=m=>N?F((F[k=(D=(n,d=2,j)=>d>n?j:n%d?D(n,d+1)+(j?[,j]:[]):D(n/d,d,-~j))(++n)]=-~F[k])>m?F[N-=p!=k,p=k]:m):n)(n=p=0)

डेमो

let f =

N=>(F=m=>N?F((F[k=(D=(n,d=2,j)=>d>n?j:n%d?D(n,d+1)+(j?[,j]:[]):D(n/d,d,-~j))(++n)]=-~F[k])>m?F[N-=p!=k,p=k]:m):n)(n=p=0)

for(let n = 1; n <= 7; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

टिप्पणी की गई

हेल्पर फंक्शन D () , रिवर्स ऑर्डर में n का घटा हुआ मुख्य गुणनखंडन :

D = (n, d = 2, j) =>             // n = input, d = divisor, j = counter
  d > n ?                        // if d is greater than n:
    j                            //   append j and stop recursion
  :                              // else:
    n % d ?                      //   if d is not a divisor of n:
      D(n, d + 1) + (            //     recursive call with n unchanged and d = d + 1
        j ?                      //     if j is not undefined:
          [,j]                   //       append a comma followed by j
        :                        //     else:
          []                     //       append nothing
      )                          //
    :                            //   else:
      D(n / d, d, -~j)           //     recursive call with n divided by d and j = j + 1

मुख्य कार्य:

N =>                             // N = target index in the sequence
  (F = m =>                      // m = # of times the leader has been encountered
    N ?                          // if N is not equal to 0:
      F(                         //   do a recursive call to F():
        (F[k = D(++n)] =         //     increment n; k = reduced prime factorization of n
                         -~F[k]) //     increment F[k] = # of times k has been encountered
        > m ?                    //     if the result is greater than m:
          F[N -= p != k,         //       decrement N if p is not equal to k
                         p = k]  //       update p and set m to F[p]
        :                        //     else:
          m                      //       let m unchanged
      )                          //   end of recursive call
    :                            // else:
      n                          //   stop recursion and return n
  )(n = p = 0)                   // initial call to F() with m = n = p = 0

Answer 3

स्टेक्स , 24 बाइट्स

Ç▓Δk/‼&²Θºk∙♥╜fv╛Pg8╝j♀§

यह कार्यक्रम कोई इनपुट नहीं लेता है और सैद्धांतिक रूप से अनंत उत्पादन का उत्पादन करता है। मैं कहता हूं "सैद्धांतिक रूप से" क्योंकि 8 वें तत्व को एक वर्ष से अधिक समय लगेगा।

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

इसी कार्यक्रम का संबंधित एएससीआई प्रतिनिधित्व यह है।

0WYi^{|n0-m|=c:uny=!*{i^Q}Md

यह आखिरी नेता को ढेर पर रखता है। पूर्णांक पर Iterating, यदि कारक प्रतिनिधित्व में एक अलग मोड है, और यह पिछले एक से भिन्न है, इसे आउटपुट करता है।

0                               push zero for a placeholder factorization
 W                              repeat the rest of the program forever
  Y                             store the last factorization in the y register
   i^                           i+1 where i is the iteration index
     {    m                     using this block, map values [1 .. i+1]
      |n0-                          get the prime exponents, and remove zeroes 
           |=                   get all modes
             c:u                copy mode array and test if there's only one
                ny=!            test if mode array is not equal to last leader
                    *           multiply; this is a logical and
                     {   }M     if true, execute this block
                      i^Q       push i+1 and print without popping
                           d    discard the top of stack
                                    if it was a leader change, this pops i+1
                                    otherwise it pops the mode array
                                at this point, the last leader is on top of 
                                the stack

Answer 4

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

m=i=0;f=[]
while 1:
 i+=1;a=i;d=[0]*-~i;k=2
 while~-a:x=a%k>0;k+=x;a/=x or k;d[k]+=1-x
 k=filter(abs,d);f+=k,;c=f.count
 if c(k)>c(m):print i;m=k

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

Ungolfed

m=0                    # reduced prime factorizations leader
i=0                    # current number
f=[]                   # list of reduced prime factorizations
while 1:               # Infinite loop:
  i+=1                 #   next number
  a=i                  #   a is used for the prime factorization
  d=[0]*-~i            #   this lists stores the multiplicity
  k=2                  #   current factor
  while~-a:            #   As long as a-1 != 0:
    x=a%k>0            #      x := not (k divides a)
    k+=x               #      If k does not divide a, go to the next factor
    a/=x or k          #      If k does not divide a,
                       #         divide a by 1,
                       #         else divide it by k
    d[k]+=1-x          #      add 1 to the multiplicity of k if k divides a
  k=filter(abs,d)      #   Only keep non-zero multiplicities
                       #     k is now the reduced prime factorization of i
  f+=k,                #   append k to the list of reduced prime factorizations
  c=f.count            #   c(x) := number of occurences of x in f
  if c(k)>c(m):        #   has the current reduced prime factorization
                       #    appeared more often than the leader?
    print i;m=k        #     print the current number, set new leader

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

Answer 5

जेली ,  35  34 बाइट्स

_{मुझे लगता है कि यह अभी भी गोल्फ है}

ÆEḟ0µ€ĠL€M⁸’ߤ¹Ṗ?
®‘©Ç€F0;ITµL<³µ¿

एक पूरा कार्यक्रम ले रहा है kऔर पहले kनेता परिवर्तन बिंदुओं की एक जेली सूची प्रतिनिधित्व का उत्पादन कर रहा है ।

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