1497. Check If Array Pairs Are Divisible by k

Given an array of integers arr of even length n and an integer k.

We want to divide the array into exactly n / 2 pairs such that the sum of each pair is divisible by k.

Return true If you can find a way to do that or false otherwise.

Example 1:

Input: arr = [1,2,3,4,5,10,6,7,8,9], k = 5
Output: true
Explanation: Pairs are (1,9),(2,8),(3,7),(4,6) and (5,10).

Example 2:

Input: arr = [1,2,3,4,5,6], k = 7
Output: true
Explanation: Pairs are (1,6),(2,5) and(3,4).

Example 3:

Input: arr = [1,2,3,4,5,6], k = 10
Output: false
Explanation: You can try all possible pairs to see that there is no way to divide arr into 3 pairs each with sum divisible by 10.

Constraints:

• arr.length == n
• 1 <= n <= 105
• n is even.
• -109 <= arr[i] <= 109
• 1 <= k <= 105

Approach 01:

class Solution {
public:
    bool canArrange(std::vector<int>& numbers, int divisor) {
        std::vector<int> remainderCount(divisor);

        for (int number : numbers) {
            number %= divisor;
            ++remainderCount[number < 0 ? number + divisor : number];
        }

        if (remainderCount[0] % 2 != 0)
            return false;

        for (int i = 1; i <= divisor / 2; ++i) {
            if (remainderCount[i] != remainderCount[divisor - i])
                return false;
        }

        return true;
    }
};

class Solution:
    def canArrange(self, numbers: List[int], divisor: int) -> bool:
        remainderCount = [0] * divisor

        for number in numbers:
            number %= divisor
            remainderCount[number if number >= 0 else number + divisor] += 1

        if remainderCount[0] % 2 != 0:
            return False

        for i in range(1, divisor // 2 + 1):
            if remainderCount[i] != remainderCount[divisor - i]:
                return False

        return True

Time Complexity

• Loop through the numbers:

  The algorithm iterates through the entire `numbers` vector once to calculate the remainder for each number. If there are \(n\) elements in the `numbers` vector, this loop takes \(O(n)\) time.

• Checking remainder counts:

  Next, the algorithm checks whether the remainders meet the pairing condition. This involves iterating over half the range of possible remainders (from 1 to \( \frac{divisor}{2} \)), which takes \(O(divisor)\) time.

• Overall Time Complexity:

  The overall time complexity is \(O(n + divisor)\), where \(n\) is the size of the `numbers` vector and `divisor` is the value of the divisor. Typically, \(n\) dominates, so the time complexity is often \(O(n)\).

Space Complexity

• Auxiliary Space:

  The algorithm uses a vector `remainderCount` of size equal to the `divisor` to store the frequency of each remainder. Thus, the space required is \(O(divisor)\).

• Overall Space Complexity:

  The overall space complexity is \(O(divisor)\), as the space is used primarily by the `remainderCount` vector.