Чи є ефективний спосіб генерувати N випадкових цілих чисел у діапазоні, який має задану суму чи середнє значення?

Чи є ефективний спосіб генерувати випадкову комбінацію N цілих чисел, така що:

• кожне ціле число знаходиться в інтервалі [ min, max],
• цілі числа мають суму sum,
• цілі числа можуть відображатися в будь-якому порядку (наприклад, випадковому порядку) та
• комбінація вибирається рівномірно випадково серед усіх комбінацій, які відповідають іншим вимогам?

Чи існує аналогічний алгоритм випадкових комбінацій, в яких цілі числа повинні відображатися в упорядкованому порядку за їх значеннями (а не в будь-якому порядку)?

(Вибір відповідної комбінації із середнім значенням mean- це окремий випадок, якщо sum = N * mean. Ця проблема еквівалентна генеруванню рівномірного випадкового розподілу sumна N частин, що знаходяться в інтервалі [ min, max] і відображаються в будь-якому порядку або в упорядкованому порядку за їх значення, залежно від випадку.)

Я знаю, що цю проблему можна вирішити наступним чином для комбінацій, що з’являються у випадковому порядку (EDIT [квіт. 27]: Алгоритм змінено.):

1. Якщо N * max < sumабо N * min > sum, рішення немає.

2. Якщо N * max == sum, існує лише одне рішення, в якому всі Nчисла рівні max. Якщо N * min == sum, існує лише одне рішення, в якому всі Nчисла рівні min.

3. Використовуйте алгоритм, наведений у Smith and Tromble ("Вибірка з Unit Simplex", 2004), щоб генерувати N випадкових невід'ємних цілих чисел із сумою sum - N * min.

4. Додайте minдо кожного створеного таким чином номера.

5. Якщо будь-яке число більше max, перейдіть до кроку 3.

Однак цей алгоритм повільний, якщо maxнабагато менше sum. Наприклад, згідно з моїми тестами (із впровадженням окремого випадку, що стосується вище mean), алгоритм в середньому відхиляє:

• приблизно 1,6 проби, якщо N = 7, min = 3, max = 10, sum = 42, але
• приблизно 30,6 проби, якщо N = 20, min = 3, max = 10, sum = 120.

Чи є спосіб змінити цей алгоритм, щоб він був ефективним для великих N, одночасно дотримуючись вищезазначених вимог?

Редагувати:

В якості альтернативи, запропонованої в коментарях, ефективним способом створення дійсної випадкової комбінації (яка задовольняє всі, крім останньої вимоги) є:

1. Розрахувати Xкількість допустимих комбінацій можливо при sum, minі max.
2. Виберіть Y, єдине випадкове ціле число в [0, X).
3. Перетворити ("unrank") Yу дійсну комбінацію.

Однак чи існує формула для обчислення кількості дійсних комбінацій (або перестановок), і чи є спосіб перетворити ціле число на допустиме поєднання? [EDIT (28 квітня): Те саме для перестановок, а не комбінацій].

EDIT (27 квітня):

Прочитавши Неуніфіковану генерацію випадкових змінних Devroye (1986), я можу підтвердити, що це проблема генерації випадкових розділів. Також вправа 2 (особливо частина Е) на сторінці 661 стосується цього питання.

EDIT (28 квітня):

Як виявилося, алгоритм, який я дав, є рівномірним, коли цілі числа, що беруть участь, задаються у випадковому порядку , на відміну від відсортованого порядку за їх значеннями . Оскільки обидві проблеми представляють загальний інтерес, я змінив це питання, щоб шукати канонічну відповідь на обидві проблеми.

Наступний код Ruby може бути використаний для перевірки потенційних рішень на однаковість (де algorithm(...)алгоритм-кандидат):

combos={}
permus={}
mn=0
mx=6
sum=12
for x in mn..mx
  for y in mn..mx
    for z in mn..mx
      if x+y+z==sum
        permus[[x,y,z]]=0
      end
      if x+y+z==sum and x<=y and y<=z
        combos[[x,y,z]]=0
      end
    end
  end
end

3000.times {|x|
 f=algorithm(3,sum,mn,mx)
 combos[f.sort]+=1
 permus[f]+=1
}
p combos
p permus

EDIT (29 квітня): знову доданий Ruby-код поточної реалізації.

Наступний приклад коду наведено в Ruby, але моє запитання не залежить від мови програмування:

def posintwithsum(n, total)
    raise if n <= 0 or total <=0
    ls = [0]
    ret = []
    while ls.length < n
      c = 1+rand(total-1)
      found = false
      for j in 1...ls.length
        if ls[j] == c
          found = true
          break
        end
      end
      if found == false;ls.push(c);end
    end
    ls.sort!
    ls.push(total)
    for i in 1...ls.length
       ret.push(ls[i] - ls[i - 1])
    end
    return ret
end

def integersWithSum(n, total)
 raise if n <= 0 or total <=0
 ret = posintwithsum(n, total + n)
 for i in 0...ret.length
    ret[i] = ret[i] - 1
 end
 return ret
end

# Generate 100 valid samples
mn=3
mx=10
sum=42
n=7
100.times {
 while true
    pp=integersWithSum(n,sum-n*mn).map{|x| x+mn }
    if !pp.find{|x| x>mx }
      p pp; break # Output the sample and break
    end
 end
}

Ось моє рішення в Java. Він повністю функціональний і містить два генератори: PermutationPartitionGeneratorдля несортованих розділів і CombinationPartitionGeneratorдля відсортованих розділів. Ваш генератор також реалізований у класі SmithTromblePartitionGeneratorдля порівняння. Клас SequentialEnumeratorперераховує всі можливі розділи (несортовані або відсортовані, залежно від параметра) у послідовному порядку. Я додав ретельні тести (включаючи ваші тестові випадки) для всіх цих генераторів. Реалізація здебільшого зрозуміла. Якщо у вас є якісь запитання, я відповім на них через пару днів.

import java.util.Random;
import java.util.function.Supplier;

public abstract class PartitionGenerator implements Supplier<int[]>{
    public static final Random rand = new Random();
    protected final int numberCount;
    protected final int min;
    protected final int range;
    protected final int sum; // shifted sum
    protected final boolean sorted;

    protected PartitionGenerator(int numberCount, int min, int max, int sum, boolean sorted) {
        if (numberCount <= 0)
            throw new IllegalArgumentException("Number count should be positive");
        this.numberCount = numberCount;
        this.min = min;
        range = max - min;
        if (range < 0)
            throw new IllegalArgumentException("min > max");
        sum -= numberCount * min;
        if (sum < 0)
            throw new IllegalArgumentException("Sum is too small");
        if (numberCount * range < sum)
            throw new IllegalArgumentException("Sum is too large");
        this.sum = sum;
        this.sorted = sorted;
    }

    // Whether this generator returns sorted arrays (i.e. combinations)
    public final boolean isSorted() {
        return sorted;
    }

    public interface GeneratorFactory {
        PartitionGenerator create(int numberCount, int min, int max, int sum);
    }
}

import java.math.BigInteger;

// Permutations with repetition (i.e. unsorted vectors) with given sum
public class PermutationPartitionGenerator extends PartitionGenerator {
    private final double[][] distributionTable;

    public PermutationPartitionGenerator(int numberCount, int min, int max, int sum) {
        super(numberCount, min, max, sum, false);
        distributionTable = calculateSolutionCountTable();
    }

    private double[][] calculateSolutionCountTable() {
        double[][] table = new double[numberCount + 1][sum + 1];
        BigInteger[] a = new BigInteger[sum + 1];
        BigInteger[] b = new BigInteger[sum + 1];
        for (int i = 1; i <= sum; i++)
            a[i] = BigInteger.ZERO;
        a[0] = BigInteger.ONE;
        table[0][0] = 1.0;
        for (int n = 1; n <= numberCount; n++) {
            double[] t = table[n];
            for (int s = 0; s <= sum; s++) {
                BigInteger z = BigInteger.ZERO;
                for (int i = Math.max(0, s - range); i <= s; i++)
                    z = z.add(a[i]);
                b[s] = z;
                t[s] = z.doubleValue();
            }
            // swap a and b
            BigInteger[] c = b;
            b = a;
            a = c;
        }
        return table;
    }

    @Override
    public int[] get() {
        int[] p = new int[numberCount];
        int s = sum; // current sum
        for (int i = numberCount - 1; i >= 0; i--) {
            double t = rand.nextDouble() * distributionTable[i + 1][s];
            double[] tableRow = distributionTable[i];
            int oldSum = s;
            // lowerBound is introduced only for safety, it shouldn't be crossed 
            int lowerBound = s - range;
            if (lowerBound < 0)
                lowerBound = 0;
            s++;
            do
                t -= tableRow[--s];
            // s can be equal to lowerBound here with t > 0 only due to imprecise subtraction
            while (t > 0 && s > lowerBound);
            p[i] = min + (oldSum - s);
        }
        assert s == 0;
        return p;
    }

    public static final GeneratorFactory factory = (numberCount, min, max,sum) ->
        new PermutationPartitionGenerator(numberCount, min, max, sum);
}

import java.math.BigInteger;

// Combinations with repetition (i.e. sorted vectors) with given sum 
public class CombinationPartitionGenerator extends PartitionGenerator {
    private final double[][][] distributionTable;

    public CombinationPartitionGenerator(int numberCount, int min, int max, int sum) {
        super(numberCount, min, max, sum, true);
        distributionTable = calculateSolutionCountTable();
    }

    private double[][][] calculateSolutionCountTable() {
        double[][][] table = new double[numberCount + 1][range + 1][sum + 1];
        BigInteger[][] a = new BigInteger[range + 1][sum + 1];
        BigInteger[][] b = new BigInteger[range + 1][sum + 1];
        double[][] t = table[0];
        for (int m = 0; m <= range; m++) {
            a[m][0] = BigInteger.ONE;
            t[m][0] = 1.0;
            for (int s = 1; s <= sum; s++) {
                a[m][s] = BigInteger.ZERO;
                t[m][s] = 0.0;
            }
        }
        for (int n = 1; n <= numberCount; n++) {
            t = table[n];
            for (int m = 0; m <= range; m++)
                for (int s = 0; s <= sum; s++) {
                    BigInteger z;
                    if (m == 0)
                        z = a[0][s];
                    else {
                        z = b[m - 1][s];
                        if (m <= s)
                            z = z.add(a[m][s - m]);
                    }
                    b[m][s] = z;
                    t[m][s] = z.doubleValue();
                }
            // swap a and b
            BigInteger[][] c = b;
            b = a;
            a = c;
        }
        return table;
    }

    @Override
    public int[] get() {
        int[] p = new int[numberCount];
        int m = range; // current max
        int s = sum; // current sum
        for (int i = numberCount - 1; i >= 0; i--) {
            double t = rand.nextDouble() * distributionTable[i + 1][m][s];
            double[][] tableCut = distributionTable[i];
            if (s < m)
                m = s;
            s -= m;
            while (true) {
                t -= tableCut[m][s];
                // m can be 0 here with t > 0 only due to imprecise subtraction
                if (t <= 0 || m == 0)
                    break;
                m--;
                s++;
            }
            p[i] = min + m;
        }
        assert s == 0;
        return p;
    }

    public static final GeneratorFactory factory = (numberCount, min, max, sum) ->
        new CombinationPartitionGenerator(numberCount, min, max, sum);
}

import java.util.*;

public class SmithTromblePartitionGenerator extends PartitionGenerator {
    public SmithTromblePartitionGenerator(int numberCount, int min, int max, int sum) {
        super(numberCount, min, max, sum, false);
    }

    @Override
    public int[] get() {
        List<Integer> ls = new ArrayList<>(numberCount + 1);
        int[] ret = new int[numberCount];
        int increasedSum = sum + numberCount;
        while (true) {
            ls.add(0);
            while (ls.size() < numberCount) {
                int c = 1 + rand.nextInt(increasedSum - 1);
                if (!ls.contains(c))
                    ls.add(c);
            }
            Collections.sort(ls);
            ls.add(increasedSum);
            boolean good = true;
            for (int i = 0; i < numberCount; i++) {
                int x = ls.get(i + 1) - ls.get(i) - 1;
                if (x > range) {
                    good = false;
                    break;
                }
                ret[i] = x;
            }
            if (good) {
                for (int i = 0; i < numberCount; i++)
                    ret[i] += min;
                return ret;
            }
            ls.clear();
        }
    }

    public static final GeneratorFactory factory = (numberCount, min, max, sum) ->
        new SmithTromblePartitionGenerator(numberCount, min, max, sum);
}

import java.util.Arrays;

// Enumerates all partitions with given parameters
public class SequentialEnumerator extends PartitionGenerator {
    private final int max;
    private final int[] p;
    private boolean finished;

    public SequentialEnumerator(int numberCount, int min, int max, int sum, boolean sorted) {
        super(numberCount, min, max, sum, sorted);
        this.max = max;
        p = new int[numberCount];
        startOver();
    }

    private void startOver() {
        finished = false;
        int unshiftedSum = sum + numberCount * min;
        fillMinimal(0, Math.max(min, unshiftedSum - (numberCount - 1) * max), unshiftedSum);
    }

    private void fillMinimal(int beginIndex, int minValue, int fillSum) {
        int fillRange = max - minValue;
        if (fillRange == 0)
            Arrays.fill(p, beginIndex, numberCount, max);
        else {
            int fillCount = numberCount - beginIndex;
            fillSum -= fillCount * minValue;
            int maxCount = fillSum / fillRange;
            int maxStartIndex = numberCount - maxCount;
            Arrays.fill(p, maxStartIndex, numberCount, max);
            fillSum -= maxCount * fillRange;
            Arrays.fill(p, beginIndex, maxStartIndex, minValue);
            if (fillSum != 0)
                p[maxStartIndex - 1] = minValue + fillSum;
        }
    }

    @Override
    public int[] get() { // returns null when there is no more partition, then starts over
        if (finished) {
            startOver();
            return null;
        }
        int[] pCopy = p.clone();
        if (numberCount > 1) {
            int i = numberCount;
            int s = p[--i];
            while (i > 0) {
                int x = p[--i];
                if (x == max) {
                    s += x;
                    continue;
                }
                x++;
                s--;
                int minRest = sorted ? x : min;
                if (s < minRest * (numberCount - i - 1)) {
                    s += x;
                    continue;
                }
                p[i++]++;
                fillMinimal(i, minRest, s);
                return pCopy;
            }
        }
        finished = true;
        return pCopy;
    }

    public static final GeneratorFactory permutationFactory = (numberCount, min, max, sum) ->
        new SequentialEnumerator(numberCount, min, max, sum, false);
    public static final GeneratorFactory combinationFactory = (numberCount, min, max, sum) ->
        new SequentialEnumerator(numberCount, min, max, sum, true);
}

import java.util.*;
import java.util.function.BiConsumer;
import PartitionGenerator.GeneratorFactory;

public class Test {
    private final int numberCount;
    private final int min;
    private final int max;
    private final int sum;
    private final int repeatCount;
    private final BiConsumer<PartitionGenerator, Test> procedure;

    public Test(int numberCount, int min, int max, int sum, int repeatCount,
            BiConsumer<PartitionGenerator, Test> procedure) {
        this.numberCount = numberCount;
        this.min = min;
        this.max = max;
        this.sum = sum;
        this.repeatCount = repeatCount;
        this.procedure = procedure;
    }

    @Override
    public String toString() {
        return String.format("=== %d numbers from [%d, %d] with sum %d, %d iterations ===",
                numberCount, min, max, sum, repeatCount);
    }

    private static class GeneratedVector {
        final int[] v;

        GeneratedVector(int[] vect) {
            v = vect;
        }

        @Override
        public int hashCode() {
            return Arrays.hashCode(v);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            return Arrays.equals(v, ((GeneratedVector)obj).v);
        }

        @Override
        public String toString() {
            return Arrays.toString(v);
        }
    }

    private static final Comparator<Map.Entry<GeneratedVector, Integer>> lexicographical = (e1, e2) -> {
        int[] v1 = e1.getKey().v;
        int[] v2 = e2.getKey().v;
        int len = v1.length;
        int d = len - v2.length;
        if (d != 0)
            return d;
        for (int i = 0; i < len; i++) {
            d = v1[i] - v2[i];
            if (d != 0)
                return d;
        }
        return 0;
    };

    private static final Comparator<Map.Entry<GeneratedVector, Integer>> byCount =
            Comparator.<Map.Entry<GeneratedVector, Integer>>comparingInt(Map.Entry::getValue)
            .thenComparing(lexicographical);

    public static int SHOW_MISSING_LIMIT = 10;

    private static void checkMissingPartitions(Map<GeneratedVector, Integer> map, PartitionGenerator reference) {
        int missingCount = 0;
        while (true) {
            int[] v = reference.get();
            if (v == null)
                break;
            GeneratedVector gv = new GeneratedVector(v);
            if (!map.containsKey(gv)) {
                if (missingCount == 0)
                    System.out.println(" Missing:");
                if (++missingCount > SHOW_MISSING_LIMIT) {
                    System.out.println("  . . .");
                    break;
                }
                System.out.println(gv);
            }
        }
    }

    public static final BiConsumer<PartitionGenerator, Test> distributionTest(boolean sortByCount) {
        return (PartitionGenerator gen, Test test) -> {
            System.out.print("\n" + getName(gen) + "\n\n");
            Map<GeneratedVector, Integer> combos = new HashMap<>();
            // There's no point of checking permus for sorted generators
            // because they are the same as combos for them
            Map<GeneratedVector, Integer> permus = gen.isSorted() ? null : new HashMap<>();
            for (int i = 0; i < test.repeatCount; i++) {
                int[] v = gen.get();
                if (v == null && gen instanceof SequentialEnumerator)
                    break;
                if (permus != null) {
                    permus.merge(new GeneratedVector(v), 1, Integer::sum);
                    v = v.clone();
                    Arrays.sort(v);
                }
                combos.merge(new GeneratedVector(v), 1, Integer::sum);
            }
            Set<Map.Entry<GeneratedVector, Integer>> sortedEntries = new TreeSet<>(
                    sortByCount ? byCount : lexicographical);
            System.out.println("Combos" + (gen.isSorted() ? ":" : " (don't have to be uniform):"));
            sortedEntries.addAll(combos.entrySet());
            for (Map.Entry<GeneratedVector, Integer> e : sortedEntries)
                System.out.println(e);
            checkMissingPartitions(combos, test.getGenerator(SequentialEnumerator.combinationFactory));
            if (permus != null) {
                System.out.println("\nPermus:");
                sortedEntries.clear();
                sortedEntries.addAll(permus.entrySet());
                for (Map.Entry<GeneratedVector, Integer> e : sortedEntries)
                    System.out.println(e);
                checkMissingPartitions(permus, test.getGenerator(SequentialEnumerator.permutationFactory));
            }
        };
    }

    public static final BiConsumer<PartitionGenerator, Test> correctnessTest =
        (PartitionGenerator gen, Test test) -> {
        String genName = getName(gen);
        for (int i = 0; i < test.repeatCount; i++) {
            int[] v = gen.get();
            if (v == null && gen instanceof SequentialEnumerator)
                v = gen.get();
            if (v.length != test.numberCount)
                throw new RuntimeException(genName + ": array of wrong length");
            int s = 0;
            if (gen.isSorted()) {
                if (v[0] < test.min || v[v.length - 1] > test.max)
                    throw new RuntimeException(genName + ": generated number is out of range");
                int prev = test.min;
                for (int x : v) {
                    if (x < prev)
                        throw new RuntimeException(genName + ": unsorted array");
                    s += x;
                    prev = x;
                }
            } else
                for (int x : v) {
                    if (x < test.min || x > test.max)
                        throw new RuntimeException(genName + ": generated number is out of range");
                    s += x;
                }
            if (s != test.sum)
                throw new RuntimeException(genName + ": wrong sum");
        }
        System.out.format("%30s :   correctness test passed%n", genName);
    };

    public static final BiConsumer<PartitionGenerator, Test> performanceTest =
        (PartitionGenerator gen, Test test) -> {
        long time = System.nanoTime();
        for (int i = 0; i < test.repeatCount; i++)
            gen.get();
        time = System.nanoTime() - time;
        System.out.format("%30s : %8.3f s %10.0f ns/test%n", getName(gen), time * 1e-9, time * 1.0 / test.repeatCount);
    };

    public PartitionGenerator getGenerator(GeneratorFactory factory) {
        return factory.create(numberCount, min, max, sum);
    }

    public static String getName(PartitionGenerator gen) {
        String name = gen.getClass().getSimpleName();
        if (gen instanceof SequentialEnumerator)
            return (gen.isSorted() ? "Sorted " : "Unsorted ") + name;
        else
            return name;
    }

    public static GeneratorFactory[] factories = { SmithTromblePartitionGenerator.factory,
            PermutationPartitionGenerator.factory, CombinationPartitionGenerator.factory,
            SequentialEnumerator.permutationFactory, SequentialEnumerator.combinationFactory };

    public static void main(String[] args) {
        Test[] tests = {
                            new Test(3, 0, 3, 5, 3_000, distributionTest(false)),
                            new Test(3, 0, 6, 12, 3_000, distributionTest(true)),
                            new Test(50, -10, 20, 70, 2_000, correctnessTest),
                            new Test(7, 3, 10, 42, 1_000_000, performanceTest),
                            new Test(20, 3, 10, 120, 100_000, performanceTest)
                       };
        for (Test t : tests) {
            System.out.println(t);
            for (GeneratorFactory factory : factories) {
                PartitionGenerator candidate = t.getGenerator(factory);
                t.procedure.accept(candidate, t);
            }
            System.out.println();
        }
    }
}

Ви можете спробувати це на Ideone .

Ось алгоритм від John McClane's PermutationPartitionGenerator в іншій відповіді на цій сторінці. Він має дві фази, а саме фазу встановлення та фазу вибірки та генерує nвипадкові числа в [ min, max] із сумою sum, де числа перераховані у випадковому порядку.

Фаза налаштування: По-перше, таблиця рішення будується за допомогою таких формул ( t(y, x)де yзнаходиться в [0, n] і xзнаходиться в [0, sum - n * min]):

• t (0, j) = 1, якщо j == 0; 0 інакше
• t (i, j) = t (i-1, j) + t (i-1, j-1) + ... + t (i-1, j- (max-min))

Тут t (y, x) зберігається відносна ймовірність того, що сума yчисел (у відповідному діапазоні) буде дорівнює x. Ця ймовірність відносна всіх t (y, x) з однаковими y.

Фаза вибірки: Тут ми генеруємо вибірку nчисел. Встановіть sна sum - n * min, а потім для кожної позиції i, починаючи з n - 1і повертаючись до 0:

• Встановіть vвипадкове ціле число в [0, t (i + 1, s)).
• Набір rдля min.
• Віднімаємо t (i, s) від v.
• Якщо vзалишається 0 або більше, відніміть t (i, s-1) від v, додайте 1 до rі відніміть 1 s.
• Число в положенні iу вибірці встановлено на r.

Редагувати:

Виявляється, що при тривіальних змінах алгоритму, наведеного вище, можливо, кожне випадкове число використовувати окремий діапазон, а не використовувати один і той же діапазон для всіх:

Кожне випадкове число в позиціях i∈ [0, n) має мінімальне значення min (i) і максимальне значення max (i).

Нехай adjsum= sum- Σmin (i).

Фаза налаштування: По-перше, таблиця рішення будується за допомогою таких формул ( t(y, x)де yзнаходиться в [0, n] і xзнаходиться в [0, adjsum]):

• t (0, j) = 1, якщо j == 0; 0 інакше
• t (i, j) = t (i-1, j) + t (i-1, j-1) + ... + t (i-1, j- (max (i-1) -min (i -1)) )

Фази дискретизації потім точно так же , як і раніше, за винятком того, ми встановили , sщоб adjsum(а не sum - n * min) і безліч rв хв (я) (а не min).

Редагувати:

Для John McClane's CombinationPartitionGenerator, фази налаштування та вибірки наступні.

Фаза налаштування: По-перше, таблиця рішення будується за допомогою таких формул ( t(z, y, x)де zзнаходиться в [0, n], yзнаходиться в [0, max - min] і xзнаходиться в [0, sum - n * min]):

• t (0, j, k) = 1, якщо k == 0; 0 інакше
• t (i, 0, k) = t (i - 1, 0, k)
• t (i, j, k) = t (i, j-1, k) + t (i - 1, j, k - j)

Фаза вибірки: Тут ми генеруємо вибірку nчисел. Встановіть sна sum - n * minі mrangeдо max - min, а потім для кожної позиції i, починаючи з n - 1і працюючи назад до 0:

• Встановіть vдовільне ціле число в [0, t (i + 1, mrange, s)).
• Встановити mrangemin ( mrange, s)
• Відняти mrangeвід s.
• Набір rдля min + mrange.
• Віднімання т ( i, mrange, s) з v.
• Поки vзалишається 0 або більше, додайте 1 до s, відняти 1 з rі 1 з mrange, а потім відніміть т ( i, mrange, s) з v.
• Число в положенні iу вибірці встановлено на r.

Я цього не перевіряв, тож насправді це не відповідь, а лише спробувати щось, що занадто довго, щоб вписатись у коментар. Почніть з масиву, який відповідає першим двом критеріям, і грайте з ним, щоб він все-таки відповідав першим двом, але набагато більше випадковий.

Якщо середнє значення є цілим числом, то ваш початковий масив може бути [4, 4, 4, ... 4] або, можливо, [3, 4, 5, 3, 4, 5, ... 5, 8, 0] або щось просте подібне. Для середнього значення 4,5 спробуйте [4, 5, 4, 5, ... 4, 5].

Далі виберіть пару чисел num1і num2в масиві. Напевно, перше число потрібно взяти для того, щоб, як і у перетасуванні Фішера-Йейта, друге число потрібно було вибрати як завгодно. Введення першого номера в порядку гарантує, що кожне число вибирається хоча б один раз.

Тепер обчислимо max-num1і num2-min. Це відстані від двох чисел до maxта minмеж. Встановіть limitна меншу з двох відстаней. Це максимально дозволена зміна, яка не ставить те чи інше число за межами дозволених меж. Якщо limitнуль, тоді пропустіть цю пару.

Виберіть випадкове ціле число в діапазоні [1, limit]: викликайте його change. Я опускаю 0 з діапазону вибору, оскільки це не має ефекту. Тестування може показати, що ви отримуєте кращу випадковість, включаючи її; Я не впевнений.

Тепер встановіть num1 <- num1 + changeі num2 <- num2 - change. Це не вплине на середнє значення, і всі елементи масиву все ще знаходяться в необхідних межах.

Вам потрібно буде пробігти весь масив хоча б один раз. Тестування повинно показувати, чи потрібно вам не один раз пробігати, щоб отримати щось досить випадкове.

ETA: включити псевдокод

// Set up the array.
resultAry <- new array size N
for (i <- 0 to N-1)
  // More complex initial setup schemes are possible here.
  resultAry[i] <- mean
rof

// Munge the array entries.
for (ix1 <- 0 to N-1)  // ix1 steps through the array in order.

  // Pick second entry different from first.
  repeat
    ix2 <- random(0, N-1)
  until (ix2 != ix1)

  // Calculate size of allowed change.
  hiLimit <- max - resultAry[ix1]
  loLimit <- resultAry[ix2] - min
  limit <- minimum(hiLimit, loLimit)
  if (limit == 0)
    // No change possible so skip.
    continue loop with next ix1
  fi

  // Change the two entries keeping same mean.
  change <- random(1, limit)  // Or (0, limit) possibly.
  resultAry[ix1] <- resultAry[ix1] + change
  resultAry[ix2] <- resultAry[ix2] - change

rof

// Check array has been sufficiently munged.
if (resultAry not random enough)
  munge the array again
fi

Як зазначає ОП, здатність до ефективного відключення дуже потужна. Якщо ми зможемо це зробити, генерувати рівномірний розподіл розділів можна в три етапи (переглянувши те, що ОП виклало у запитанні):

1. Обчисліть загальну кількість, M , перегородок довжиною N числа, sumтаким чином, щоб деталі знаходились у діапазоні [ min, max].
2. Створити рівномірний розподіл цілих чисел від [1, M].
3. Відкрутіть кожне ціле число з кроку 2 у відповідний розділ.

Нижче ми зосереджуємось лише на генерації n- ^го розділу, оскільки існує велика кількість інформації про генерування рівномірного розподілу цілого числа в заданому діапазоні. Ось простий C++алгоритм розв’язування, який слід легко перекласти на інші мови.

std::vector<int> unRank(int n, int m, int myMax, int nth) {

    std::vector<int> z(m, 0);
    int count = 0;
    int j = 0;

    for (int i = 0; i < z.size(); ++i) {
        int temp = pCount(n - 1, m - 1, myMax);

        for (int r = n - m, k = myMax - 1;
             (count + temp) < nth && r > 0 && k; r -= m, --k) {

            count += temp;
            n = r;
            myMax = k;
            ++j;
            temp = pCount(n - 1, m - 1, myMax);
        }

        --m;
        --n;
        z[i] = j;
    }

    return z;
}

Функція робочого коня pCountзадається:

int pCount(int n, int m, int myMax) {

    if (myMax * m < n) return 0;
    if (myMax * m == n) return 1;

    if (m < 2) return m;
    if (n < m) return 0;
    if (n <= m + 1) return 1;

    int niter = n / m;
    int count = 0;

    for (; niter--; n -= m, --myMax) {
        count += pCount(n - 1, m - 1, myMax);
    }

    return count;
}

Ця функція ґрунтується на відмінній відповіді на питання. Чи існує ефективний алгоритм для цілого розподілу з обмеженою кількістю частин? користувачем @ m69_snarky_and_unwelcoming. Наведене вище - це незначна модифікація простого алгоритму (того, що не запам'ятовується). Це можна легко змінити, щоб включити запам'ятовування для більшої ефективності. Ми покинемо це поки що і зосередимо увагу на нерозбірливій частині.

Пояснення unRank

Спершу зауважимо, що існує однозначне відображення від розділів довжиною N числа, sumтаким чином, що частини знаходяться в діапазоні [ min, max] до обмежених розділів довжиною N числа sum - m * (min - 1)з частинами в [ 1, max - (min - 1)].

Як невеликий приклад розглянемо перегородки 50довжини 4такі, що min = 10і max = 15. Це матиме таку ж структуру, що і обмежені перегородки 50 - 4 * (10 - 1) = 14довжини 4з максимальною частиною, що дорівнює 15 - (10 - 1) = 6.

10   10   15   15   --->>    1    1    6    6
10   11   14   15   --->>    1    2    5    6
10   12   13   15   --->>    1    3    4    6
10   12   14   14   --->>    1    3    5    5
10   13   13   14   --->>    1    4    4    5
11   11   13   15   --->>    2    2    4    6
11   11   14   14   --->>    2    2    5    5
11   12   12   15   --->>    2    3    3    6
11   12   13   14   --->>    2    3    4    5
11   13   13   13   --->>    2    4    4    4
12   12   12   14   --->>    3    3    3    5
12   12   13   13   --->>    3    3    4    4

Зважаючи на це, для того, щоб легко порахувати, ми можемо додати крок 1а, щоб перекласти проблему у "одиничний" випадок, якщо хочете.

Тепер у нас просто проблема з підрахунком. Як @ m69 блискуче відображається, підрахунок розділів можна легко досягти, розбивши проблему на менші проблеми. Функція @ m69 забезпечує нам 90% шляху, нам просто потрібно розібратися, що робити з доданим обмеженням, що існує обмеження. Тут ми отримуємо:

int pCount(int n, int m, int myMax) {

    if (myMax * m < n) return 0;
    if (myMax * m == n) return 1;

Ми також маємо пам’ятати, що myMaxвона зменшиться в міру просування. Це має сенс, якщо ми подивимось на 6- ^й розділ вище:

2   2   4   6

Для того, щоб порахувати кількість розділів звідси і далі, ми повинні продовжувати застосовувати переклад до справи "одиниця". Це виглядає так:

1   1   3   5

Де раніше, ніж у нас був крок 6, тепер ми вважаємо лише макс 5.

Зважаючи на це, вилучення розділу не відрізняється від видалення стандартної перестановки або комбінації. Ми повинні мати можливість порахувати кількість розділів у певному розділі. Наприклад, щоб підрахувати кількість розділів, які починаються 10вище, все, що ми робимо, - це видалити 10в першому стовпці:

10   10   15   15
10   11   14   15
10   12   13   15
10   12   14   14
10   13   13   14

10   15   15
11   14   15
12   13   15
12   14   14
13   13   14

Перекладіть на корпус одиниці:

1   6   6
2   5   6
3   4   6
3   5   5
4   4   5

і зателефонуйте pCount:

pCount(13, 3, 6) = 5

З огляду на випадкове ціле число для розблокування, ми продовжуємо обчислювати кількість розділів у менших та менших розділах (як ми це робили вище), поки ми не заповнили наш індексний вектор.

Приклади

З огляду на min = 3, max = 10, n = 7і sum = 42, ось ideone демо , яка генерує 20 випадкових розділів.