Phân vùng nghiêm ngặt của một số nguyên dương


14

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à , vì vậy giải pháp ngắn nhất tính bằng byte sẽ thắng.

Câu trả lời:


4

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} *)


3

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.


Xuất sắc! Bản thân tôi đã tìm kiếm một sự thay thế cho subsequences(+ import) trong câu trả lời của mình, nhưng cho đến nay vẫn chưa thành công.
nimi

2

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ộ.)


2

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


làm cho nó n>0, bạn lưu một byte và đi nhanh hơn (tôi tin rằng bạn tái diễn trên các số âm): P
st0le

Ngoài ra, Ghi nhớ loại tăng tốc này
st0le

Bạn không thể thay đổi câu lệnh if của mình thành:return sum(...)if n else 1
andlrc

@randomra Tất nhiên, tất nhiên ...
Bob

1

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.


1

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


n%k|q<-k-1=n%q+(n-k)%qloại bỏ một byte khỏi dòng 3.
Izaak Weiss

0

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.


0

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][[]]và tổng của []0.


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

0

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
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.