$n$$(k_1,k_2,...,k_m)$$k_i \geqslant 2$$k_1 \cdot k_2 \cdot ... \cdot k_m = n$

Trong trường hợp bạn tò mò nơi này đến từ đâu: Sự phân tách này được gọi là phân rã nhân tố bất biến trong lý thuyết số và nó được sử dụng trong việc phân loại các nhóm Abelian được tạo ra một cách chính xác.

Thử thách

Cho đầu ra tất cả các bộ dữ liệu như vậy cho cho chính xác một lần, theo bất kỳ thứ tự nào bạn muốn. Các định dạng đầu ra trình tự tiêu chuẩn được cho phép.$n$$(k_1,k_2,...,k_m)$$n$

Ví dụ

  1: () (empty tuple)
  2: (2)
  3: (3)
  4: (2,2), (4)
  5: (5)
  6: (6)
  7: (7)
  8: (2,2,2), (2,4), (8)
  9: (3,3), (9)
 10: (10)
 11: (11)
 12: (2,6), (12)
108: (2,54), (3,3,12), (3,6,6), (3,36), (6,18), (108)

Liên quan: http://oeis.org/A000688 , Liệt kê tất cả các phân vùng nhân của n

Haskell, 66 62 60 byte

f n=[n|n>1]:[k:l:m|k<-[2..n],l:m<-f$div n k,mod(gcd n l)k<1]

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

05AB1E , 13 byte

Òœ€.œP€`êʒüÖP

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

Ò                      # prime factorization of the input
 œ€.œ                  # all partitions
     P                 # product of each sublist
      €`               # flatten
        ê              # sorted uniquified
         ʒ             # filter by:
          üÖ           #  pairwise divisible-by (yields list of 0s or 1s)
            P          #  product (will be 1 iff the list is all 1s)

Thạch , 17 byte

ÆfŒ!Œb€ẎP€€QḍƝẠ$Ƈ

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

JavaScript (V8) ,  73  70 byte

$(k_m,k_{m-1},...,k_1)$

f=(n,d=2,a=[])=>n>1?d>n||f(n,d+1,a,d%a[0]||f(n/d,d,[d,...a])):print(a)

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

Đã bình luận

f = (             // f is a recursive function taking:
  n,              //   n   = input
  d = 2,          //   d   = current divisor
  a = []          //   a[] = list of divisors
) =>              //
  n > 1 ?         // if n is greater than 1:
    d > n ||      //   unless d is greater than n,
    f(            //   do a recursive call with:
      n,          //     -> n unchanged
      d + 1,      //     -> d + 1
      a,          //     -> a[] unchanged
      d % a[0] || //     unless the previous divisor does not divide the current one,
      f(          //     do another recursive call with:
        n / d,    //       -> n / d
        d,        //       -> d unchanged
        [d, ...a] //       -> d preprended to a[]
      )           //     end of inner recursive call
    )             //   end of outer recursive call
  :               // else:
    print(a)      //   this is a valid list of divisors: print it

05AB1E , 17 15 14 byte

ѦIиæʒPQ}êʒüÖP

Rất chậm cho các trường hợp thử nghiệm lớn hơn.

-1 byte nhờ @Grimy .

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

Giải trình:

Ñ               # Get all divisors of the (implicit) input-integer
 ¦              # Remove the first value (the 1)
  Iи            # Repeat this list (flattened) the input amount of times
                #  i.e. with input 4 we now have [2,4,2,4,2,4,2,4]
    æ           # Take the powerset of this list
     ʒ  }       # Filter it by:
      PQ        #  Where the product is equal to the (implicit) input
         ê      # Then sort and uniquify the filtered lists
          ʒ     # And filter it further by:
           ü    #  Loop over each overlapping pair of values
            Ö   #   And check if the first value is divisible by the second value
             P  #  Check if this is truthy for all pairs

                # (after which the result is output implicitly)

JavaScript, 115 byte

f=(n,a=[],i=1)=>{for(;i++<n;)n%i||(a=a.concat(f(n/i).filter(e=>!(e[0]%i)).map(e=>[i].concat(e))));return n>1?a:[a]}

Tôi sẽ viết một lời giải thích sau

Ngôn ngữ Wolfram (Mathicala) , 78 76 72 71 67 byte

If[#>(p=1##2),Join@@If[i∣##,##~#0~i,{}]~Table~{i,2,#/p},{{##2}}]&

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

Cây tìm đệ quy.

Giải pháp vũ lực, 64 byte :

Union@Cases[Range@#~Tuples~#,{a__,__}/;1a==#&&a>=2&&1∣a:>{a}]&

Sửa đổi tầm thường của giải pháp Mathicala của tôi để Liệt kê tất cả các phân vùng nhân của n .

Vì điều này cần phải kiểm tra $n^n$bộ dữ liệu, hãy thử một phiên bản hiệu quả hơn bằng cách sử dụng cùng logic .

Japt , 22 byte

â Åï c à f@¥XשXäv eÃâ

Thử nó

â Åï c à f@¥XשXäv eÃâ     :Implicit input of integer U
â                          :Divisors
  Å                        :Slice off the first element, removing the 1
   ï                       :Cartesian product
     c                     :Flatten
       à                   :Combinations
         f                 :Filter by
          @                :Passing each sub-array X through the following function
           ¥               :  Test U for equality with
            X×             :  X reduced by multiplication
              ©            :  Logical AND with
               Xä          :  Consecutive pairs of X
                 v         :  Reduced by divisibility
                   e       :  All truthy?
                    Ã      :End filter
                     â     :Deduplicate