tl; dr: gera os valores em que o líder de fatoração principal reduzido muda.

Todo número inteiro positivo possui uma fatoração primária única. Vamos chamar de fatoração primária reduzida apenas a lista de multiplicidade dos fatores primos, ordenada pelo tamanho dos fatores. Por exemplo, a fatoração primária reduzida de 1980é [2, 2, 1, 1], porque 1980 = 2 * 2 * 3 * 3 * 5 * 11.

A seguir, vamos registrar com que frequência cada fatoração primária reduzida ocorre, sobre números inteiros em [1, 2, ..., n]. Por exemplo, em [1, 2, ..., 10], ocorrem as seguintes fatorações primárias reduzidas:

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

Chamaremos o líder até a nfatoração primária reduzida que ocorre com mais frequência [1, 2, ..., n]. Portanto, o líder de fatoração primária reduzido para n = 10é [1]. Os laços serão quebrados pelo tamanho do maior número inteiro menor ou igual a nessa fatoração primária reduzida, com o maior número inteiro menor sendo melhor. Por exemplo, até n = 60, as fatorações primárias reduzidas [1]e [1, 1]ocorrem 17 vezes cada. O número máximo máximo nesse intervalo [1, 1]é 58, enquanto o número máximo máximo [1]é 59. Portanto, com n = 60, o líder de fatoração primária reduzido é [1, 1].

Estou interessado nos valores de nonde o líder de fatoração primária reduzida muda. Esses são os valores de nonde o líder de fatoração primária reduzida é diferente do líder de fatoração primária reduzido até n-1. Como um caso extremo, diremos que a liderança muda em n = 1, porque um líder não existe n = 0.

Seu desafio é produzir.

Uma sequência inicial da saída desejada é:

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

Os estilos de saída permitidos são:

• Saída infinita.
• O primeiro klíder muda, onde kestá a entrada.
• A kmudança de líder, onde kestá a entrada.

k pode ser zero ou um indexado.

Isso é código-golfe. Se você não tiver certeza de nada, pergunte nos comentários. Boa sorte!

Casca , 18 bytes

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

Experimente online! Isso imprime a lista infinita. O link trunca o resultado para os 7 primeiros valores, pois o programa é bastante ineficiente e atinge o tempo limite no TIO.

Os parênteses são feios, mas não sei como me livrar deles.

Explicação

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 bytes

Retorna a n-ésima mudança de líder, 1 indexada.

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)

Demo

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

Comentado

Função auxiliar D () , retornando a fatoração primária reduzida de n na ordem inversa:

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

Função principal:

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 bytes

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

Este programa não requer entrada e teoricamente produz saída infinita. Eu digo "teoricamente" porque o oitavo elemento levará mais de um ano.

Execute e depure

A representação ascii correspondente do mesmo programa é essa.

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

Mantém o último líder na pilha. Iterando sobre números inteiros, se houver um modo distinto na representação de fatores, e for diferente do último, faça a saída.

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 bytes

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

Experimente online!

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

Experimente online!

Geléia ,  35  34 bytes

_{Eu sinto que ainda é jogável}

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

Um programa completo que captura ke gera uma representação da lista Jelly dos primeiros kpontos de mudança de líder.

Experimente online!