public static List<Integer> maxSubarray(List<Integer> arr) {
        int maxSubarraySum = Integer.MIN_VALUE;
        int currentSum = 0;
        int maxSubsequenceSum = 0;
        boolean hasPositive = false;
        int maxNegative = Integer.MIN_VALUE;
        for (int num : arr) {
            // Kadane's Algorithm for Maximum Subarray Sum
            currentSum += num;
            if (currentSum > maxSubarraySum) {
                maxSubarraySum = currentSum;
            }
            if (currentSum < 0) {
                currentSum = 0;
            }
            if (num > 0) {
                maxSubsequenceSum += num;
                hasPositive = true;
            }
            if (num < 0 && num > maxNegative) {
                maxNegative = num;
            }
        }
        if (!hasPositive) {
            maxSubsequenceSum = maxNegative;
        }
        
        return Arrays.asList(maxSubarraySum, maxSubsequenceSum);
    }
}

def maxSubarray(arr):
    max_ar, max_se = arr[0], 0
    curr_ar = 0
    for val in arr:
        # calculate maximum subarray
        curr_ar = max(val, curr_ar + val)
        max_ar = max(max_ar, curr_ar)
        # calculate maximum subsequence
        if val > 0:
            max_se += val
    # if all val in arr are negative
    if max_se == 0:
        max_se = max(arr)
    
    return max_ar, max_se

function maxSubArr(nums) {    
    let current_max = nums[0], max_so_far = nums[0];
        for (let i = 1; i < nums.length; i++){
            current_max = Math.max(nums[i], current_max + nums[i]);
            max_so_far = Math.max(max_so_far, current_max);
        }
        return max_so_far;
}

function maxSubarray(arr) {
    let maxSeq = pstvSum(arr)
    let min = Math.min(...arr)    
    let max = Math.max(...arr)        
    if(min>=0){
        return [maxSeq, maxSeq]     
    }else if(max<=0){
        return [max,max]
    }else{   
		// Kadane's algorithm for subArray max sum
      return [maxSubArr(arr), maxSeq]               
    }

}

function pstvSum(a){
    if(a.length==0)
      return 0
    return a.reduce((tot, curr)=> {
        if(curr>0) 
          tot+=curr          
        return tot
    })
}