Partisi Integer Terbatas

8

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 (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

code-golf  combinatorics  integer-partitions 
— Matthew Roh
sumber
1
Anda harus menyatakan dengan jelas bahwa ini adalah kode-golf , meskipun ini ditandai.
— Tn. Xcoder
2
Adakah yang bisa menautkan ke OEIS untuk ini (saya berasumsi ada satu dengan jumlah sekuens partisi yang telah kita temui pada postingan CnR OEIS)
— Stephen
3
Saya pikir test case terakhir adalah 8
— H.PWiz
2
Saya setuju dengan H.PWiz bahwa testcase terakhir seharusnya 8bukan 7.
— Erik the Outgolfer
2
— mil

Jawaban:

3

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 (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.

— Tuan Xcoder
sumber
2

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!

— benar-benar manusiawi
sumber
1
Ini istirahat pada kasus uji terakhir dari 10, 3. Terlalu banyak rekursi
— jkelm
1
(n>0and k>0)->n>0<k
— Erik the Outgolfer
1
Anda juga dapat melakukan +(n==k)bukan [0,1][n==k].
— Erik the Outgolfer
1
Anda tidak membutuhkan ruang dalam or +.
— Erik the Outgolfer
1
50 byte , ganti n>0<k anddengann*k>0and
— Tn. Xcoder
2

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
— J42161217
sumber
1
Tentu saja. Saya tahu ada builtin.
— Matius Roh
Sebuah Mathematica Sederhana pelabuhan akan menyimpan 13 byte di sini saya percaya ( Length-> Len`1dan IntegerPartitions->Int`7
— Jonathan Allan
@ Jonathanathan Allan Saya sebenarnya membuat versi super singkat ini. Semoga saya bisa menyelesaikannya di akhir bulan
— JungHwan Min
2

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>
Luaskan cuplikan

— Shaggy
sumber
2

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
— Luis Mendo
sumber
Jujur saya terkejut MATL tidak memiliki built-in "partisi integer" atau sesuatu.
— Erik the Outgolfer
@Sanchises Ini seharusnya berfungsi sekarang. Terima kasih sudah memberitahuku!
— Luis Mendo
Tidak masalah. Saya hanya bermain dengannya untuk memahami metode Anda (yang umumnya lebih mudah untuk kasus kecil) ketika saya mengalami kesalahan.
— Sanchises
0

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!

— V. Courtois
sumber
0

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.

— JAD
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.