정수 ≥ 2의 입력이 주어지면, 소수로 나눈 순서에 따라 지수로 정렬 된 제수의 목록을 오름차순으로, 가장 큰 소수 순으로 정렬 한 다음 두 번째로 큰 순서대로 출력하십시오.

예를 들어, 정수 72 (2 ³ 3 ^{2)를 사용하십시오} . 제수가 있습니다

1     3^0 · 2^0
2     3^0 · 2^1
3     3^1 · 2^0
4     3^0 · 2^2
6     3^1 · 2^1
8     3^0 · 2^3
9     3^2 · 2^0
12    3^1 · 2^2
18    3^2 · 2^1
24    3^1 · 2^3
36    3^2 · 2^2
72    3^2 · 2^3

소수에 대한 지수를 기준으로 지수에 따라 오름차순으로 정렬하면 큰 소수가 우선합니다.

1     3^0 · 2^0
2     3^0 · 2^1
4     3^0 · 2^2
8     3^0 · 2^3
3     3^1 · 2^0
6     3^1 · 2^1
12    3^1 · 2^2
24    3^1 · 2^3
9     3^2 · 2^0
18    3^2 · 2^1
36    3^2 · 2^2
72    3^2 · 2^3

목록은 먼저 지수 3의 순서로 정렬 된 다음 지수 2의 순서로 정렬됩니다. 또한 다음 표에서 왼쪽에서 오른쪽으로, 위에서 아래로 읽는 것으로 생각할 수 있습니다.

        2^0  2^1  2^2  2^3

3^0     1    2    4    8
3^1     3    6    12   24
3^2     9    18   36   72

테스트 사례 :

2 => 1 2
72 => 1 2 4 8 3 6 12 24 9 18 36 72
101 => 1 101
360 => 1 2 4 8 3 6 12 24 9 18 36 72 5 10 20 40 15 30 60 120 45 90 180 360
3780 => 1 2 4 3 6 12 9 18 36 27 54 108 5 10 20 15 30 60 45 90 180 135 270 540 7 14 28 21 42 84 63 126 252 189 378 756 35 70 140 105 210 420 315 630 1260 945 1890 3780
30030 => 1 2 3 6 5 10 15 30 7 14 21 42 35 70 105 210 11 22 33 66 55 110 165 330 77 154 231 462 385 770 1155 2310 13 26 39 78 65 130 195 390 91 182 273 546 455 910 1365 2730 143 286 429 858 715 1430 2145 4290 1001 2002 3003 6006 5005 10010 15015 30030
65536 => 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536
74088 => 1 2 4 8 3 6 12 24 9 18 36 72 27 54 108 216 7 14 28 56 21 42 84 168 63 126 252 504 189 378 756 1512 49 98 196 392 147 294 588 1176 441 882 1764 3528 1323 2646 5292 10584 343 686 1372 2744 1029 2058 4116 8232 3087 6174 12348 24696 9261 18522 37044 74088

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

05AB1E , 6 바이트

암호:

ÑÒí{€P

설명:

Ñ       # Get the divisors of input.
 Ò      # Factorize each.
  í     # Reverse each.
   {    # Sort the array.
    €P  # Product each.

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

젤리 , 8 7 바이트

ÆDÆfU$Þ

온라인으로 사용해보십시오! -1 바이트의 @Dennis에게 감사드립니다.

ÆD         Array of divisors, e.g. 24 -> [1, 2, 4, 8, 3, 6, 12, 24]
      Þ    Sort by...
     $       Combine previous two links...
  Æf           Factorise each, e.g. ['', [2], [3], [2, 2], [2, 3], [2, 2, 2],
                   [2, 2, 3], [2, 2, 2, 3]]
    U          Upend/reverse each sublist

Pyth, 10 바이트

+1{*Mt_DyP

온라인으로 사용해보십시오 : 데모

슬프게도 빈 목록의 제품은 Pyth에서 1로 정의되지 않았습니다. 이것은 3 바이트의 추가 비용이 듭니다.

설명:

+1{*Mt_DyPQ   implicit Q (=input number) at the end
         PQ   prime factorization of input
        y     powerset
      _D      order by reversed subsets
     t        remove the empy subset
   *M         compute the product of each subsets
  {           remove duplicates
+1            prepend 1

젤리 , 12 10 바이트

@ Sp3000 덕분에 2 바이트.

ÆE'ḶUṚŒpUṚÆẸ
ÆEU'ḶŒpUÆẸ

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

테스트 스위트.

ÆE            Array of exponents, e.g. 24 -> [3, 1] since 24 = 2^3*3^1
  U           Upend/reverse, e.g. [1, 3]
   ‘Ḷ         Range of each, from 0, e.g. [[0, 1], [0, 1, 2, 3]]
     Œp       Cartesian product, e.g. [[0, 0], [0, 1], ..., [1, 3]]
       U      Upend, reversing the innermost lists
        ÆẸ    Inverse of ÆE, converting exponents back into a number

설명 형식으로 @ Sp3000에 크레딧을 제공합니다.

파이썬 2, 85 바이트

n=input()
p,=L=[1]
while~-n:
 l=L;p+=1
 while n%p<1:L=l+[x*p for x in L];n/=p
print L

인수 분해, 정렬 없음. 동일한 길이의 재귀 구현 :

f=lambda n,p=2:1/n*[1]or n%p and f(n,p+1)or[x*c for x in f(n/p)for c in[1,p][x%p<1:]]

실제로는 19 바이트

;÷#o♂w♂RS`"iⁿ"£Mπ`M

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

설명:

;÷#o♂w♂RS`"iⁿ"£Mπ`M
;                    duplicate input
 ÷                   divisors
  #o                 include input in divisors list (note to self: fix this bug)
    ♂w               factor each integer into a list of [prime, exponent] pairs
      ♂R             reverse each list, so that the largest prime comes first
        S            sort the list
         `"iⁿ"£Mπ`M  for each factorization:
          "iⁿ"£M       for each [prime, exponent] pair:
           iⁿ            push prime**exponent
                π      product

자바 스크립트, 78 바이트

f=(n,p=2,a=[1],b=a)=>n<2?a:n%p?f(n,p+1,a):f(n/p,p,a.concat(b=b.map(m=>m*p)),b)

@xnor의 아이디어를 기반으로하지만 그의 코드를 이해하지 못했기 때문에 처음부터 다시 구현해야했습니다. 기본 알고리즘은 n의 소인수 분해에서 각 pᵏ에 대해 [1]로 시작하고 [1, ..., pᵏ]를 곱하는 것입니다. 재귀 적으로. 예:

n=72 p=2 a=[1] b=[1]
n=36 p=2 a=[1,2] b=[2]
n=18 p=2 a=[1,2,4] b=[4]
 n=9 p=2 a=[1,2,4,8] b=[8]
 n=9 p=3 a=[1,2,4,8] b=[1,2,4,8]
 n=3 p=3 a=[1,2,4,8,3,6,12,24] b=[3,6,12,24]
 n=1 p=3 a=[1,2,4,8,3,6,12,24,9,18,36,72] b=[9,18,36,72]

R, 196 바이트

n=scan()
if(n<4)c(1,n)else{
r=2:n
d=NULL
while(n>1){i=r[min(which(n%%r==0))];d=c(d,i);n=n/i}
m=unique(d)
b=table(d)
l=list()
for(i in 1:length(m))l[[i]]=m[i]^(0:b[i])
apply(expand.grid(l),1,prod)}

나는 사용의 유혹에 거의 저항하지 않았기 때문에 도대체 비효율적 library(primes)입니다. d입력의 모든 주요 요소로 구성된 벡터 를 생성 하고 주파수 (발생 횟수)를 계산 한 다음 함수가 적용되는 모든 가능한 거듭 제곱 (0에서 각 주파수까지 b[i]) 의 데카르트 곱을 계산합니다 prod. Dang it, 2와 3의 특별한 경우! 그렇지 않으면 이것은 R 데이터 프레임 처리 및 벡터 함수 / 행 단위 연산 (그리고 순수한 통계 table함수) 의 멋진 쇼케이스입니다 .

물론 r=2:ceiling(sqrt(n))누군가가 걱정한다면 15 바이트의 비용으로 효율성을 향상시킬 수 있습니다 . 더 나은 ungolfed 버전은 다음과 같습니다.

factorise <- function(n){
  if (n<4) c(1,n) else { # Now that all special cases have been handled
    r=2:ceiling(sqrt(n)) # We check all divisors smaller than the square root
    d=NULL # Initiate the variable for divisors
    while (n>1) {
      i=r[min(which(n%%r==0))] # Check the first divisor with a zero remainder
      d=c(d,i) # Append it to the list of divisors
      n=n/i   # Divide by it and check again
    }
    m=unique(d) # Get unique divisors, and they are already sorted
    b=table(d) # Count their frequencies
    l=list() # Initiate a list of all possible powers of unique factors
    for(i in 1:length(m)) l[[i]]=m[i]^(0:b[i]) # Calculate powers
    apply(expand.grid(l),1,prod) # Make a cartesian dataframe and row-multiply
  }
}

Mathematica 150 바이트

f[t_]:=Thread@{#,IntegerExponent[t,#]&/@#}&@Prime@Range@PrimePi@Max@FactorInteger[t][[All,1]];Times@@@(#^#2&@@@#&/@Sort[Reverse/@(f@#&/@Divisors@#)])&

Brachylog , 3 바이트

fḋᵒ

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

이 코드는 도전 과제의 제목과 같이 "입력의 요소, 주요 분해도에 따라 정렬 됨"과 같이 다소 읽습니다. 이 3 바이트의 아름다움이 실제로 목록을 정렬하는 방법에 대한 Brachylog의 내장 의미 만 사용하여 테스트 사례를 통과했는지 확인하면 결국 많은 요소를 복사하여 Clojure REPL에 붙여 넣어야합니다. 목록 요소는 공백으로 구분됩니다. 쉼표는 공백이지만 실제로 작동한다는 것이 밝혀졌습니다.

APL (Dyalog Extended) , 17 바이트

APL 을 배우고 APL의 도움을받을 수있는 좋은 장소 인 APL Orchard 에서 이러한 APL 프로그램을 모두 골프화하는 데 도움을 주신 ngn과 Adám에게 많은 감사를드립니다 .

∊×⍀/⌽{⊂×\1,⍵}⌸⍨⍭⎕

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

언 골핑

∊×⍀/⌽{⊂×\1,⍵}⌸⍨⍭⎕

                ⎕  Gets evaluated input from stdin.
               ⍭   Gives us a list of the prime factors of our input.
                   Example for 720: 2 2 2 2 3 3 5
     {      }⌸⍨    ⌸ groups our prime factors by the keys in the left argument,
                   and ⍨ passes the prime factors as both arguments,
                   grouping all the identical primes together
                   before running a {} dfn on them
      ⊂×\1,⍵       We append 1 to each group, get a list of powers of each prime,
                   and enclose the groups to remove 0s from uneven rows.
    ⌽             This reverses the prime power groups.
 ×⍀/              This multiplies all the powers together into
                   a matrix of the divisors of our input.
                   (Same as ∘.×/ in Dyalog Unicode)
∊                  And this turns the matrix into 
                   a list of divisors sorted by prime factorization.
                   We print implicitly, and we're done.

APL (Dyalog Unicode) , 29 바이트 ^SBCS

{∊∘.×/⌽{⊂×\1,⍵}⌸⍨¯2÷/∪∧\⍵∨⍳⍵}

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

언 골핑

{∊∘.×/⌽{⊂×\1,⍵}⌸⍨¯2÷/∪∧\⍵∨⍳⍵}

{                           }  A dfn, a function in brackets.
                        ⍵∨⍳⍵   We take the GCD of our input with 
                               all the numbers in range(1, input).
                     ∪∧\       This returns all the unique LCMs of
                               every prefix of our list of GCDs.
                               Example for 72: 1 2 6 12 24 72.
                 ¯2÷/          We divide pairwise (and in reverse)
                               by using a filter window of negative two (¯2).
                               Example for 72: 2 3 2 2 3, our prime factors.
       {      }⌸⍨              ⌸ groups our prime factors by the keys in the left argument,
                               and ⍨ passes the prime factors as both arguments,
                               grouping all the identical primes together
                               before running a {} dfn on them
           1,⍵                 We append 1 to each group.
        ⊂×\                    Then we get a list of powers of each prime,
                               and enclose the groups to remove 0s from uneven rows.
      ⌽                        This reverses the prime power groups.
  ∘.×/                         This multiplies all the powers together into 
                               a matrix of the divisors of our input.
 ∊                             And this turns the matrix into a list of divisors
                               sorted by prime factorization.
                               We return implicitly, and we're done.

J, 32 31 바이트

[:(*/@#~>:#:[:i.[:*/>:)&|./2&p:

입력 정수의 소수와 지수 목록을 잡고 각각을 뒤집고 그로부터 제수를 만듭니다.

용법

   f =: [:(*/@#~>:#:[:i.[:*/>:)&|./2&p:
   f 2
1 2
   f 72
1 2 4 8 3 6 12 24 9 18 36 72
   f 101
1 101

설명

[:(*/@#~>:#:[:i.[:*/>:)&|./2&p:  Input: n
                           2&p:  Factor n as a list where the first row are the primes
                                 and the second are their exponents
[:                     &|./      Reverse each list
                    >:           Increment each exponent by 1
                [:*/             Reduce it using multiplication
            [:i.                 Construct a range from 0 to that product exclusive
        >:                       The list of each exponent incremented
          #:                     Reduce each number in the previous range as a mixed base
                                 using the incremented exponents
      #~                         For each mixed base value in that range, copy from
                                 the list of primes that many times
   */@                           Reduce the copied primes using multiplication
                                 Return this list of products as the result

루비, 71 바이트

이 답변은 xnor의 Python 2 답변을 기반으로합니다.

->n{a,=t=[1];(s=t;a+=1;(t=s+t.map{|z|z*a};n/=a)while n%a<1)while n>1;t}

동일한 길이의 대안은 다음과 같습니다.

->n{a,=t=[1];(a+=1;(t+=t.map{|z|z*a};n/=a)while n%a<1)while n>1;t.uniq}

풀기 :

def f(num)
  factor = 1
  list = [1]
  while num != 1
    s = list
    factor += 1
    while num % factor == 0
      list = s + list.map{|z| z*factor}
      num /= factor
    end
  end
  return list
end

def g(num)
  factor = 1
  list = [1]
  while num != 1
    factor += 1
    while num % factor == 0
      list += list.map{|z| z*factor}
      num /= factor
    end
  end
  return list.uniq
end

Japt , 12 9 바이트

â mk ñÔ®×

@Shaggy 덕분에 -3 바이트

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

apt, 7 바이트

â ñ_k w

온라인으로 실행

매스 매 티카, 56 바이트

1##&@@@Tuples@Reverse[#^Range[0,#2]&@@@FactorInteger@#]&