tl; dr: Xuất ra các giá trị trong đó người lãnh đạo nhân tố nguyên tố giảm thay đổi.

Mỗi số nguyên dương có một thừa số nguyên tố duy nhất. Chúng ta hãy gọi hệ số nguyên tố giảm chỉ là danh sách bội số của các thừa số nguyên tố, được sắp xếp theo kích thước của các yếu tố. Ví dụ, hệ số nguyên tố giảm 1980là [2, 2, 1, 1]bởi vì 1980 = 2 * 2 * 3 * 3 * 5 * 11.

Tiếp theo, hãy ghi lại tần suất từng yếu tố nguyên tố giảm xảy ra, trên các số nguyên trong [1, 2, ..., n]. Ví dụ, trong [1, 2, ..., 10], các yếu tố nguyên tố giảm sau đây xảy ra:

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

Chúng tôi sẽ gọi nhà lãnh đạo lên đến nyếu tố nguyên tố giảm xảy ra thường xuyên nhất [1, 2, ..., n]. Do đó, giảm lãnh đạo nguyên tố cho n = 10là [1]. Các mối quan hệ sẽ bị phá vỡ bởi kích thước của số nguyên lớn nhất nhỏ hơn hoặc bằng nvới hệ số nguyên tố giảm đó, với số nguyên lớn nhất nhỏ hơn sẽ tốt hơn. Chẳng hạn, tối đa n = 60, các thừa số nguyên tố giảm [1]và [1, 1]xảy ra 17 lần mỗi lần. Số nguyên tối đa trong phạm vi cho đó [1, 1]là 58, trong khi số nguyên tối đa [1]là 59. Do đó, với n = 60, các nhà lãnh đạo yếu tố chính giảm [1, 1].

Tôi quan tâm đến các giá trị của nnơi mà người lãnh đạo nhân tố chính bị giảm thay đổi. Đó là những giá trị nmà ở đó nhà lãnh đạo nhân tố nguyên tố giảm khác với nhà lãnh đạo nhân tố chính giảm đến n-1. Trong trường hợp cạnh, chúng tôi sẽ nói rằng lãnh đạo thay đổi tại n = 1, bởi vì một nhà lãnh đạo không tồn tại n = 0.

Thách thức của bạn là đầu ra.

Một chuỗi ban đầu của đầu ra mong muốn là:

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

Các kiểu đầu ra được phép là:

• Sản lượng vô hạn.
• Nhà klãnh đạo đầu tiên thay đổi, đâu klà đầu vào.
• Người klãnh đạo thứ th thay đổi, đâu klà đầu vào.

k có thể bằng 0 hoặc một chỉ mục.

Đây là môn đánh gôn. Nếu bạn không chắc chắn về bất cứ điều gì, hãy hỏi trong các ý kiến. Chúc may mắn!

Husk , 18 byte

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

Hãy thử trực tuyến! Điều này in danh sách vô hạn. Liên kết cắt ngắn kết quả thành 7 giá trị đầu tiên, vì chương trình này khá kém hiệu quả và hết thời gian sau đó trên TIO.

Các dấu ngoặc đơn là xấu, nhưng tôi không biết làm thế nào để loại bỏ chúng.

Giải trình

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 byte

Trả về thay đổi người lãnh đạo thứ N, 1 chỉ mục.

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)

Bản giới thiệu

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))
}

Đã bình luận

Hàm trợ giúp D () , trả về hệ số nguyên tố giảm của n theo thứ tự ngược lại:

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

Chức năng chính:

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 byte

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

Chương trình này không có đầu vào và về mặt lý thuyết tạo ra đầu ra vô hạn. Tôi nói "về mặt lý thuyết" bởi vì yếu tố thứ 8 sẽ mất hơn một năm.

Chạy và gỡ lỗi nó

Đại diện ascii tương ứng của cùng một chương trình là đây.

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

Nó giữ người lãnh đạo cuối cùng trên stack. Lặp lại các số nguyên, nếu có một chế độ riêng biệt trong biểu diễn nhân tố và nó khác với chế độ cuối cùng, hãy xuất nó.

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 byte

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

Hãy thử trực tuyến!

Ung dung

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

Hãy thử trực tuyến!

Thạch ,  35  34 byte

_{Tôi cảm thấy như nó vẫn có thể chơi được}

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

Một chương trình đầy đủ lấy kvà xuất ra một đại diện danh sách Jelly của các kđiểm thay đổi nhà lãnh đạo đầu tiên .

Hãy thử trực tuyến!