tl; dr: produce i valori in cui cambia il leader della fattorizzazione in fattori primi ridotti.

Ogni numero intero positivo ha una fattorizzazione primaria unica. Chiamiamo la scomposizione in fattori primi ridotta solo l'elenco della molteplicità dei fattori primi, ordinati in base alla dimensione dei fattori. Ad esempio, la ridotta scomposizione in fattori primi 1980è [2, 2, 1, 1], perché 1980 = 2 * 2 * 3 * 3 * 5 * 11.

Quindi, registriamo con quale frequenza si verifica ogni ridotta fattorizzazione in primi, rispetto ai numeri interi in [1, 2, ..., n]. Ad esempio, in [1, 2, ..., 10], si verificano le seguenti prime prime riduzioni:

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

Chiameremo il leader fino alla nridotta scomposizione in fattori primi che si verifica più spesso [1, 2, ..., n]. Pertanto, il leader della fattorizzazione ridotta per n = 10è [1]. I legami saranno spezzati dalla dimensione dell'intero più grande minore o uguale a ncon quella ridotta fattorizzazione in primo piano, con un intero più grande più piccolo migliore. Ad esempio, fino a n = 60, ridotte fattorizzazione prime [1]e [1, 1]verificano 17 volte ciascuno. Il numero intero massimo in tale intervallo [1, 1]è 58, mentre il numero intero massimo [1]è 59. Pertanto, con n = 60, il leader della fattorizzazione in fattori primi ridotto è [1, 1].

Sono interessato ai valori di ndove cambia il leader della scomposizione in fattori primi ridotti. Questi sono i valori in ncui il leader della fattorizzazione primaria ridotta è diverso dal leader della fattorizzazione primaria ridotta fino a n-1. Come caso limite, diremo che la leadership cambia n = 1, perché non esiste un leader per n = 0.

La tua sfida è quella di produrre.

Una sequenza iniziale dell'output desiderato è:

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

Gli stili di output consentiti sono:

• Uscita infinita.
• Il primo kleader cambia, dov'è kl'input.
• Il kcapo cambia, dov'è kl'input.

k può essere zero o uno indicizzato.

Questo è code-golf. Se non sei sicuro di qualcosa, chiedi nei commenti. In bocca al lupo!

Buccia , 18 byte

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

Provalo online! Questo stampa l'elenco infinito. Il collegamento tronca il risultato ai primi 7 valori, poiché il programma è abbastanza inefficiente e scade dopo quello su TIO.

Le parentesi sono brutte, ma non so come liberarmene.

Spiegazione

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 byte

Restituisce l'N-esimo cambio di leader, 1 indicizzato.

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)

dimostrazione

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

Commentate

Funzione helper D () , che restituisce la fattorizzazione in fattori primi ridotta di n in ordine 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

Funzione 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 byte

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

Questo programma non accetta input e produce teoricamente output infinito. Dico "teoricamente" perché l'ottavo elemento richiederà più di un anno.

Esegui ed esegui il debug

La corrispondente rappresentazione ASCII dello stesso programma è questa.

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

Mantiene l'ultimo leader in pila. Iterando su numeri interi, se esiste una modalità distinta nella rappresentazione del fattore, ed è diversa dall'ultima, emetterla.

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 byte

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

Provalo 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

Provalo online!

Gelatina ,  35  34 byte

_{Sento che è ancora golfabile}

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

Un programma completo che prende ke produce una rappresentazione della Jelly list dei primi kpunti di cambio leader.

Provalo online!