Infinite array problem in for q number of queries - c++

Question

Given an array, "A" of integers and you have also defined the new array"B"as a concatenation of
array"A" for an infinite number of times.
For example,if the given array"A"is[1,2,3]then,infinite array“B”is[1,2,3,1,2,3,1,2,3 ........
Now you are given q queries, each query consists of two integers"L" and"R"(1-based indexing).
Your task is to find the sum of the subarray from index"L" to"R"(both inclusive)in the infinite array "B" for each query.
Note:
The value of the sum can be very large,return the answer as modulus 10^9+7.
Input Format
The first line of input contains a single integer T, representing the number of test cases
or queries to be run.
Then the test cases follow.
The first line of each test case contains a single integer N, denoting the size of the
array"A".
The second line of each test case contains N single space-separated integers, elements of
the array"A".
The third line of each test case contains a single integer Q, denoting the number of
queries.
Then each of the Q lines of each test case contains two single space-separated integers L,
and R denote the left and the right index of the infinite array"B" whose sum is to be
returned.
I have come up with an approach that doesn't think is the optimal solution for this. I have used two pointer approach in this.
#include <iostream>
#include <vector>
vector<int> sumInRanges(vector<int> &arr, int n, vector<vector<long long>> &queries, int q) {
// Write your code here
vector<int> res;
for(int i = 0; i < q; i++){
int sum = 0;
int start = queries[i][0];
int end = queries[i][1];
while( start <= end ){
if(start < arr.size()){
sum += arr[start - 1];
}
else{
int mod = start % arr.size();
sum += arr[mod - 1];
}
}
res.push_back(sum);
}
return res;
}

Answer 1

Hint: think where you do the same things
Suppose A=[1,2,3], L=2, R=14
Your approach iterates over
2,3, 1,2,3, 1,2,3, 1,2,3, 1,2
see, how many times you iterate over the whole array?
instead, calculate sum(A) ONCE
then, calculate how many times it's used in the query (something like floor(R/len(A)) - ceil(L/len(A)))
multiply them
iterate ONCE to find missing sums (left from L%len(A) to len(A) and right from beginning to R%len(A))
And don't forget about the modulo 1e9+7
If len(A) and q get huge - save partial sums to beginning and partial sums till end once
And then retrieve them each query in constant time