<script>
// Javascript program to determine if the element
// exists for different range queries


// Structure to represent a query range
class Query
{

    constructor(L, R, X)
    {
        this.L = L;
        this.R = R;
        this.X = X;
    }
};

let maxn = 100;

let root = new Array(maxn);

// Find the root of the group containing
// the element at index x
function find(x)
{
    if(x == root[x])
        return x;
    else
        return root[x] = find(root[x]);
}

// merge the two groups containing elements
// at indices x and y into one group
function uni(x, y)
{
    let p = find(x), q = find(y);
    if (p != q)
    {
        root[p] = root[q];
    }
}

function initialize(a, n, q, m)
{
    // make n subsets with every
    // element as its root
    for (let i = 0; i < n; i++)
        root[i] = i;

    // consecutive elements equal in value are
    // merged into one single group
    for (let i = 1; i < n; i++)
        if (a[i] == a[i - 1])
            uni(i, i - 1);
}

// Driver code

    let a = [ 1, 1, 5, 4, 5 ];
    let n = a.length;
    let q = [ new Query(0, 2, 2 ),
                new Query( 1, 4, 1 ),
                new Query( 2, 4, 5 ) ];
    let m = q.length;
    initialize(a, n, q, m);

    for (let i = 0; i < m; i++)
    {
        let flag = 0;
        let l = q[i].L, r = q[i].R, x = q[i].X;
        let p = r;

        while (p >= l)
        {

            // check if the current element in
            // consideration is equal to x or not
            // if it is equal, then x exists in the range
            if (a[p] == x)
            {
                flag = 1;
                break;
            }
            p = find(p) - 1;
        }

        // Print if x exists or not
        if (flag != 0)
            document.write(x + " exists between [" +
                            l + ", " + r + "] " + "<br>");
        else
            document.write(x + " does not exist between [" +
                            l + ", " + r + "] " + "<br>");
    }

// This code is contributed by gfgking
</script>

// Variable to represent block size.
// This is made global, so compare() 
// of sort can use it.
let block;

// Structure to represent a query range
class Query {
    constructor(L, R, X) {
        this.L = L;
        this.R = R;
        this.X = X;
    }
}

// Function used to sort all queries so
// that all queries of same block are
// arranged together and within a block,
// queries are sorted in increasing order 
// of R values.
function compare(x, y) {
    // Different blocks, sort by block.
    if (Math.floor(x.L / block) !== Math.floor(y.L / block)) {
        return Math.floor(x.L / block) - Math.floor(y.L / block);
    }

    // Same block, sort by R value
    return x.R - y.R;
}

// Determines if the element is present for all
// query ranges. m is number of queries
// n is size of array a[].
function queryResults(a, n, q, m) {
    // Find block size
    block = Math.floor(Math.sqrt(n));

    // Sort all queries so that queries of same
    // blocks are arranged together.
    q.sort(compare);

    // Initialize current L, current R
    let currL = 0;
    let currR = 0;

    // To store the frequencies of 
    // elements of the given range
    const mp = new Map();

    // Traverse through all queries
    for (let i = 0; i < m; i++) {
        // L and R values of current range
        const {
            L,
            R,
            X
        } = q[i];

        // Decrement frequencies of extra elements
        // of previous range. For example if previous
        // range is [0, 3] and current range is [2, 5],
        // then the frequencies of a[0] and a[1] are decremented
        while (currL < L) {
            const value = mp.get(a[currL]);
            if (value === 1) {
                mp.delete(a[currL]);
            } else {
                mp.set(a[currL], value - 1);
            }
            currL++;
        }

        // Increment frequencies of elements of current Range
        while (currL > L) {
            currL--;
            const value = mp.get(a[currL]);
            mp.set(a[currL], value ? value + 1 : 1);
        }

        while (currR <= R) {
            const value = mp.get(a[currR]);
            mp.set(a[currR], value ? value + 1 : 1);
            currR++;
        }

        // Decrement frequencies of elements of previous
        // range.  For example when previous range is [0, 10] 
        // and current range is [3, 8], then frequencies of 
        // a[9] and a[10] are decremented
        while (currR > R + 1) {
            currR--;
            const value = mp.get(a[currR]);
            if (value) {
                mp.set(a[currR], value - 1);
            }
        }




        // Print if X exists or not.
        if (mp.get(X) !== undefined && mp.get(X) > 0)
            console.log(`${X} exists between [${L}, ${R}]`);
        else
            console.log(`${X} does not exist between [${L}, ${R}]`);
    }
}

// Driver program
const a = [1, 1, 5, 4, 5];
const n = a.length;
let q = [new Query(0, 2, 2), new Query(1, 4, 1), new Query(2, 4, 5)];
let m = q.length;
queryResults(a, n, q, m);