##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1497.html

# 1497. Check If Array Pairs Are Divisible by k (Medium)

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.


Example 4:

Input: arr = [-10,10], k = 2
Output: true


Example 5:

Input: arr = [-1,1,-2,2,-3,3,-4,4], k = 3
Output: true


Constraints:

• arr.length == n
• 1 <= n <= 10^5
• n is even.
• -10^9 <= arr[i] <= 10^9
• 1 <= k <= 10^5

Related Topics:
Array, Math, Greedy

## Solution 1.

Use a map to store the frequencies of remainders and check if each remainder satisfies the requirement.

1. If there are odd number 0 remainders, return false
2. For 1 <= i < k / 2, if m[i] != m[k - i], return false.

If k is an even number, we can return false if m[k / 2] % 2 != 0 but it’s not needed because if m[k / 2] is odd, one of the above conditions above must be false.

// OJ: https://leetcode.com/problems/check-if-array-pairs-are-divisible-by-k/
// Time: O(N + K)
// Space: O(K)
class Solution {
public:
bool canArrange(vector<int>& A, int k) {
unordered_map<int, int> m;
for (int n : A) m[(n % k + k) % k]++;
if (m[0] % 2) return false;
for (int i = 1; i < k / 2; ++i) {
if (m[i] != m[k - i]) return false;
}
return true;
}
};


## Solution 2.

// OJ: https://leetcode.com/problems/check-if-array-pairs-are-divisible-by-k/
// Time: O(N)
// Space: O(K)
class Solution {
public:
bool canArrange(vector<int>& A, int k) {
unordered_map<int, int> m;
for (int &n : A) {
n = (n % k + k) % k;
m[n]++;
}
for (int n : A) {
if ((n == 0 && m[n] % 2) || (n && m[n] != m[k - n])) return false;
}
return true;
}
};

• class Solution {
public boolean canArrange(int[] arr, int k) {
int length = arr.length;
if (length % 2 != 0)
return false;
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int num : arr) {
int remainder = num % k;
if (remainder < 0)
remainder += k;
int count = map.getOrDefault(remainder, 0) + 1;
map.put(remainder, count);
}
int count0 = map.getOrDefault(0, 0);
if (count0 % 2 != 0)
return false;
if (k % 2 == 0) {
int countHalf = map.getOrDefault(k / 2, 0);
if (countHalf % 2 != 0)
return false;
}
int half = k / 2;
for (int i = 1; i <= half; i++) {
int count1 = map.getOrDefault(i, 0);
int count2 = map.getOrDefault(k - i, 0);
if (count1 != count2)
return false;
}
return true;
}
}

############

class Solution {
public boolean canArrange(int[] arr, int k) {
int[] cnt = new int[k];
for (int x : arr) {
++cnt[(x % k + k) % k];
}
for (int i = 1; i < k; ++i) {
if (cnt[i] != cnt[k - i]) {
return false;
}
}
return cnt[0] % 2 == 0;
}
}

• // OJ: https://leetcode.com/problems/check-if-array-pairs-are-divisible-by-k/
// Time: O(N + K)
// Space: O(K)
class Solution {
public:
bool canArrange(vector<int>& A, int k) {
unordered_map<int, int> m;
for (int n : A) m[(n % k + k) % k]++;
if (m[0] % 2) return false;
for (int i = 1; i < k / 2; ++i) {
if (m[i] != m[k - i]) return false;
}
return true;
}
};

• class Solution:
def canArrange(self, arr: List[int], k: int) -> bool:
mod = [0] * k
for v in arr:
mod[v % k] += 1
return all(mod[i] == mod[k - i] for i in range(1, k)) and mod[0] % 2 == 0


• func canArrange(arr []int, k int) bool {
cnt := make([]int, k)
for _, x := range arr {
cnt[(x%k+k)%k]++
}
for i := 1; i < k; i++ {
if cnt[i] != cnt[k-i] {
return false
}
}
return cnt[0]%2 == 0
}