Java Program to Implement Inversion Method for Random Number Generation

// Java Program to implement inversion for random number
// generation

// Importing Random class from java.util package
import java.util.Random;

// Main class
class GFG {

    // Method 1
    // To calculate seed value
    public static long calcSeed(long nextLong)
    {

        // Declaring and initializing variables
        // Custom initialization
        final long x = 0x5DEECE66DL;
        final long xinv = 0xdfe05bcb1365L;
        final long y = 0xBL;
        final long mask = ((1L << 48) - 1);

        long a = nextLong >>> 32;
        long b = nextLong & ((1L << 32) - 1);

        if ((b & 0x80000000) != 0)
            a++;

        // b had a sign bit, so we need to restore a
        long q = ((b << 16) - y - (a << 16) * x) & mask;

        for (long k = 0; k <= 5; k++) {

            long rem = (x - (q + (k << 48))) % x;
            long d = (rem + x) % x; // force positive

            if (d < 65536) {

                long c = ((q + d) * xinv) & mask;

                if (c < 65536) {
                    return ((((a << 16) + c) - y) * xinv)
                        & mask;
                }
            }
        }

        // Throws keyword pops up the message
        // as exception is encountered during runtime
        throw new RuntimeException("Failed!!");
    }

    // Method 2
    // Main driver method
    public static void main(String[] args)
    {

        // Setting a random number in main() method by
        // creating an object of Random class
        Random r = new Random();

        // Getting the next random number
        long next = r.nextLong();

        // Print and display the next long value
        System.out.println("Next long value: " + next);

        // Calling method 1
        long seed = calcSeed(next);

        // Print and display the ssed value
        System.out.println("Seed " + seed);

        // setSeed mangles the input,
        // so demangling here to get the right output by
        // creating another object of Random class
        Random r2 = new Random((seed ^ 0x5DEECE66DL)
                               & ((1L << 48) - 1));

        // Printing the next ssed value
        // using nextLong() method
        System.out.println("Next long value from seed: "
                           + r2.nextLong());
    }
}

// Java Program to Implement Inversion Method for
// Random Number Generation

// Importing required classes 
import java.util.Arrays;
import java.util.Random;
import javax.sql.RowSetEvent;
import javax.sql.RowSetListener;
import javax.sql.rowset.JdbcRowSet;
import javax.sql.rowset.RowSetProvider;

// Main class
// To test random reverse
class GFG {

    // The secret seed that we want to find
    private static long SEED = 782634283105L;

    // Number of random numbers to be generated
    private static int NUM_GEN = 5;

    // Method 1
    private static int[] genNum(long seed)
    {
        Random rand = new Random(seed);
        int arr[] = new int[NUM_GEN];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = rand.nextInt();
        }

        return arr;
    }

    // Method 2
    // Main driver method
    public static void main(String args[])
    {

        int arr[] = genNum(SEED);
        System.out.println(Arrays.toString(arr));

        Long result = reverse(arr);

        if (result != null) {
            System.out.println(
                Arrays.toString(genNum(result)));
        }
        else {
            System.out.println("Seed not found");
        }
    }

    // Method 3
    private static long combine(int rand, int suffix)
    {
        return (unsignedIntToLong(rand) << 16)
            | (suffix & ((1L << 16) - 1));
    }

    // Method 4
    private static long unsignedIntToLong(int num)
    {
        return num & ((1L << 32) - 1);
    }

    // Method 5
    // To find the seed of a sequence of
    // integer, generated by nextInt() Can be easily
    // modified to find the seed of a sequence of long,
    // generated by nextLong()
    private static Long reverse(int arr[])
    {

        // Need at least 2 numbers.
        assert (arr.length > 1);

        int end = arr.length - 1;

        // Brute force lower 16 bits, then compare
        // upper 32 bit of the previous seed generated
        // to the previous number.
        for (int i = 0; i < (1 << 16); i++) {

            long candidateSeed = combine(arr[end], i);
            long previousSeed
                = getPreviousSeed(candidateSeed);

            if ((previousSeed >>> 16)
                == unsignedIntToLong(arr[end - 1])) {

                System.out.println("Testing seed: "
                                   + previousSeed + " --> "
                                   + candidateSeed);

                for (int j = end - 1; j >= 0; j--) {
                    candidateSeed = previousSeed;
                    previousSeed
                        = getPreviousSeed(candidateSeed);

                    if (j > 0
                        && (previousSeed >>> 16)
                               == unsignedIntToLong(
                                   arr[j - 1])) {

                        System.out.println(
                            "Verifying: " + previousSeed
                            + " --> " + candidateSeed);
                    }
                    else if (j == 0) {

                        // The XOR is done when the seed is
                        // set, need to reverse it
                        System.out.println(
                            "Seed found: "
                            + (previousSeed ^ MULTIPLIER));

                        return previousSeed ^ MULTIPLIER;
                    }
                    else {
                        // Print statement
                        System.out.println("Failed");

                        // break keyword
                        break;
                    }
                }
            }
        }

        return null;
    }

    private static long ADDEND = 0xBL;
    private static long MULTIPLIER = 0x5DEECE66DL;

    // Method 6
    private static long getPreviousSeed(long currentSeed)
    {

        long seed = currentSeed;

        // Reverse the addend from the seed
        // Reversing the addend
        seed -= ADDEND;

        long result = 0;

        // Iterating through the seeds bits
        for (int i = 0; i < 48; i++) {

            long mask = 1L << i;
            // find the next bit
            long bit = seed & mask;
            // add it to the result

            result |= bit;

            if (bit == mask) {
                // if the bit was 1, subtract its effects
                // from the seed
                seed -= MULTIPLIER << i;
            }
        }

        return result & ((1L << 48) - 1);
    }
}