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 може бути нульовим або одним індексованим.

Це код-гольф. Якщо ви нічого не впевнені, запитайте в коментарях. Удачі!

Лушпиння , 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-го лідера, 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

Стакс , 24 байти

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

Ця програма не бере ніяких вкладів і теоретично виробляє нескінченний вихід. Я кажу "теоретично", тому що восьмий елемент займе більше року.

Запустіть і налагоджуйте його

Відповідне представлення такої ж програми 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

Спробуйте в Інтернеті!

Безумовно

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та виводить список зі списку желе, представлений першими kточками зміни лідера.

Спробуйте в Інтернеті!