The idea is that you separate elements into buckets depending on their mod k. For example, you have the elements: 1 3 2 6 4 5 9 and k = 3

mod 3 == 0 : 3 6 9
mod 3 == 1 : 1 4
mod 3 == 2 : 2 5

Now, you can make pairs like so: Elements with mod 3 == 0 will match with elements with (3 - 0) mod k = 0, so other elements in the mod 3 == 0 list, like so:

(3, 6) (3, 9) (6, 9)

There will be n * (n - 1) / 2 such pairs, where n is length of the list, because the list is the same and i != j. Elements with mod 3 == 1 will match with elements with (3 - 1) mod k = 2, so elements in the mod 3 == 2 list, like so:

(1, 2) (1, 5) (4, 2) (4, 5)

There will be n * k such elements, where n is the length of the first list, and k of the second.

Because you don't need to print the actual pairs, you need to store only the number of elements in each list.

Please use better variable names It makes other fellows easy to understand

Uhm, let see, I'm guessing you're having trouble seeing how it manages to comply with the i < j rule. So, what does the rule really mean? It's only telling you that a value a[i] should not be paired with itself, and a tuple a[i],a[j] should not be considered twice so.. a[j],a[i] is not considered.
You can think of this solution of only running forward, so a number a[i] appears always before a number a[j]. As it runs forward, for each number it looks for previous occurrences of its complement (it looks for the i's for a particular j).
Say for instance if the divisor is 3, you could have this sequence:
1, 2, 1

1. The first is not matched with anything.
2. The second is matched with the first. Although the 2nd could be matched with the 3rd, the algorithm isn't yet aware of the 3rd value...
3. When the third value is read, it will be matched against the 2nd. Effectively matching the 2nd with the 3rd (remember a[i][j] and a[j][i] should only be counted once ;)
   
   I'm no algorithm guru, I had never seen this problem before... just started exercising for fun. But from my perspective there's no golden rule here, I don't see a generalization of this that's particularly valuable.
   If the intention is learning, I would recommend you to focus your energy in understanding more generalized forms of algorithms... these here are mostly "quizes", perhaps try an algorithms book to find generalized sets of problems and solutions.
   Also, many interesting real life problems are more about the data structures used and then the algorith comes natural to the data structure itself, so perhaps a focus on data structures is worth your while too...
   Of course, these quizes have a "fun" element, and exercising can really help in making the learning stick, so you could do both :P... just get the basics strong and then go for the corresponding quizes I guess.

Your i-loop terminates at < n-1 but your j-loop terminates at < n. Is there a possible Index out of bounds error there?

Also you could save yourself a few iterations if every j-loop started at i+1. However this would not impact the O(n^2) time complexity.

function divisibleSumPairs(n, k, ar) { let count = 0; for(let i=0; i< n-1 ; i++) { for(let j=i+1 ; j< n ; j++){ if((((ar[i]+ar[j]) % k) === 0)) { count++; } } } return count; }

Hi. I added a detailed explanation to my original post to help clear up any confusion.

HackerRank solutions.

There are some tricks that are handy to know. I think this is called bucket sort and it's a good one to memorize, so you can apply to new problems in the future.

I think I came across this trick when learning about sorting algorithms (Such as QuickSort and MergeSort). Wikipedia might have some good summaries and pseudocode for various sorts.

HackerRank solutions.

and it doesnt mean it?