P _k (n) berarti jumlah partisi nmenjadi kbagian-bagian yang tepat . Diberikan ndan k, hitung P _k (n).

Kiat: P _k (n) = P _k (n − k) + P _{k − 1} (n − 1), dengan nilai awal p ₀ (0) = 1 dan p _k (n) = 0 jika n ≤ 0 atau k ≤ 0. ^[Wiki]

Contohnya

n    k    Ans
1    1    1
2    2    1
4    2    2
6    2    3
10   3    8

Aturan

• Aturan golf-kode umum berlaku.

Pyth , 9 7 6 byte

^{-1 byte terima kasih kepada Erik the Outgolfer !}

/lM./E

Cobalah online!

Input ke program dibalik (yaitu k, n).

Swift , 76 73 byte

func P(_ n:Int,_ k:Int)->Int{return n*k>0 ?P(n-k,k)+P(n-1,k-1):n==k ?1:0}

Cobalah online!

Penjelasan

Bagaimana cara kerja kode secara struktural?

Pertama-tama, kita mendefinisikan fungsi kita P, dengan dua parameter bilangan bulat ndan k, dan memberikan jenis kembalinya Int, dengan potongan kode ini: func P(_ n:Int,_ k:Int)->Int{...}. Trik keren di sini adalah bahwa kita memberi tahu kompiler untuk mengabaikan nama-nama parameter, dengan _diikuti oleh spasi, yang menyelamatkan kita dua byte ketika kita memanggil fungsi. returnjelas digunakan untuk mengembalikan hasil terner bersarang kami yang dijelaskan di bawah ini.

Trik lain yang saya gunakan adalah n*k>0, yang menyelamatkan kita beberapa byte n>0&&k>0. Jika kondisinya benar (kedua bilangan bulat masih lebih tinggi dari 0), maka kami secara rekursif memanggil fungsi kami dengan ndikurangi oleh ksebagai yang baru ndan ktetap sama, dan kami menambahkan hasil P()dengan ndan kdikurangi dengan 1. Jika kondisi tersebut tidak benar , kami mengembalikan salah satu 1atau 0bergantung pada apakah nsama dengan k.

Bagaimana cara kerja algoritma rekursif?

Kita tahu bahwa elemen pertama dari urutan adalah p ₀ (0) , dan kami memeriksa bahwa kedua bilangan bulat positif ( n*k>0). Jika mereka tidak lebih tinggi dari 0, kami memeriksa apakah mereka sama ( n==l ?1:0), di sini menjadi dua kasus:

• Tepat ada 1 partisi yang mungkin, dan dengan demikian kita mengembalikan 1, jika bilangan bulat sama.

• Tidak ada partisi jika salah satunya sudah 0 dan yang lainnya belum.

Namun, jika keduanya positif, kami memanggil Pdua kali secara rekursif , menambahkan hasil P(n-k,k)dan P(n-1,k-1). Dan kita mengulang lagi sampai nmencapai 0.

_{* Catatan: Spasi tidak dapat dihapus.}

Jelly , 6 byte

œċS€ċ⁸

Cobalah online!

Python 2 , 61 55 51 50 byte

-10 byte terima kasih kepada Erik the Outgolfer. -1 byte terima kasih kepada Tn. Xcoder.

Saya akan mengatakan, saya menyalin petunjuk dari OP dan menerjemahkannya ke Python. : P

P=lambda n,k:n*k>0and P(n-k,k)+P(n-1,k-1)or+(n==k)

Cobalah online!

Mathematica, 33 byte

Length@IntegerPartitions[#,{#2}]&

di sini adalah tabel nxk

 \k->
 n1  0  0   0   0   0   0   0   0   0  
 |1  1  0   0   0   0   0   0   0   0  
 v1  1  1   0   0   0   0   0   0   0  
  1  2  1   1   0   0   0   0   0   0  
  1  2  2   1   1   0   0   0   0   0  
  1  3  3   2   1   1   0   0   0   0  
  1  3  4   3   2   1   1   0   0   0  
  1  4  5   5   3   2   1   1   0   0  
  1  4  7   6   5   3   2   1   1   0  
  1  5  8   9   7   5   3   2   1   1  

JavaScript (ES6), 42 40 39 byte

Saya pikir ini berhasil.

f=(x,y)=>x*y>0?f(x-y,y)+f(--x,--y):x==y

Cobalah

k.value=(
f=(x,y)=>x*y>0?f(x-y,y)+f(--x,--y):x==y
)(i.value=10,j.value=3)
onchange=_=>k.value=f(+i.value,+j.value)

*{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}#j,#k{width:50px;}

<label for=i>n: </label><input id=i type=number><label for=j>k: </label><input id=j type=number><label for=k>P<sub>k</sub>(n): </label><input id=k readonly>

MATL , 14 byte

y:Z^!S!Xu!Xs=s

Cobalah online!

Penjelasan

Pertimbangkan input 6, 2.

y     % Implicitly take the two inputs. Duplicate from below
      % STACK: 6, 2, 6
:     % Range
      % STACK: 6, 2, [1 2 3 4 5 6]
Z^    % Cartesian power
      % STACK: 6, [1 1; 1 2; ... 1 5; 1 6; 2 1; 2 2; ...; 6 6]
!S!   % Sort each row
      % STACK: 6, [1 1; 1 2; ... 1 5; 1 6; 1 2; 2 2; ...; 6 6]
Xu    % Unique rows
      % STACK: 6, [1 1; 1 2; ... 1 5; 1 6; 2 2; ...; 6 6]
!Xs   % Sum of each row, as a row vector
      % STACK: 6, [2 3 ... 6 7 4 ... 12]
=     % Equals, element-wise
      % STACK: [0 0 ... 1  0 0 ... 0]
s     % Sum. Implicitly display
      % STACK: 3

Haskell, 41 byte

0#0=1
n#k|n*k>0=(n-k)#k+(n-1)#(k-1)
_#_=0

Cobalah online!

Haskell , 41 byte

n&0=0^n
n&k=sum$map(&(k-1))[n-1,n-k-1..0]

Cobalah online!

Perulangan alternatif.

Pari / GP , 35 byte

Pari / GP memiliki built-in untuk iterasi partisi integer.

n->k->i=0;forpart(x=n,i++,,[k,k]);i

Cobalah online!

Jelly , 13 byte

Saya merasa tahu pendekatan dasar ini tidak akan menjadi golfiest!

RŒṖL€€Ṣ€QṀ€=S

Cobalah online!

05AB1E , 9 byte

L²ã€{ÙO¹¢

Cobalah online!

CJam , 18 byte

{_,:)@m*:$_&::+e=}

Cobalah online!

Mengharapkan input terbalik, yaitu k nbukannya n k.

Scala , 73 byte

Nah ini adalah beberapa penggunaan tip OP yang bebas unorkorked.

kdan nmerupakan parameter fungsi rekursif saya f. Lihat tautan TIO untuk konteks.

Karena ini bersifat rekursif, haruskah saya menyertakan fungsi def dalam jumlah byte?

(k,n)match{case(0,0)=>1
case _ if k<1|n<1=>0
case _=>f(n-k,k)+f(n-1,k-1)}

Cobalah online!

C (gcc) , 41 byte

f(n,k){n=n*k>0?f(n-k,k)+f(--n,--k):n==k;}

Cobalah online!

R (+ pryr), 49 byte

f=pryr::f(`if`(k<1|n<1,!n+k,f(n-k,k)+f(n-1,k-1)))

Yang mengevaluasi fungsi rekursif

function (k, n) 
if (k < 1 | n < 1) !n + k else f(n - k, k) + f(n - 1, k - 1)

(k < 1 | n < 1)memeriksa apakah ada kondisi awal terpenuhi. !n + kmengevaluasi ke TRUE (1) jika keduanya ndan k0, dan FALSE (0) sebaliknya. f(n - k, k) + f(n - 1, k - 1)menangani rekursi.