Bài tập

Cho 2 số nguyên dương nvà k, trong đó n > k, xuất số lần xuất từ ​​một tập hợp các nphần tử có thể phân biệt thành một tập hợp các kphần tử có thể phân biệt.

Định nghĩa

Hàm f: S → T được gọi là từ chối nếu với mọi t∈T có s∈S sao cho f (s) = t.

Thí dụ

Khi n=3và k=2, đầu ra là 6, vì có 6sự thay đổi từ {1,2,3}đến {1,2}:

1. 1↦1, 2↦1, 3↦2
2. 1↦1, 2↦2, 3↦1
3. 1↦1, 2↦2, 3↦2
4. 1↦2, 2↦1, 3↦1
5. 1↦2, 2↦1, 3↦2
6. 1↦2, 2↦2, 3↦1

Tủ thử

n k output
5 3 150
8 4 40824
9 8 1451520

Tài liệu tham khảo

• OEIS A019538

Chấm điểm

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Tiêu chuẩn áp dụng.

Thạch , 5 4 byte

ṗṬML

Đây là một giải pháp vũ lực O (k ⁿ ) .

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

Làm thế nào nó hoạt động

ṗṬML  Main link. Left argument: k. Right argument: n.

ṗ     Cartesian power; yield the list of all n-tuples over {1, ..., k}.
      Each tuple represents a (not necessarily surjective) function from
      {1, ..., n} to {1, ..., k}.
 Ṭ    Apply the "untruth" atom to each tuple.
      Ṭ maps a list of indices to an array with 1's at those indices, and exactly
      as many zeroes as needed to build the array.
      Examples:
           [1, 2, 3, 3, 3] -> [1, 1, 1]
           [1, 3, 5]       -> [1, 0, 1, 0, 1]
           [2, 6, 2, 4, 4] -> [0, 1, 0, 1, 0, 1]
  M   Yield all indices of maximal elements, i.e., all indices of [1] * k.
   L  Take the length.

Haskell , 48 byte

s(_,1)=1
s(1,_)=0
s(m,n)=n*(s(m-1,n-1)+s(m-1,n))

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

Tại sao số lượng từ chối s(m,n)=n*s(m-1,n-1)+n*s(m-1,n)?

để thu hoạch nhình ảnh, tôi có thể

• siết một [m]sáng tạo đơn lẻ vào bất kỳ nranh giới nào xung quanh n-1các nhóm
• hoặc thêm cái mới của tôi mvào bất kỳ nhóm nào nđã có[1..m-1]

Haskell , 38 byte

m#n|n<2=1|m<2=0|o<-m-1=n*(o#(n-1)+o#n)

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

Lean , 66 byte

def s:_->nat->nat|(m+1)(n+1):=(n+1)*(s m n+s m(n+1))|0 0:=1|_ _:=0

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

Bằng chứng chính xác

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

Giải trình

Hãy để chúng tôi ungolf chức năng:

def s : nat->nat->nat
| (m+1) (n+1) := (n+1)*(s m n + s m (n+1))
| 0     0     := 1
| _     _     := 0

Hàm được xác định bởi khớp mẫu và đệ quy, cả hai đều có hỗ trợ tích hợp.

Chúng tôi xác định s(m+1, n+1) = (n+1) * (s(m, n) + s(m, n+1)và s(0, 0) = 1, để lại mở s(m+1, 0)và s(0, n+1), cả hai đều được xác định là 0trường hợp cuối cùng.

Nạc sử dụng cú pháp lamdba calculus, vì vậy s m nlà s(m, n).

Bây giờ, bằng chứng về sự đúng đắn: tôi đã nêu nó theo hai cách:

def correctness : ∀ m n, fin (s m n) ≃ { f : fin m → fin n // function.surjective f } :=
λ m, nat.rec_on m (λ n, nat.cases_on n s_zero_zero (λ n, s_zero_succ n)) $
λ m ih n, nat.cases_on n (s_succ_zero m) $ λ n,
calc fin (s (nat.succ m) (nat.succ n))
   ≃ (fin (n + 1) × (fin (s m n + s m (n + 1)))) :
  (fin_prod _ _).symm
... ≃ (fin (n + 1) × (fin (s m n) ⊕ fin (s m (n + 1)))) :
  equiv.prod_congr (equiv.refl _) (fin_sum _ _).symm
... ≃ (fin (n + 1) × ({f : fin m → fin n // function.surjective f} ⊕
         {f : fin m → fin (n + 1) // function.surjective f})) :
  equiv.prod_congr (equiv.refl _) (equiv.sum_congr (ih n) (ih (n + 1)))
... ≃ {f // function.surjective f} : s_aux m n

def correctness_2 (m n : nat) : s m n = fintype.card { f : fin m → fin n // function.surjective f } :=
by rw fintype.of_equiv_card (correctness m n); simp

Điều đầu tiên là những gì đang thực sự diễn ra: một sự lựa chọn giữa [0 ... s(m, n)-1]và sự từ bỏ từ [0 ... m-1]trên xuống [0 ... n-1].

Cái thứ hai là cách nó thường được nêu, đó s(m, n)là tính chính xác của các từ đầu [0 ... m-1]ra [0 ... n-1].

Lean sử dụng lý thuyết loại làm nền tảng của nó (thay vì lý thuyết tập hợp). Trong lý thuyết loại, mọi đối tượng đều có một loại vốn có của nó. natlà loại số tự nhiên và câu lệnh 0là số tự nhiên được biểu thị là 0 : nat. Chúng ta nói rằng 0là loại nat, và đó natcó 0là một cư dân.

Các đề xuất (tuyên bố / khẳng định) cũng là loại: cư dân của họ là một bằng chứng của các đề xuất.

• def: Chúng tôi sẽ giới thiệu một định nghĩa (bởi vì một bijection thực sự là một chức năng, không chỉ là một đề xuất).

• correctness: tên của định nghĩa

• ∀ m n: cho mọi mvà n(Lean tự động cho rằng loại của chúng là natvì những gì tiếp theo).

• fin (s m n)là loại số tự nhiên nhỏ hơn s m n. Để làm cho một cư dân, người ta cung cấp một số tự nhiên và một bằng chứng rằng nó nhỏ hơn s m n.

• A ≃ B: bijection giữa loại Avà loại B. Nói bijection là sai lệch, vì người ta thực sự phải cung cấp chức năng nghịch đảo.

• { f : fin m → fin n // function.surjective f }các loại từ trên fin mđến fin n. Cú pháp này xây dựng một kiểu con từ loại fin m → fin n, tức là loại hàm từ fin mđến fin n. Cú pháp là { var : base type // proposition about var }.

• λ m: ∀ var, proposition / type involving varthực sự là một hàm lấy varđầu vào, vì vậy λ mgiới thiệu đầu vào. ∀ m n,là tay ngắn cho∀ m, ∀ n,

• nat.rec_on m: làm đệ quy trên m. Để xác định một cái gì đó cho m, xác định điều cho 0và sau đó đưa ra điều cho k, xây dựng điều cho k+1. Người ta sẽ nhận thấy rằng điều này tương tự như cảm ứng, và thực sự đây là kết quả của sự tương ứng của Church-Howard . Cú pháp là nat.rec_on var (thing when var is 0) (for all k, given "thing when k is k", build thing when var is "k+1").

Heh, điều này đang trở nên dài và tôi chỉ ở dòng thứ ba của correctness...

J , 19 byte

-/@(^~*]!0{])],i.@-

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

Giải trình

-/@(^~*]!0{])],i.@-  Input: n (LHS), k (RHS)
                  -  Negate k
               i.@   Range [k-1, k-2, ..., 0]
             ]       Get RHS
              ,      Join, forms [k, k-1, ..., 0]
   (        )        Dyad between n (LHS), [k, k-1, ..., 0] (RHS)
           ]           Get RHS
         0{            Select value at index 0
       ]               Get RHS
        !              Binomial coefficient
    ^~                 Raise each in RHS to power of n
      *                Multiply
-/@                  Reduce from right to left using subtraction (forms alternating sum)

R , 49 byte

function(n,k,j=0:k)((-1)^(k-j)*j^n)%*%choose(k,j)

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

Thực hiện một trong những công thức của Mario Catalani:

T(n, k) = Sum_{j=0..k} (-1)^(k-j)*j^n*binomial(k, j)

hoặc luân phiên:

T(n, k) = Sum_{j=0..k} (-1)^j*binomial(k, j)*(k-j)^n

mang lại số byte tương tự trong R.

Python 2 , 56 53 50 byte

f=lambda n,k:n/k and(1/k or f(n-1,k-1)+f(n-1,k))*k

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

-3 byte nhờ H.PWiz.

-3 byte nhờ Dennis.

• Nếu n<kkhông phải tất cả kcó thể được ánh xạ lên do đó không có sự thay thế. n/k andquan tâm đến điều này.
• Lấy f(0,0)=1cho chúng tôi trường hợp cơ sở duy nhất khác không chúng tôi cần. 1/k orđạt được điều này.

Ruby , 46 byte

f=->n,k{k>n ?0:k+n<1?1:k*(f[n-=1,k]+f[n,k-1])}

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

Phương pháp đệ quy tiêu chuẩn ...

Brain-Flak , 142 byte

({}<({}()){({}[(())]<<>{({}({})<>)<>}{}>)}{}>)<>{<>(({}<>)<{({}[()]<([])({([{}]()({}))([{}]({}))}{}[{}])>)}{}({}<>)>)<>}<>{}{}{({}<>[{}])<>}<>

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

Điều này sử dụng công thức loại trừ bao gồm tiêu chuẩn.

Tôi không thể viết một lời giải thích đầy đủ tại thời điểm này, nhưng đây là một lời giải thích cấp cao:

# Compute k-th row of Pascal's triangle
({}<({}()){({}[(())]<<>{({}({})<>)<>}{}>)}{}>)<>

# Multiply each element by n^j (and reverse to other stack)
{<>(({}<>)<{({}[()]<([])({([{}]()({}))([{}]({}))}{}[{}])>)}{}({}<>)>)<>}

# Compute alternating sum
<>{}{}{({}<>[{}])<>}<>

Pari / GP , 38 byte

(n,k)->Pol(exp(x+O(x^n))-1)^k*n!\x^n%x

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

Sử dụng công thức của Vladimir Kruchinin trên OEIS:

E.g.f.: (exp(x)-1)^k = sum T(n,k)x^n/n!

Husk , 7 byte

#`¦ḣ¹π²

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

Giải trình

#`¦ḣ¹π²  Inputs: n (²), implicit k (¹)
     π²  Cartesian power of [1..k] to n
#        Count if:
   ḣ¹      Range [1..k]
 `¦        Is a subset

JavaScript (Node.js) , 43 byte

T=(n,k)=>n<k?0:k+n<1||k*(T(--n,k)+T(n,k-1))

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

05AB1E , 10 byte

sLsãʒêgQ}g

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

Giải trình

sLsã       # Cartesian product of range(k) repeated n times
    ʒ   }  # Filter by ...
     êgQ   # Connected uniquified length == k  (every item in range(k) appears at least once)
         g # Count