Given an array **arr[]** of size **N**, the task is to find the maximum sum non-empty subsequence present in the given array.

**Examples:**

Input:arr[] = { 2, 3, 7, 1, 9 }Output:22Explanation:

Sum of the subsequence { arr[0], arr[1], arr[2], arr[3], arr[4] } is equal to 22, which is the maximum possible sum of any subsequence of the array.

Therefore, the required output is 22.

Input:arr[] = { -2, 11, -4, 2, -3, -10 }Output:13Explanation:

Sum of the subsequence { arr[1], arr[3] } is equal to 13, which is the maximum possible sum of any subsequence of the array.

Therefore, the required output is 13.

**Naive Approach:** The simplest approach to solve this problem is to generate all possible non-empty subsequences of the array and calculate the sum of each subsequence of the array. Finally, print the maximum sum obtained from the subsequence.

**Time Complexity:** O(N * 2^{N})**Auxiliary Space:** O(N)

**Efficient Approach:** The idea is to traverse the array and calculate the sum of positive elements of the array and print the sum obtained. Follow the steps below to solve the problem:

- Check if the largest element of the array is greater than
**0**or not. If found to be true, then traverse the array and print the sum of all positive elements of the array. - Otherwise, print the largest element present in the array.

Below is the implementation of the above approach:

## C++

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to print the maximum` `// non-emepty subsequence sum` `int` `MaxNonEmpSubSeq(` `int` `a[], ` `int` `n)` `{` ` ` `// Stores the maximum non-emepty` ` ` `// subsequence sum in an array` ` ` `int` `sum = 0;` ` ` `// Stores the largest element` ` ` `// in the array` ` ` `int` `max = *max_element(a, a + n);` ` ` `if` `(max <= 0) {` ` ` `return` `max;` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// If a[i] is greater than 0` ` ` `if` `(a[i] > 0) {` ` ` `// Update sum` ` ` `sum += a[i];` ` ` `}` ` ` `}` ` ` `return` `sum;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { -2, 11, -4, 2, -3, -10 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `cout << MaxNonEmpSubSeq(arr, N);` ` ` `return` `0;` `}` |

## Java

`// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG` `{` ` ` `// Function to print the maximum` ` ` `// non-emepty subsequence sum` ` ` `static` `int` `MaxNonEmpSubSeq(` `int` `a[], ` `int` `n)` ` ` `{` ` ` `// Stores the maximum non-emepty` ` ` `// subsequence sum in an array` ` ` `int` `sum = ` `0` `;` ` ` `// Stores the largest element` ` ` `// in the array` ` ` `int` `max = a[` `0` `];` ` ` `for` `(` `int` `i = ` `1` `; i < n; i++)` ` ` `{` ` ` `if` `(max < a[i])` ` ` `{` ` ` `max = a[i];` ` ` `}` ` ` `}` ` ` `if` `(max <= ` `0` `)` ` ` `{ ` ` ` `return` `max;` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `// If a[i] is greater than 0` ` ` `if` `(a[i] > ` `0` `)` ` ` `{` ` ` `// Update sum` ` ` `sum += a[i];` ` ` `}` ` ` `}` ` ` `return` `sum;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `arr[] = { -` `2` `, ` `11` `, -` `4` `, ` `2` `, -` `3` `, -` `10` `};` ` ` `int` `N = arr.length;` ` ` `System.out.println(MaxNonEmpSubSeq(arr, N));` ` ` `}` `}` `// This code is contributed by divyesh072019` |

## Python3

`# Python3 program to implement` `# the above approach` `# Function to print the maxmimum` `# non-emepty subsequence sum` `def` `MaxNonEmpSubSeq(a, n):` ` ` ` ` `# Stores the maxmimum non-emepty` ` ` `# subsequence sum in an array` ` ` `sum` `=` `0` ` ` `# Stores the largest element` ` ` `# in the array` ` ` `maxm ` `=` `max` `(a)` ` ` `if` `(maxm <` `=` `0` `):` ` ` `return` `maxm` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(n):` ` ` ` ` `# If a[i] is greater than 0` ` ` `if` `(a[i] > ` `0` `):` ` ` ` ` `# Update sum` ` ` `sum` `+` `=` `a[i]` ` ` ` ` `return` `sum` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `arr ` `=` `[ ` `-` `2` `, ` `11` `, ` `-` `4` `, ` `2` `, ` `-` `3` `, ` `-` `10` `]` ` ` `N ` `=` `len` `(arr)` ` ` `print` `(MaxNonEmpSubSeq(arr, N))` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` ` ` `// Function to print the maximum` `// non-emepty subsequence sum` `static` `int` `MaxNonEmpSubSeq(` `int` `[] a, ` `int` `n)` `{` ` ` ` ` `// Stores the maximum non-emepty` ` ` `// subsequence sum in an array` ` ` `int` `sum = 0;` ` ` ` ` `// Stores the largest element` ` ` `// in the array` ` ` `int` `max = a[0];` ` ` `for` `(` `int` `i = 1; i < n; i++)` ` ` `{` ` ` `if` `(max < a[i])` ` ` `{` ` ` `max = a[i];` ` ` `}` ` ` `}` ` ` ` ` `if` `(max <= 0)` ` ` `{` ` ` `return` `max;` ` ` `}` ` ` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// If a[i] is greater than 0` ` ` `if` `(a[i] > 0)` ` ` `{` ` ` ` ` `// Update sum` ` ` `sum += a[i];` ` ` `}` ` ` `}` ` ` `return` `sum;` `}` `// Driver Code` `static` `void` `Main()` `{` ` ` `int` `[] arr = { -2, 11, -4, 2, -3, -10 };` ` ` `int` `N = arr.Length;` ` ` ` ` `Console.WriteLine(MaxNonEmpSubSeq(arr, N));` `}` `}` `// This code is contributed by divyeshrabadiya07` |

## Javascript

`<script>` ` ` `// Javascript program to implement` ` ` `// the above approach` ` ` ` ` `// Function to print the maximum` ` ` `// non-emepty subsequence sum` ` ` `function` `MaxNonEmpSubSeq(a, n)` ` ` `{` ` ` `// Stores the maximum non-emepty` ` ` `// subsequence sum in an array` ` ` `let sum = 0;` ` ` `// Stores the largest element` ` ` `// in the array` ` ` `let max = a[0];` ` ` `for` `(let i = 1; i < n; i++)` ` ` `{` ` ` `if` `(max < a[i])` ` ` `{` ` ` `max = a[i];` ` ` `}` ` ` `}` ` ` `if` `(max <= 0)` ` ` `{` ` ` `return` `max;` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(let i = 0; i < n; i++)` ` ` `{` ` ` `// If a[i] is greater than 0` ` ` `if` `(a[i] > 0)` ` ` `{` ` ` `// Update sum` ` ` `sum += a[i];` ` ` `}` ` ` `}` ` ` `return` `sum;` ` ` `}` ` ` ` ` `let arr = [ -2, 11, -4, 2, -3, -10 ];` ` ` `let N = arr.length;` ` ` ` ` `document.write(MaxNonEmpSubSeq(arr, N));` ` ` `</script>` |

**Output:**

13

**Time Complexity:** O(N)**Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**