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 = 10is [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

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и выводящая в виде желе представление первых kточек смены лидера.

Попробуйте онлайн!