Aquileo | Mean of Range in Array

You are given an array arr[] consisting of n positive integers and a set of q queries represented by a 2D array queries queries[][]. Each query contains two integers l and r, indicating a range of indices in the array.

For every query, calculate the mean of the elements in the subarray from index l to index r (inclusive). After computing the mean, return its floor value.

Examples:

Input: arr[] = [3, 7, 2, 8, 2] , queries[][] = [[0,1], [1, 3], [2, 4]]
Output: 5 5 4
Explanation:
For query [0, 1] - Elements in the range are [3, 7], Mean is (3+7)/2 = 5, Floor value is 5.
For query [1, 3] - Elements in the range are [7, 2, 8], Mean is (7+2+8)/3 = 5.6, Floor value is 5.
For query [2, 4] - Elements in the range are [2, 8, 2], Mean is (2+8+2)/3 = 4, Floor value is 4.
Input: arr[] = [10, 20, 30, 40, 50, 60], queries[][] = [[3, 5]]
Output: 50
Explanation: For query [3, 5] - Elements in the range are [40, 50, 60], Mean is (40+50+60)/3 = 50, Floor value is 50.

Try It Yourself

Table of Content

[Naive Approach] Direct Range Traversal
Expected Approach] Using Prefix Sum

[Naive Approach] Direct Range Traversal

The idea is to process each query separately by iterating over the given range l to r and computing the sum and count of elements. Since the mean is sum/count, we can directly compute its floor value using integer division. The approach ensures that each query is handled independently.

Dry run for arr[] = [3, 7, 2, 8, 2] , queries[][] = [[0,1], [1, 3], [2, 4]]:

Query [0,1]: take elements from index 0 to 1 (3,7), sum = 10, count = 2, mean = 10/2 = 5, result = 5
Query [1,3]: take elements from index 1 to 3 (7,2,8), sum = 17, count = 3, mean = 17/3 = 5 (floor), result = 5
Query [2,4]: take elements from index 2 to 4 (2,8,2), sum = 12, count = 3, mean = 12/3 = 4, result = 4

Final answer: 5 5 4

C++

#include <iostream>
#include <vector>
using namespace std;

vector<int> findMean(vector<int> &arr,
                     vector<vector<int>> &queries)
{
    int n = arr.size();
    int q = queries.size();
    vector<int> result;

    for (int i = 0; i < q; i++)
    {
        int l = queries[i][0];
        int r = queries[i][1];
        int sum = 0, count = 0;

        // sum from l to r
        for (int j = l; j <= r; j++)
        {
            sum += arr[j];
            count++;
        }
        
        // floor value
        result.push_back(sum / count);
    }
    return result;
}

int main()
{

    vector<int> arr = {3, 7, 2, 8, 2};
    vector<vector<int>> queries = {{0, 1}, {1, 3}, {2, 4}};

    vector<int> result = findMean(arr, queries);
    for (int i = 0; i < result.size(); i++)
        cout << result[i] << " ";

    return 0;
}

Java

import java.util.*;

class GfG {

    static ArrayList<Integer> findMean(int[] arr,
                                       int[][] queries) {
        int n = arr.length;
        int q = queries.length;
        ArrayList<Integer> result = new ArrayList<>();

        for (int i = 0; i < q; i++) {
            
            int l = queries[i][0];
            int r = queries[i][1];
            int sum = 0, count = 0;

            // sum from l to r
            for (int j = l; j <= r; j++) {
                sum += arr[j];
                count++;
            }

            // floor value
            result.add(sum / count);
        }

        return result;
    }

    public static void main(String[] args) {

        int[] arr = {3, 7, 2, 8, 2};
        int[][] queries = {{0, 1}, {1, 3}, {2, 4}};

        ArrayList<Integer> result = findMean(arr, queries);

        for (int val : result)
            System.out.print(val + " ");
    }
}

Python

def findMean(arr, queries):
    
    n = len(arr)
    q = len(queries)
    result = []

    for i in range(q):
        
        l = queries[i][0]
        r = queries[i][1]
        sum = 0
        count = 0

        # sum from l to r
        for j in range(l, r + 1):
            sum += arr[j]
            count += 1

        # floor value
        result.append(sum // count)
        
    return result


if __name__ == "__main__":
    arr = [3, 7, 2, 8, 2]
    queries = [[0, 1], [1, 3], [2, 4]]

    result = findMean(arr, queries)
    print(*result)

using System;
using System.Collections.Generic;

class GfG
{
    static List<int> FindMean(int[] arr, int[][] queries)
    {
        int n = arr.Length;
        int q = queries.Length;
        List<int> result = new List<int>();

        for (int i = 0; i < q; i++)
        {
            int l = queries[i][0];
            int r = queries[i][1];
            int sum = 0, count = 0;

            // sum from l to r
            for (int j = l; j <= r; j++)
            {
                sum += arr[j];
                count++;
            }

            // floor value
            result.Add(sum / count);
        }

        return result;
    }

    static void Main()
    {
        int[] arr = { 3, 7, 2, 8, 2 };
        int[][] queries = {
            new int[] {0, 1},
            new int[] {1, 3},
            new int[] {2, 4}
        };

        List<int> result = FindMean(arr, queries);

        foreach (int val in result)
            Console.Write(val + " ");
    }
}

JavaScript

function findMean(arr, queries) {
    
    let n = arr.length;
    let q = queries.length;
    let result = [];

    for (let i = 0; i < q; i++) {
        
        let l = queries[i][0];
        let r = queries[i][1];
        let sum = 0, count = 0;

        // sum from l to r
        for (let j = l; j <= r; j++) {
            sum += arr[j];
            count++;
        }

        // floor value
        result.push(Math.floor(sum / count));
    }

    return result;
}

// Driver code
let arr = [3, 7, 2, 8, 2];
let queries = [[0, 1], [1, 3], [2, 4]];

let result = findMean(arr, queries);
console.log(result.join(" "));

Output

5 5 4

Time Complexity: O(n * q), for each of the q queries, we iterate over the range l to r, taking O(n) time.
Auxiliary Space: O(1)

Expected Approach] Using Prefix Sum

Use a prefix sum array to calculate the sum from l to r in O(1) time. For each query, compute the range sum using the prefix array and divide it by the number of elements to obtain the mean.