Đưa ra một danh sách các số nguyên, xuất ra số lượng hoán vị của các số nguyên, với các hoán vị không thể phân biệt được tính một lần. Nếu có nsố nguyên và mỗi nhóm số không thể phân biệt có độ dài n_i, thì đây làn! / (n_1! * n_2! * ...)

Quy tắc

• Đầu vào sẽ là một số dạng danh sách dưới dạng đối số cho hàm hoặc chương trình có 1 đến 12 số nguyên không âm.

• Đầu ra sẽ được in hoặc trả về số lượng hoán vị như mô tả ở trên.

• Không có sơ hở tiêu chuẩn hoặc chức năng tích hợp (tạo hoán vị, kết hợp, v.v.). Yếu tố được phép.

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

Đầu vào:

1, 3000, 2, 2, 8
1, 1, 1
2, 4, 3, 2, 3, 4, 4, 4, 4, 4, 1, 1

Đầu ra:

60
1
83160

Python, 48 byte

f=lambda l:l==[]or len(l)*f(l[1:])/l.count(l[0])

Một thực hiện đệ quy.

Trong công thức, n! / (n_1! * n_2! * ...)nếu chúng ta loại bỏ phần tử đầu tiên (giả sử nó 1), số lượng hoán vị cho các n-1phần tử còn lại là

(n-1)! / ((n_1-1)! * n_2! * ...) ==
n! / n / (n_1! / n_1! * n_2! * ...) == 
n/n_1 * (n! / (n_1! * n_2! * ...)`)

Vì vậy, chúng tôi nhận được câu trả lời bằng cách nhân n/n1với phần tử đối ứng của các phần tử bằng với phần tử đầu tiên, bằng kết quả đệ quy cho phần còn lại của danh sách. Danh sách trống cho trường hợp cơ sở là 1.

MATL , 14 13 12 byte

fpGu"@G=s:p/

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

Giải trình

Cách tiếp cận rất giống với câu trả lời của @ Adnan .

f       % Take input implicitly. Push array of indices of nonzero entries.
        % This gives [1 2 ... n] where n is input length.
p       % Product (compute factorial)
Gu      % Push input. Array of its unique elements
"       % For each of those unique values
  @     %   Push unique value of current iteration
  G=s   %   Number of times (s) it's present (=) in the input (G)
  :p    %   Range, product (compute factorial)
  /     %   Divide
        % End for each implicitly. Display implicitly

05AB1E , 15 14 13 byte

Mã số:

D©g!rÙv®yQO!/

Giải trình:

               # implicit input
D©             # duplicate and save a copy to register
  g!           # factorial of input length (total nr of permutations without duplicates)
    rÙv        # for each unique number in input
       ®yQO!   # factorial of number of occurances in input
            /  # divide total nr of permutations by this
               # implicit output

Sử dụng mã hóa CP-1252 .

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

JavaScript (ES6), 64 61 byte

a=>a.sort().map((x,i)=>r=r*++i/(x-y?(y=x,c=1):++c),y=r=-1)|-r

Sử dụng công thức đã cho, ngoại trừ việc tính toán từng yếu tố tăng dần (ví dụ như các phép tính r=r*++ihiệu quả n!).

Chỉnh sửa: Ban đầu tôi chấp nhận bất kỳ số hữu hạn nào nhưng tôi đã lưu 3 byte khi @ user81655 chỉ ra rằng tôi chỉ cần hỗ trợ các số nguyên dương (mặc dù tôi thực sự chấp nhận các số nguyên không âm).

Bình thường, 11 byte

/.!lQ*F/V._

Bộ kiểm tra

Sử dụng công thức tiêu chuẩn n! / (count1! * count2! * ...), ngoại trừ các giai thừa của các số đếm được tìm thấy bằng cách đếm số lần mỗi phần tử xảy ra trong tiền tố dẫn đến đó, sau đó nhân tất cả các số đó với nhau.

Giải trình:

/.!lQ*F/V._
/.!lQ*F/V._QQ    Implicit variable introduction.
                 Q = eval(input())
         ._Q     Form all prefixes of the input.
       /V   Q    Count how many times each element occurs in the prefix
                 ending with that element.
     *F          Fold on multiplication - take the product.
 .!lQ            Take the factorial of the input length
/                Divide.

Pyth - 14 12 byte

/F.!M+lQ/LQ{

Phòng thử nghiệm .

Ruby, 75 74 byte

Kinda ước rằng Mathmô-đun của Ruby có chức năng giai thừa nên tôi không phải tự xây dựng.

->l{f=->x{x<2?1:x*f[x-1]};l.uniq.map{|e|f[l.count e]}.inject f[l.size],:/}

CJam, 17 byte

q~_,\$e`0f=+:m!:/

Kiểm tra nó ở đây.

Giải trình

q~   e# Read input and evaluate.
_,   e# Duplicate and get length.
\$   e# Swap with other copy and sort it.
e`   e# Run-length encode. Since the list is sorted, this tallies the numbers.
0f=  e# Select the tally of each number.
+    e# Prepend the length of the input.
:m!  e# Compute the factorial of each number in the list.
:/   e# Fold division over it, which divides each factorial of a tally into
     e# the factorial of the length.

Thạch, 8 byte

W;ĠL€!:/

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

W;ĠL€!:/ example input:             [1, 3000, 2, 2, 8]
W        wrap:                      [[1, 3000, 2, 2, 8]]
  Ġ      group index by appearance: [[1], [3, 4], [5], [2]]
 ;       concatenate:               [[1, 3000, 2, 2, 8], [1], [3, 4], [5], [2]]
   L€    map by length:             [5, 1, 2, 1, 1]
     !   [map by] factorial:        [120, 1, 2, 1, 1]
      :/ reduce by division:        120÷1÷2÷1÷1 = 60

J, 13 byte

#(%*/)&:!#/.~

Sử dụng

   f =: #(%*/)&:!#/.~
   f 1 3000 2 2 8
60
   f 1 1 1
1
   f 2 4 3 2 3 4 4 4 4 4 1 1
83160

Giải trình

#(%*/)&:!#/.~  Input: A
         #/.~  Partition A by equal values and get the size of each, these are the tallies
#              Get the size of A
      &:!      Take the factorial of both the size and the tallies
   */          Reduce using multiplication the factorial of the tallies
  %            Divide the factorial of the size by that product and return