OEIS A000009 menghitung jumlah partisi ketat dari bilangan bulat. SEBUAH partisi yang ketat dari bilangan bulat positif nadalah himpunan bilangan bulat positif (sehingga tidak ada pengulangan diperbolehkan, dan ketertiban tidak peduli) bahwa jumlah untuk n.

Sebagai contoh, 5 memiliki tiga partisi ketat: 5 , 4,1, dan 3,2.

10 memiliki sepuluh partisi:

10
9,1
8,2
7,3
6,4
7,2,1
6,3,1
5,4,1
5,3,2
4,3,2,1

Tantangan

Diberikan bilangan bulat negatif n <1000, hasilkan jumlah partisi ketat yang dimilikinya.

Kasus uji:

0 -> 1

42 -> 1426

Berikut adalah daftar nomor partisi ketat dari 0 hingga 55, dari OEIS:

[1,1,1,2,2,3,4,5,6,8,10,12,15,18,22,27,32,38,46,54,64,76,89,104,122,142,165,192,222,256,296,340,390,448,512,585,668,760,864,982,1113,1260,1426,1610,1816,2048,2304,2590,2910,3264,3658,4097,4582,5120,5718,6378]

Ini adalah kode-golf , jadi solusi terpendek dalam byte menang.

Mathematica, 11 byte

PartitionsQ

Kasus cobaan

PartitionsQ@Range[10]
(* {1,1,2,2,3,4,5,6,8,10} *)

Pyth, 7 byte

l{I#./Q

Cobalah online. Suite uji.

• Ambil input ( Q).
• Temukan partisinya ( ./).
• Saring ( #) pada uniquify ( {) tidak berubah (I ) partisi. Ini menghapus partisi dengan duplikat.
• Temukan panjang hasilnya ( l).

Haskell, 39 byte

f n=sum[1|x<-mapM(:[0])[1..n],sum x==n]

Fungsi (:[0])mengubah nomor kmenjadi daftar [k,0]. Begitu,

mapM(:[0])[1..n]

menghitung produk Cartesian [1,0],[2,0],...,[n,0], yang memberikan semua himpunan bagian dari [1..n]status 0 untuk elemen yang dihilangkan. Partisi ketat nsesuai dengan daftar tersebut dengan jumlah n. Elemen-elemen tersebut dihitung dengan pemahaman daftar, yang lebih pendek dari length.filter.

ES6, 64 byte

f=(n,k=0)=>[...Array(n)].reduce((t,_,i)=>n-i>i&i>k?t+f(n-i,i):t,1)

Bekerja dengan pengurangan percobaan rekursif. kadalah angka yang terakhir dikurangkan, dan angka berikutnya yang harus dikurangkan harus lebih besar (tetapi tidak terlalu besar sehingga jumlah yang lebih besar tidak dapat dikurangkan). 1 ditambahkan karena Anda selalu dapat mengurangi nsendiri. (Juga karena ini bersifat rekursif saya harus berhati-hati karena semua variabel saya adalah lokal.)

Python, 68 byte

p=lambda n,d=0:sum(p(n-k,n-2*k+1)for k in range(1,n-d+1))if n else 1

Panggil saja fungsi anonim melewati bilangan bulat negatif nsebagai argumen ... dan tunggu akhir jagat raya.

Python 2, 49 byte

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

Cabang-cabang rekursi pada setiap peubah potensial kdari 1ke nuntuk memutuskan apakah itu harus dimasukkan. Setiap sumum yang dimasukkan dikurangi dari jumlah yang diinginkan n, dan pada akhirnya, jika n=0tetap, jalur itu dihitung.

Haskell, 43 byte

0%0=1
_%0=0
n%k=n%(k-1)+(n-k)%(k-1)
f n=n%n

Fungsi biner n%kmenghitung jumlah partisi ketat nmenjadi beberapa bagian dengan bagian maksimum k, sehingga fungsi yang diinginkan adalah f n=n%n. Setiap nilai kdapat dimasukkan, yang menurun ndengan k, atau dikecualikan, dan bagaimanapun maksimum baru ksatu lebih rendah, memberikan rekursi n%k=n%(k-1)+(n-k)%(k-1).

Julia, 53 byte

n->endof(collect(filter(p->p==∪(p),partitions(n))))

Ini adalah fungsi anonim yang menerima integer dan mengembalikan integer. Untuk menyebutnya, tetapkan ke variabel.

Kami mendapatkan partisi integer menggunakan partitions, filterhanya mereka yang memiliki puncak yang berbeda, collectke dalam array, dan menemukan indeks terakhir (yaitu panjang) menggunakan endof.

Haskell, 58 byte

import Data.List
h x=sum[1|i<-subsequences[1..x],sum i==x]

Contoh penggunaan: map h [0..10]-> [1,1,1,2,2,3,4,5,6,8,10].

Ini adalah pendekatan brute force sederhana. Periksa jumlah semua bagian dari 1..x. Ini juga bekerja untuk x == 0, karena semua urutan dari [1..0]adalah [[]]dan jumlah dari []adalah 0.

05AB1E , 8 byte

ÅœʒDÙQ}g

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Ŝ          # Get all integer partitions of the (implicit) input
            #  i.e. 5 → [[1,1,1,1,1],[1,1,1,2],[1,1,3],[1,2,2],[1,4],[2,3],[5]]
  ʒ   }     # Filter by:
   D        #  Duplicate the current partition
    Ù       #  Uniquify (removing any duplicated values from) this copied partition
            #   i.e. [1,1,1,1,1] → [1]
            #   i.e. [1,4] → [1,4]
     Q      #  Check if it's still the same
            #   i.e. [1,1,1,1,1] and [1] → 0 (falsey)
            #   i.e. [1,4] and [1,4] → 1 (truthy)
       g    # Then take the length of the filtered list (and implicitly output it)
            #  i.e. [[1,4],[2,5],[5]] → 3

05AB1E , 5 byte

LæOQO

Cobalah online!

Catatan: ini sangat lambat dan akan kehabisan input lebih dari sekitar 20.

Penjelasan:

L         # range 1..input
 æ        # list of subsets
  O       # sum each subset
   Q      # equal? (1 for each sum that equals the input, 0 otherwise)
    O     # sum the booleans