Introduction

Creating constrained random numbers is not one single technique. The right method depends on the constraint: a bounded range, uniqueness, a fixed total sum, weighted probabilities, or more complex rules such as parity or ordering.

Start By Classifying The Constraint

Before choosing code, decide which kind of constraint you have.

Common cases are:

• one random number in a range
• several unique random numbers
• numbers that must add up to a target
• numbers drawn with non-uniform weights
• values that must satisfy a predicate

Different constraints imply different algorithms. A mistake many people make is trying to solve all of them with random.randint and repeated retries.

Simple Range Constraints

If the only rule is "pick a value between a and b", use the standard random API directly.

1import random
2
3value = random.randint(10, 20)
4print(value)

For floating-point values in a closed-open interval style, use uniform.

1import random
2
3value = random.uniform(1.5, 3.5)
4print(value)

This is the easy case because the generator already matches the constraint.

Unique Integers Without Replacement

If you need several distinct integers, use sampling without replacement instead of repeatedly generating values and checking for duplicates.

1import random
2
3numbers = random.sample(range(1, 21), k=5)
4print(numbers)

This guarantees uniqueness and is clearer than looping until a set reaches the required size.

Values That Must Sum To A Target

A common constrained-random problem is generating n non-negative integers that add up to a fixed total.

One clean approach is to generate random cut points and convert the gaps into parts.

1import random
2
3
4def random_partition(total, parts):
5    cuts = sorted(random.sample(range(total + parts - 1), parts - 1))
6    values = []
7    previous = -1
8
9    for cut in cuts + [total + parts - 1]:
10        values.append(cut - previous - 1)
11        previous = cut
12
13    return values
14
15print(random_partition(10, 4))

This returns four non-negative integers whose sum is always 10.

If you need strictly positive integers, allocate one unit to each part first and partition the remainder.

1import random
2
3
4def positive_partition(total, parts):
5    if total < parts:
6        raise ValueError("total must be at least parts")
7    base = [1] * parts
8    extra = random_partition(total - parts, parts)
9    return [a + b for a, b in zip(base, extra)]
10
11print(positive_partition(10, 4))

Weighted Random Choices

Sometimes the constraint is probabilistic rather than structural. For example, you may want small numbers to be more likely than large ones.

Use weighted choice instead of manual hacks.

1import random
2
3values = [1, 2, 3, 4]
4weights = [0.6, 0.2, 0.15, 0.05]
5
6picked = random.choices(values, weights=weights, k=10)
7print(picked)

This does not guarantee exact frequencies in small samples, but it respects the weight distribution over repeated draws.

Rejection Sampling For Predicate Constraints

If the rule is something like "generate a random point inside a circle" or "pick a value that passes condition X", rejection sampling is often the simplest method.

Generate candidates from a broader easy distribution, and reject the ones that fail.

1import random
2
3
4def random_even_between(a, b):
5    while True:
6        x = random.randint(a, b)
7        if x % 2 == 0:
8            return x
9
10print(random_even_between(1, 11))

This is fine when the acceptance rate is reasonably high. It becomes inefficient when valid outputs are rare.

Generate In The Constrained Space When You Can

The best constrained-random algorithm is usually the one that samples directly from valid states rather than sampling invalid states and rejecting them.

For example, for even numbers in a range, do not use rejection sampling if you can map the problem directly:

1import random
2
3
4def direct_random_even(a, b):
5    first = a if a % 2 == 0 else a + 1
6    last = b if b % 2 == 0 else b - 1
7    count = ((last - first) // 2) + 1
8    return first + 2 * random.randrange(count)
9
10print(direct_random_even(1, 11))

This is cleaner and has predictable performance.

Think About Distribution, Not Only Validity

A subtle but important issue is whether all valid outputs should be equally likely. Some improvised algorithms satisfy the constraint but bias the distribution.

For example, repeatedly picking random values and clipping them into range is not the same as uniform sampling in range. Likewise, building partitions incrementally can bias certain compositions unless the algorithm was designed carefully.

So the real question is often:

• do I only need valid values?
• or do I need valid values with a specific distribution?

That distinction matters a lot in simulations and tests.

Common Pitfalls

• Using rejection sampling when valid outputs are extremely rare.
• Forgetting to ask whether the valid outputs should be uniformly distributed.
• Reimplementing unique sampling with loops when random.sample already solves it.
• Generating floats and rounding them, which often distorts the intended distribution.
• Solving a structured constraint with ad hoc retries instead of generating directly in the valid space.

Summary

• Constrained random generation depends on the exact constraint you need to satisfy.
• Use direct APIs for simple ranges and random.sample for uniqueness.
• For fixed-sum problems, partition the total instead of guessing and retrying.
• Rejection sampling is fine for simple predicates with good acceptance rates.
• Always think about distribution as well as validity.