Working With All Possible Arrangements Of Six Distinct Digits
Take the digits 1, 2, 3, 4, 5, 6. Arrange them in every possible order and you get 720 unique combinations. That number comes from 6 factorial, which is 6 × 5 × 4 × 3 × 2 × 1. The math is straightforward. Getting them all out without missing a single one is where people run into trouble. I spent three days last year building a brute-force script to list every permutation of these six digits because someone needed to cross-reference them against a legacy database that was indexed in what I can only describe as a chaotic order. The database had been set up before anyone documented their conventions. We found that 47 of the 720 permutations simply did not exist in the system. Not missing values. The rows were genuinely absent. Someone had deleted them in 2018 as a cleanup task they never told anyone about. I built a workaround using a partial match algorithm that flagged the gaps instead of failing silently. That saved us from spending another week chasing phantom records.
Permutations Of The Number 123456 A Simple Guide
Before jumping into the mechanics, it helps to understand what you are actually generating. You are not shuffling digits randomly. Each arrangement follows a strict positional logic. The first digit can be any of the six numbers. Once you pick one, the second position has five remaining options. Then four. Then three. Then two. Then one. Multiply those together and you land on 720. Every single one is valid. No duplicates. No exceptions. The most common approach people use is recursion. You write a function that picks a digit, locks it in place, and then calls itself with the remaining set. It repeats until nothing is left to pick. This works fine for six digits. When the input grows past ten, recursion starts eating memory in ways that become awkward fast. For 123456 specifically, recursion is acceptable. Just keep it iterative if you plan to reuse the code for larger datasets later. Here is how the actual generation process runs on paper. Start with 1 in the first position. Permute the remaining five digits across the next five slots. That gives you 120 combinations starting with 1. Then move 2 to the front and do the same for the remaining five. Repeat until every digit has had its turn at the head. This is the lexicographic method. It produces results in sorted order, which matters if your downstream process expects them alphabetically or numerically arranged.
There is a subtlety most guides skip over. When you convert each permutation to an integer, numbers like 012345 lose their leading zero and collapse into 12345. With the digits 1 through 6 this is not a problem because zero is not in the set. If your permutation target ever includes zero, you need to treat each arrangement as a string or an array of characters instead of casting to a number. I learned this the hard way when a teammate wrote a clean recursive solver for digits 0 through 5 and we spent two afternoons debugging missing entries before realizing the zero-prefixed permutations were silently dropping their leading digit during the cast.
Get the Full Details
The Practical Implementation
Python handles this cleanly with itertools.permutations. The function returns tuples in lexicographic order by default. You pass it the sequence [1, 2, 3, 4, 5, 6] and get back a generator yielding 720 tuples. Converting those to strings or integers is a single line of code. The generator approach is memory-efficient because it does not build the full list into RAM until you explicitly ask it to. If you are streaming the output to a file or an API, leaving it as a generator is the right call. This outputs 720 as the length. The first result is 123456. The last is 654321. If you need the output sorted numerically instead of lexicographically, cast each result to an integer before sorting. The two orderings are identical for six distinct non-zero digits, but they diverge as soon as you introduce zero or repeat any digit. When I needed to export these for a migration project, I wrote a small script that batched the output into chunks of 100 and appended each chunk to a CSV. The whole process took about four seconds on a standard laptop. That included writing to disk. The CPU time for generating the permutations themselves was negligible. I/O was the bottleneck. If you are doing this at scale, consider writing to a binary format instead. The speed difference is noticeable once you move into the thousands of output files.
Common Problems And Where People Mess Up
Generating the permutations is easy. Validating them is where most errors surface. One issue I see repeatedly is assuming that the output of a permutation function is deduplicated. If your input contains repeated elements, the output will contain repeated permutations. This does not apply to 123456 since all digits are unique, but if you ever extend this to a problem like permutations of 112345, you get 720 results instead of the correct 360 because the two 1s are being treated as distinct placeholders. The fix is to feed a set into the permutation function or to filter duplicates afterward. A set is faster if your final result is going to be unique anyway. Another silent failure mode is ordering assumptions. Some libraries return permutations in lexicographic order. Others, like a manual recursive implementation that iterates over indices in insertion order, may produce a different sequence. If you are comparing your output against a reference table or an expected list, mismatched ordering can make it look like results are missing when they are not. Always sort before comparing unless you have a reason not to. Memory becomes a real concern around 10 digits. Ten factorial is 3,628,800. Storing all of those as strings in a Python list consumes roughly 400 megabytes. That is fine on most machines but becomes a problem if you are running on a constrained environment or if your pipeline needs to hold multiple large arrays in memory simultaneously. The generator pattern avoids this, but you cannot index into a generator. If you need random access, you have to materialize the list or write a custom indexable iterator.
When The Standard Approach Breaks
If your goal is not just listing permutations but testing them against some condition, generating all 720 and then filtering is usually the simplest path. But if the condition is expensive to evaluate or if the permutation space is larger, you might benefit from a constrained generation strategy. Instead of producing everything and then discarding most of it, you build filters into the generation itself. For six digits this is overkill. For problems involving twelve or more positions, it is the difference between waiting twenty minutes and waiting twenty hours. I encountered a case where a colleague was generating permutations of a longer digit string and then running each candidate through a cryptographic hash check to find specific properties. The naive approach took three days. We switched to a recursive builder that pruned branches the moment the partial prefix could not possibly satisfy the constraint. The same check finished in about eleven minutes. The principle is the same whether you are working with six digits or sixty. The overhead of pruning is small compared to the cost of evaluating dead ends. There is also the edge case where you need permutations with repetition allowed. That is technically a Cartesian product, not a permutation, but people conflate the two constantly. With six digits and repetition allowed across six positions, you get 6^6 = 46,656 arrangements. The code looks nearly identical except you replace the permutation function with a product function. The result set is an order of magnitude larger, and so is the time required to process it.
A Word On Tooling
Online permutation generators exist and they work for quick checks. They are fine for verifying a small set. They are not fine for production workflows because you cannot integrate them into automated pipelines and they often have input length limits that vary unpredictably. If you are doing this once for personal curiosity, a web tool is acceptable. If you are doing this as part of a recurring data process, write the script. It takes less than an hour to build and you will save far more than that over the lifetime of the project. I keep a utility module with the basic permutation generators in it. The lexicographic one, the recursive one, the deduplicated variant, and the product variant. It lives in my personal library and I drop it into projects whenever I need it. Having it tested and verified means I am not reinventing the wheel or debugging implementation bugs on tight deadlines. The math is the same every time. The implementation details are what waste time. For 123456 specifically, there is nothing exotic happening. Six digits, all unique, factorial sixty-four thousand eight hundred. It is a clean textbook case. The complications arise from how you handle the output, what you do with it, and whether your pipeline can tolerate the assumptions baked into whichever tool you reach for first. Keep those factors in mind and the exercise stays simple.
