Cho đầu vào của một số nguyên ≥ 2, xuất ra một danh sách các ước của nó được sắp xếp theo số mũ theo các thừa số nguyên tố của chúng, theo thứ tự tăng dần, sắp xếp trước theo số nguyên tố lớn nhất, sau đó theo số lớn thứ hai, v.v.

Lấy ví dụ, lấy số nguyên 72, là 2 ³ 3 ² . Nó có các ước số

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

Khi được sắp xếp theo thứ tự tăng dần theo số mũ trên các thừa số nguyên tố, với các số nguyên tố lớn hơn được ưu tiên, điều này trở thành

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

Lưu ý rằng danh sách được sắp xếp trước theo thứ tự số mũ của 3 và sau đó theo số mũ của 2. Bạn cũng có thể nghĩ về điều này như đọc từ trái sang phải và từ trên xuống dưới qua lưới sau:

        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

Các trường hợp thử nghiệm:

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

Vì đây là mã golf , mã ngắn nhất tính bằng byte sẽ thắng.

05AB1E , 6 byte

Mã số:

ÑÒí{€P

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Thạch , 8 7 byte

ÆDÆfU$Þ

Hãy thử trực tuyến! Cảm ơn @Dennis cho -1 byte.

Æ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

Bình thường, 10 byte

+1{*Mt_DyP

Dùng thử trực tuyến: Trình diễn

Đáng buồn là sản phẩm trong danh sách trống không được xác định là 1 trong Pyth. Điều này có giá ba byte thêm.

Giải trình:

+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

Thạch , 12 10 byte

2 byte nhờ @ Sp3000.

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

Hãy thử trực tuyến!

Bộ thử nghiệm.

Æ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

Tín dụng cho @ Sp3000 để đưa ra định dạng của lời giải thích.

Python 2, 85 byte

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

Không có yếu tố, không phân loại. Thực hiện đệ quy cùng chiều dài:

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:]]

Trên thực tế, 19 byte

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

Hãy thử trực tuyến!

Giải trình:

;÷#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

JavaScript, 78 byte

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)

Dựa trên ý tưởng của @ xnor, mặc dù tôi không hiểu mã của anh ấy nên tôi phải thực hiện lại từ đầu. Thuật toán cơ bản là bạn bắt đầu với [1] và nhân với [1, ..., pᵏ] cho mỗi pᵏ trong hệ số nguyên tố của n, mặc dù vì tôi không có yếu tố chính hoặc sản phẩm cartesian nên tôi phải làm điều đó Tất cả đệ quy. Thí dụ:

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 byte

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

Điều này sẽ không hiệu quả như quái vì tôi hầu như không chống lại sự cám dỗ của việc sử dụng library(primes). Nó tạo ra một vectơ dcủa tất cả các thừa số nguyên tố của đầu vào, tính toán tần số của chúng (số lần xuất hiện) và sau đó tính sản phẩm cartesian của tất cả các công suất có thể (từ 0 đến tần số tương ứng b[i]), theo đó prodhàm được áp dụng. Dang nó, trường hợp đặc biệt của 2 và 3! Mặt khác, đây là một ví dụ hay về xử lý khung dữ liệu R và các hàm vectơ / hoạt động theo hàng (và thậm chí là tablehàm thống kê thuần túy !).

Tất nhiên, hiệu quả của nó có thể được cải thiện với chi phí 15 byte bằng cách sử dụng r=2:ceiling(sqrt(n)), nếu có ai đó quan tâm. Đây là một phiên bản chưa được chỉnh sửa đẹp hơn:

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

Toán học 150 byte

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

Brachylog , 3 byte

fḋᵒ

Hãy thử trực tuyến!

Mã đọc ít nhiều giống như tiêu đề của thách thức: "các yếu tố của đầu vào, được sắp xếp theo phân tách chính của chúng". Đảm bảo rằng vẻ đẹp 3 byte này thực sự đã vượt qua các trường hợp thử nghiệm chỉ sử dụng ý nghĩa tích hợp sẵn của Brachylog về cách sắp xếp danh sách yêu cầu tôi sao chép và dán tất cả nhiều số đó vào Clojure REPL, trong đó các thành phần danh sách được phân tách bằng khoảng trắng và dấu phẩy là khoảng trắng, nhưng hóa ra nó thực sự hoạt động.

APL (Dyalog Extended) , 17 byte

Rất cám ơn ngn và Adám vì sự giúp đỡ của họ trong việc chơi golf cả hai chương trình APL này trong The APL Orchard , một nơi tuyệt vời để học APL và nhận trợ giúp APL.

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

Hãy thử trực tuyến!

Ungolfing

∊×⍀/⌽{⊂×\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 byte ^SBCS

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

Hãy thử trực tuyến!

Ungolfing

{∊∘.×/⌽{⊂×\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 byte

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

Lấy danh sách các số nguyên tố và số mũ của số nguyên đầu vào, đảo ngược từng số nguyên và xây dựng các ước số từ đó.

Sử dụng

   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

Giải trình

[:(*/@#~>:#:[: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

Ruby, 71 byte

Câu trả lời này dựa trên câu trả lời Python 2 của xnor.

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

Một thay thế có cùng độ dài là:

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

Ungolfing:

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 byte

â mk ñÔ®×

-3 byte nhờ @Shaggy

Hãy thử trực tuyến!

Japt, 7 byte

â ñ_k w

Chạy nó trực tuyến

Toán học, 56 byte

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