Precomputation Techniques for Competitive Programming

// Initialize arrays with size 100000
const prefixSum = new Array(100000).fill(0);
const prefixXor = new Array(100000).fill(0);
const minLeft = new Array(100000).fill(0);
const maxLeft = new Array(100000).fill(0);

function preCompute(n, arr) {
    // Initialize values for the first element
    prefixSum[0] = prefixXor[0] = minLeft[0] = maxLeft[0] = arr[0];

    // Compute prefix sums, XORs, minimums, and maximums
    for (let i = 1; i < n; i++) {
        prefixSum[i] = prefixSum[i - 1] + arr[i];
        prefixXor[i] = prefixXor[i - 1] ^ arr[i];
        minLeft[i] = Math.min(minLeft[i - 1], arr[i]);
        maxLeft[i] = Math.max(maxLeft[i - 1], arr[i]);
    }
}

// Example usage
const n = 5;
const arr = [2, 3, 1, 4, 5];
preCompute(n, arr);

// Print the computed arrays
console.log("Prefix Sum:", prefixSum);
console.log("Prefix XOR:", prefixXor);
console.log("Min Left:", minLeft);
console.log("Max Left:", maxLeft);

// Define the value of N
let N = 1000;

// Initialize an array to track whether each number up to N is prime
let prime = Array(N + 1).fill(true);

// Function to pre-compute prime numbers up to N using the Sieve of Eratosthenes algorithm
function preComputeSieve() {
    // Mark 0 and 1 as non-prime
    prime[0] = prime[1] = false;

    // Loop through numbers from 2 up to the square root of N
    for (let i = 2; i <= Math.sqrt(N); i++) {
        // If i is prime
        if (prime[i]) {
            // Mark all multiples of i as non-prime
            for (let j = i * i; j <= N; j += i) {
                prime[j] = false;
            }
        }
    }
}

// Call the pre-computation function
preComputeSieve();

// Output the prime array, indicating whether each number up to N is prime
console.log(prime);
//This code is contributed by Adarsh

const N = 1000000; // Assuming a maximum value for N

// Arrays to store smallest prime factor (spf) and prime flags
const spf = new Array(N).fill(0);
const prime = new Array(N).fill(true);

// Function to perform Sieve of Eratosthenes algorithm
function sieve() {
    // Initialize the spf array with indices
    for (let i = 0; i < N; i++) {
        spf[i] = i;
    }

    // Initialize the prime array and mark 0 and 1 as not prime
    fill(prime, true);
    prime[0] = prime[1] = false;

    // Iterate over numbers starting from 2 and mark multiples as not prime
    for (let i = 2; i * i <= N; i++) {
        if (prime[i]) {
            // Mark multiples of i as not prime
            for (let j = i * i; j < N; j += i) {
                prime[j] = false;

                // Update smallest prime factor (spf) if not updated before
                if (spf[j] === j) {
                    spf[j] = i;
                }
            }
        }
    }
}

// Utility method to fill an array with a given value
function fill(arr, value) {
    for (let i = 0; i < arr.length; i++) {
        arr[i] = value;
    }
}

// Main method (for testing)
function main() {
    // Call the sieve method to generate primes and smallest prime factors
    sieve();

    // Print some results (you can customize this part)
    console.log("Prime numbers up to 100:");
    for (let i = 0; i <= 100; i++) {
        if (prime[i]) {
            process.stdout.write(i + " ");
        }
    }

    console.log("\nSmallest prime factors up to 20:");
    for (let i = 1; i <= 20; i++) {
        console.log("smallest prime factor of " + i + " is: " + spf[i]);
    }
}

// Call the main method to execute the code
main();

const N = 1000001;
const mod = 1000000007;

// Function to compute the modular exponentiation (a^b) % mod
function power(a, b) {
    let result = 1;
    a = a % mod;
    while (b > 0) {
        if (b % 2 === 1)
            result = (result * a) % mod;
        b = Math.floor(b / 2);
        a = (a * a) % mod;
    }
    return result;
}

// Function to compute the modular multiplication (a * b) % mod
function mul(a, b) {
    return ((a % mod) * (b % mod)) % mod;
}

// Function to initialize the factorial and inverse factorial arrays
function initNCR() {
    const fact = new Array(N);
    const invfact = new Array(N);

    fact[0] = 1;
    for (let i = 1; i < N; i++) {
        fact[i] = mul(i, fact[i - 1]);
    }
    let i = N - 1;
    invfact[i] = power(fact[i], mod - 2);
    for (i--; i >= 0; i--) {
        invfact[i] = mul((i + 1), invfact[i + 1]);
    }

    // Return the initialized arrays
    return { fact, invfact };
}

// Function to compute nCr using precomputed factorials and inverse factorials
function ncr(n, r, fact, invfact) {
    if (r > n || n < 0 || r < 0)
        return 0;
    return mul(mul(fact[n], invfact[r]), invfact[n - r]);
}

// Initialize the factorial and inverse factorial arrays
const { fact, invfact } = initNCR();

// Example usage:
const n = 5;
const r = 2;
console.log(ncr(n, r, fact, invfact)); // Output: 10

// Function to perform precomputation and answer queries
function preComputation(s, queries, characters) {
    const n = s.length;

    // Create a 2D array to store prefix sum of character occurrences
    const psum = Array.from({ length: n + 1 }, () => Array(26).fill(0));

    // Calculate prefix sums
    for (let i = 1; i <= n; i++) {
        for (let j = 0; j < 26; j++) {
            // Update prefix sum
            psum[i][j] += psum[i - 1][j];
        }
        // Increment the count of current character
        psum[i][s.charCodeAt(i - 1) - 'a'.charCodeAt(0)] += 1;
    }

    const m = queries.length;
    const ans = [];

    // Calculate answers for each query
    for (let i = 0; i < m; i++) {
        // Calculate the count of character within the specified range
        ans.push(psum[queries[i][1]][characters[i].charCodeAt(0) - 'a'.charCodeAt(0)]
                   - psum[queries[i][0] - 1][characters[i].charCodeAt(0) - 'a'.charCodeAt(0)]);
    }

    return ans;
}

// Define the input string 's'.
const s = "examplestring";
// Define the list of queries.
const queries = [[1, 5], [3, 7], [2, 10]];
// Define the list of characters for queries.
const characters = ['e', 'a', 's'];

// Call the pre_computation function to get the answers.
const result = preComputation(s, queries, characters);

// Print the result.
console.log(result);
//This code is contributed by Prachi.