我刚刚检查了你的链接，问题语句中给出的条件是
找出并打印（i，j）对的个数，其中i〈j且ar[i] + ar[j]可被k整除。
简单地说就是unordered pairs个元素的个数，这些元素的和可以被k整除。
不管你怎么写
还有一个条件，就是：从这些对中得到arr[i]〈arr[j]。
看起来你误解了这个问题，它解释了为什么i<j条件有效，而arr[i] < arr[j]条件无效。
既然你知道你只需要无序对，就不需要从1到ar.length迭代j。因为你需要j > i，所以1和i之间的每个j都是无用的。你可以简化你的代码：

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

当你做i = {0 ... 10}和j = {1 ... 10}时，就会有（大约）100个（i和j的）组合，（大约）50个，其中i〈j，其余的反之亦然。所以你的假设是错误的：
应该是给了我一个错误的答案
...它给你正确的错误答案！...既然当a[i] + a[j] % k == 0，那么a[j] + a[i] % k == 0也！
如果不包括if(i < j)，则会加倍计算（对..的出现次数）。
一种（实施）备选方案是：

for (int i = 0; i < ar.length; i++) {
  // ensure i < j via initialization ;)
  for (int j = i + 1; j < ar.length; j++) {
    if (((ar[i]+ar[j]) % k) == 0) {
      counter++;
    }
  }
}

...用i + 1而不是1初始化内部循环。
编辑：（在问题变得更好之后）
您的假设，即a[i] > a[j]与i > j或j < i等价（但不是两者都等价），几乎是正确的：除了当a[i] == a[j]时。

这是我在javaScript中的解决方案（通过了所有测试用例）：

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

此解决方案使用javaScript：

divisibleSumPairs (n, k, ar) => {
  let count = 0;
  ar = ar.map((value, index, arr) => {
    for (let i = index + 1; i <= arr.length; i++) {
      if ((value + arr[i]) % k === 0) {
        count++;
      }
    }
  });
  return count
}

Python 3中的解决方案（通过所有测试用例）：
itertools.combinations（arr，r）函数返回输入可迭代对象的r个元素长度的子序列。组合是按照字典排序的顺序发出的。因此，如果输入可迭代对象是排序的，那么组合元组将按照排序的顺序产生。

from itertools import combinations

def divisibleSumPairs(n,ar,k):
    pairs = []
    for com in combinations(ar,2): 
        if sum(com) % k == 0:
            pairs.append(com)
    return len(pairs)

nk = input().split()
n = int(nk[0])
k = int(nk[1])            
ar = list(map(int, input().rstrip().split()))
print(divisibleSumPairs(n,ar,k))

如果有人对O（n）解感兴趣，这里是我的C#解。

public static int divisibleSumPairs(int n, int k, List<int> ar)
{
    Dictionary<int, int> map = new Dictionary<int, int>();
    int cnt = 0;
    
    foreach (int elem in ar)
    {
        int modulo = elem % k;
        int complement = modulo == 0 ? 0 : k - modulo;
        
        if (map.ContainsKey(complement))
        {
            cnt += map[complement];
        }
        
        if (map.ContainsKey(modulo))
        {
            ++map[modulo];
        }
        else
        {
            map.Add(modulo, 1);
        }
    }
    
    return cnt;
}

def divisibleSumPairs(n, k, ar):
    result = 0
    d = {}

    for i in range(n):
        mod = ar[i] % k
        result += d.get(( k - mod ) % k, 0)
        d[mod] = d.get(mod, 0) + 1

    return result

时间复杂度O（n）

飞镖解决方案

n = arr.length;
int numberOfDivisiblePairs = 0;
for (int i = 0; i < n; i++) {
  for (int j = i + 1; j < n; j++) {
    if (arr[i] + arr[j] % k == 0) {
      numberOfDivisiblePairs++;
    }
  }
}
return numberOfDivisiblePairs;