Integer partition calculator

The integer partition function p(n) answers a classic counting question: in how many ways can you write a non-negative integer n as a sum of positive integers when the order of summands does not matter? For example, 4 equals 4, 3+1, 2+2, 2+1+1, and 1+1+1+1, so p(4) equals five; 5 has seven partitions and 10 has forty-two. Partitions appear in number theory, generating functions, statistical mechanics, and programming contests whenever you count multiset sums rather than ordered compositions or labeled set partitions. This capability accepts a non-negative integer n and returns the exact p(n) as a decimal string computed with BigInt dynamic programming, so values far beyond ordinary safe-integer limits stay correct digit for digit. Negative n is rejected with a clear validation error instead of a silent zero or a wrong answer.

How the partition function p(n) is defined

An unrestricted integer partition of a non-negative integer n is a way of writing n as a sum of positive integers in which the order of summands is irrelevant. By convention p(0) equals one, counting the empty partition of zero. Small textbook values are p(1)=1, p(2)=2 (namely 2 and 1+1), p(3)=3, p(4)=5, p(5)=7, p(6)=11, and p(10)=42.

The ordinary generating function for the sequence is the infinite product over k greater than or equal to one of one over one minus x to the k, which encodes that each positive integer may appear any number of times as a part. A practical recurrence used in software is the classic coin-change style dynamic program: initialize an array with one way to make sum zero, then for each part size from one through n, add the ways to form the remaining sum.

That recurrence fills p(n) exactly and never double-counts orderings because parts are introduced in non-decreasing size order only once. Related but different objects include compositions, where order matters and there are two to the n minus one compositions of n; set partitions counted by Stirling numbers of the second kind or Bell numbers, which partition labeled elements rather than add unlabeled positive integers; and restricted partitions that require distinct parts, odd parts only, or a fixed number of parts.

This implementation never uses floating-point approximation, Monte Carlo sampling, or external tables: it fills a one-dimensional BigInt array so every digit is correct. The path is fully deterministic—no random seeds, no clocks, no network, and no model drift—so the same n always yields the same string.

Where integer partitions show up in real work

Number-theory courses and programming contests constantly ask how many unrestricted partitions a given n has, how p(n) grows, or whether a table of small values matches the Ramanujan congruences and other classical identities. Algorithm designers use partition counts when analyzing integer knapsack style state spaces, counting multiset decompositions of a resource budget, or sizing DP tables whose dimensions track part sizes.

Physics and combinatorics contexts connect p(n) to bosonic partition functions and generating-function coefficients; educators often show a short list of partitions of a small n and then ask for the count alone. Interview prep and olympiad training frequently need a single reliable p(n) without hand-maintaining large tables or risking off-by-one composition counts.

If you later need compositions where order matters, set partitions via Stirling numbers of the second kind, Bell numbers alone, restricted partitions with distinct or odd parts only, or an explicit listing of every partition rather than the count, treat those as separate search intents rather than overloading this landing. Keep n inside the documented bound so free-tier latency stays predictable, and prefer string consumers for the returned value because p(n) leaves the safe-integer range long before five thousand.