OEIS A000009 đếm số phân vùng nghiêm ngặt của các số nguyên. Một phân vùng nghiêm ngặt của một số nguyên không âm nlà một tập hợp các số nguyên dương (vì vậy không cho phép lặp lại và thứ tự không quan trọng) mà tổng hợp n.

Ví dụ, 5 có ba phân vùng nghiêm ngặt: 5, 4,1, và 3,2.

10 có mười phân vùng:

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

Thử thách

Cho một số nguyên không âm n<1000, xuất ra số lượng phân vùng nghiêm ngặt mà nó có.

Các trường hợp thử nghiệm:

0 -> 1

42 -> 1426

Dưới đây là danh sách các số phân vùng nghiêm ngặt từ 0 đến 55, từ 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]

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất tính bằng byte sẽ thắng.

Toán học, 11 byte

PartitionsQ

Trường hợp thử nghiệm

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

Bình thường, 7 byte

l{I#./Q

Hãy thử trực tuyến. Bộ thử nghiệm.

• Lấy đầu vào ( Q).
• Tìm phân vùng của nó ( ./).
• Lọc nó ( #) trên uniquify ( {) không thay đổi ( I) phân vùng. Điều này loại bỏ các phân vùng với các bản sao.
• Tìm độ dài kết quả ( l).

Haskell, 39 byte

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

Hàm (:[0])chuyển đổi một số kvào danh sách [k,0]. Vì thế,

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

tính toán sản phẩm của Cartesian [1,0],[2,0],...,[n,0], cung cấp tất cả các tập hợp con [1..n]có giá trị 0 cho các phần tử bị bỏ qua. Các phân vùng nghiêm ngặt ntương ứng với các danh sách như vậy với tổng n. Các yếu tố như vậy được tính bằng cách hiểu danh sách, ngắn hơn 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)

Hoạt động bằng phép trừ đệ quy. klà số bị trừ lần cuối và số tiếp theo được trừ phải lớn hơn (nhưng không lớn đến mức số lớn hơn thậm chí không thể được trừ). 1 được thêm vào bởi vì bạn luôn có thể trừ nchính nó. (Ngoài ra vì đây là đệ quy nên tôi phải lưu ý rằng tất cả các biến của tôi là cục bộ.)

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

Chỉ cần gọi hàm ẩn danh đi qua số nguyên không âm nlà đối số ... và chờ kết thúc vũ trụ.

Python 2, 49 byte

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

Các chi nhánh đệ quy ở mọi summand tiềm năng ktừ 1để nquyết định liệu có nên được đưa vào. Mỗi triệu hồi được bao gồm được trừ vào tổng số mong muốn nvà cuối cùng, nếu n=0còn lại, đường dẫn đó được tính.

Haskell, 43 byte

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

Hàm nhị phân n%kđếm số lượng phân vùng nghiêm ngặt nthành các phần có phần tối đa k, vì vậy hàm mong muốn là f n=n%n. Mỗi giá trị kcó thể được bao gồm, mà giảm nbởi k, hoặc loại trừ, và một trong hai cách tối đa mới klà một trong thấp hơn, đưa ra các đệ quy n%k=n%(k-1)+(n-k)%(k-1).

Julia, 53 byte

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

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một số nguyên. Để gọi nó, gán nó cho một biến.

Chúng tôi nhận được các phân vùng số nguyên bằng cách sử dụng partitions, filterchỉ những phân vùng có triệu hồi riêng biệt, collectvào một mảng và tìm chỉ mục cuối cùng (tức là độ dài) bằng cách sử dụng endof.

Haskell, 58 byte

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

Ví dụ sử dụng: map h [0..10]-> [1,1,1,2,2,3,4,5,6,8,10].

Đó là một cách tiếp cận đơn giản. Kiểm tra tổng của tất cả các phần sau của 1..x. Điều này cũng hoạt động x == 0, bởi vì tất cả các phần sau [1..0]là [[]]và tổng của []là 0.

05AB1E , 8 byte

ÅœʒDÙQ}g

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Ŝ          # 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

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

Lưu ý: điều này cực kỳ chậm và sẽ hết thời gian cho các đầu vào lớn hơn khoảng 20.

Giải trình:

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