Time complexity: O(n)
Space complexity: O(1)

class Solution {
public:
  int minOperations(vector<int>& nums, int k) {
    return accumulate(begin(nums), end(nums), 0) % k;
  }
};

Return true if these subarrays exist, and false otherwise.

A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums = [4,2,4]
Output: true
Explanation: The subarrays with elements [4,2] and [2,4] have the same sum of 6.

Example 2:

Input: nums = [1,2,3,4,5]
Output: false
Explanation: No two subarrays of size 2 have the same sum.

Example 3:

Input: nums = [0,0,0]
Output: true
Explanation: The subarrays [nums[0],nums[1]] and [nums[1],nums[2]] have the same sum of 0. 
Note that even though the subarrays have the same content, the two subarrays are considered different because they are in different positions in the original array.

Constraints:

• 2 <= nums.length <= 1000
• -109 <= nums[i] <= 109

Solution: Hashset

Use a hashset to track all the sums seen so far.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  bool findSubarrays(vector<int>& nums) {
    unordered_set<int> s;
    for (int i = 1; i < nums.size(); ++i)
      if (!s.emplace(nums[i] + nums[i - 1]).second) return true;    
    return false;
  }
};

Return an array answer of length m where answer[i] is the maximum size of a subsequence that you can take from nums such that the sum of its elements is less than or equal to queries[i].

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Example 1:

Input: nums = [4,5,2,1], queries = [3,10,21]
Output: [2,3,4]
Explanation: We answer the queries as follows:
- The subsequence [2,1] has a sum less than or equal to 3. It can be proven that 2 is the maximum size of such a subsequence, so answer[0] = 2.
- The subsequence [4,5,1] has a sum less than or equal to 10. It can be proven that 3 is the maximum size of such a subsequence, so answer[1] = 3.
- The subsequence [4,5,2,1] has a sum less than or equal to 21. It can be proven that 4 is the maximum size of such a subsequence, so answer[2] = 4.

Example 2:

Input: nums = [2,3,4,5], queries = [1]
Output: [0]
Explanation: The empty subsequence is the only subsequence that has a sum less than or equal to 1, so answer[0] = 0.

Constraints:

• n == nums.length
• m == queries.length
• 1 <= n, m <= 1000
• 1 <= nums[i], queries[i] <= 106

Solution: Sort + PrefixSum + Binary Search

Time complexity: O(nlogn + mlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {    
    sort(begin(nums), end(nums));
    partial_sum(begin(nums), end(nums), begin(nums));
    vector<int> ans;
    for (int q : queries)
      ans.push_back(upper_bound(begin(nums), end(nums), q) - begin(nums));
    return ans;
  }
};

Solution 1: Range sum query

Assuming we can collect fruits in range [l, r], we need a fast query to compute the sum of those fruits.

Given startPos and k, we have four options:
1. move i steps to the left
2. move i steps to the left and k – i steps to the right.
3. move i steps to the right
4. move i steps to the right and k – i steps to the left.

We enumerate i steps and calculate maximum range [l, r] covered by each option, and collect all the fruit in that range.

Time complexity: O(m + k)
Space complexity: O(m)
where m = max(max(pos), startPos)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    const int m = max(startPos, (*max_element(begin(fruits), end(fruits)))[0]);
    vector<int> sums(m + 2);   
    for (int i = 0, j = 0; i <= m; ++i) {
      sums[i + 1] += sums[i];
      while (j < fruits.size() && fruits[j][0] == i)        
        sums[i + 1] += fruits[j++][1];      
    }    
    int ans = 0;
    for (int s = 0; s <= k; ++s) {
      if (startPos - s >= 0) {
        int l = startPos - s;
        int r = min(max(startPos, l + (k - s)), m);        
        ans = max(ans, sums[r + 1] - sums[l]);
      }
      if (startPos + s <= m) {
        int r = startPos + s;
        int l = max(0, min(startPos, r - (k - s)));
        ans = max(ans, sums[r + 1] - sums[l]);
      }
    }             
    return ans;
  }
};

Solution 2: Sliding Window

Maintain a window [l, r] such that the steps to cover [l, r] from startPos is less or equal to k.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    auto steps = [&](int l, int r) {
      if (r <= startPos)
        return startPos - l;
      else if (l >= startPos)
        return r - startPos;
      else
        return min(startPos + r - 2 * l, 2 * r - startPos - l);
    };
    int ans = 0;
    for (int r = 0, l = 0, cur = 0; r < fruits.size(); ++r) {
      cur += fruits[r][1];
      while (l <= r && steps(fruits[l][0], fruits[r][0]) > k)
        cur -= fruits[l++][1];      
      ans = max(ans, cur);
    }
    return ans;
  }
};

The absolute sum difference of arrays nums1 and nums2 is defined as the sum of |nums1[i] - nums2[i]| for each 0 <= i < n (0-indexed).

You can replace at most one element of nums1 with any other element in nums1 to minimize the absolute sum difference.

Return the minimum absolute sum difference after replacing at most oneelement in the array nums1. Since the answer may be large, return it modulo 109 + 7.

|x| is defined as:

• x if x >= 0, or
• -x if x < 0.

Example 1:

Input: nums1 = [1,7,5], nums2 = [2,3,5]
Output: 3
Explanation: There are two possible optimal solutions:
- Replace the second element with the first: [1,7,5] => [1,1,5], or
- Replace the second element with the third: [1,7,5] => [1,5,5].
Both will yield an absolute sum difference of |1-2| + (|1-3| or |5-3|) + |5-5| = 3.

Example 2:

Input: nums1 = [2,4,6,8,10], nums2 = [2,4,6,8,10]
Output: 0
Explanation: nums1 is equal to nums2 so no replacement is needed. This will result in an 
absolute sum difference of 0.

Example 3:

Input: nums1 = [1,10,4,4,2,7], nums2 = [9,3,5,1,7,4]
Output: 20
Explanation: Replace the first element with the second: [1,10,4,4,2,7] => [10,10,4,4,2,7].
This yields an absolute sum difference of |10-9| + |10-3| + |4-5| + |4-1| + |2-7| + |7-4| = 20

Constraints:

• n == nums1.length
• n == nums2.length
• 1 <= n <= 105
• 1 <= nums1[i], nums2[i] <= 105

Solution: Binary Search

Greedy won’t work, e.g. finding the max diff pair and replace it. Counter example:
nums1 = [7, 5], nums2 = [1, -2]
pair1 = abs(7 – 1) = 6
pair2 = abs(5 – (-2)) = 7
If we replace 5 with 7, we got pair2′ = abs(7 – (-2)) = 9 > 7.

Every pair of numbers can be the candidate, we just need to find the closest number for each nums2[i].

Time complexity: O(nlogn)
Space complexity: O(n)

class Solution {
public:
  int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {
    constexpr int kMod = 1e9 + 7;
    const int n = nums1.size();
    long ans = 0;
    int gain = 0;
    set<int> s(begin(nums1), end(nums1));
    for (int i = 0; i < n; ++i) {
      const int diff = abs(nums1[i] - nums2[i]);
      ans += diff;
      if (diff <= gain) continue;
      auto it = s.lower_bound(nums2[i]);      
      if (it != s.end()) 
        gain = max(gain, diff - abs(*it - nums2[i]));
      if (it != s.begin()) 
        gain = max(gain, diff - abs(*prev(it) - nums2[i])); 
    }
    return (ans - gain) % kMod;
  }
};

A customer’s wealth is the amount of money they have in all their bank accounts. The richest customer is the customer that has the maximum wealth.

Example 1:

Input: accounts = [[1,2,3],[3,2,1]]
Output: 6
Explanation:
1st customer has wealth = 1 + 2 + 3 = 6
2nd customer has wealth = 3 + 2 + 1 = 6
Both customers are considered the richest with a wealth of 6 each, so return 6.

Example 2:

Input: accounts = [[1,5],[7,3],[3,5]]
Output: 10
Explanation: 
1st customer has wealth = 6
2nd customer has wealth = 10 
3rd customer has wealth = 8
The 2nd customer is the richest with a wealth of 10.

Example 3:

Input: accounts = [[2,8,7],[7,1,3],[1,9,5]]
Output: 17

Constraints:

• m == accounts.length
• n == accounts[i].length
• 1 <= m, n <= 50
• 1 <= accounts[i][j] <= 100

Solution: Sum each row up

Time complexity: O(mn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maximumWealth(vector<vector<int>>& accounts) {
    int ans = 0;
    for (const vector<int>& row : accounts)
      ans = max(ans, accumulate(begin(row), end(row), 0));
    return ans;
  }
};

# Author: Huahua
class Solution:
  def maximumWealth(self, accounts: List[List[int]]) -> int:
    return max(sum(account) for account in accounts)

You have an inventory of different colored balls, and there is a customer that wants orders balls of any color.

The customer weirdly values the colored balls. Each colored ball’s value is the number of balls of that color you currently have in your inventory. For example, if you own 6 yellow balls, the customer would pay 6 for the first yellow ball. After the transaction, there are only 5 yellow balls left, so the next yellow ball is then valued at 5 (i.e., the value of the balls decreases as you sell more to the customer).

You are given an integer array, inventory, where inventory[i] represents the number of balls of the ith color that you initially own. You are also given an integer orders, which represents the total number of balls that the customer wants. You can sell the balls in any order.

Return the maximum total value that you can attain after selling orders colored balls. As the answer may be too large, return it modulo 109 + 7.

Example 1:

Input: inventory = [2,5], orders = 4
Output: 14
Explanation: Sell the 1st color 1 time (2) and the 2nd color 3 times (5 + 4 + 3).
The maximum total value is 2 + 5 + 4 + 3 = 14.

Example 2:

Input: inventory = [3,5], orders = 6
Output: 19
Explanation: Sell the 1st color 2 times (3 + 2) and the 2nd color 4 times (5 + 4 + 3 + 2).
The maximum total value is 3 + 2 + 5 + 4 + 3 + 2 = 19.

Example 3:

Input: inventory = [2,8,4,10,6], orders = 20
Output: 110

Example 4:

Input: inventory = [1000000000], orders = 1000000000
Output: 21
Explanation: Sell the 1st color 1000000000 times for a total value of 500000000500000000. 500000000500000000 modulo 109 + 7 = 21.

Constraints:

• 1 <= inventory.length <= 105
• 1 <= inventory[i] <= 109
• 1 <= orders <= min(sum(inventory[i]), 109)

Solution: Greedy

1. Sort the colors by # of balls in descending order.
   e.g. 3 7 5 1 => 7 5 3 1
2. Sell the color with largest number of balls until it has the same number of balls of next color
   1. 7 5 3 1 => 6 5 3 1 => 5 5 3 1 # value = 7 + 6 = 13
   2. 5 5 3 1 => 4 4 3 1 => 3 3 3 1 # value = 13 + (5 + 4) * 2 = 31
   3. 3 3 3 1 => 2 2 2 1 => 1 1 1 1 # value = 31 + (3 + 2) * 3 = 46
   4. 1 1 1 1 => 0 0 0 0 # value = 46 + 1 * 4 = 50
3. Need to handle the case if orders < total balls…
   

Time complexity: O(nlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maxProfit(vector<int>& inventory, int orders) {
    constexpr int kMod = 1e9 + 7;
    const int n = inventory.size();
    sort(rbegin(inventory), rend(inventory));
    long cur = inventory[0];
    long ans = 0;
    int c = 0;
    while (orders) {      
      while (c < n && inventory[c] == cur) ++c;
      int nxt = c == n ? 0 : inventory[c];      
      int count = min(static_cast<long>(orders), c * (cur - nxt));
      int t = cur - nxt;
      int r = 0;
      if (orders < c * (cur - nxt)) {
        t = orders / c;
        r = orders % c;
      }
      ans = (ans + (cur + cur - t + 1) * t / 2 * c + (cur - t) * r) % kMod;
      orders -= count;
      cur = nxt;
    }
    return ans;
  }
};

Note that the subarray needs to be non-empty after deleting one element.

Example 1:

Input: arr = [1,-2,0,3]
Output: 4
Explanation: Because we can choose [1, -2, 0, 3] and drop -2, thus the subarray [1, 0, 3] becomes the maximum value.

Example 2:

Input: arr = [1,-2,-2,3]
Output: 3
Explanation: We just choose [3] and it's the maximum sum.

Example 3:

Input: arr = [-1,-1,-1,-1]
Output: -1
Explanation: The final subarray needs to be non-empty. You can't choose [-1] and delete -1 from it, then get an empty subarray to make the sum equals to 0.

Constraints:

• 1 <= arr.length <= 10^5
• -10^4 <= arr[i] <= 10^4

Solution: DP

First, handle the special case: all numbers are negative, return the max one.

s0 = max subarray sum ends with a[i]
s1 = max subarray sum ends with a[i] with at most one deletion

whenever s0 or s1 becomes negative, reset them to 0.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maximumSum(vector<int>& arr) {    
    int m = *max_element(begin(arr), end(arr));
    if (m <= 0) return m;
    
    int s0 = 0;
    int s1 = 0;
    int ans = 0;
    
    for (int a : arr) {
      s1 = max(s0, s1 + a);
      s0 += a;
      ans = max(ans, max(s0, s1));
      if (s0 < 0) s0 = 0;
      if (s1 < 0) s1 = 0;
    }
    
    return ans;
  }
};

The bus goes along both directions i.e. clockwise and counterclockwise.

Return the shortest distance between the given start and destination stops.

Example 1:

Input: distance = [1,2,3,4], start = 0, destination = 1
Output: 1
Explanation: Distance between 0 and 1 is 1 or 9, minimum is 1.

Example 2:

Input: distance = [1,2,3,4], start = 0, destination = 2
Output: 3
Explanation: Distance between 0 and 2 is 3 or 7, minimum is 3.

Example 3:

Input: distance = [1,2,3,4], start = 0, destination = 3
Output: 4
Explanation: Distance between 0 and 3 is 6 or 4, minimum is 4.

Constraints:

• 1 <= n <= 10^4
• distance.length == n
• 0 <= start, destination < n
• 0 <= distance[i] <= 10^4

Solution: Summation

1. compute the total sum
2. compute the sum from s to d, c
3. ans = min(c, sum – c)

Time complexity: O(d-s)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int distanceBetweenBusStops(vector<int>& ds, int s, int d) {    
    if (s > d) swap(s, d);
    int sum = accumulate(begin(ds), end(ds), 0);
    int d1 = accumulate(begin(ds) + s, begin(ds) + d, 0);
    return min(d1, sum - d1);
  }
};

We have an array A of integers, and an array queries of queries.

For the i-th query val = queries[i][0], index = queries[i][1], we add val to A[index].  Then, the answer to the i-th query is the sum of the even values of A.

(Here, the given index = queries[i][1] is a 0-based index, and each query permanently modifies the array A.)

Return the answer to all queries.  Your answer array should have answer[i] as the answer to the i-th query.

Example 1:

Input: A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
Output: [8,6,2,4]
Explanation: 
At the beginning, the array is [1,2,3,4].
After adding 1 to A[0], the array is [2,2,3,4], and the sum of even values is 2 + 2 + 4 = 8.
After adding -3 to A[1], the array is [2,-1,3,4], and the sum of even values is 2 + 4 = 6.
After adding -4 to A[0], the array is [-2,-1,3,4], and the sum of even values is -2 + 4 = 2.
After adding 2 to A[3], the array is [-2,-1,3,6], and the sum of even values is -2 + 6 = 4.

Note:

1. 1 <= A.length <= 10000
2. -10000 <= A[i] <= 10000
3. 1 <= queries.length <= 10000
4. -10000 <= queries[i][0] <= 10000
5. 0 <= queries[i][1] < A.length

Solution: Simulation

Time complexity: O(n + |Q|)
Space complexity: O(n)

// Author: Huahua, Running time: 100 ms / 6.5 MB
class Solution {
public:
  vector<int> sumEvenAfterQueries(vector<int>& A, vector<vector<int>>& queries) {
    int sum = 0;
    for (int i = 0; i < A.size(); ++i)
      if (A[i] % 2 == 0)
        sum += A[i];
    vector<int> ans;
    for (const auto& query : queries) {
      int& a = A[query[1]];
      if (a % 2 == 0)
        sum -= a;
      a += query[0];
      if (a % 2 == 0)
        sum += a;
      ans.push_back(sum);
    }
    return ans;
  }
};

# Author: Huahua, running time: 188 ms / 16.4MB
class Solution:
  def sumEvenAfterQueries(self, A: 'List[int]', queries: 'List[List[int]]') -> 'List[int]':
    s = sum(x for x in A if x % 2 == 0)
    ans = []
    for val, index in queries:
      if A[index] % 2 == 0: s -= A[index]
      A[index] += val
      if A[index] % 2 == 0: s += A[index]
      ans.append(s)
    return ans

Solution: Recursion

Time complexity: O(n)

Space complexity: O(h)

C++

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int sumOfLeftLeaves(TreeNode* root) {
    if (!root) return 0;
    if (root->left && !root->left->left && !root->left->right)
        return root->left->val + sumOfLeftLeaves(root->right);
    return sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
  }
};

Iterative

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int sumOfLeftLeaves(TreeNode* root) {
    if (!root) return 0;
    queue<TreeNode*> q;
    q.push(root);
    int sum = 0;
    while (!q.empty()) {
      TreeNode* n = q.front();            
      q.pop();

      TreeNode* l = n->left;
      if (l) {
        if (!l->left && !l->right)
            sum += l->val;
        else
            q.push(l);
      }
      if (n->right) q.push(n->right);
    }
    return sum;
  }
};

题目大意：找出k长度的子数组的平均值的最大值。

https://leetcode.com/problems/maximum-average-subarray-i/description/

Given an array consisting of n integers, find the contiguous subarray of given length k that has the maximum average value. And you need to output the maximum average value.

Example 1:

Input: [1,12,-5,-6,50,3], k = 4
Output: 12.75
Explanation: Maximum average is (12-5-6+50)/4 = 51/4 = 12.75

Note:

1. 1 <= k <= n <= 30,000.
2. Elements of the given array will be in the range [-10,000, 10,000].

Solution: Sliding Window

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 124 ms
class Solution {
public:
  double findMaxAverage(vector<int>& nums, int k) {
    const int n = nums.size();
    int sum = 0;
    int ans = INT_MIN;
    for (int i = 0; i < n; ++i) {
      if (i >= k) sum -= nums[i - k];
      sum += nums[i];      
      if (i + 1 >= k) ans = max(ans, sum);      
    }
    return static_cast<double>(ans) / k;
  }
};

Related Problems

• 花花酱 LeetCode 239. Sliding Window Maximum
• 花花酱 LeetCode 813. Largest Sum of Averages

Given a list of non-negative numbers and a target integer k, write a function to check if the array has a continuous subarray of size at least 2 that sums up to the multiple of k, that is, sums up to n*k where n is also an integer.

Example 1:

Input: [23, 2, 4, 6, 7],  k=6
Output: True
Explanation: Because [2, 4] is a continuous subarray of size 2 and sums up to 6.

Example 2:

Input: [23, 2, 6, 4, 7],  k=6
Output: True
Explanation: Because [23, 2, 6, 4, 7] is an continuous subarray of size 5 and sums up to 42.

Note:

1. The length of the array won’t exceed 10,000.
2. You may assume the sum of all the numbers is in the range of a signed 32-bit integer.

Special case:

nums = [0,0], k = 0, return = True

Solution: Prefix Sum Reminder

Time complexity: O(n)

Space complexity: O(min(n, k))

// Author: Huahua
// Running time: 16 ms (<99.62%)
class Solution {
public:
  bool checkSubarraySum(vector<int>& nums, int k) {    
    unordered_map<int, int> m; // sum % k -> first index
    m[0] = -1;
    int sum = 0;
    for (int i = 0; i < nums.size(); ++i) {
      sum += nums[i];
      if (k != 0) sum %= k;      
      if (m.count(sum)) {
        if (i - m.at(sum) > 1) return true;
      } else {
        m[sum] = i;
      }
    }
    return false;
  }
};

Related Problems

• 花花酱 LeetCode 560. Subarray Sum Equals K
• 花花酱 LeetCode 525. Contiguous Array

Problem

Given an array which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays. Write an algorithm to minimize the largest sum among these m subarrays.

Note:
If n is the length of array, assume the following constraints are satisfied:

• 1 ≤ n ≤ 1000
• 1 ≤ m ≤ min(50, n)

Examples:

Input:
nums = [7,2,5,10,8]
m = 2

Output:
18

Explanation:
There are four ways to split nums into two subarrays.
The best way is to split it into [7,2,5] and [10,8],
where the largest sum among the two subarrays is only 18.

Solution: DP

Time complexity: O(n^2*m)

Space complexity: O(n*m)

C++ / Recursion + Memorization

// Author: Huahua
// Running time: 111 ms
class Solution {
public:
  int splitArray(vector<int>& nums, int m) {
    const int n = nums.size();
    sums_ = vector<int>(n);
    mem_ = vector<vector<int>>(n, vector<int>(m + 1, INT_MAX));
    sums_[0] = nums[0];
    for (int i = 1; i < n; ++i)
      sums_[i] = sums_[i - 1] + nums[i];
    return splitArray(nums, n - 1, m);
  }
private:
  vector<vector<int>> mem_;
  vector<int> sums_;
  
  // min of largest sum of spliting nums[0] ~ nums[k] into m groups
  int splitArray(const vector<int>& nums, int k, int m) {
    if (m == 1) return sums_[k];
    if (m > k + 1) return INT_MAX;    
    if (mem_[k][m] != INT_MAX) return mem_[k][m];
    int ans = INT_MAX;
    for (int i = 0; i < k; ++i)
      ans = min(ans, max(splitArray(nums, i, m - 1), sums_[k] - sums_[i]));    
    return mem_[k][m] = ans;
  }
};

C++ / DP

// Author: Huahua
// Running time: 90 ms
class Solution {
public:
  int splitArray(vector<int>& nums, int m) {
    const int n = nums.size();
    vector<int> sums(n);
    // dp[i][j] := min of largest sum of splitting nums[0] ~ nums[j] into i groups.
    vector<vector<int>> dp(m + 1, vector<int>(n, INT_MAX));
    sums[0] = nums[0];
    for (int i = 1; i < n; ++i)
      sums[i] = sums[i - 1] + nums[i];
    for (int i = 0; i < n; ++i)
      dp[1][i] = sums[i];
    
    for (int i = 2; i <= m; ++i)
      for (int j = i - 1; j < n; ++j)
        for (int k = 0; k < j; ++k)
          dp[i][j] = min(dp[i][j], max(dp[i - 1][k], sums[j] - sums[k]));
    return dp[m][n - 1];
  }  
};

Solution: Binary Search

Time complexity: O(log(sum(nums))*n)

Space complexity: O(1)

// Author: Huahua
// Running time: 3 ms
class Solution {
public:
  int splitArray(vector<int>& nums, int m) {
    long l = *max_element(begin(nums), end(nums));
    long r = accumulate(begin(nums), end(nums), 0L) + 1;
    while (l < r) {
      long limit = (r - l) / 2 + l;
      if (min_groups(nums, limit) > m) 
        l = limit + 1;
      else
        r = limit;
    }
    return l;
  }
private:
  int min_groups(const vector<int>& nums, long limit) {
    long sum = 0;
    int groups = 1;
    for (int num : nums) {
      if (sum + num > limit) {
        sum = num;
        ++groups;
      } else {
        sum += num;
      }
    }    
    return groups;
  }
};