Open in App
Not now

# Range Queries to find the Element having Maximum Digit Sum

• Last Updated : 31 Mar, 2023

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++

 `// C++ code for the approach`   `#include ` `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

 `// 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));` `    ``}` `}`

Output

```55
43```

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

### Efficient Approach:

• An efficient approach will be to build a Segment Tree where each node stores two values(value and max_digit_sum), and do a range query on it to find the max digit sum and the corresponding element. But for building the segment tree we have to think about what to store on the nodes of the tree.
• For finding out the maximum digit sum value, we will require two things, one being the value and the other digit sum. The merging will return two things, the digit sum will store the max(max_digit_sum.left, max_digit_sum.right) in the segment tree and value will contain the corresponding element value.
• If we have a deep look into it, the max digit sum for any two range combining will either be the max digit sum from the left side or the max digit sum from the right side, whichever is maximum will taken into account.
• Representation of Segment trees:
1. Leaf Nodes are the elements of the given array.
2. Each internal node represents some merging of the leaf nodes. The merging may be different for different problems. For this problem, merging is the maximum of the max_digit_sum of leaves under a node.
3. An array representation of the tree is used to represent Segment Trees. For each node at index i, the left child is at index 2*i+1, right child at 2*i+2 and the parent is at (i-1)/2

• Construction of Segment Tree from a given array:
1. We start with a segment arr[0 . . . n-1]. And every time we divide the current segment into two halves(if it has not yet become a segment of length 1), and then call the same procedure on both halves, and for each such segment, we store the max_digit_sum and the value in the corresponding node.
2. We then do a range query on the segment tree to find out the max_digit_sum for the given range and output the corresponding value.

Below is the implementation of the above approach.

## C++

 `// C++ program to find` `// maximum digit sum value` `#include ` `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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

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)

My Personal Notes arrow_drop_up
Related Articles