# Count Array Pairs Divisible by K solution leetcode – Given a 0-indexed integer array nums of length n and an integer k, return the number of pairs (i, j)

Given a 0-indexed integer array `nums` of length `n` and an integer `k`, return the number of pairs `(i, j)` such that:

• `0 <= i < j <= n - 1` and
• `nums[i] * nums[j]` is divisible by `k`.

# Count Array Pairs Divisible by K solution leetcode

```Input: nums = [1,2,3,4,5], k = 2
Output: 7
Explanation:
The 7 pairs of indices whose corresponding products are divisible by 2 are
(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), and (3, 4).
Their products are 2, 4, 6, 8, 10, 12, and 20 respectively.
Other pairs such as (0, 2) and (2, 4) have products 3 and 15 respectively, which are not divisible by 2.
```

## Count Array Pairs Divisible by K solution leetcode

```Input: nums = [1,2,3,4], k = 5
Output: 0
Explanation: There does not exist any pair of indices whose corresponding product is divisible by 5.
```

There is a stream of `n` `(idKey, value)` pairs arriving in an arbitrary order, where `idKey` is an integer between `1` and `n` and `value` is a string. No two pairs have the same `id`.

Design a stream that returns the values in increasing order of their IDs by returning a chunk (list) of values after each insertion. The concatenation of all the chunks should result in a list of the sorted values.

Implement the `OrderedStream` class:

• `OrderedStream(int n)` Constructs the stream to take `n` values.
• `String[] insert(int idKey, String value)` Inserts the pair `(idKey, value)` into the stream, then returns the largest possible chunk of currently inserted values that appear next in the order.

Constraints:

• `1 <= nums.length <= 105`
• `1 <= nums[i], k <= 105`