tl; dr : 감소 된 소인수 분해 리더가 변경되는 값을 출력합니다.

모든 양의 정수에는 고유 한 소인수 분해가 있습니다. 소인수 분해를 소인수의 크기에 따라 정렬 된 소수 인 소인수의 목록이라고하겠습니다. 예를 들어,의 소인수 분해 감소 1980IS를 [2, 2, 1, 1]하기 때문에 1980 = 2 * 2 * 3 * 3 * 5 * 11.

다음으로,에서 감소 된 각 소인수 분해가 얼마나 자주 발생하는지 기록해 봅시다 [1, 2, ..., n]. 예를 들어에서에서 [1, 2, ..., 10]다음과 같이 감소 된 소인수 분해가 발생합니다.

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

우리는 n가장 자주 발생하는 감소 된 소인수 분해 까지 리더를 부를 것 [1, 2, ..., n]입니다. 따라서 감소 된 소인수 분해 계수 n = 10는 [1]입니다. n감소 된 소인수 분해 보다 작거나 같은 가장 큰 정수의 크기로 인해 연결이 끊어지며 가장 작은 정수가 더 좋습니다. 최대 인스턴스의 경우 n = 60, 감소 된 주요 인수 분해 [1]하고 [1, 1]17 회를 발생합니다. 해당 범위 내 최대 정수 [1, 1]는 58이고 최대 정수 [1]는 59입니다. 따라서로 n = 60감소 된 소인수 분해 리더는 [1, 1]입니다.

n감소 된 소인수 분해 리더가 변하는 값에 관심이 있습니다. 이 값은 n감소 된 소인수 분해 리더가 감소 된 소인수 분해 리더와 다른 값입니다 n-1. 엣지 n = 1리더로서 존재하지 않기 때문에 엣지 리더쉽이에서 변화한다고 말할 것 입니다 n = 0.

당신의 도전은 출력하는 것입니다.

원하는 출력의 초기 순서는 다음과 같습니다.

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

허용되는 출력 스타일은 다음과 같습니다.

• 무한 출력.
• 첫 번째 k지시선이 변경됩니다 ( k입력 위치 ).
• k번째 리더 변화는 여기서 k입력된다.

k 인덱스가 0 또는 1 일 수 있습니다.

이것은 코드 골프입니다. 확실하지 않은 경우 의견을 물어보십시오. 행운을 빕니다!

껍질 , 18 바이트

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

온라인으로 사용해보십시오! 무한리스트가 인쇄됩니다. 프로그램은 매우 비효율적이며 TIO에서는 그 이후 시간이 초과되므로 링크는 결과를 처음 7 개 값으로 자릅니다.

괄호는 추악하지만 제거 방법을 모르겠습니다.

설명

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 바이트

N 번째 지시선 변경 사항을 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)

데모

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

댓글

도우미 함수 D () , n 의 감소 된 소인수 분해를 역순으로 반환합니다 .

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

주요 기능:

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 바이트

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

이 프로그램은 입력을받지 않으며 이론적으로 무한 출력을 생성합니다. 나는 8 번째 요소가 1 년 이상 걸릴 것이기 때문에 "이론적으로"라고 말합니다.

실행 및 디버깅

동일한 프로그램의 해당 ASCII 표현은 이렇습니다.

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

스택의 마지막 리더를 유지합니다. 요인 표현에 고유 모드가 있고 마지막 모드와 다른 경우 정수를 반복하여 출력하십시오.

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

파이썬 2 , 145 바이트

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

온라인으로 사용해보십시오!

언 골프

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

온라인으로 사용해보십시오!

젤리 ,  35  34 바이트

_{아직도 골프 인 것 같아}

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

k첫 번째 k리더 변경 지점 의 젤리 목록 표현을 가져 와서 출력하는 전체 프로그램 입니다.

온라인으로 사용해보십시오!