如何从单条20位随机数生成多个独立5位短随机数？

Hey there! Great question—since you're working with true entropy-based random numbers from random.org (way better than algorithmic PRNGs for any use case where unbias matters), here are some statistically sound, practical ways to split that 20-digit number into independent 5-digit chunks while preserving all that precious randomness:

Since your 20-digit number is uniformly distributed, splitting it into 4 non-overlapping 5-digit segments is the most straightforward and unbiased approach:

• 1st 5-digit chunk: b₁b₂b₃b₄b₅
• 2nd 5-digit chunk: b₆b₇b₈b₉b₁₀
• 3rd 5-digit chunk: b₁₁b₁₂b₁₃b₁₄b₁₅
• 4th 5-digit chunk: b₁₆b₁₇b₁₈b₁₉b₂₀

Why this works: Every digit in your original number is independent and uniformly distributed. Splitting them into contiguous groups doesn't introduce any bias—each 5-digit chunk will also be uniformly distributed, and all chunks are completely independent of each other. This is actually the go-to method recommended for splitting true random numbers, as it preserves all the entropy you've collected.

If you need more than 4 5-digit numbers, you can treat the entire 20-digit string as a single large integer and use modulo arithmetic to extract chunks:

1. Convert your 20-digit string to an integer: N = int(b₁b₂...b₂₀)
2. Extract a 5-digit chunk: chunk = N % 100000 (this gives you a number between 0 and 99999)
3. Update N to remove the extracted chunk: N = N // 100000
4. Repeat steps 2-3 until N is less than 100000 (discard the remaining digits if they're fewer than 5—don't pad with zeros, as that would introduce bias)

Important note: This method still produces independent, uniformly distributed chunks. Since the original large integer is uniformly random, taking modulo 100000 will spread the results evenly across all 100000 possible 5-digit values. Just avoid reusing the original number once you've exhausted N—that would create duplicate chunks and break independence.

If you want to avoid using contiguous segments (for example, if you're worried about any hypothetical correlation between adjacent digits—though there's none in true random numbers), you can shuffle the digits first, then split:

1. Turn your 20-digit string into a list of individual characters: digits = list(b₁b₂...b₂₀)
2. Shuffle the list using an unbiased algorithm like the Fisher-Yates shuffle (since your digits are already true random, even a simple random reordering works, but Fisher-Yates guarantees no bias)
3. Split the shuffled list into 4 groups of 5 digits each, then convert each group back to a string

Why this is safe: Any permutation of a true random sequence is also true random. Shuffling just rearranges the entropy—your final chunks will still be independent and uniformly distributed, same as direct splitting. This is purely a cosmetic choice if you prefer non-contiguous segments.

• Do not reuse digits across chunks: Using the same digit in multiple chunks will create correlations between those chunks, destroying their independence.
• Handle leading zeros carefully: If your use case doesn't allow leading zeros (e.g., you need numbers from 10000 to 99999), filtering out chunks below 10000 will introduce a small bias. If possible, accept leading zeros—they're valid random digits. If you can't, you'll have to discard low-value chunks and use extra entropy if you have it.
• Do not "stretch" entropy beyond its limits: You can't get more than 4 fully independent 5-digit chunks from 20 digits without reusing entropy (which breaks independence). The modulo method lets you extract up to 4 full chunks plus a partial one, but don't try to generate more than that without getting additional random numbers from random.org.

内容的提问来源于stack exchange，提问作者Joel W.