Skip to content

Complete Interview Preparation at 20% off | Use code: PREPAREKARO Check Now

Related Articles

Related Articles

Sum of elements in range L-R where first half and second half is filled with odd and even numbers

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 31 Aug, 2021

Given a number N, create an array such the first half of the array is filled with odd numbers till N, and the second half of the array is filled with even numbers. Also given are L and R indices, the task is to print the sum of elements in the array in the range [L, R]. 

Examples: 

Input: N = 12, L = 1, R = 11 
Output: 66 
The array formed thus is {1, 3, 5, 7, 9, 11, 2, 4, 6, 8, 10, 12} 
The sum between index 1 and index 11 is 66 {1+3+5+7+9+11+2+4+6+8+10}

Input: N = 11, L = 3 and R = 7 
Output: 34 
The array formed is {1, 3, 5, 7, 9, 11, 2, 4, 6, 8, 10} 
The sum between index 3 and index 7 is 34 {5+7+9+11+2}

A naive approach will be to form the array of size N and iterate from L to R and return the sum.  

C++




// C++ program to find the sum between L-R
// range by creating the array
// Naive Approach
#include<bits/stdc++.h>
using namespace std;
 
    // Function to find the sum between L and R
    int rangesum(int n, int l, int r)
    {
        // array created
        int arr[n];
 
        // fill the first half of array
        int c = 1, i = 0;
        while (c <= n) {
            arr[i++] = c;
            c += 2;
        }
 
        // fill the second half of array
        c = 2;
        while (c <= n) {
            arr[i++] = c;
            c += 2;
        }
        int sum = 0;
 
        // find the sum between range
        for (i = l - 1; i < r; i++) {
            sum += arr[i];
        }
 
        return sum;
    }
 
    // Driver Code
    int  main()
    {
        int n = 12;
        int l = 1, r = 11;
        cout<<(rangesum(n, l, r));
    }
// This code is contributed by
// Sanjit_Prasad

Java



// Java program to find the sum between L-R
// range by creating the array
// Naive Approach
import java.io.*;
public class GFG {
 
    // Function to find the sum between L and R
    static int rangesum(int n, int l, int r)
    {
        // array created
        int[] arr = new int[n];
 
        // fill the first half of array
        int c = 1, i = 0;
        while (c <= n) {
            arr[i++] = c;
            c += 2;
        }
 
        // fill the second half of array
        c = 2;
        while (c <= n) {
            arr[i++] = c;
            c += 2;
        }
        int sum = 0;
 
        // find the sum between range
        for (i = l - 1; i < r; i++) {
            sum += arr[i];
        }
 
        return sum;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 12;
        int l = 1, r = 11;
        System.out.println(rangesum(n, l, r));
    }
}
Python3



# Python3 program to find the sum between L-R
# range by creating the array
# Naive Approach
 
# Function to find the sum between L and R
def rangesum(n, l, r):
 
    # array created
    arr = [0] * n;
 
    # fill the first half of array
    c = 1; i = 0;
    while (c <= n):
        arr[i] = c;
        i += 1;
        c += 2;
     
    # fill the second half of array
    c = 2;
    while (c <= n):
        arr[i] = c;
        i += 1;
        c += 2;
 
    sum = 0;
 
    # find the sum between range
    for i in range(l - 1, r, 1):
        sum += arr[i];
     
    return sum;
 
# Driver Code
if __name__ == '__main__':
 
    n = 12;
    l, r = 1, 11;
    print(rangesum(n, l, r));
     
# This code contributed by PrinciRaj1992
C#



// C# program to find the sum
// between L-R range by creating
// the array Naive Approach
using System;
 
class GFG
{
 
    // Function to find the
    // sum between L and R
    static int rangesum(int n,
                        int l, int r)
    {
        // array created
        int[] arr = new int[n];
 
        // fill the first
        // half of array
        int c = 1, i = 0;
        while (c <= n)
        {
            arr[i++] = c;
            c += 2;
        }
 
        // fill the second
        // half of array
        c = 2;
        while (c <= n)
        {
            arr[i++] = c;
            c += 2;
        }
        int sum = 0;
 
        // find the sum
        // between range
        for (i = l - 1; i < r; i++)
        {
            sum += arr[i];
        }
 
        return sum;
    }
 
    // Driver Code
    public static void Main()
    {
        int n = 12;
        int l = 1, r = 11;
        Console.WriteLine(rangesum(n, l, r));
    }
}
 
// This code is contributed
// by inder_verma.
PHP



<?php
// PHP program to find the sum between
// L-R range by creating the array
// Naive Approach
 
// Function to find the sum between L and R
function rangesum($n, $l, $r)
{
    // array created
    $arr = array_fill(0, $n, 0);
 
    // fill the first half of array
    $c = 1;
    $i = 0;
    while ($c <= $n)
    {
        $arr[$i++] = $c;
        $c += 2;
    }
 
    // fill the second half of array
    $c = 2;
    while ($c <= $n)
    {
        $arr[$i++] = $c;
        $c += 2;
    }
    $sum = 0;
 
    // find the sum between range
    for ($i = $l - 1; $i < $r; $i++)
    {
        $sum += $arr[$i];
    }
 
    return $sum;
}
 
// Driver Code
$n = 12;
$l = 1;
$r = 11;
echo(rangesum($n, $l, $r));
     
// This code is contributed by mits
?>
Javascript



<script>
 
// Javascript program to find the sum between L-R
// range by creating the array
// Naive Approach
 
    // Function to find the sum between L and R
    function rangesum(n, l, r)
    {
        // array created
        let arr = new Array(n);
 
        // fill the first half of array
        let c = 1, i = 0;
        while (c <= n) {
            arr[i++] = c;
            c += 2;
        }
 
        // fill the second half of array
        c = 2;
        while (c <= n) {
            arr[i++] = c;
            c += 2;
        }
        let sum = 0;
 
        // find the sum between range
        for (i = l - 1; i < r; i++) {
            sum += arr[i];
        }
 
        return sum;
    }
 
    // Driver Code
    let n = 12;
    let l = 1, r = 11;
    document.write(rangesum(n, l, r));
     
    // This code is contributed by rishavmahato348.
</script>
Output: 
66
 
Time complexity: O(N) 
Auxiliary Space: O(N)
Efficient Approach: Without building the array the problem can be solved in O(1) complexity. Consider the middle point of the sequence thus formed. Then there can be 3 possibilities for L and R.  
  • l and r both are on the right of the middle point.
  • l and r both are on the left of the middle point.
  • l is on the left of the middle point and r is on the left of the middle point.
For the 1st and 2nd case, just find the number which corresponds to the l-th position from the start or middle and the number which corresponds to the r-th position from start or middle. The below formula can be used to find out the sum:  
sum = (no. of terms in the range)*(first term + last term)/2
For the third case, consider it as [L-mid] and [mid-R] and then apply case 1 and case 2 formulae as mentioned above.
Below is the implementation of the above approach:  
C++



// C++ program to find the sum between L-R
// range by creating the array
// Naive Approach
#include<bits/stdc++.h>
using namespace std;
 
// // Function to calculate the sum if n is even
int sumeven(int n, int l, int r)
{
    int sum = 0;
    int mid = n / 2;
 
    // both l and r are to the left of mid
    if (r <= mid)
    {
        // first and last element
        int first = (2 * l - 1);
        int last = (2 * r - 1);
 
        // Total number of terms in
        // the sequence is r-l+1
        int no_of_terms = r - l + 1;
 
        // use of formula derived
        sum = ((no_of_terms) * ((first + last))) / 2;
    }
     
    // both l and r are to the right of mid
    else if (l >= mid)
    {
        // first and last element
        int first = (2 * (l - n / 2));
        int last = (2 * (r - n / 2));
 
        int no_of_terms = r - l + 1;
 
        // Use of formula derived
        sum = ((no_of_terms) * ((first + last))) / 2;
    }
 
    // left is to the left of mid and
    // right is to the right of mid
    else
    {
         
        // Take two sums i.e left and
        // right differently and add
        int sumleft = 0, sumright = 0;
 
        // first and last element
        int first_term1 = (2 * l - 1);
        int last_term1 = (2 * (n / 2) - 1);
 
        // total terms
        int no_of_terms1 = n / 2 - l + 1;
 
        // no of terms
        sumleft = ((no_of_terms1) *
                  ((first_term1 + last_term1))) / 2;
 
        // The first even number is 2
        int first_term2 = 2;
 
        // The last element is given by 2*(r-n/2)
        int last_term2 = (2 * (r - n / 2));
        int no_of_terms2 = r - mid;
 
        // formula applied
        sumright = ((no_of_terms2) *
                   ((first_term2 + last_term2))) / 2;
        sum = (sumleft + sumright);
    }
    return sum;
}
 
// Function to calculate the sum if n is odd
int sumodd(int n, int l, int r)
{
 
    // take ceil value if n is odd
    int mid = n / 2 + 1;
    int sum = 0;
 
    // // both l and r are to the left of mid
    if (r <= mid)
    {
        // first and last element
        int first = (2 * l - 1);
        int last = (2 * r - 1);
 
        // number of terms
        int no_of_terms = r - l + 1;
 
        // formula
        sum = ((no_of_terms) *
             ((first + last))) / 2;
    }
 
    // // both l and r are to the right of mid
    else if (l > mid)
    {
 
        // first and last term,
        int first = (2 * (l - mid));
        int last = (2 * (r - mid));
 
        // no of terms
        int no_of_terms = r - l + 1;
 
        // formula used
        sum = ((no_of_terms) *
              ((first + last))) / 2;
    }
 
    // If l is on left and r on right
    else
    {
 
        // calculate separate sums
        int sumleft = 0, sumright = 0;
 
        // first half
        int first_term1 = (2 * l - 1);
        int last_term1 = (2 * mid - 1);
 
        // calculate terms
        int no_of_terms1 = mid - l + 1;
        sumleft = ((no_of_terms1) *
                  ((first_term1 + last_term1))) / 2;
 
        // second half
        int first_term2 = 2;
        int last_term2 = (2 * (r - mid));
        int no_of_terms2 = r - mid;
        sumright = ((no_of_terms2) *
                   ((first_term2 + last_term2))) / 2;
 
        // add both halves
        sum = (sumleft + sumright);
    }
    return sum;
}
 
// Function to find the sum between L and R
int rangesum(int n, int l, int r)
{
    int sum = 0;
 
    // If n is even
    if (n % 2 == 0)
        return sumeven(n, l, r);
 
    // If n is odd
    else
        return sumodd(n, l, r);
}
 
// Driver Code
int main()
{
    int n = 12;
    int l = 1, r = 11;
    cout << (rangesum(n, l, r));
}
 
// This code is contributed by 29AjayKumar
Java



// Java program to find the sum between L-R
// range by creating the array
// Efficient Approach
import java.io.*;
public class GFG {
 
    // // Function to calculate the sum if n is even
    static int sumeven(int n, int l, int r)
    {
        int sum = 0;
        int mid = n / 2;
 
        // both l and r are to the left of mid
        if (r <= mid) {
            // first and last element
            int first = (2 * l - 1);
            int last = (2 * r - 1);
 
            // Total number of terms in
            // the sequence is r-l+1
            int no_of_terms = r - l + 1;
 
            // use of formula derived
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
        // both l and r are to the right of mid
        else if (l >= mid) {
            // // first and last element
            int first = (2 * (l - n / 2));
            int last = (2 * (r - n / 2));
 
            int no_of_terms = r - l + 1;
 
            // Use of formula derived
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
 
        // left is to the left of mid and
        // right is to the right of mid
        else {
            // Take two sums i.e left and
            // right differently and add
            int sumleft = 0, sumright = 0;
 
            // first and last element
            int first_term1 = (2 * l - 1);
            int last_term1 = (2 * (n / 2) - 1);
 
            // total terms
            int no_of_terms1 = n / 2 - l + 1;
 
            // no of terms
            sumleft = ((no_of_terms1) * ((first_term1 + last_term1))) / 2;
 
            // The first even number is 2
            int first_term2 = 2;
 
            // The last element is given by 2*(r-n/2)
            int last_term2 = (2 * (r - n / 2));
            int no_of_terms2 = r - mid;
 
            // formula applied
            sumright = ((no_of_terms2) * ((first_term2 + last_term2))) / 2;
            sum = (sumleft + sumright);
        }
 
        return sum;
    }
 
    // Function to calculate the sum if n is odd
    static int sumodd(int n, int l, int r)
    {
 
        // take ceil value if n is odd
        int mid = n / 2 + 1;
        int sum = 0;
 
        // // both l and r are to the left of mid
        if (r <= mid) {
            // first and last element
            int first = (2 * l - 1);
            int last = (2 * r - 1);
 
            // number of terms
            int no_of_terms = r - l + 1;
 
            // formula
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
 
        // // both l and r are to the right of mid
        else if (l > mid) {
 
            // first and last term,
            int first = (2 * (l - mid));
            int last = (2 * (r - mid));
 
            // no of terms
            int no_of_terms = r - l + 1;
 
            // formula used
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
 
        // If l is on left and r on right
        else {
 
            // calculate separate sums
            int sumleft = 0, sumright = 0;
 
            // first half
            int first_term1 = (2 * l - 1);
            int last_term1 = (2 * mid - 1);
 
            // calculate terms
            int no_of_terms1 = mid - l + 1;
            sumleft = ((no_of_terms1) * ((first_term1 + last_term1))) / 2;
 
            // second half
            int first_term2 = 2;
            int last_term2 = (2 * (r - mid));
            int no_of_terms2 = r - mid;
            sumright = ((no_of_terms2) * ((first_term2 + last_term2))) / 2;
 
            // add both halves
            sum = (sumleft + sumright);
        }
 
        return sum;
    }
    // Function to find the sum between L and R
    static int rangesum(int n, int l, int r)
    {
        int sum = 0;
 
        // If n is even
        if (n % 2 == 0)
            return sumeven(n, l, r);
 
        // If n is odd
        else
            return sumodd(n, l, r);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 12;
        int l = 1, r = 11;
        System.out.println(rangesum(n, l, r));
    }
}
Python3



# Python3 program to find
# the sum between L-R range
# by creating the array
# Naive Approach
 
# Function to calculate
# the sum if n is even
def sumeven(n, l, r):
 
    sum = 0
    mid = n // 2
 
    # Both l and r are
    # to the left of mid
    if (r <= mid):
     
        # First and last element
        first = (2 * l - 1)
        last = (2 * r - 1)
 
        # Total number of terms in
        # the sequence is r-l+1
        no_of_terms = r - l + 1
 
        # Use of formula derived
        sum = ((no_of_terms) *
              ((first + last))) // 2
    
    # Both l and r are to the right of mid
    elif (l >= mid):
     
        # First and last element
        first = (2 * (l - n // 2))
        last = (2 * (r - n // 2))
 
        no_of_terms = r - l + 1
 
        # Use of formula derived
        sum = ((no_of_terms) *
              ((first + last))) // 2
 
    # Left is to the left of mid and
    # right is to the right of mid
    else :
       
        # Take two sums i.e left and
        # right differently and add
        sumleft, sumright = 0, 0
 
        # First and last element
        first_term1 = (2 * l - 1)
        last_term1 = (2 * (n // 2) - 1)
 
        # total terms
        no_of_terms1 = n // 2 - l + 1
 
        # no of terms
        sumleft = (((no_of_terms1) *
                  ((first_term1 +
                    last_term1))) // 2)
 
        # The first even number is 2
        first_term2 = 2
 
        # The last element is
        #
        last_term2 = (2 * (r - n // 2))
        no_of_terms2 = r - mid
 
        # formula applied
        sumright = (((no_of_terms2) *
                   ((first_term2 +
                     last_term2))) // 2)
        sum = (sumleft + sumright);
   
    return sum
 
# Function to calculate
# the sum if n is odd
def sumodd(n, l, r):
   
    # Take ceil value if n is odd
    mid = n // 2 + 1;
    sum = 0
 
    # Both l and r are to
    # the left of mid
    if (r <= mid):
     
        # First and last element
        first = (2 * l - 1)
        last = (2 * r - 1)
 
        # number of terms
        no_of_terms = r - l + 1
 
        # formula
        sum = (((no_of_terms) *
              ((first + last))) // 2)
    
    # both l and r are to the right of mid
    elif (l > mid):
     
        # first and last term,
        first = (2 * (l - mid))
        last = (2 * (r - mid))
 
        # no of terms
        no_of_terms = r - l + 1
 
        # formula used
        sum = (((no_of_terms) *
              ((first + last))) // 2)
     
    # If l is on left and r on right
    else :
 
        # calculate separate sums
        sumleft, sumright = 0, 0
 
        # first half
        first_term1 = (2 * l - 1)
        last_term1 = (2 * mid - 1)
 
        # calculate terms
        no_of_terms1 = mid - l + 1
        sumleft = (((no_of_terms1) *
                  ((first_term1 +
                    last_term1))) // 2)
 
        # second half
        first_term2 = 2
        last_term2 = (2 * (r - mid))
        no_of_terms2 = r - mid
        sumright = (((no_of_terms2) *
                   ((first_term2 +
                     last_term2))) // 2)
 
        # add both halves
        sum = (sumleft + sumright)
     
    return sum
 
# Function to find the
# sum between L and R
def rangesum(n, l, r):
 
    sum = 0
 
    # If n is even
    if (n % 2 == 0):
        return sumeven(n, l, r);
 
    # If n is odd
    else:
        return sumodd(n, l, r)
 
# Driver Code
if __name__ == "__main__":
    n = 12
    l = 1
    r = 11;
    print (rangesum(n, l, r))
 
# This code is contributed by Chitranayal
C#



// C# program to find the sum
// between L-R range by creating
// the array Efficient Approach
using System;
 
class GFG
{
 
    // Function to calculate
    // the sum if n is even
    static int sumeven(int n,
                       int l, int r)
    {
        int sum = 0;
        int mid = n / 2;
 
        // both l and r are
        // to the left of mid
        if (r <= mid)
        {
            // first and last element
            int first = (2 * l - 1);
            int last = (2 * r - 1);
 
            // Total number of terms in
            // the sequence is r-l+1
            int no_of_terms = r - l + 1;
 
            // use of formula derived
            sum = ((no_of_terms) *
                  ((first + last))) / 2;
        }
         
        // both l and r are
        // to the right of mid
        else if (l >= mid)
        {
            // first and last element
            int first = (2 * (l - n / 2));
            int last = (2 * (r - n / 2));
 
            int no_of_terms = r - l + 1;
 
            // Use of formula derived
            sum = ((no_of_terms) *
                  ((first + last))) / 2;
        }
 
        // left is to the left of
        // mid and right is to the
        // right of mid
        else
        {
            // Take two sums i.e left and
            // right differently and add
            int sumleft = 0, sumright = 0;
 
            // first and last element
            int first_term1 = (2 * l - 1);
            int last_term1 = (2 * (n / 2) - 1);
 
            // total terms
            int no_of_terms1 = n / 2 - l + 1;
 
            // no of terms
            sumleft = ((no_of_terms1) *
                      ((first_term1 +
                        last_term1))) / 2;
 
            // The first even
            // number is 2
            int first_term2 = 2;
 
            // The last element is
            // given by 2*(r-n/2)
            int last_term2 = (2 * (r - n / 2));
            int no_of_terms2 = r - mid;
 
            // formula applied
            sumright = ((no_of_terms2) *
                       ((first_term2 +
                         last_term2))) / 2;
            sum = (sumleft + sumright);
        }
 
        return sum;
    }
 
    // Function to calculate
    // the sum if n is odd
    static int sumodd(int n,
                      int l, int r)
    {
 
        // take ceil value
        // if n is odd
        int mid = n / 2 + 1;
        int sum = 0;
 
        // both l and r are
        // to the left of mid
        if (r <= mid)
        {
            // first and last element
            int first = (2 * l - 1);
            int last = (2 * r - 1);
 
            // number of terms
            int no_of_terms = r - l + 1;
 
            // formula
            sum = ((no_of_terms) *
                  ((first + last))) / 2;
        }
 
        // both l and r are
        // to the right of mid
        else if (l > mid)
        {
 
            // first and last term,
            int first = (2 * (l - mid));
            int last = (2 * (r - mid));
 
            // no of terms
            int no_of_terms = r - l + 1;
 
            // formula used
            sum = ((no_of_terms) *
                  ((first + last))) / 2;
        }
 
        // If l is on left
        // and r on right
        else
        {
 
            // calculate separate sums
            int sumleft = 0, sumright = 0;
 
            // first half
            int first_term1 = (2 * l - 1);
            int last_term1 = (2 * mid - 1);
 
            // calculate terms
            int no_of_terms1 = mid - l + 1;
            sumleft = ((no_of_terms1) *
                      ((first_term1 +
                        last_term1))) / 2;
 
            // second half
            int first_term2 = 2;
            int last_term2 = (2 * (r - mid));
            int no_of_terms2 = r - mid;
            sumright = ((no_of_terms2) *
                       ((first_term2 +
                         last_term2))) / 2;
 
            // add both halves
            sum = (sumleft + sumright);
        }
 
        return sum;
    }
     
    // Function to find the
    // sum between L and R
    static int rangesum(int n,
                        int l, int r)
    {
         
        // If n is even
        if (n % 2 == 0)
            return sumeven(n, l, r);
 
        // If n is odd
        else
            return sumodd(n, l, r);
    }
 
    // Driver Code
    public static void Main()
    {
        int n = 12;
        int l = 1, r = 11;
        Console.WriteLine(rangesum(n, l, r));
    }
}
 
// This code is contributed
// by chandan_jnu.
Javascript



<script>
// Javascript program to find the sum between L-R
// range by creating the array
// Efficient Approach
     
     // Function to calculate the sum if n is even
    function sumeven(n,l,r)
    {
        let sum = 0;
        let mid = Math.floor(n / 2);
  
        // both l and r are to the left of mid
        if (r <= mid) {
            // first and last element
            let first = (2 * l - 1);
            let last = (2 * r - 1);
  
            // Total number of terms in
            // the sequence is r-l+1
            let no_of_terms = r - l + 1;
  
            // use of formula derived
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
        // both l and r are to the right of mid
        else if (l >= mid) {
            // // first and last element
            let first = (2 * (l - n / 2));
            let last = (2 * (r - n / 2));
  
            let no_of_terms = r - l + 1;
  
            // Use of formula derived
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
  
        // left is to the left of mid and
        // right is to the right of mid
        else {
            // Take two sums i.e left and
            // right differently and add
            let sumleft = 0, sumright = 0;
  
            // first and last element
            let first_term1 = (2 * l - 1);
            let last_term1 = (2 * (n / 2) - 1);
  
            // total terms
            let no_of_terms1 = n / 2 - l + 1;
  
            // no of terms
            sumleft = ((no_of_terms1) * ((first_term1 + last_term1))) / 2;
  
            // The first even number is 2
            let first_term2 = 2;
  
            // The last element is given by 2*(r-n/2)
            let last_term2 = (2 * (r - n / 2));
            let no_of_terms2 = r - mid;
  
            // formula applied
            sumright = ((no_of_terms2) * ((first_term2 + last_term2))) / 2;
            sum = (sumleft + sumright);
        }
  
        return sum;
    }
     
    // Function to calculate the sum if n is odd
    function sumodd(n,l,r)
    {
        // take ceil value if n is odd
        let mid = Math.floor(n / 2) + 1;
        let sum = 0;
  
        // // both l and r are to the left of mid
        if (r <= mid) {
            // first and last element
            let first = (2 * l - 1);
            let last = (2 * r - 1);
  
            // number of terms
            let no_of_terms = r - l + 1;
  
            // formula
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
  
        // // both l and r are to the right of mid
        else if (l > mid) {
  
            // first and last term ,
            let first = (2 * (l - mid));
            let last = (2 * (r - mid));
  
            // no of terms
            let no_of_terms = r - l + 1;
  
            // formula used
            sum = ((no_of_terms) * ((first + last))) / 2;
        }
  
        // If l is on left and r on right
        else {
  
            // calculate separate sums
            let sumleft = 0, sumright = 0;
  
            // first half
            let first_term1 = (2 * l - 1);
            let last_term1 = (2 * mid - 1);
  
            // calculate terms
            let no_of_terms1 = mid - l + 1;
            sumleft = ((no_of_terms1) * ((first_term1 + last_term1))) / 2;
  
            // second half
            let first_term2 = 2;
            let last_term2 = (2 * (r - mid));
            let no_of_terms2 = r - mid;
            sumright = ((no_of_terms2) * ((first_term2 + last_term2))) / 2;
  
            // add both halves
            sum = (sumleft + sumright);
        }
  
        return sum;
    }
     
    // Function to find the sum between L and R
    function rangesum(n,l,r)
    {
        let sum = 0;
  
        // If n is even
        if (n % 2 == 0)
            return sumeven(n, l, r);
  
        // If n is odd
        else
            return sumodd(n, l, r);
    }
     
    // Driver Code
    let n = 12;
    let l = 1, r = 11;
    document.write(rangesum(n, l, r));
     
 
 
// This code is contributed by rag2127
</script>
Output: 
66
 
Time complexity: O(1) 
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Find the sum of the first half and second half elements of an array
Next

Divide a number into two parts
Recommended Articles
Page :
Find the sum of the first half and second half elements of an array
19, Jul 19
Find prime numbers in the first half and second half of an array
22, Jul 19
Find the XOR of first half and second half elements of an array
27, Apr 20
Count number of rotated strings which have more number of vowels in the first half than second half
23, Oct 19
Find all even length binary sequences with same sum of first and second half bits | Iterative
26, Sep 19
Count numbers from given range having odd digits at odd places and even digits at even places
02, Dec 20
Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array
04, Dec 21
Count of integers in a range which have even number of odd digits and odd number of even digits
21, Aug 19
Check if array sum of first half is divisible by sum of other half or vice versa
10, Nov 21
Count of numbers of length N having prime numbers at odd indices and odd numbers at even indices
25, Aug 21
Sum of range in a series of first odd then even natural numbers
24, Apr 18
Find the nearest odd and even perfect squares of odd and even array elements respectively
05, Mar 21
Minimize the maximum difference of any pair by doubling odd elements and reducing even elements by half
20, Dec 20
Kth element in permutation of first N natural numbers having all even numbers placed before odd numbers in increasing order
03, Mar 21
Count numbers in given range such that sum of even digits is greater than sum of odd digits
26, Jun 19
Check if a number has an odd count of odd divisors and even count of even divisors
20, Aug 20
Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively
22, Feb 21
Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays
16, Dec 20
Maximize the difference of sum of elements at even indices and odd indices by shifting an odd sized subarray to end of given Array.
29, Dec 21
Check if sum of digits in the left half is divisible by sum of digits in the right half in the largest permutation of N
15, Jun 21
Reorder an array such that sum of left half is not equal to sum of right half
16, Jun 20
Count Numbers in Range with difference between Sum of digits at even and odd positions as Prime
22, Feb 19
Construct an Array of size N in which sum of odd elements is equal to sum of even elements
22, Apr 20
Find the Array Permutation having sum of elements at odd indices greater than sum of elements at even indices
07, Jul 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
debjitdbb
@debjitdbb
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!