排列组合

复制import math

# 阶乘：n!
n = 5
fact = math.factorial(n)
print(f"{n}! = {fact}")  # 120

# 排列数 P(n,k) = n! / (n-k)!
n, k = 5, 3
perm = math.perm(n, k)
print(f"P({n},{k}) = {perm}")  # 60

# 组合数 C(n,k) = n! / (k! * (n-k)!)
comb = math.comb(n, k)
print(f"C({n},{k}) = {comb}")  # 10

# 大数阶乘（Python 自动支持大整数）
big_n = 100
big_fact = math.factorial(big_n)
print(f"{big_n}! 有 {len(str(big_fact))} 位")  # 158 位

复制package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 阶乘：n!（使用 big.Int 支持大数）
	n := int64(5)
	fact := new(big.Int).MulRange(1, n)
	fmt.Printf("%d! = %s\n", n, fact.String()) // 120

	// 排列数 P(n,k) = n! / (n-k)!
	n, k := int64(5), int64(3)
	nFact := new(big.Int).MulRange(1, n)
	nkFact := new(big.Int).MulRange(1, n-k)
	perm := new(big.Int).Div(nFact, nkFact)
	fmt.Printf("P(%d,%d) = %s\n", n, k, perm.String()) // 60

	// 组合数 C(n,k) = n! / (k! * (n-k)!)
	kFact := new(big.Int).MulRange(1, k)
	comb := new(big.Int).Div(perm, kFact)
	fmt.Printf("C(%d,%d) = %s\n", n, k, comb.String()) // 10

	// 大数阶乘
	bigN := int64(100)
	bigFact := new(big.Int).MulRange(1, bigN)
	fmt.Printf("%d! 有 %d 位\n", bigN, len(bigFact.String())) // 158 位
}

复制// 阶乘：n!（支持大整数 BigInt）
function factorial(n) {
  let result = 1n;
  for (let i = 2n; i <= BigInt(n); i++) result *= i;
  return result;
}

const n = 5;
console.log(`${n}! = ${factorial(n)}`); // 120n

// 排列数 P(n,k) = n! / (n-k)!
function perm(n, k) {
  return factorial(n) / factorial(n - k);
}

const pn = 5, pk = 3;
console.log(`P(${pn},${pk}) = ${perm(pn, pk)}`); // 60n

// 组合数 C(n,k) = n! / (k! * (n-k)!)
function comb(n, k) {
  return factorial(n) / (factorial(k) * factorial(n - k));
}

const cn = 5, ck = 3;
console.log(`C(${cn},${ck}) = ${comb(cn, ck)}`); // 10n

// 大数阶乘（100!）
const bigN = 100;
const bigFact = factorial(bigN);
console.log(`${bigN}! 有 ${bigFact.toString().length} 位`); // 158 位