4001 LeetCode problem solution

Previously, I described the first problems from 4000 to 4010, except for 4004 and 4005.

Below is the solution to LeetCode problem 4001.

LeetCode link: 4001. Aggregate Two Time Series

4001 LeetCode problem: description

Example 1:

Input: series1 = [[1, 3],[4, 1]], series2 = [[2, 2],[5, 2]]
Output: [[1, 5],[2, 3],[4, 3],[5, 2]]

Explanation: the aggregated series is [[1, 5], [2, 3], [4, 3], [5, 2]].

Example 2:

Input: series1 = [[1, 5],[3, 1]], series2 = [[2, 2]]
Output: [[1, 7],[2, 3],[3, 1]]

Explanation: the aggregated series is [[1, 7], [2, 3], [3, 1]].

Example 3:

Input: series1 = [[1, 5]], series2 = [[1000000000, 2]]
Output: [[1, 7],[1000000000, 2]]

Explanation:

At timestamp 1, the next available value in series2 is 2 at timestamp 1000000000. At timestamp 1000000000, there is no later timestamp in series1, so its value is 0. Only timestamps that appear in at least one of the two series are included.

LeetCode 4001 problem: solution explanation

For this problem we use the Two Pointers pattern to merge the two sorted time series, similar to the Merge Two Sorted Arrays approach.
Pointer i moves through series1, while pointer j moves through series2.
At each step, we compare the timestamps at i and j and process the smaller one. If the timestamps are equal, we sum their values and move both pointers; otherwise, only the pointer with the smaller timestamp moves.
The other pointer stays at the next available timestamp, so its current value is used in the sum. Each element is processed only once, giving O(n + m) time and O(1) auxiliary space.

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

LeetCode 4001 C++ solution

class Solution {
public:
  vector<vector<int>> aggregateTimeSeries(vector<vector<int>>& series1, vector<vector<int>>& series2) {
    int i = 0;
    int j = 0;
    int n = series1.size();
    int m = series2.size();

    vector<vector<int>> res;

    while(i < n && j < m) 
    {
      if(series1[i][0] == series2[j][0]) 
      {
        res.push_back({series1[i][0], series1[i][1] + series2[j][1]});
        i++;
        j++;
      }
      else if(series1[i][0] < series2[j][0]) 
      {
        res.push_back({series1[i][0], series1[i][1] + series2[j][1]});
        i++;
      }
      else 
      {
        res.push_back({series2[j][0], series1[i][1] + series2[j][1]});
        j++;
      }
    }

    while(i < n) 
    {
      res.push_back(series1[i]);
      i++;
    }

    while(j < m) 
    {
      res.push_back(series2[j]);
      j++;
    }

    return res;
  }
};

LeetCode 4001 Java solution

class Solution {
  public List<List<Integer>> aggregateTimeSeries(int[][] series1, int[][] series2) {
    int i = 0, j = 0;
    int n = series1.length;
    int m = series2.length;

    List<List<Integer>> result = new ArrayList<>();

    while(i < n && j < m) {
      if(series1[i][0] == series2[j][0]) {
        result.add(Arrays.asList(series1[i][0], series1[i][1] + series2[j][1]));
        i++;
        j++;
      } 
      else if(series1[i][0] < series2[j][0]) {
        result.add(Arrays.asList(series1[i][0], series1[i][1] + series2[j][1]));
        i++;
      } 
      else {
        result.add(Arrays.asList(series2[j][0], series1[i][1] + series2[j][1]));
        j++;
      }
    }

    while(i < n) {
      result.add(Arrays.asList(series1[i][0], series1[i][1]));
      i++;
    }

    while(j < m) {
      result.add(Arrays.asList(series2[j][0], series2[j][1]));
      j++;
    }

    return result;
  }
}

LeetCode 4001 JavaScript solution

var aggregateTimeSeries = function(series1, series2) {
  let i = 0;
  let j = 0;

  const result = [];

  while(i < series1.length && j < series2.length) {
    if (series1[i][0] === series2[j][0]) {
      result.push([series1[i][0], series1[i][1] + series2[j][1]]);
      i++;
      j++;
    } else if(series1[i][0] < series2[j][0]) {
      result.push([series1[i][0], series1[i][1] + series2[j][1]]);
      i++;
    } else {
      result.push([series2[j][0], series1[i][1] + series2[j][1]]);
      j++;
    }
  }

  while(i < series1.length) {
    result.push(series1[i]);
    i++;
  }

  while(j < series2.length) {
    result.push(series2[j]);
    j++;
  }

  return result;
};

LeetCode 4001 TypeScript solution

function aggregateTimeSeries(series1: number[][], series2: number[][]): number[][] {
  let i = 0;
  let j = 0;

  const result: number[][] = [];

  while(i < series1.length && j < series2.length) {
    if(series1[i][0] === series2[j][0]) {
      result.push([series1[i][0], series1[i][1] + series2[j][1]]);
      i++;
      j++;
    } else if(series1[i][0] < series2[j][0]) {
      result.push([series1[i][0], series1[i][1] + series2[j][1]]);
      i++;
    } else {
      result.push([series2[j][0], series1[i][1] + series2[j][1]]);
      j++;
    }
  }

  while(i < series1.length) {
    result.push(series1[i]);
    i++;
  }

  while(j < series2.length) {
    result.push(series2[j]);
    j++;
  }

  return result;
};

LeetCode 4001 Python solution

class Solution:
  def aggregateTimeSeries(self, series1: list[list[int]], series2: list[list[int]]) -> list[list[int]]:
      i = 0
      j = 0

      result = []

      while i < len(series1) and j < len(series2):
        if series1[i][0] == series2[j][0]:
          result.append([series1[i][0], series1[i][1] + series2[j][1]])
          i += 1
          j += 1

        elif series1[i][0] < series2[j][0]:
          result.append([series1[i][0], series1[i][1] + series2[j][1]])
          i += 1

        else:
          result.append([series2[j][0], series1[i][1] + series2[j][1]])
          j += 1

      while i < len(series1):
        result.append(series1[i])
        i += 1

      while j < len(series2):
        result.append(series2[j])
        j += 1

    return result