Sum of all elements between k1'th and k2'th smallest elements

function sumBetween(arr, k1, k2) {
    // Sort the array
    arr.sort((a, b) => a - b);

    // Sum elements between k1-th and k2-th smallest
    return arr.slice(k1, k2 - 1).reduce((acc, val) => acc + val, 0);
}

// Driver code
const arr = [20, 8, 22, 4, 12, 10, 14];
const k1 = 3, k2 = 6;

console.log(sumBetween(arr, k1, k2));

// Min-heapify function
function minHeapify(a, index, heapSize) {
    let small = index;
    let l = 2 * index + 1;
    let r = 2 * index + 2;

    if (l < heapSize && a[l] < a[small]) small = l;
    if (r < heapSize && a[r] < a[small]) small = r;

    if (small !== index) {
        [a[small], a[index]] = [a[index], a[small]];
        minHeapify(a, small, heapSize);
    }
}

// Function to calculate sum of elements between k1-th and k2-th smallest
function sumBetweenK1K2(arr, k1, k2) {
    let a = [...arr];
    let heapSize = a.length;
    let ans = 0;

    // Build the min-heap
    for (let i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
        minHeapify(a, i, heapSize);
    }

    // Adjust for 0-based indexing
    k1--;
    k2--;

    // Step 1: Extract minimum k1 times (skip these elements)
    for (let i = 0; i <= k1; i++) {
        a[0] = a[heapSize - 1];
        heapSize--;
        minHeapify(a, 0, heapSize);
    }

    // Step 2: Extract minimum k2 – k1 – 1 times and sum all extracted elements
    for (let i = k1 + 1; i < k2; i++) {
        ans += a[0];
        a[0] = a[heapSize - 1];
        heapSize--;
        minHeapify(a, 0, heapSize);
    }

    return ans;
}

// Driver code
const arr = [20, 8, 22, 4, 12, 10, 14];
const k1 = 3, k2 = 6;

console.log(sumBetweenK1K2(arr, k1, k2)); // Output: 26

// JS program to find sum of all element between
// to K1'th and k2'th smallest elements in array

function PriorityQueue () {
    let collection = [];
    this.printCollection = function() {
      (console.log(collection));
    };
    this.enqueue = function(element){
        if (this.isEmpty()){ 
            collection.push(element);
        } else {
            let added = false;
            for (let i=0; i<collection.length; i++){
                 if (element[1] < collection[i][1]){ //checking priorities
                    collection.splice(i,0,element);
                    added = true;
                    break;
                }
            }
            if (!added){
                collection.push(element);
            }
        }
    };
    this.dequeue = function() {
        let value = collection.shift();
        return value[0];
    };
    this.front = function() {
        return collection[0];
    };
    this.size = function() {
        return collection.length; 
    };
    this.isEmpty = function() {
        return (collection.length === 0); 
    };
}

function sumBetweenTwoKth(A, N, K1, K2)
{
    // Using max heap to find K1'th and K2'th smallest
    // elements
    let maxH = new PriorityQueue(); 

    // Using this for loop we eliminate the extra elements
    // which are greater than K2'th smallest element as they
    // are not required for us

    for (let i = 0; i < N; i++) {

        maxH.enqueue(A[i]);

        if (maxH.size() > K2) {
            maxH.dequeue();
        }
    }
    // popping out the K2'th smallest element
    maxH.dequeue();

    let ans = 0;
    // adding the elements to ans until we reach the K1'th
    // smallest element
    while (maxH.size() > K1) {

        ans += maxH.front();
        maxH.dequeue();
    }

    return ans;
}

let arr = [ 20, 8, 22, 4, 12, 10, 14 ];
let k1 = 3, k2 = 6;
let n = arr.length;
console.log(sumBetweenTwoKth(arr, n, k1, k2));

// This code is contributed by akashish__