The Mode switch at the left of the control bar toggles between ● Balls (numbered coloured balls) and A Letters (letter labels). Learn more about the mode switch
The n stepper (3 to 5) sets the source row and the r stepper (1 to n) sets the number of slots; lowering n below r pulls r down with it, and either change resets the build. Learn more about adjusting n and r
Step ▶ moves one ball into the next slot, ◀ Back undoes one step, ▶ Play builds every arrangement, ↺ Reset clears the completed list, and the Speed slider (0.3 to 3) sets the pace. Learn more about the transport controls
The two lines at the top right of the scene show P(n,r) with its total and the status: the current step and its count, or Complete. Learn more about getting started
In the build area only r slots appear; each ball flies in along a dotted guide line, used items dim, and the unused ones stay bright. Learn more about the build area
The right panel adds a row for each first-item group with its progress and a one-line narration of how the remaining slots are filled. Learn more about the right panel
Press ▶ Play to build all P(n, r) arrangements, or Step ▶ to advance one ball at a time. Switch balls / letters and adjust n and r.
● BallsA Letters
n =3?
r =2?
Speed
Building partial permutations
P(3, 2) = 3! / (3−2)! = 3 × 2 = 6
Choose and arrange r items out of n — order matters, no repetition. Each step builds the family of arrangements starting with one fixed first item; there are n such families, each containing (n−1)! / (n−r)! arrangements.
r dashed slots wait below the n source balls — the scenario: choose r of the n items and put them in order (at r = n it is a full permutation). Learn more about getting started · Adjusting n and r
Partial permutation — an ordered selection of r items from a set of n distinct items, with no item reused. The count is P(n,r)=n!/(n−r)!.
P(n,r) — standard notation for the number of partial permutations of size r taken from n items. Also written nPr or Prn.
Order matters — two selections with the same items in different positions count as different partial permutations. This is what distinguishes partial permutations from combinations.
Position — a slot in the arrangement, numbered #1 through #r from left to right in the build area.
First-item group — the family of partial permutations that share the same item in position #1. There are n such groups, each containing (n−1)!/(n−r)! partial permutations.
Source row — the set of n available items shown at the top of the scene. Items already placed in the current build are dimmed.
Getting Started
The tool opens with n=3 and r=2, ready to build. The scene splits into three areas:
• A source row at the top showing all n available items.
• A build area in the middle with exactly r slots labeled #1 through #r.
• A completed section below, where every finished partial permutation is filed under the row matching its first item.
To run the visualization:
• Press ▶ Play to auto-build all P(n,r) partial permutations.
• Press Step ▶ to advance one ball at a time.
• Press ◀ to step backward through the animation.
• Adjust the Speed slider to control how fast play advances.
The header in the top right shows P(n,r)=total alongside a live status line such as *Step X (item name): k / (n−1)!/(n−r)!* while building, or *Complete · total / total* when done.
(n, r) = (3, 2), idle, frozen
Three source balls and only two slots: the build area is deliberately shorter than the source row — the defining picture of a partial permutation.
The frozen frame above is the opening position, and its geometry already states the problem: three balls in the source row, but only two dashed slots below. A partial permutation never intends to use everything — the mismatch between pool and positions is the point.
Every run therefore ends with someone left out. Which items are left out, and in what order the chosen ones stand, together determine the count — the build area shows the mechanics.
The Build Area
DemoTwo slots, one ball left out
Step 0 of 5
The build area is where one partial permutation at a time is constructed. Unlike a full permutation, only r slots appear — not n. The label above the area reads *BUILD AREA (r = R)* with the current r.
What to watch:
• Empty slot outlines with dashed borders, labeled #1,#2,…,#r. The label tells you the position number being filled.
• When a ball is in flight from the source row to a slot, a dotted guide line in that ball's color traces the trajectory.
• Each ball lands in its assigned slot and stays put until the partial permutation completes.
• In the source row above, every item already placed in the current build (plus the one in flight) is dimmed to indicate it's out of play.
• When all r slots are filled, a flash ring briefly pulses around the build area. The completed arrangement is then copied to the appropriate first-item row in the completed section below.
(3, 2) mid-build, frozen
The third arrangement begins: B has claimed slot #1, A is dropping into #2 — while C stays bright, available but about to be left out.
The frozen frame above catches the third arrangement mid-build: B has claimed slot #1, A is dropping into #2 along its dotted guide, and both are dimmed above. Green C stays bright — available, but about to be left out of this particular pair.
The stop-after-r discipline is what separates this build from the full permutation's: when slot #2 fills, the arrangement is finished, with a bright ball still sitting unused in the source row. That permanent leftover is the (n−r)! that the formula divides away.
Adjusting n and r
Demon, r and the clamp
Step 0 of 5
Two steppers in the control bar control the size:
• n sets the size of the source set — the pool of available items.
• r sets the number of positions to fill. The constraint r≤n is enforced; if you reduce n below the current r, the tool clamps r down automatically.
• n=5,r=5: P(5,5)=120 — this is the full permutation case, where r=n and the formula reduces to n!.
Changing either n or r resets the build, refreshes the formula in the header, and reorganizes the completed grid into the new number of first-item rows. Two boundary settings repay a visit of their own: r = n, where nothing is left out, and r = 1, where nothing is ordered.
Grouping by First Item
DemoRows by first item
Step 0 of 5
The completed section organizes partial permutations into first-item groups — every arrangement starting with the same item appears in the same row.
There are exactly n groups (one per item in the source set), and each group holds exactly (n−1)!/(n−r)! partial permutations. So the total is:
n×(n−r)!(n−1)!=(n−r)!n!=P(n,r)
This is the visual proof of the partial permutation formula. Pick any item to put in position #1: n choices. For each choice, fill the remaining r−1 positions with r−1 items chosen in order from the remaining n−1 items: (n−1)!/(n−r)! ways. Multiply.
Each group row in the completed area has:
• A tinted background in a faint version of the group's color.
• A colored accent stripe on the left edge.
• A left-side avatar showing the first item — a colored circle with the item's number in balls mode, or the letter in letters mode.
• Mini partial-permutation cards, each one a full arrangement of r items starting with that first item.
P(3, 2) complete, frozen
Six ordered pairs in three rows of two: each first choice leaves two ways to fill the one remaining slot — 3 × 2 = 6.
The frozen frame above is the default P(3,2) completed: six ordered pairs in three rows of two. Read any row and the factoring appears — first slot fixed, one slot to fill, two candidates for it.
Two cards per row instead of the full permutation's (n−1)! is the visible effect of stopping early: the second slot exhausts the arrangement, so the deeper orderings of the leftover item never happen. Multiply rows by row size — 3×2=6 — and you have P(3,2) without touching a factorial.
When r = n: The Full Permutation Limit
Push r all the way up to n and the partial permutation stops being partial: every item from the source row is used, nothing is left out, and the tool momentarily becomes a full permutation visualizer.
The formula agrees gracefully. With r=n the denominator is (n−n)!=0!, and by the convention 0!=1:
P(n,n)=0!n!=n!
This is where the otherwise odd-looking convention earns its keep — without 0!=1, the boundary case would break a formula that works everywhere else.
Set n=4,r=4 and run: 24 cards fill four rows of six, exactly the 4! enumeration, built with the same fix-the-first-item structure.
P(4, 4) complete, frozen
With r = n the build uses every item: 24 cards in four rows of six — the full permutation 4! recovered as a boundary case.
Boundary cases like this are how counting formulas are sanity-checked: a good formula degrades into a known one when its parameters hit their extremes. Here the extreme also explains the plateau noted under the derivation: P(5,4)=P(5,5)=120, because once only one item remains, its "placement" is forced — a last factor of 1 that changes nothing.
The opposite boundary tells the complementary story: see r = 1, where the arrangement collapses into a bare choice.
When r = 1: A Single Choice
Push r down to 1 and the arrangement disappears: one slot, one landing, done. The count is as small as it gets:
P(n,1)=(n−1)!n!=n
Set n=4,r=1 and run: four cards, one per item, each first-item group holding exactly one arrangement — a group structure where every family is a family of one.
With a single position, "order matters" has nothing to bite on. That is why P(n,1) coincides with the combination count C(n,1)=n: choosing one item and arranging one item are the same act.
P(4, 1) complete, frozen
One slot, four outcomes: with r = 1 each "arrangement" is just a choice, and every group row holds a single card.
The case is also the base of the recursion the whole tool enacts: P(n,r)=n⋅P(n−1,r−1), falling step by step until it lands on P(n−r+1,1)=n−r+1 — the last factor of the multiplication chain.
The agreement between permutations and combinations at r=1 is worth remembering when the two are later divided: the gap between P(n,r) and C(n,r) is a factor of r!, which equals 1 here and grows with every extra slot — see the combination entry under related concepts.
Transport Controls
DemoSlow speed, Back, Reset
Step 0 of 5
The control bar offers four transport buttons plus a speed slider:
• ◀ (Step back) — walks the animation one step backward. Useful for re-examining a single partial permutation or pausing mid-build.
• Step ▶ (Step forward) — advances one ball into one slot. Stop after each step to read the partial arrangement so far.
• ▶ Play / ⏸ Pause — runs the animation continuously until all P(n,r) partial permutations are built, then auto-pauses.
• ↺ Reset — clears the completed section and starts over from the first arrangement.
The Speed slider controls how fast play advances. At higher speeds the fly and land timings shrink proportionally; at slower speeds you can clearly see each ball travel from source to slot and follow the dotted guide line in detail.
Mode Switch
The Mode switch at the start of the control bar toggles how each item is rendered:
• Balls mode (default) — items appear as colored circles. The first-item avatar in each completed group is a circle with the item's number. Best for tracking position and group membership visually.
• Letters mode — items appear with letter labels (A, B, C, …). The first-item avatar in each completed group is just the letter, colored to match. Best for reading off the sequence in each partial permutation and matching it to algebraic notation like (A,C) or (B,A,D).
The encoding is consistent across the source row, the build slots, the flying ball, every mini card in the completed grid, and the right-panel narration. Switching modes mid-animation is safe — the build state preserves; only the rendering changes.
Right Panel and Progress
The right panel narrates the build as it unfolds, anchored by the header Building partial permutations with the full formula P(n,r)=n!/(n−r)!=n×(n−1)×⋯=total.
A StepRow is added for each first-item group as soon as a partial permutation in that group either starts building or completes. Each StepRow shows:
• The first item as a chip plus its name — for instance, *First item: A*.
• A progress counter like k/((n−1)!/(n−r)!) tracking how many partial permutations in this group have completed.
• A short narration of the structure: *Position 1 is locked to A. The next r−1 positions are filled from B, C, D, or E in (n−1)×(n−2)×⋯=M ways.* When r=1 the narration adjusts: with only one position, the outcome is just the first item alone.
When all groups complete, every StepRow shows done with a checkmark, and the header counter reaches total/total.
What Is a Partial Permutation
A partial permutation is an ordered selection of r items from a set of n distinct items, with no item used twice. The count of such selections is:
P(n,r)=(n−r)!n!=n×(n−1)×⋯×(n−r+1)
The formula collapses to n!when r = n — the full permutation. When r<n, the multiplication stops after r factors instead of continuing all the way down to 1.
Examples:
• Picking a 1st, 2nd, and 3rd place from 8 runners: P(8,3)=8×7×6=336 podiums.
• Choosing a president and a vice-president from 10 candidates: P(10,2)=90 outcomes.
• Forming a 4-digit code from 10 digits with no repeats: P(10,4)=5040 codes.
The partial permutation is the right model whenever you need both which items and what order — and reuse is not allowed.
For deeper coverage of the formula and its derivation, see the partial permutation without repetition section on the permutations theory page.
Deriving P(n,r) Step by Step
Apply the multiplication principle of counting one position at a time:
• Position #1: any of the n items. n choices.
• Position #2: any of the remaining n−1 items. n−1 choices.
• Position #3: any of the remaining n−2 items. n−2 choices.
• …
• Position #r: any of the remaining n−r+1 items. n−r+1 choices.
Multiply the r factors:
P(n,r)=n×(n−1)×(n−2)×⋯×(n−r+1)
This product equals n!/(n−r)! because the r factors are exactly the top r terms of n!, with the bottom n−r terms canceled by the (n−r)! in the denominator.
The tool visualizes the equivalent factoring: fix the first item (n ways), then arrange r−1 of the remaining n−1 items in order ((n−1)!/(n−r)! ways). Every row in the completed section is one of those nfirst-item families.
P(5, 3) complete, frozen
Sixty ordered triples in five rows of twelve: the product 5 × 4 × 3 drawn to scale, stopping after exactly three factors.
The frozen frame above is the derivation at full stretch: P(5,3)=5×4×3=60 ordered triples, five rows of twelve. The chain runs exactly three factors and stops — the factors 2×1 that a full permutation would keep multiplying belong to the two leftover items and never enter the count.
Sixty is also where enumeration starts arguing for the formula: every card is on screen, but nobody would list them by hand. One stepper click to r=4 would give 120, and r=5 the same 120 again — a curious plateau explained at the r = n boundary.
Related Concepts
Full permutation — the case r = n, where every item from the source set is used. Formula P(n,n)=n!.
Permutation with repetition — relaxes the no-reuse rule, allowing the same item in multiple positions. Formula nr, which is larger than P(n,r).