Для заданного числа создайте другое случайное число, которое каждый раз будет одинаковым и отличным от всех других результатов.

Это похоже на неповторяющийся генератор случайных чисел. Есть несколько возможных подходов к этому.

Как описано в этой статье, мы можем сгенерировать их, выбрав простое число p и удовлетворив p % 4 = 3, которое достаточно велико (больше максимального значения в выходном диапазоне), и сгенерировать их следующим образом:

int randomNumberUnique(int range_len , int p , int x)
    if(x * 2 < p)
       return (x * x) % p
    else
       return p - (x * x) % p

Этот алгоритм будет охватывать все значения в [0 , p) для входа в диапазоне [0 , p).

Вот пример на C #:

    private void DoIt()
    {
        const long m = 101;
        const long x = 387420489; // must be coprime to m

        var multInv = MultiplicativeInverse(x, m);

        var nums = new HashSet<long>();
        for (long i = 0; i < 100; ++i)
        {
            var encoded = i*x%m;
            var decoded = encoded*multInv%m;
            Console.WriteLine("{0} => {1} => {2}", i, encoded, decoded);
            if (!nums.Add(encoded))
            {
                Console.WriteLine("Duplicate");
            }
        }
    }

    private long MultiplicativeInverse(long x, long modulus)
    {
        return ExtendedEuclideanDivision(x, modulus).Item1%modulus;
    }

    private static Tuple<long, long> ExtendedEuclideanDivision(long a, long b)
    {
        if (a < 0)
        {
            var result = ExtendedEuclideanDivision(-a, b);
            return Tuple.Create(-result.Item1, result.Item2);
        }
        if (b < 0)
        {
            var result = ExtendedEuclideanDivision(a, -b);
            return Tuple.Create(result.Item1, -result.Item2);
        }
        if (b == 0)
        {
            return Tuple.Create(1L, 0L);
        }
        var q = a/b;
        var r = a%b;
        var rslt = ExtendedEuclideanDivision(b, r);
        var s = rslt.Item1;
        var t = rslt.Item2;
        return Tuple.Create(t, s - q*t);
    }

Это генерирует числа в диапазоне 0-100 из ввода в диапазоне 0-100. Каждый ввод приводит к уникальному результату.

Он также показывает, как обратить процесс, используя мультипликативное обратное.

Вы можете расширить диапазон, увеличив значение m. x должен быть взаимно прост с m.

Код взят из статьи Эрика Липперта Практическое использование мультипликативного обратное и несколько предыдущих статей из этой серии.

Вы не можете быть совершенно не связанными (особенно если вы хотите и обратное).

Существует концепция modulo inverse числа, но это будет работать, только если range число является простым, например. 100 не подойдет, понадобится 101 (простое). Это может предоставить вам псевдослучайное число, если хотите.

Вот концепция обратного по модулю:

Если есть два числа a and b, такие что

(a * b) % p = 1

где p - любое число, тогда

a and b are modular inverses of each other.

Чтобы это было правдой, если нам нужно найти модульную инверсию a относительно числа p, тогда a and p должен быть взаимно простым, т.е. gcd(a,p) = 1

Итак, чтобы все числа в диапазоне имели модульные обратные значения, граница диапазона должна быть простым числом.

Несколько выходных данных для диапазона 101 будут:

1 == 1
2 == 51
3 == 34
4 == 76
etc.

РЕДАКТИРОВАТЬ:

Эй ... на самом деле вы знаете, вы можете использовать комбинированный подход обратного по модулю и метода, определенного @Paul. Поскольку каждая пара будет уникальной и все числа будут покрыты, ваше случайное число может быть:

random(k) = randomUniqueNumber(ModuloInverse(k), p)      //this is Paul's function