Pythonic 2 lines:

def maxSubarray(arr):
    p = [n for n in arr if n > 0]
    return [max(accumulate(arr, lambda s, n: 0 if s+n < 0 else s+n, initial=0)), sum(p)] if p else [max(arr)] * 2

Python

def getmaxsubsequence(arr):
    total = 0
    for elem in arr:
        if elem > 0:
            total += elem
    return total if total > 0 else max(arr)    

def getmaxsubarray(arr):
    maxbeforeindex = [arr[0]]
    for index in range(1, len(arr)):
        curvalue = arr[index]
        connectedvalue = curvalue + maxbeforeindex[index-1]
        maxbeforeindex.append(max(connectedvalue, curvalue))
    
    return max(maxbeforeindex)

def maxSubarray(arr):
    return [getmaxsubarray(arr), getmaxsubsequence(arr)]

C#

public static List<int> maxSubarray(List<int> arr)
    {
        int sum = 0;
        int maxSubArrSum = 0;
        int maxSubSeqSum = 0;
        foreach (int num in arr) {
            if (num > 0) maxSubSeqSum += num;
            sum += num;
            if (sum > maxSubArrSum)
                maxSubArrSum = sum;
            if (sum < 0)
                sum = 0;
        }
        
        if (arr.All(num => num < 0)) {
            maxSubSeqSum = arr.Max();
            maxSubArrSum = maxSubSeqSum;
        }
        
        return new List<int> { maxSubArrSum, maxSubSeqSum };
    }

JS

function maxSubarray(array) {
    const getMaxSubsum = array => {
        let maxSum = -Infinity;
        array.reduce((sum, value) => {
            sum += value;
            maxSum = Math.max(maxSum, sum);
            return (sum > 0) ? sum : 0;
        }, 0);
        return maxSum;
    };
    const getMaxSubsequence = array => {
        array.sort((a, b) => a - b);
        return (array.at(-1) < 0) ? array.at(-1) : array.filter(value => value >= 0).reduce((sum, value) => sum + value);
    };
    return [getMaxSubsum(array), getMaxSubsequence(array)];
}

EASY C++ SOLUTION

include

using namespace std;

string ltrim(const string &); string rtrim(const string &); vector split(const string &);

/* * Complete the 'maxSubarray' function below. * * The function is expected to return an INTEGER_ARRAY. * The function accepts INTEGER_ARRAY arr as parameter. */

vector maxSubarray(vector arr) { vector result(2); // Create a vector of array with size 2 //maxSubarray Sum int maxSum = INT32_MIN;//assgining a minimum value to the maxSum int currSum = 0; for(int i=0;i<=arr.size()-1;i++){ currSum += arr[i]; if (currSum > maxSum){ maxSum = currSum; } if(currSum < 0){ currSum = 0; } } //-------------- //maxSubsequence Sum int sum = 0; for (int i = 0; i < arr.size(); ++i) { int num = arr[i]; if (num > 0) { sum += num; } } if (sum == 0) { sum = *std::max_element(arr.begin(), arr.end()); }

// Fill the individual vectors with some values
result[0] = maxSum;
result[1] = sum;
return result;

}

int main() { ofstream fout(getenv("OUTPUT_PATH"));

string t_temp;
getline(cin, t_temp);

int t = stoi(ltrim(rtrim(t_temp)));

for (int t_itr = 0; t_itr < t; t_itr++) {
    string n_temp;
    getline(cin, n_temp);

    int n = stoi(ltrim(rtrim(n_temp)));

    string arr_temp_temp;
    getline(cin, arr_temp_temp);

    vector<string> arr_temp = split(rtrim(arr_temp_temp));

    vector<int> arr(n);

    for (int i = 0; i < n; i++) {
        int arr_item = stoi(arr_temp[i]);

        arr[i] = arr_item;
    }

    vector<int> result = maxSubarray(arr);

    for (size_t i = 0; i < result.size(); i++) {
        fout << result[i];

        if (i != result.size() - 1) {
            fout << " ";
        }
    }

    fout << "\n";
}

fout.close();

return 0;

}

string ltrim(const string &str) { string s(str);

s.erase(
    s.begin(),
    find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
);

return s;

}

string rtrim(const string &str) { string s(str);

s.erase(
    find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
    s.end()
);

return s;

}

vector split(const string &str) { vector tokens;

string::size_type start = 0;
string::size_type end = 0;

while ((end = str.find(" ", start)) != string::npos) {
    tokens.push_back(str.substr(start, end - start));

    start = end + 1;
}

tokens.push_back(str.substr(start));

return tokens;

}