Open In App

Range Queries to find the Element having Maximum Digit Sum

Given an array Arr of N integers and Q queries, each query having a range from L to R. Find the element having maximum digit sum for the range L to R, and if more than one element has a maximum digit sum, then find the maximum element out of those.

Examples: 

Input: Arr[] = { 16, 12, 43, 55} 
       Q = 2
       L = 0, R = 3
       L = 0, R = 2

Output: 55
        43

Explanation:
 The range (0, 3) in the 1st query has
 [16, 12, 43, 55]. Here, the digit sums are:
 for 16, 1 + 6 = 7
 for 12, 1 + 2 = 3
 for 43, 4 + 3 = 7
 for 55, 5 + 5 = 10
 Hence, the max digit sum is 10 and 
 max digit sum value is 55.

 The range (0, 2) in the 1st query has
 [16, 12, 43]. Here, the digit sums are:
 for 16, 1 + 6 = 7
 for 12, 1 + 2 = 3
 for 43, 4 + 3 = 7
 Hence, the max digit sum is 7 and 
 max digit sum value is max( 16, 43) = 43. 

Naive Approach: 

A simple solution is to run a loop from L to R and calculate the digit sum for each element and find the maximum digit sum element from L to R for every query.

Below is the implementation of the approach:




// C++ code for the approach
 
#include <iostream>
using namespace std;
 
// Function to calculate the digit sum of a number
int digit_sum(int n)
{
    int sum = 0;
    while (n > 0) {
        sum += n % 10;
        n /= 10;
    }
    return sum;
}
 
// Function to find the element having maximum digit sum in
// the given range
int max_digit_sum(int arr[], int n, int l, int r)
{
    int max_sum = -1, max_num = -1;
    for (int i = l; i <= r; i++) {
        int sum = digit_sum(arr[i]);
        if (sum > max_sum) {
            max_sum = sum;
            max_num = arr[i];
        }
        else if (sum == max_sum && arr[i] > max_num) {
            max_num = arr[i];
        }
    }
    return max_num;
}
 
// Main function to handle the queries
int main()
{
    // Input array
    int arr[] = { 16, 12, 43, 55 };
 
    // Calculates the length of array
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // query 1
    int l = 0, r = 3;
    cout << max_digit_sum(arr, n, l, r) << endl;
 
    // query 2
    l = 0, r = 2;
    cout << max_digit_sum(arr, n, l, r) << endl;
 
    return 0;
}




// Java code for the approach
 
import java.util.*;
 
public class GFG {
    // Function to calculate the digit sum of a number
    public static int digit_sum(int n)
    {
        int sum = 0;
        while (n > 0) {
            sum += n % 10;
            n /= 10;
        }
        return sum;
    }
    // Function to find the element having maximum digit sum
    // in
    // the given range
    public static int max_digit_sum(int[] arr, int n, int l,
                                    int r)
    {
        int max_sum = -1, max_num = -1;
        for (int i = l; i <= r; i++) {
            int sum = digit_sum(arr[i]);
            if (sum > max_sum) {
                max_sum = sum;
                max_num = arr[i];
            }
            else if (sum == max_sum && arr[i] > max_num) {
                max_num = arr[i];
            }
        }
        return max_num;
    }
 
    // Main function to handle the queries
    public static void main(String[] args)
    {
        // Input array
        int[] arr = { 16, 12, 43, 55 };
 
        // Calculates the length of array
        int n = arr.length;
 
        // query 1
        int l = 0, r = 3;
        System.out.println(max_digit_sum(arr, n, l, r));
 
        // query 2
        l = 0;
        r = 2;
        System.out.println(max_digit_sum(arr, n, l, r));
    }
}




# Python3 code for the approach
 
# Function to calculate the digit sum of a number
def digit_sum(n):
  sum = 0
  while n > 0:
    sum += n % 10
    n //= 10
     
  return sum
 
# Function to find the element having maximum digit sum in the given range
def max_digit_sum(arr, l, r):
  max_sum = -1
  max_num = -1
   
  for i in range(l, r+1):
    sum = digit_sum(arr[i])
    if sum > max_sum:
      max_sum = sum
      max_num = arr[i]
    elif sum == max_sum and arr[i] > max_num:
      max_num = arr[i]
       
  return max_num
 
# Main function to handle the queries
if __name__ == '__main__':
  # Input array
  arr = [16, 12, 43, 55]
  # Calculates the length of array
  n = len(arr)
 
  # query 1
  l = 0
  r = 3
  print(max_digit_sum(arr, l, r))
 
  # query 2
  l = 0
  r = 2
  print(max_digit_sum(arr, l, r))




using System;
 
namespace MaxDigitSum
{
    class Program
    {
        // Function to calculate the digit sum of a number
        static int DigitSum(int n)
        {
            int sum = 0;
            while (n > 0)
            {
                sum += n % 10;
                n /= 10;
            }
            return sum;
        }
 
        // Function to find the element having maximum digit sum in
        // the given range
        static int MaxDigitSum(int[] arr, int n, int l, int r)
        {
            int maxSum = -1, maxNum = -1;
            for (int i = l; i <= r; i++)
            {
                int sum = DigitSum(arr[i]);
                if (sum > maxSum)
                {
                    maxSum = sum;
                    maxNum = arr[i];
                }
                else if (sum == maxSum && arr[i] > maxNum)
                {
                    maxNum = arr[i];
                }
            }
            return maxNum;
        }
 
        // Main function to handle the queries
        static void Main(string[] args)
        {
            // Input array
            int[] arr = { 16, 12, 43, 55 };
 
            // Calculates the length of array
            int n = arr.Length;
 
            // query 1
            int l = 0, r = 3;
            Console.WriteLine(MaxDigitSum(arr, n, l, r));
 
            // query 2
            l = 0; r = 2;
            Console.WriteLine(MaxDigitSum(arr, n, l, r));
        }
    }
}




function digitSum(n) {
    let sum = 0;
    while (n > 0) {
        sum += n % 10;
        n = Math.floor(n / 10);
    }
    return sum;
}
 
function maxDigitSum(arr, l, r) {
    let maxSum = -1, maxNum = -1;
    for (let i = l; i <= r; i++) {
        let sum = digitSum(arr[i]);
        if (sum > maxSum) {
            maxSum = sum;
            maxNum = arr[i];
        }
        else if (sum === maxSum && arr[i] > maxNum) {
            maxNum = arr[i];
        }
    }
    return maxNum;
}
 
// Example usage
let arr = [16, 12, 43, 55];
console.log(maxDigitSum(arr, 0, 3)); // Output: 55
console.log(maxDigitSum(arr, 0, 2)); // Output: 43

Output
55
43

Time Complexity: O(Q * N * log10(Max)),  where Max is the maximum value in arr.
Auxiliary Space: O(1).

Efficient Approach:  

Below is the implementation of the above approach.




// C++ program to find
// maximum digit sum value
#include <bits/stdc++.h>
using namespace std;
 
// Struct two store two values in one node
struct Node {
    int value;
    int max_digit_sum;
};
 
Node tree[4 * 10000];
 
// Function to find the digit sum
// for a number
int digitSum(int x)
{
    int sum = 0;
    while (x) {
        sum += (x % 10);
        x /= 10;
    }
}
 
// Function to build the segment tree
void build(int a[], int index, int beg, int end)
{
    if (beg == end) {
 
        // If there is one element in array,
        tree[index].value = a[beg];
        tree[index].max_digit_sum = digitSum(a[beg]);
    }
    else {
 
        int mid = (beg + end) / 2;
 
        // If there are more than one elements,
        // then recur for left and right subtrees
        build(a, 2 * index + 1, beg, mid);
        build(a, 2 * index + 2, mid + 1, end);
 
        if (tree[2 * index + 1].max_digit_sum >
            tree[2 * index + 2].max_digit_sum)
        {
            tree[index].max_digit_sum =
                tree[2 * index + 1].max_digit_sum;
            tree[index].value =
                tree[2 * index + 1].value;
        }
        else if (tree[2 * index + 2].max_digit_sum >
                 tree[2 * index + 1].max_digit_sum)
        {
            tree[index].max_digit_sum =
                tree[2 * index + 2].max_digit_sum;
            tree[index].value =
                tree[2 * index + 2].value;
        }
        else
        {
            tree[index].max_digit_sum =
                tree[2 * index + 2].max_digit_sum;
            tree[index].value =
                max(tree[2 * index + 2].value,
                    tree[2 * index + 1].value);
        }
    }
}
 
// Function to do the range query in the segment
// tree for the maximum digit sum
Node query(int index, int beg, int end,
           int l, int r)
{
    Node result;
    result.value = result.max_digit_sum = -1;
 
    // If segment of this node is outside the given
    // range, then return the minimum value.
    if (beg > r || end < l)
        return result;
 
    // If segment of this node is a part of given
    // range, then return the node of the segment
    if (beg >= l && end <= r)
        return tree[index];
 
    int mid = (beg + end) / 2;
 
    // If left segment of this node falls out of
    // range, then recur in the right side of
    // the tree
    if (l > mid)
        return query(2 * index + 2, mid + 1,
                     end, l, r);
 
    // If right segment of this node falls out of
    // range, then recur in the left side of
    // the tree
    if (r <= mid)
        return query(2 * index + 1, beg,
                     mid, l, r);
 
    // If a part of this segment overlaps with
    // the given range
    Node left = query(2 * index + 1, beg,
                      mid, l, r);
    Node right = query(2 * index + 2, mid + 1,
                       end, l, r);
 
    if (left.max_digit_sum > right.max_digit_sum)
    {
        result.max_digit_sum = left.max_digit_sum;
        result.value = left.value;
    }
    else if (right.max_digit_sum > left.max_digit_sum)
    {
        result.max_digit_sum = right.max_digit_sum;
        result.value = right.value;
    }
    else
    {
        result.max_digit_sum = left.max_digit_sum;
        result.value = max(right.value, left.value);
    }
 
    // Returns the value
    return result;
}
 
// Driver code
int main()
{
 
    int a[] = {16, 12, 43, 55};
 
    // Calculates the length of array
    int N = sizeof(a) / sizeof(a[0]);
 
    // Calls the build function to build
    // the segment tree
    build(a, 0, 0, N - 1);
 
    // Find the max digit-sum value between
    // 0th and 3rd index of array
    cout << query(0, 0, N - 1, 0, 3).value
         << endl;
 
    // Find the max digit-sum value between
    // 0th and 2nd index of array
    cout << query(0, 0, N - 1, 0, 2).value
         << endl;
 
    return 0;
}




// Java program to find
// maximum digit sum value
import java.util.*;
 
class GFG{
 
// Struct two store two values
// in one node
static class Node
{
    int value;
    int max_digit_sum;
};
 
static Node []tree = new Node[4 * 10000];
 
// Function to find the digit sum
// for a number
static int digitSum(int x)
{
    int sum = 0;
     
    while (x > 0)
    {
        sum += (x % 10);
        x /= 10;
    }
    return sum;
}
 
// Function to build the segment tree
static void build(int a[], int index,
                  int beg, int end)
{
    if (beg == end)
    {
         
        // If there is one element in array,
        tree[index].value = a[beg];
        tree[index].max_digit_sum = digitSum(a[beg]);
    }
    else
    {
        int mid = (beg + end) / 2;
 
        // If there are more than one elements,
        // then recur for left and right subtrees
        build(a, 2 * index + 1, beg, mid);
        build(a, 2 * index + 2, mid + 1, end);
 
        if (tree[2 * index + 1].max_digit_sum >
            tree[2 * index + 2].max_digit_sum)
        {
            tree[index].max_digit_sum =
                tree[2 * index + 1].max_digit_sum;
            tree[index].value =
                tree[2 * index + 1].value;
        }
        else if (tree[2 * index + 2].max_digit_sum >
                 tree[2 * index + 1].max_digit_sum)
        {
            tree[index].max_digit_sum =
                tree[2 * index + 2].max_digit_sum;
            tree[index].value =
                tree[2 * index + 2].value;
        }
        else
        {
            tree[index].max_digit_sum =
                tree[2 * index + 2].max_digit_sum;
            tree[index].value =
                Math.max(tree[2 * index + 2].value,
                         tree[2 * index + 1].value);
        }
    }
}
 
// Function to do the range query in the segment
// tree for the maximum digit sum
static Node query(int index, int beg, int end,
                  int l, int r)
{
    Node result = new Node();
    result.value = result.max_digit_sum = -1;
 
    // If segment of this node is outside the given
    // range, then return the minimum value.
    if (beg > r || end < l)
        return result;
 
    // If segment of this node is a part of given
    // range, then return the node of the segment
    if (beg >= l && end <= r)
        return tree[index];
 
    int mid = (beg + end) / 2;
 
    // If left segment of this node falls out of
    // range, then recur in the right side of
    // the tree
    if (l > mid)
        return query(2 * index + 2, mid + 1,
                     end, l, r);
 
    // If right segment of this node falls out of
    // range, then recur in the left side of
    // the tree
    if (r <= mid)
        return query(2 * index + 1, beg,
                     mid, l, r);
 
    // If a part of this segment overlaps with
    // the given range
    Node left = query(2 * index + 1, beg,
                      mid, l, r);
    Node right = query(2 * index + 2, mid + 1,
                       end, l, r);
 
    if (left.max_digit_sum > right.max_digit_sum)
    {
        result.max_digit_sum = left.max_digit_sum;
        result.value = left.value;
    }
    else if (right.max_digit_sum > left.max_digit_sum)
    {
        result.max_digit_sum = right.max_digit_sum;
        result.value = right.value;
    }
    else
    {
        result.max_digit_sum = left.max_digit_sum;
        result.value = Math.max(right.value,
                                 left.value);
    }
 
    // Returns the value
    return result;
}
 
// Driver code
public static void main(String[] args)
{
    int a[] = { 16, 12, 43, 55 };
 
    // Calculates the length of array
    int N = a.length;
     
    for(int i = 0; i < tree.length; i++)
        tree[i] = new Node();
         
    // Calls the build function to build
    // the segment tree
    build(a, 0, 0, N - 1);
 
    // Find the max digit-sum value between
    // 0th and 3rd index of array
    System.out.print(
        query(0, 0, N - 1, 0, 3).value + "\n");
 
    // Find the max digit-sum value between
    // 0th and 2nd index of array
    System.out.print(
        query(0, 0, N - 1, 0, 2).value + "\n");
}
}
 
// This code is contributed by Amit Katiyar




# Python3 program to find
# maximum digit sum value
  
# Struct two store two values in one node
class Node:
     
    def __init__(self):
         
        self.value = 0
        self.max_digit_sum = 0
     
tree = [Node() for i in range(4 * 10000)]
 
# Function to find the digit sum
# for a number
def digitSum(x):
     
    sum = 0;
    while(x != 0):
        sum += (x % 10)
        x //= 10
         
    return sum
     
# Function to build the segment tree
def build(a, index, beg, end):
     
    if (beg == end):
  
        # If there is one element in array,
        tree[index].value = a[beg]
        tree[index].max_digit_sum = digitSum(a[beg])
     
    else:
        mid = (beg + end) // 2
  
        # If there are more than one elements,
        # then recur for left and right subtrees
        build(a, 2 * index + 1, beg, mid)
        build(a, 2 * index + 2, mid + 1, end)
         
        if (tree[2 * index + 1].max_digit_sum >
            tree[2 * index + 2].max_digit_sum):
         
            tree[index].max_digit_sum = tree[2 * index + 1].max_digit_sum
            tree[index].value = tree[2 * index + 1].value
         
        elif (tree[2 * index + 2].max_digit_sum >
              tree[2 * index + 1].max_digit_sum):
         
            tree[index].max_digit_sum = tree[2 * index + 2].max_digit_sum
            tree[index].value = tree[2 * index + 2].value
         
        else:
            tree[index].max_digit_sum = tree[2 * index + 2].max_digit_sum
            tree[index].value = max(tree[2 * index + 2].value,
                                    tree[2 * index + 1].value)
         
# Function to do the range query in the segment
# tree for the maximum digit sum
def query(index, beg, end, l, r):
 
    result = Node()
    result.value = result.max_digit_sum = -1
  
    # If segment of this node is outside the given
    # range, then return the minimum value.
    if (beg > r or end < l):
        return result
  
    # If segment of this node is a part of given
    # range, then return the node of the segment
    if (beg >= l and end <= r):
        return tree[index]
  
    mid = (beg + end) // 2
  
    # If left segment of this node falls out of
    # range, then recur in the right side of
    # the tree
    if (l > mid):
        return query(2 * index + 2, mid + 1, end, l, r)
  
    # If right segment of this node falls out of
    # range, then recur in the left side of
    # the tree
    if (r <= mid):
        return query(2 * index + 1, beg, mid, l, r)
  
    # If a part of this segment overlaps with
    # the given range
    left = query(2 * index + 1, beg, mid, l, r)
    right = query(2 * index + 2, mid + 1, end, l, r)
  
    if (left.max_digit_sum > right.max_digit_sum):
        result.max_digit_sum = left.max_digit_sum
        result.value = left.value
     
    elif (right.max_digit_sum > left.max_digit_sum):
        result.max_digit_sum = right.max_digit_sum
        result.value = right.value
     
    else:
        result.max_digit_sum = left.max_digit_sum
        result.value = max(right.value, left.value)
  
    # Returns the value
    return result
     
# Driver code
if __name__=="__main__":
     
    a = [ 16, 12, 43, 55 ]
  
    # Calculates the length of array
    N = len(a)
  
    # Calls the build function to build
    # the segment tree
    build(a, 0, 0, N - 1)
  
    # Find the max digit-sum value between
    # 0th and 3rd index of array
    print(query(0, 0, N - 1, 0, 3).value)
  
    # Find the max digit-sum value between
    # 0th and 2nd index of array
    print(query(0, 0, N - 1, 0, 2).value)
    
# This code is contributed by rutvik_56




// C# program to find
// maximum digit sum value
using System;
class GFG{
 
// Struct two store
// two values in one node
class Node
{
  public int value;
  public int max_digit_sum;
};
 
static Node []tree = new Node[4 * 10000];
 
// Function to find the digit sum
// for a number
static int digitSum(int x)
{
  int sum = 0;
 
  while (x > 0)
  {
    sum += (x % 10);
    x /= 10;
  }
  return sum;
}
 
// Function to build the segment tree
static void build(int []a, int index,
                  int beg, int end)
{
  if (beg == end)
  {
    // If there is one element in array,
    tree[index].value = a[beg];
    tree[index].max_digit_sum =
                digitSum(a[beg]);
  }
  else
  {
    int mid = (beg + end) / 2;
 
    // If there are more than one elements,
    // then recur for left and right subtrees
    build(a, 2 * index + 1, beg, mid);
    build(a, 2 * index + 2, mid + 1, end);
 
    if (tree[2 * index + 1].max_digit_sum >
        tree[2 * index + 2].max_digit_sum)
    {
      tree[index].max_digit_sum =
           tree[2 * index + 1].max_digit_sum;
      tree[index].value =
           tree[2 * index + 1].value;
    }
    else if (tree[2 * index + 2].max_digit_sum >
             tree[2 * index + 1].max_digit_sum)
    {
      tree[index].max_digit_sum =
           tree[2 * index + 2].max_digit_sum;
      tree[index].value =
           tree[2 * index + 2].value;
    }
    else
    {
      tree[index].max_digit_sum =
           tree[2 * index + 2].max_digit_sum;
      tree[index].value =
           Math.Max(tree[2 * index + 2].value,
                tree[2 * index + 1].value);
    }
  }
}
 
// Function to do the range query
// in the segment tree for the
// maximum digit sum
static Node query(int index, int beg,
                  int end, int l, int r)
{
  Node result = new Node();
  result.value = result.max_digit_sum = -1;
 
  // If segment of this node is
  // outside the given range,
  // then return the minimum value.
  if (beg > r || end < l)
    return result;
 
  // If segment of this node
  // is a part of given range,
  // then return the node of the segment
  if (beg >= l && end <= r)
    return tree[index];
 
  int mid = (beg + end) / 2;
 
  // If left segment of this
  // node falls out of range,
  // then recur in the right
  // side of the tree
  if (l > mid)
    return query(2 * index + 2, mid + 1,
                 end, l, r);
 
  // If right segment of this
  // node falls out of range,
  // then recur in the left side of
  // the tree
  if (r <= mid)
    return query(2 * index + 1, beg,
                 mid, l, r);
 
  // If a part of this segment
  // overlaps with the given range
  Node left = query(2 * index + 1, beg,
                    mid, l, r);
  Node right = query(2 * index + 2, mid + 1,
                     end, l, r);
 
  if (left.max_digit_sum > right.max_digit_sum)
  {
    result.max_digit_sum = left.max_digit_sum;
    result.value = left.value;
  }
  else if (right.max_digit_sum > left.max_digit_sum)
  {
    result.max_digit_sum = right.max_digit_sum;
    result.value = right.value;
  }
  else
  {
    result.max_digit_sum = left.max_digit_sum;
    result.value = Math.Max(right.value,
                            left.value);
  }
 
  // Returns the value
  return result;
}
 
// Driver code
public static void Main(String[] args)
{
  int []a = {16, 12, 43, 55};
 
  // Calculates the length
  // of array
  int N = a.Length;
 
  for(int i = 0; i < tree.Length; i++)
    tree[i] = new Node();
 
  // Calls the build function
  // to build the segment tree
  build(a, 0, 0, N - 1);
 
  // Find the max digit-sum value between
  // 0th and 3rd index of array
  Console.Write(query(0, 0,
                      N - 1,
                      0, 3).value + "\n");
 
  // Find the max digit-sum value between
  // 0th and 2nd index of array
  Console.Write(query(0, 0,
                      N - 1,
                      0, 2).value + "\n");
}
}
 
// This code is contributed by Rajput-Ji




<script>
    // Javascript program to find maximum digit sum value
     
    // Struct two store two values in one node
    class Node
    {
        constructor() {
           this.value = 0;
           this.max_digit_sum = 0;
        }
    }
     
    let tree = new Array(4 * 10000);
     
    // Function to find the digit sum for a number
    function digitSum(x)
    {
      let sum = 0;
 
      while (x > 0)
      {
        sum += (x % 10);
        x = parseInt(x / 10, 10);
      }
      return sum;
    }
 
    // Function to build the segment tree
    function build(a, index, beg, end)
    {
      if (beg == end)
      {
        // If there is one element in array,
        tree[index].value = a[beg];
        tree[index].max_digit_sum = digitSum(a[beg]);
      }
      else
      {
        let mid = parseInt((beg + end) / 2, 10);
 
        // If there are more than one elements,
        // then recur for left and right subtrees
        build(a, 2 * index + 1, beg, mid);
        build(a, 2 * index + 2, mid + 1, end);
 
        if (tree[2 * index + 1].max_digit_sum >
            tree[2 * index + 2].max_digit_sum)
        {
          tree[index].max_digit_sum =
               tree[2 * index + 1].max_digit_sum;
          tree[index].value =
               tree[2 * index + 1].value;
        }
        else if (tree[2 * index + 2].max_digit_sum >
                 tree[2 * index + 1].max_digit_sum)
        {
          tree[index].max_digit_sum =
               tree[2 * index + 2].max_digit_sum;
          tree[index].value =
               tree[2 * index + 2].value;
        }
        else
        {
          tree[index].max_digit_sum =
               tree[2 * index + 2].max_digit_sum;
          tree[index].value =
               Math.max(tree[2 * index + 2].value,
                    tree[2 * index + 1].value);
        }
      }
    }
 
    // Function to do the range query
    // in the segment tree for the
    // maximum digit sum
    function query(index, beg, end, l, r)
    {
      let result = new Node();
      result.value = result.max_digit_sum = -1;
 
      // If segment of this node is
      // outside the given range,
      // then return the minimum value.
      if (beg > r || end < l)
        return result;
 
      // If segment of this node
      // is a part of given range,
      // then return the node of the segment
      if (beg >= l && end <= r)
        return tree[index];
 
      let mid = parseInt((beg + end) / 2, 10);
 
      // If left segment of this
      // node falls out of range,
      // then recur in the right
      // side of the tree
      if (l > mid)
        return query(2 * index + 2, mid + 1, end, l, r);
 
      // If right segment of this
      // node falls out of range,
      // then recur in the left side of
      // the tree
      if (r <= mid)
        return query(2 * index + 1, beg, mid, l, r);
 
      // If a part of this segment
      // overlaps with the given range
      let left = query(2 * index + 1, beg,
                        mid, l, r);
      let right = query(2 * index + 2, mid + 1,
                         end, l, r);
 
      if (left.max_digit_sum > right.max_digit_sum)
      {
        result.max_digit_sum = left.max_digit_sum;
        result.value = left.value;
      }
      else if (right.max_digit_sum > left.max_digit_sum)
      {
        result.max_digit_sum = right.max_digit_sum;
        result.value = right.value;
      }
      else
      {
        result.max_digit_sum = left.max_digit_sum;
        result.value = Math.max(right.value, left.value);
      }
 
      // Returns the value
      return result;
    }
     
    let a = [16, 12, 43, 55];
  
    // Calculates the length
    // of array
    let N = a.length;
 
    for(let i = 0; i < tree.length; i++)
      tree[i] = new Node();
 
    // Calls the build function
    // to build the segment tree
    build(a, 0, 0, N - 1);
 
    // Find the max digit-sum value between
    // 0th and 3rd index of array
    document.write(query(0, 0,
                        N - 1,
                        0, 3).value + "</br>");
 
    // Find the max digit-sum value between
    // 0th and 2nd index of array
    document.write(query(0, 0,
                        N - 1,
                        0, 2).value + "</br>");
 
// This code is contributed by divyeshrabadiya07.
</script>

Output: 
55
43

 

Complexity Analysis: 
Time Complexity for tree construction is O(N). There are total 2n-1 nodes, and the value of every node is calculated only once in tree construction.
Time complexity to every query is O(log N).
Time complexity for the problem is O(Q * log N)


Article Tags :