|
Given an array arr[](1-based indexing) consisting of N positive integers and two positive integers L and R, the task is to find the sum of array elements over the range [L, R] if the given array arr[] is concatenating to itself infinite times.
Examples:
Input: arr[] = {1, 2, 3}, L = 2, R = 8
Output: 14
Explanation:
The array, arr[] after concatenation is {1, 2, 3, 1, 2, 3, 1, 2, …} and the sum of elements from index 2 to 8 is 2 + 3 + 1 + 2 + 3 + 1 + 2 = 14.
Input: arr[] = {5, 2, 6, 9}, L = 10, R = 13
Output: 22
Naive Approach: The simplest approach to solve the given problem is to iterate over the range [L, R] using the variable i and add the value of arr[i % N] to the sum for each index. After completing the iteration, print the value of the sum as the resultant sum.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void rangeSum(int arr[], int N, int L, int R)
{
int sum = 0;
for (int i = L - 1; i < R; i++) {
sum += arr[i % N];
}
cout << sum;
}
int main()
{
int arr[] = { 5, 2, 6, 9 };
int L = 10, R = 13;
int N = sizeof(arr) / sizeof(arr[0]);
rangeSum(arr, N, L, R);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static void rangeSum(int arr[], int N, int L, int R)
{
int sum = 0;
for (int i = L - 1; i < R; i++) {
sum += arr[i % N];
}
System.out.println(sum);
}
public static void main(String[] args)
{
int arr[] = { 5, 2, 6, 9 };
int L = 10, R = 13;
int N = arr.length;
rangeSum(arr, N, L, R);
}
}
|
Python3
def rangeSum(arr, N, L, R):
sum = 0
for i in range(L - 1,R,1):
sum += arr[i % N]
print(sum)
if __name__ == '__main__':
arr = [5, 2, 6, 9 ]
L = 10
R = 13
N = len(arr)
rangeSum(arr, N, L, R)
|
C#
using System;
class GFG {
static void rangeSum(int[] arr, int N, int L, int R)
{
int sum = 0;
for (int i = L - 1; i < R; i++) {
sum += arr[i % N];
}
Console.Write(sum);
}
public static void Main(string[] args)
{
int[] arr = { 5, 2, 6, 9 };
int L = 10, R = 13;
int N = arr.Length;
rangeSum(arr, N, L, R);
}
}
|
Javascript
<script>
function rangeSum(arr, N, L, R)
{
let sum = 0;
for(let i = L - 1; i < R; i++)
{
sum += arr[i % N];
}
document.write(sum);
}
let arr = [ 5, 2, 6, 9 ];
let L = 10, R = 13;
let N = arr.length
rangeSum(arr, N, L, R);
</script>
|
Time Complexity: O(R – L)
Auxiliary Space: O(1)
Efficient Approach: The above approach can also be optimized by using the Prefix Sum. Follow the steps below to solve the problem:
- Initialize an array, say prefix[] of size (N + 1) with all elements as 0s.
- Traverse the array, arr[] using the variable i and update prefix[i] to sum of prefix[i – 1] and arr[i – 1].
- Now, the sum of elements over the range [L, R] is given by:
the sum of elements in the range [1, R] – sum of elements in the range [1, L – 1].
- Initialize a variable, say leftSum as ((L – 1)/N)*prefix[N] + prefix[(L – 1)%N] to store the sum of elements in the range [1, L-1].
- Similarly, initialize another variable rightSum as (R/N)*prefix[N] + prefix[R%N] to store the sum of elements in the range [1, R].
- After completing the above steps, print the value of (rightSum – leftSum) as the resultant sum of elements over the given range [L, R].
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void rangeSum(int arr[], int N, int L,
int R)
{
int prefix[N + 1];
prefix[0] = 0;
for (int i = 1; i <= N; i++) {
prefix[i] = prefix[i - 1]
+ arr[i - 1];
}
int leftsum
= ((L - 1) / N) * prefix[N]
+ prefix[(L - 1) % N];
int rightsum = (R / N) * prefix[N]
+ prefix[R % N];
cout << rightsum - leftsum;
}
int main()
{
int arr[] = { 5, 2, 6, 9 };
int L = 10, R = 13;
int N = sizeof(arr) / sizeof(arr[0]);
rangeSum(arr, N, L, R);
return 0;
}
|
Java
import java.io.*;
class GFG{
static void rangeSum(int arr[], int N, int L, int R)
{
int prefix[] = new int[N+1];
prefix[0] = 0;
for (int i = 1; i <= N; i++) {
prefix[i] = prefix[i - 1]
+ arr[i - 1];
}
int leftsum
= ((L - 1) / N) * prefix[N]
+ prefix[(L - 1) % N];
int rightsum = (R / N) * prefix[N]
+ prefix[R % N];
System.out.print( rightsum - leftsum);
}
public static void main (String[] args)
{
int arr[] = { 5, 2, 6, 9 };
int L = 10, R = 13;
int N = arr.length;
rangeSum(arr, N, L, R);
}
}
|
Python3
def rangeSum(arr, N, L, R):
prefix = [0 for i in range(N + 1)]
prefix[0] = 0
for i in range(1,N+1,1):
prefix[i] = prefix[i - 1] + arr[i - 1]
leftsum = ((L - 1) // N) * prefix[N] + prefix[(L - 1) % N]
rightsum = (R // N) * prefix[N] + prefix[R % N]
print(rightsum - leftsum)
if __name__ == '__main__':
arr = [5, 2, 6, 9]
L = 10
R = 13
N = len(arr)
rangeSum(arr, N, L, R)
|
C#
using System;
class GFG{
static void rangeSum(int []arr, int N, int L, int R)
{
int []prefix = new int[N+1];
prefix[0] = 0;
for (int i = 1; i <= N; i++) {
prefix[i] = prefix[i - 1]
+ arr[i - 1];
}
int leftsum
= ((L - 1) / N) * prefix[N]
+ prefix[(L - 1) % N];
int rightsum = (R / N) * prefix[N]
+ prefix[R % N];
Console.Write( rightsum - leftsum);
}
public static void Main (String[] args)
{
int []arr = { 5, 2, 6, 9 };
int L = 10, R = 13;
int N = arr.Length;
rangeSum(arr, N, L, R);
}
}
|
Javascript
<script>
function rangeSum(arr, N, L, R) {
let prefix = new Array(N + 1);
prefix[0] = 0;
for (let i = 1; i <= N; i++) {
prefix[i] = prefix[i - 1] + arr[i - 1];
}
let leftsum = ((L - 1) / N) * prefix[N] + prefix[(L - 1) % N];
let rightsum = (R / N) * prefix[N] + prefix[R % N];
document.write(rightsum - leftsum);
}
let arr = [5, 2, 6, 9];
let L = 10,
R = 13;
let N = arr.length;
rangeSum(arr, N, L, R);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
|
