Math calculator

Permutation Combination Calculator

Calculate exact permutations and combinations for 0 ≤ k ≤ n ≤ 1000. Compare ordered and unordered selections, share inputs, and export the complete count.

Instant result

Result

—

Enter values to calculate.

Inputs—

Mode—

Formula—

Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published modes

Input interpretation: Enter values to calculate.
Result: —
Verified scope: all published modes
Assurance: Core
Declared partition coverage: PASS · 3/3 declared partitions (combination, permutation, invalid-domain) · Matrix
Known limitations: Core CVP does not include live graph, viewport, or pointer interaction.
Model: Exact P(n,k) or C(n,k) for integers 0 ≤ k ≤ n ≤ 1000.
Scope: Integers 0 ≤ k ≤ n ≤ 1000; distinct items, without replacement
Verification: Engine tested · Source checked · v1.0.3 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published modes· View Manifest · CVP overview · Specification
Versions: Calculation 1.0.3 · CVP protocol 1.0.0-proposed · Evidence 2026-10-28.meta-metrics-v2
Verification revision: 2026-10-28.meta-metrics-v2 · 3/3 property · digest 671939159b19
Legacy regression: 11/11 tests · Production surface contract 5/5
Trust layers: Verification VERIFIED · Production CURRENT · Overall CVP state: VERIFIED under CVP 1.0.0-proposed
Reference: O1 model · O2 expected_values · O2 numerical_behavior
Interfaces: PASS · UI (SSR) / REST / MCP — ui-ssr is query-result HTML, not a live browser session. Error-path engine·REST·MCP 1/1 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only.
Supplemental domain review: Not performed
Named expert review: Not performed
CVP suite: 90/90 golden · 4/4 CVP boundary · 7/7 invalid · 3/3 property · 2/2 metamorphic · 3/3 cross-interface · 2/2 cross-calculator · 5/5 CVP contract · Manifest
Sources: ISO 80000-2:2019 Quantities and units — Mathematics (combinatorial numbers)
NIST DLMF — 26.3 Lattice Paths: Binomial Coefficients
MIT Mathematics for Computer Science — Counting — Chapter 14, especially §§14.3 and 14.5
Sources
Evidence: 2 legacy golden · 3 legacy boundary · legacy regression suite · 90/90 oracle-backed golden · 7/7 invalid · Artifact integrity PASS
Semantic contract: PASS

Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

PermutationP(n,k) = n! / (n − k)!

CombinationC(n,k) = n! / (k!(n − k)!)

IdentityP(n,k) = C(n,k) × k!

iThis page uses the multiplicative product, not a call to the factorial calculator. Domain 0 ≤ k ≤ n ≤ 1000. Multinomials and with-replacement counts are out of scope.

How to use

Choose permutation or combination

Permutation (nPr) is ordered. Combination / binomial (nCr) is unordered.

Enter integers n and k

0 ≤ k ≤ n ≤ 1000. Safe JSON integers or integer strings, at most 4 digits and 512 characters; fractions, scientific notation, unknown keys and conflicting aliases reject.

Read the exact integer

Counts are exact BigInt. Above 18 digits, the main preview is explicitly approximate and rounded to 8 significant digits; the complete exact count appears in the working and exports. C(n,k) = C(n, n−k).

Example calculations

Common configurations with formula and result.

C(10,3)

Unordered selections of 3 from 10

C(10,3) = 10! / (3!·7!)

120

P(10,3)

Ordered selections of 3 from 10

P(10,3) = 10×9×8

720

Empty selection

C(n,0) = 1

C(8,0)

Permutation Combination calculator specification

Version 1.0.3 · Engine tested

Calculation status

Engine tested 11/11 tests · Production surface contract 5/5
Named expert review Not performed
Calculation version 1.0.3

Review policy · Evidence

Definition: P(n,k) counts ordered selections of k items from n. C(n,k) counts unordered selections (binomial coefficient). Both require 0 ≤ k ≤ n.
What it calculates: Exact P(n,k) or C(n,k) for integers 0 ≤ k ≤ n ≤ 1000.
Inputs: mode?
n
k
Outputs: value
exact
digits
symbol
display
work
algorithm
calculation_version
Formula: P(n,k)=n!/(n−k)!; C(n,k)=n!/(k!(n−k)!)
Assumptions: Integers 0 ≤ k ≤ n ≤ 1000; distinct items, without replacement
4 digits and 512 characters per integer string; matching n/nInput and k/kInput aliases
Safe JSON integer numbers; counts exact relative to accepted normalized integers
Counts above 18 digits have an explicitly approximate 8-significant-digit preview; full exact counts remain in working and CSV/JSON
Not factorial n!
Not multinomial and not with-replacement
Units: dimensionless
Boundary conditions: missing n or k → MISSING_REQUIRED_INPUT
k > n → INVALID_INPUT
n > 1000 → VALUE_ABOVE_MAX
unknown mode → INVALID_MODE
Example: mode=combination n=10 k=3 → 120
Validation cases: 3 published on this page · 11/11 tests · Production surface contract 5/5 · View evidence
mode=combination n=10 k=3 → 120
mode=permutation n=10 k=3 → 720
n=5 k=6 → error INVALID_INPUT
Sources: ISO 80000-2:2019 Quantities and units — Mathematics (combinatorial numbers)
Supports: Mathematical symbols and notation. This standard is not numerical verification or an endorsement of this implementation.
NIST DLMF — 26.3 Lattice Paths: Binomial Coefficients
Supports: Binomial coefficients, their factorial representation and recurrence relations. Mathematical reference only; not validation or endorsement of this implementation.
MIT Mathematics for Computer Science — Counting — Chapter 14, especially §§14.3 and 14.5
Supports: The product rule for choices, n! permutations, and ordered k-selections n!/(n−k)!. Their finite counting domain requires integers 0 ≤ k ≤ n. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.
Calculation version: 1.0.3

Background

Interpretation and common distinctions.

What does this permutation combination calculator compute?

P(n,k) counts ordered selections of k items from n. C(n,k) counts unordered selections (binomial coefficient). Both require 0 ≤ k ≤ n.

The published formula or method is P(n,k)=n!/(n−k)!; C(n,k)=n!/(k!(n−k)!). The following references support the stated mathematics or method:

NIST DLMF — 26.3 Lattice Paths: Binomial Coefficients: Binomial coefficients, their factorial representation and recurrence relations. Mathematical reference only; not validation or endorsement of this implementation.
MIT Mathematics for Computer Science — Counting: The product rule for choices, n! permutations, and ordered k-selections n!/(n−k)!. Their finite counting domain requires integers 0 ≤ k ≤ n. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.

Which inputs and limits should you check?

Combinations ignore order; permutations retain it. Items are distinct and selections are without replacement. Use safe JSON integers or integer strings of at most 4 digits and 512 characters, with 0 ≤ k ≤ n ≤ 1000; matching aliases must agree. Both C(0,0) and P(0,0) equal 1. This product rejects k > n with INVALID_INPUT, although some mathematical references extend the binomial coefficient to 0 in that region.

Counts use exact BigInt arithmetic. For counts above 18 digits, ≈ marks a preview rounded to 8 significant digits; the full exact decimal, formula and working remain available below and in complete JSON/CSV exports. JSON numeric literals follow binary64 transport before integer validation; raw nonzero-to-zero underflow is rejected. Integer strings do not accept decimal points or scientific notation.

Canonical mode names are combination and permutation; named aliases are c/ncr/binomial/binomial_coefficient/binomial-coefficient and p/npr, with the named notation aliases nCr/nPr. n/nInput and k/kInput must agree if supplied together. REST route aliases identify the same capability; specify mode explicitly when using a compatibility route. Empty, null and unrecognized modes do not fall back to a different calculation.

The worked example uses Unordered selections of 3 from 10 with C(10,3) = 10! / (3!·7!). Compare it with the Example calculations and the complete result for the same inputs.

How can you verify and cite this result?

CalculatorX is responsible for this page. The mathematical references above explain the model; implementation checks and their scope are documented separately in the math.combinatorics v1.0.3 Evidence and capability contract. Read the displayed verification and production state together with the specification's numerical limits.

Use the clean calculator URL to cite the tool. A shared input link identifies a particular calculation. Content updates, numerical verification, and domain reviews have separate dates and scopes.

Other calculators in this family: Arithmetic Sequence Calculator, Factorial Calculator, Fibonacci Calculator, GCF Calculator, Geometric Sequence Calculator, LCM Calculator, Modular Inverse Calculator, Modulo Calculator . Explore all Number Theory & Discrete Math.

Frequently asked questions

Key distinctions behind the calculation.

Is this the factorial calculator?

No. n! is /calc/math/factorial. This page computes P(n,k) and C(n,k). Internally it uses a multiplicative product, not n!/(n−k)! as a quotient of two factorial calls.

What is the difference between P and C?

P(n,k) cares about order. C(n,k) does not. P(n,k) = C(n,k)×k!.

Is C(n,k) the binomial coefficient?

Yes. Combination mode is C(n,k) = (n choose k).

Where does this run?

Typing runs locally in the browser. Shared URLs and REST/MCP transmit inputs to the server and may enter logs; browser history may retain inputs. Share links execute the current engine and carry a version hint. Logging retention and processing regions depend on the hosting/analytics configuration; this page makes no zero-log claim.