정수 목록이 주어지면 구별 할 수없는 순열이 한 번 계산 된 정수의 순열 수를 출력합니다. 이 경우 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

파이썬, 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 인코딩을 사용합니다 .

온라인으로 사용해보십시오! .

자바 스크립트 (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!).

편집 : 원래 유한 수를 허용했지만 @ user81655가 양의 정수만 지원해야한다고 지적했을 때 3 바이트를 절약했습니다 (실제로 음이 아닌 정수를 허용하지만).

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{

테스트 스위트 .

루비, 75 74 바이트

Kinda는 Ruby의 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