ให้ลิสต์ของจำนวนเต็มเอาท์พุทจำนวนพีชคณิตของจำนวนเต็มกับพีชคณิตเรียงกันไม่ได้นับครั้งเดียว หากมีnจำนวนเต็มและแต่ละกลุ่มของตัวเลขที่แยกไม่ออกมีความยาวn_iนี่คือn! / (n_1! * n_2! * ...)

กฎระเบียบ

• อินพุตจะเป็นรูปแบบของรายการบางรายการเป็นอาร์กิวเมนต์ของฟังก์ชันหรือโปรแกรมที่มีจำนวนเต็ม 1 ถึง 12 ที่ไม่ใช่ค่าลบ

• ผลลัพธ์จะเป็นการพิมพ์หรือคืนจำนวนการเรียงสับเปลี่ยนตามที่อธิบายไว้ข้างต้น

• ไม่มีช่องโหว่มาตรฐานหรือฟังก์ชั่นในตัว (สร้างการเรียงสับเปลี่ยนชุดค่าผสม ฯลฯ ) อนุญาตให้ใช้แฟกทอรี

กรณีทดสอบ

ปัจจัยการผลิต:

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

ขาออก:

60
1
83160

Python ขนาด 48 ไบต์

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

การใช้งานแบบเรียกซ้ำ

ในสูตรn! / (n_1! * n_2! * ...)ถ้าเราลบองค์ประกอบแรก (บอกว่ามัน1) จำนวนการเปลี่ยนแปลงสำหรับn-1องค์ประกอบที่เหลืออยู่คือ

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

ดังนั้นเราจึงได้คำตอบโดยการคูณด้วยn/n1องค์ประกอบส่วนกลับซึ่งเท่ากับส่วนแรกโดยผลการเรียกซ้ำสำหรับส่วนที่เหลือของรายการ รายการว่างให้ตัวพิมพ์ใหญ่ของ 1

MATL , 14 13 12 ไบต์

fpGu"@G=s:p/

ลองออนไลน์!

คำอธิบาย

วิธีการนี้คล้ายกับคำตอบของ @ 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 ไบต์

รหัส:

D©g!rÙv®yQO!/

คำอธิบาย:

               # 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

ใช้การเข้ารหัสCP-1252

ลองออนไลน์! .

JavaScript (ES6), 64 61 ไบต์

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

ใช้สูตรที่กำหนดยกเว้นการคำนวณแต่ละแฟคทอเรียลที่เพิ่มขึ้น (เช่นตัวอย่างการr=r*++iคำนวณอย่างมีประสิทธิภาพn!)

แก้ไข: เดิมฉันยอมรับหมายเลขที่ จำกัด แต่ฉันบันทึก 3 ไบต์เมื่อ @ user81655 ชี้ให้เห็นว่าฉันต้องการเพียงเพื่อสนับสนุนจำนวนเต็มบวก (แม้ว่าจริง ๆ แล้วฉันยอมรับจำนวนเต็มไม่เป็นลบ)

Pyth, 11 ไบต์

/.!lQ*F/V._

ชุดทดสอบ

ใช้สูตรมาตรฐานn! / (count1! * count2! * ...)ยกเว้นว่ามีการพบแฟคทอเรียลของการนับโดยการนับจำนวนครั้งที่แต่ละองค์ประกอบเกิดขึ้นในคำนำหน้าที่นำไปสู่การนั้นแล้วคูณตัวเลขทั้งหมดเข้าด้วยกัน

คำอธิบาย:

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

/F.!M+lQ/LQ{

Test Suite

Ruby, 75 74 ไบต์

Kinda หวังว่าMathโมดูลของรูบี้จะมีฟังก์ชันแบบแฟคทอเรียลดังนั้นฉันจึงไม่ต้องสร้างเอง

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

CJam, 17 ไบต์

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

ทดสอบที่นี่

คำอธิบาย

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.

เยลลี่ 8 ไบต์

W;ĠL€!:/

ลองออนไลน์!

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

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

การใช้

   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

คำอธิบาย

#(%*/)&:!#/.~  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