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 = 2Output:7Explanation: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 = 5Output:0Explanation: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 <= 10`

^{5}`1 <= nums[i], k <= 10`

^{5}