Question

int n, k;
int count = 0, diff;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] input;
input = br.readLine().split(" ");
n = Integer.parseInt(input[0]);
int[] a = new int[n];
k = Integer.parseInt(input[1]);
input = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
  a[i] = Integer.parseInt(input[i]);
     for (int j = 0; j < i; j++) {
        diff = a[j] - a[i];
        if (diff == k || -diff == k) {
           count++;
        }
     }
}
System.out.print(count);

This is a sample program where I am printing particular difference count, where n range is <=100000
Now problem is to decrease execution for this program. How can I make it better to reduce running time.

Thanks in advance for suggestions

Answer 1

Here is a comparison of @Socha23’s solution using HashSet, TIntIntHashSet and the original solution.

For 100,000 numbers I got the following (without the reading and parsing)

For 100 unique values, k=10

Set: 89,699,743 took 0.036 ms
Trove Set: 89,699,743 took 0.017 ms
Loops: 89,699,743 took 3623.2 ms

For 1000 unique values, k=10

Set: 9,896,049 took 0.187 ms
Trove Set: 9,896,049 took 0.193 ms
Loops: 9,896,049 took 2855.7 ms

The code

import gnu.trove.TIntIntHashMap;
import gnu.trove.TIntIntProcedure;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

class Main {
    public static void main(String... args) throws Exception {
        Random random = new Random(1);
        int[] a = new int[100 * 1000];
        int k = 10;
        for (int i = 0; i < a.length; i++)
            a[i] = random.nextInt(100);

        for (int i = 0; i < 5; i++) {
            testSet(a, k);
            testTroveSet(a, k);
            testLoops(a, k);
        }
    }

    private static void testSet(int[] a, int k) {
        Map<Integer, Integer> readNumbers = new HashMap<Integer, Integer>();
        for (int num : a) {
            Integer freq = readNumbers.get(num);
            readNumbers.put(num, freq == null ? 1 : freq + 1);
        }

        long start = System.nanoTime();
        int count = 0;
        for (Integer aNumber : readNumbers.keySet()) {
            if (readNumbers.containsKey(aNumber + k)) {
                count += (readNumbers.get(aNumber) * readNumbers.get(aNumber + k));
            }
        }
        long time = System.nanoTime() - start;
        System.out.printf("Set: %,d took %.3f ms%n", count, time / 1e6);
    }

    private static void testTroveSet(int[] a, final int k) {
        final TIntIntHashMap readNumbers = new TIntIntHashMap();
        for (int num : a)
            readNumbers.adjustOrPutValue(num, 1,1);

        long start = System.nanoTime();
        final int[] count = { 0 };
        readNumbers.forEachEntry(new TIntIntProcedure() {
            @Override
            public boolean execute(int key, int keyCount) {
                count[0] += readNumbers.get(key + k) * keyCount;
                return true;
            }
        });
        long time = System.nanoTime() - start;
        System.out.printf("Trove Set: %,d took %.3f ms%n", count[0], time / 1e6);
    }

    private static void testLoops(int[] a, int k) {
        long start = System.nanoTime();
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < i; j++) {
                int diff = a[j] - a[i];
                if (diff == k || -diff == k) {
                    count++;
                }
            }
        }
        long time = System.nanoTime() - start;
        System.out.printf("Loops: %,d took %.1f ms%n", count, time / 1e6);
    }

    private static long free() {
        return Runtime.getRuntime().freeMemory();
    }
}