Is my friend cheating?

coderwars Is my friend cheating?

• A friend of mine takes the sequence of all numbers from 1 to n (where n > 0).
• Within that sequence, he chooses two numbers, a and b
• He says that the product of a and b should be equal to the sum of all numbers in the sequence, excluding a and b.
• Given a number n, could you tell me the numbers he excluded from the sequence?
  The function takes the parameter: n (n is always strictly greater than 0) and returns an array or a string (depending on the language) of the form:

[(a, b), ...] or [[a, b], ...] or {{a, b}, ...} or or [{a, b}, ...]

with all (a, b) which are the possible removed numbers in the sequence 1 to n.
[(a, b), ...] or [[a, b], ...] or {{a, b}, ...} or ...will be sorted in increasing order of the “a”.
It happens that there are several possible (a, b). The function returns an empty array (or an empty string) if no possible numbers are found which will prove that my friend has not told the truth! (Go: in this case return nil).
Examples:

removNb(26) should return [(15, 21), (21, 15)]
or
removNb(26) should return { {15, 21}, {21, 15} }
or
removeNb(26) should return [[15, 21], [21, 15]]
or
removNb(26) should return [ {15, 21}, {21, 15} ]
or
removNb(26) should return "15 21, 21 15"

or

in C:
removNb(26) should return  {{15, 21}{21, 15}} tested by way of strings.
Function removNb should return a pointer to an allocated array of Pair pointers, each one also allocated. 

/*
   We desire: ab = 1 + ... + n - a - b
   Take advantage of b = sum - a
                         -------
                          a + 1
   */
   public static List<long[]> removNb(long n) {
       List<long[]> res = new ArrayList<long[]>();
       long sum = (1 + n) * n >>> 1;
       for (long a = 1; a <= n; a++) {
           long b = (sum - a) / (a + 1);
           if (b <= n && b * (a + 1) == (sum - a)) {
               res.add(new long[] { a, b });
           }
       }
       return res;
   }
  // 写法二
  public static List<long[]> removNb(long n) {
       long sum = (1 + n) * n >>> 1;
       return LongStream.rangeClosed(1, n).filter(a -> (sum - a) % (a + 1) == 0)
               .mapToObj(a -> new long[] { a, (sum - a) / (a + 1) }).filter(arr -> arr[1] <= n)
               .collect(Collectors.toList());
   }