tl; dr: affiche les valeurs où le leader de factorisation premier réduit change.

Chaque entier positif a une factorisation première unique. Appelons la factorisation première réduite simplement la liste de la multiplicité des facteurs premiers, ordonnée par la taille des facteurs. Par exemple, la factorisation en nombre réduit de 1980est [2, 2, 1, 1], car 1980 = 2 * 2 * 3 * 3 * 5 * 11.

Ensuite, enregistrons la fréquence à laquelle chaque facteur premier réduit se produit, sur des entiers dans [1, 2, ..., n]. Par exemple, dans [1, 2, ..., 10], les factorisations premières réduites suivantes se produisent:

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

Nous appellerons le leader à nla factorisation en nombre réduit qui se produit le plus souvent [1, 2, ..., n]. Par conséquent, le leader de la factorisation en nombre réduit pour n = 10est [1]. Les liens seront rompus par la taille du plus grand entier inférieur ou égal à ncette factorisation réduite, le plus petit entier étant meilleur. Par exemple, jusqu'à n = 60, les factorisations premières réduites [1]et [1, 1]se produisent 17 fois chacune. Le nombre entier maximal dans cette plage [1, 1]est de 58, tandis que le nombre entier maximal [1]est 59. Par conséquent, avec n = 60, le leader de la factorisation en nombre réduit est [1, 1].

Je m'intéresse aux valeurs de nl'évolution du leader de la factorisation en nombre réduit. Ce sont les valeurs de l' nendroit où le leader de factorisation premier réduit est différent du leader de factorisation premier réduit jusqu'à n-1. À titre d'exemple, nous dirons que le leadership change à n = 1, car un leader n'existe pas pour n = 0.

Votre défi est de produire.

Une séquence initiale de la sortie souhaitée est:

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

Les styles de sortie autorisés sont:

• Sortie infinie.
• Le premier kleader change, où kest l'entrée.
• Le kchangement de leader e, où kest l'entrée.

k peut être zéro ou un indexé.

C'est du code-golf. Si vous n'êtes sûr de rien, demandez dans les commentaires. Bonne chance!

Husk , 18 octets

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

Essayez-le en ligne! Cela imprime la liste infinie. Le lien tronque le résultat aux 7 premières valeurs, car le programme est assez inefficace et expire après cela sur TIO.

Les parenthèses sont moches, mais je ne sais pas comment m'en débarrasser.

Explication

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 octets

Renvoie le N-ème changement de leader, indexé sur 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)

Démo

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

Commenté

Fonction d'assistance D () , renvoyant la factorisation première réduite de n dans l'ordre inverse:

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

Fonction principale:

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 octets

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

Ce programme ne prend aucune entrée et produit théoriquement une sortie infinie. Je dis "théoriquement" car le 8ème élément prendra plus d'un an.

Exécuter et déboguer

La représentation ascii correspondante du même programme est la suivante.

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

Il garde le dernier leader de la pile. En itérant sur des entiers, s'il existe un mode distinct dans la représentation factorielle, et différent du dernier, affichez-le.

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 octets

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

Essayez-le en ligne!

Non 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

Essayez-le en ligne!

Gelée ,  35  34 octets

_{J'ai l'impression que c'est toujours jouable au golf}

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

Un programme complet prenant ket sortant une représentation de liste Jelly des premiers kpoints de changement de leader.

Essayez-le en ligne!