tl; dr: Muestra los valores donde cambia el líder de factorización prima reducido.

Cada entero positivo tiene una factorización prima única. Llamemos a la factorización prima reducida solo la lista de multiplicidad de factores primos, ordenada por el tamaño de los factores. Por ejemplo, la factorización prima reducida de 1980es [2, 2, 1, 1], porque 1980 = 2 * 2 * 3 * 3 * 5 * 11.

A continuación, registremos con qué frecuencia ocurre cada factorización reducida, sobre enteros en [1, 2, ..., n]. Por ejemplo, en [1, 2, ..., 10], ocurren las siguientes factorizaciones reducidas:

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

Llamaremos al líder a nla factorización reducida que ocurre con mayor frecuencia [1, 2, ..., n]. Por lo tanto, el líder de factorización reducida para n = 10es [1]. Los lazos se romperán por el tamaño del entero más grande menor o igual que ncon la factorización prima reducida, siendo mejor el entero más grande más pequeño. Por ejemplo, hasta n = 60, las factorizaciones primas reducidas [1]y [1, 1]ocurren 17 veces cada una. El número entero máximo en ese rango [1, 1]es 58, mientras que el número entero máximo [1]es 59. Por lo tanto, con n = 60, el líder de factorización prima reducida es [1, 1].

Estoy interesado en los valores de ndónde cambia el líder de factorización reducida. Esos son los valores nen los que el líder de factorización prima reducida es diferente del líder de factorización reducida hasta n-1. Como caso límite, diremos que el liderazgo cambia en n = 1, porque no existe un líder para n = 0.

Su desafío es la salida.

Una secuencia inicial de la salida deseada es:

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

Los estilos de salida permitidos son:

• Salida infinita.
• El primer klíder cambia, ¿dónde kestá la entrada?
• El kcambio de líder th, donde kestá la entrada.

k puede ser cero o uno indexado.

Este es el código de golf. Si no está seguro de nada, pregunte en los comentarios. ¡Buena suerte!

Casco , 18 bytes

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

Pruébalo en línea! Esto imprime la lista infinita. El enlace trunca el resultado a los primeros 7 valores, ya que el programa es bastante ineficiente y se agota después de eso en TIO.

Los paréntesis son feos, pero no sé cómo deshacerme de ellos.

Explicación

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

Devuelve el cambio de N-ésimo líder, 1 indexado.

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)

Manifestación

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

Función auxiliar D () , que devuelve la factorización prima reducida de n en orden inverso:

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

Función 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 no tiene entrada y teóricamente produce una salida infinita. Digo "teóricamente" porque el octavo elemento llevará más de un año.

Ejecutar y depurarlo

La representación ascii correspondiente del mismo programa es esta.

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

Mantiene al último líder en la pila. Iterando sobre los enteros, si hay un modo distinto en la representación del factor, y es diferente al último, imprímalo.

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

Pruébalo en línea!

Sin golf

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

Pruébalo en línea!

Jalea ,  35  34 bytes

_{Siento que todavía es golfable}

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

Un programa completo que toma ky genera una representación de lista Jelly de los primeros kpuntos de cambio de líder

Pruébalo en línea!