Odd parts partition count

This odd-parts partition counter returns the exact number of ways to write a non-negative integer n as a sum of odd positive integers, with order ignored. Euler's partition theorem says that the same number also counts partitions whose parts are all distinct. Enter one integer to obtain an exact decimal result rather than a floating-point approximation. The calculation is deterministic, runs without network access, and treats the empty partition of zero as one valid partition.

What the calculator counts

A partition writes an integer as a sum of positive integers while ignoring the order of the addends. For example, reversing the same addends does not create a new partition. This calculator restricts the first interpretation to odd parts: every addend must be odd, although an odd value may be repeated.

It simultaneously answers a second-looking question, the number of partitions into distinct parts, where no positive integer may appear twice. These two families are equinumerous for every non-negative n, even though their individual members usually look different. The returned count is therefore useful whether your problem is stated with odd summands or with nonrepeating summands.

For n equal to zero, the result is one because the empty sum is the conventional unique partition. The service rejects negative n because ordinary integer partitions in this setting are defined only for non-negative targets.

Why odd parts and distinct parts agree

Euler's theorem can be understood through generating functions or through a direct transformation. In the generating-function view, allowing any number of each odd part produces a product with one geometric factor for every odd integer. Requiring distinct parts produces a product in which each positive integer is either absent or selected once.

Algebraically, the two products have identical coefficients, so the coefficient attached to a chosen n is the same count. A constructive view repeatedly separates powers of two from repeated odd parts and combines equal copies, producing distinct parts without losing the total. The process can be reversed, which establishes a bijection rather than a numerical coincidence.

The implementation counts the distinct-parts side using dynamic programming. It visits each possible part once and updates target sums in descending order. Descending traversal is essential: it prevents a part from being reused during its own pass.

Exact BigInt arithmetic preserves every digit, and the final integer is serialized as a decimal string for reliable transport.

How to use and interpret the result

Provide n as a non-negative integer from zero through the published limit. The response repeats n and supplies count, the exact number of qualifying partitions. You do not need to choose between an odd-parts mode and a distinct-parts mode because Euler's identity guarantees that both requested counts are identical.

This makes the capability convenient for checking combinatorics exercises, validating coefficient tables, testing symbolic generating-function code, or supplying reference values to another deterministic program. Remember that the output counts unordered partitions, not compositions: changing the order of the same terms never creates another result. Repeated values are permitted under the odd-parts interpretation but forbidden under the distinct-parts interpretation; mixing those rules would describe a different problem.

Large answers should remain strings in downstream systems unless their integer type can represent arbitrary precision. Invalid fractions, missing inputs, values over the declared bound, and negative integers return a typed input error instead of a misleading count.