如何从给定集合生成指定长度、均值与标准差逼近预设μ、σ的数值列表？

Yes, this is totally doable—and you don’t need the resulting list to follow a normal distribution, which makes things even more flexible. Let’s walk through how to approach this, with practical steps and considerations:

First, nail the mean (it’s the easier target) #

The mean boils down to hitting a specific total sum. Let’s say you need x elements, target mean μ—so your required total is total = μ * x.

Your job is to pick x elements from your source set whose sum is as close as possible to that total. If you can get an exact match, your mean will be perfect. If not, go with the combination that’s nearest. For small x, you can just brute-force test combinations; for larger sets, a greedy approach (picking elements that get you closer to the total step by step) works well.

Then tweak for standard deviation #

Once you’ve got a subset that’s close to your target mean, you can adjust elements to nudge the standard deviation:

• To make σ bigger: swap elements in your current list with values from the source set that are way off from μ (super large or super small).
• To make σ smaller: swap in elements that are as close to μ as possible.

You can iterate this process: swap one element at a time, recalculate the mean and std dev, and keep the swap if it moves both metrics closer to your targets. If a swap helps one but hurts the other, you can decide which metric is more important to you and prioritize that.

Quick code example (Python) #

If you want to automate this, here’s a rough script you can adapt. It uses random swaps to iteratively get closer to your targets:

import random
import math

def get_stats(lst):
    mean = sum(lst) / len(lst)
    variance = sum((val - mean)**2 for val in lst) / len(lst)
    return mean, math.sqrt(variance)

def build_sample(source_set, sample_size, target_mu, target_sigma, max_tries=1000):
    # Start with a random sample
    current = random.sample(source_set, sample_size)
    curr_mu, curr_sigma = get_stats(current)
    
    for _ in range(max_tries):
        # Pick a random element to swap out
        swap_idx = random.randint(0, sample_size - 1)
        # Pick a candidate from the source set (allow repeats if your use case allows)
        candidate = random.choice(source_set)
        
        # Test the swap
        test_sample = current.copy()
        test_sample[swap_idx] = candidate
        test_mu, test_sigma = get_stats(test_sample)
        
        # Check if this brings us closer (adjust weighting if one metric matters more)
        curr_error = abs(curr_mu - target_mu) + abs(curr_sigma - target_sigma)
        test_error = abs(test_mu - target_mu) + abs(test_sigma - target_sigma)
        
        if test_error <= curr_error:
            current = test_sample
            curr_mu, curr_sigma = test_mu, test_sigma
    
    return current, curr_mu, curr_sigma

Note: If you can reuse elements from the source set (i.e., sampling with replacement), you don’t need to worry about picking duplicates—just remove any checks for existing elements.

What to watch out for #

• Range limits: If your source set’s values are all clustered tightly, you can’t get a very high standard deviation (there’s no spread to work with). Similarly, if your target mean is way outside the min/max of your source set, you’ll never hit it exactly—you’ll only get as close as possible.
• Large sample sizes: For very big x, brute-force or random swaps will be slow. You’ll want to use more optimized methods (like dynamic programming to hit the sum target first, then adjust elements for variance).

内容的提问来源于stack exchange，提问作者Tony