กำหนดอินพุตของจำนวนเต็ม≥ 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$Þ

ลองออนไลน์! ขอบคุณ @Dennis สำหรับ -1 ไบต์

Æ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

ลองใช้งานออนไลน์: การสาธิต

น่าเศร้าที่ผลิตภัณฑ์ในรายการว่างเปล่าไม่ได้ถูกกำหนดเป็น 1 ใน Pyth ค่าใช้จ่ายเพิ่มเติมสามไบต์

คำอธิบาย:

+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 ไบต์

2 ไบต์ขอบคุณ @ Sp3000

Æ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 สำหรับการจัดรูปแบบของคำอธิบาย

Python 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

JavaScript, 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 แม้ว่าฉันจะไม่เข้าใจรหัสของเขาดังนั้นฉันจึงต้องนำมันมาใช้ใหม่ตั้งแต่ต้น อัลกอริทึมพื้นฐานคือคุณเริ่มต้นด้วย [1] และคูณด้วย [1, ... , pᵏ] สำหรับแต่ละpᵏในการแยกตัวประกอบเฉพาะของ n แม้ว่าในขณะที่ฉันไม่มีการแยกตัวประกอบเฉพาะหรือผลิตภัณฑ์คาร์ทีเซียนฉันต้องทำ ทั้งหมดซ้ำ ตัวอย่าง:

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 dataframe และฟังก์ชั่นเวกเตอร์ / การดำเนินการต่อแถว (และแม้แต่tableฟังก์ชั่นทางสถิติอย่างหมดจด!)

แน่นอนว่าประสิทธิภาพของมันนั้นสามารถปรับปรุงได้โดยเสียค่าใช้จ่าย 15 ไบต์r=2:ceiling(sqrt(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
  }
}

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 ไบต์

ขอบคุณมากสำหรับ ngn และAdámสำหรับความช่วยเหลือในการตีกอล์ฟทั้งสองโปรแกรม APL ในAPL Orchardที่เหมาะสำหรับการเรียนรู้ APL และรับความช่วยเหลือ APL

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

ลองออนไลน์!

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 ไบต์^SBCS

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

ลองออนไลน์!

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 ไบต์

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

Ruby, 71 ไบต์

คำตอบนี้ขึ้นอยู่กับคำตอบ Python 2 ของ 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}

ทางเลือกความยาวเดียวกันคือ:

->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 ไบต์

â mk ñÔ®×

-3 ไบต์ขอบคุณ @Shaggy

ลองออนไลน์!

Japtap, 7 ไบต์

â ñ_k w

เปิดใช้งานออนไลน์

Mathematica, 56 ไบต์

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