Maximize value of a pair from two given arrays based on given conditions

 
        // JavaScript code for the above approach
        // Class to store the values of a[i], b[i], a[i] + b[i]
        class Triplet {
            constructor(a, b, c) {
                this.a = a;
                this.b = b;
                this.c = c;
            }

            // Sort values according to array
            compareTo(other) {
                return this.a - other.a;
            }
        }

        // Stores the segment tree
        let seg = [];

        // Function to find the maximum
        // possible value according to the
        // given condition
        function maxValue(a, b, n, k) 
        {
        
            // Initialize triplet array
            let arr = new Array(n);

            // Store the values a[i], b[i],
            // a[i] + b[i]
            for (let i = 0; i < n; i++) {
                arr[i] = new Triplet(a[i], b[i], a[i] + b[i]);
            }

            // Sort the array according
            // to array a[]
            arr.sort((a, b) => a.compareTo(b));

            // Build segment tree
            seg = new Array(4 * n);
            build(arr, 0, 0, n - 1);

            // Initialise the maxvalue of
            // the selected pairs
            let maxvalue = Number.MIN_SAFE_INTEGER;

            // Traverse the array
            for (let i = 0; i < n; i++)
            {
            
                // For each value find the
                // floor(arr[i] + k)
                let right = search(arr, arr[i].a + k);

                // Find the maximum value of
                // the select pairs i and max
                // from (i + 1, right)
                if (right !== -1) {
                    maxvalue = Math.max(maxvalue, arr[i].b - arr[i].a + getMax(arr, 0, 0, n - 1, i + 1, right));
                }
            }

            // Print the maximum value
            console.log(maxvalue);
        }

        // Function to search floor of
        // the current value
        function search(arr, val) 
        {
        
            // Initialise low and high values
            let low = 0;
            let high = arr.length - 1;
            let ans = -1;

            // Perform Binary Search
            while (low <= high) {
                let mid = low + Math.floor((high - low) / 2);

                // If the current value is
                // <= val then store the
                // candidate answer and
                // find for rightmost one
                if (arr[mid].a <= val) {
                    ans = mid;
                    low = mid + 1;
                } else {
                    high = mid - 1;
                }
            }
            return ans;
        }

        // Function to build segment tree
        function build(arr, index, s, e) 
        {
        
            // Base Case
            if (s === e) {
                seg[index] = arr[s].c;
                return;
            }
            let mid = s + Math.floor((e - s) / 2);

            // Buildthe left and right
            // segment trees
            build(arr, 2 * index + 1, s, mid);
            build(arr, 2 * index + 2, mid + 1, e);

            // Update current index
            seg[index] = Math.max(seg[2 * index + 1], seg[2 * index + 2]);
        }

        // Function to get maximum value
        // in the range [qs, qe]
        function getMax(arr, index, s, e, qs, qe) 
        {
        
            // If segment is not in range
            if (qe < s || e < qs) 
            {
                return Number.MIN_SAFE_INTEGER;
            }

            // If segment is fully in range
            if (qs <= s && e <= qe) {
                return seg[index];
            }

            // If a part of this segment is
            // in range
            let mid = s + Math.floor((e - s) / 2);
            let left = getMax(arr, 2 * index + 1, s, mid, qs, qe);
            let right = getMax(arr, 2 * index + 2, mid + 1, e, qs, qe);

            // Return the maximum value
            return Math.max(left, right);
        }
        
        // Driver code
        let a = [5, 6, 9, 10]
        let b = [3, 0, 10, -10]
        let N = 4
        let K = 1
        maxValue(a, b, N, K);

 // This code is contributed by Potta Lokesh