tl; dr: İndirgenmiş asal çarpanlara ayırma liderinin değiştiği değerleri çıktılar.

Her pozitif tamsayının benzersiz bir birincil çarpanlara ayrımı vardır. Azaltılmış asal çarpanlaştırmaya, faktörlerin büyüklüğüne göre sıralanan asal çarpanların çokluğunun listesi diyelim. Örneğin, bir asal çarpanlara azaltılmış 1980DİR [2, 2, 1, 1]çünkü 1980 = 2 * 2 * 3 * 3 * 5 * 11.

Ardından, her bir azaltılmış asal çarpanın ne kadar sıklıkta gerçekleştiğini kaydedelim [1, 2, ..., n]. Örneğin [1, 2, ..., 10], aşağıdaki azaltılmış asal çarpanlara ayırma işlemleri gerçekleşir:

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

Lideri n, en sık meydana gelen azaltılmış asal çarpanlara ayırmaya çağırırız [1, 2, ..., n]. Bu nedenle, için azaltılmış asal çarpanlara lideri n = 10olduğunu [1]. Bağlar, nazaltılmış asal çarpanlara ayırma işleminden daha küçük veya buna eşit olan en büyük tamsayı boyutuna göre kırılacak ve daha küçük en büyük tamsayı daha iyi olacaktır. Örneğin n = 60, azaltılmış asal çarpanlara ayırma [1]ve [1, 1]her biri 17 kez meydana gelir. Bu aralık verme maksimum tamsayı [1, 1]olduğu 58veren tam sayı fazla ise, [1]bir 59. Bu nedenle, n = 60azaltılmış asal çarpanlara ayırma lideridir [1, 1].

nAsal çarpanlara ayırma liderliğinin değiştiği değerlerle ilgileniyorum . Bunlar n, azaltılmış asal çarpanlara ayırma liderinin azaltılmış asal çarpanlara ayırma liderinden farklı olduğu değerlerdir n-1. Bir uç durum olarak, liderliğin değiştiğini söyleyeceğiz n = 1, çünkü bir lider var değildir n = 0.

Sizin meydan okuma çıktı.

İstenen çıktının başlangıç ​​sırası:

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

İzin verilen çıktı stilleri:

• Sonsuz çıktı.
• İlk klider değişir, kgirdi nerede .
• kİnci lider değişimi, nerede kgirişidir.

k sıfır veya biri endekslenmiş olabilir.

Bu kod golfü. Hiçbir şeyden emin değilseniz yorumlarda sorun. İyi şanslar!

Kabuk , 18 bayt

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

Çevrimiçi deneyin! Bu sonsuz listeyi yazdırır. Program oldukça verimsiz olduğundan ve TIO'da bundan sonra zaman aşımına uğradığından, bağlantı sonucu ilk 7 değere indirir.

Parantezler çirkin, ama onlardan nasıl kurtulacağımı bilmiyorum.

açıklama

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 bayt

1 dizinli N'inci lider değişikliği döndürür.

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)

gösteri

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

Yorumlananlar

Yardımcı fonksiyon D () , n'nin azaltılmış asal çarpanlarına ayırma işlemini ters sırada döndürür :

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

Ana işlev:

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 bayt

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

Bu program girdi almaz ve teorik olarak sonsuz çıktı üretir. "Teorik olarak" diyorum çünkü 8. element bir yıldan fazla sürecek.

Çalıştır ve hata ayıkla

Aynı programın karşılık gelen ascii temsili budur.

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

Son lideri yığının üstünde tutar. Tamsayılar üzerinde yineleme, faktör gösteriminde farklı bir mod varsa ve öncekinden farklıysa, çıktı alın.

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 bayt

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

Jöle ,  35  34 bayt

_{Hâlâ golf oynayabilir gibi hissediyorum}

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

kİlk klider değişim noktalarının Jelly listesi temsilini alan ve çıkaran tam bir program .

Çevrimiçi deneyin!