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 = 1n = 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การเปลี่ยนแปลงผู้นำ, th ที่kคือการป้อนข้อมูล

k อาจเป็นศูนย์หรือหนึ่งดัชนี

นี่คือรหัสกอล์ฟ หากคุณไม่แน่ใจเกี่ยวกับอะไรให้ถามในความคิดเห็น โชคดี!

Husk , 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,..

JavaScript (ES6), 120 ไบต์

ส่งคืนการเปลี่ยนแปลงผู้นำ N-th ซึ่งจัดทำดัชนี 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

Stax , 24 ไบต์

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

โปรแกรมนี้ไม่มีการป้อนข้อมูลและสร้างผลลัพธ์ในทางทฤษฎี ฉันพูดว่า "ตามหลักวิชา" เพราะองค์ประกอบที่ 8 จะใช้เวลานานกว่าหนึ่งปี

เรียกใช้และแก้ไขข้อบกพร่อง

การแสดง ascii ที่สอดคล้องกันของโปรแกรมเดียวกันคือสิ่งนี้

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

มันทำให้ผู้นำคนสุดท้ายในกองซ้อน วนซ้ำกว่าจำนวนเต็มถ้ามีโหมดที่แตกต่างกันในการแสดงปัจจัยและมันแตกต่างจากโหมดสุดท้ายให้ส่งออก

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

Python 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

ลองออนไลน์!

เยลลี่ ,  35  34 ไบต์

_{ฉันรู้สึกว่ามันยังสามารถเล่นกอล์ฟได้}

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

โปรแกรมเต็มรูปแบบkและการส่งออกการแสดงรายการ Jelly ของkจุดเปลี่ยนผู้นำคนแรก

ลองออนไลน์!