Code counts the number of identical elements between the arrays 's' and 'd' at the same index

Question

I wrote a code and the code counts the number of identical elements between the arrays s and d at the same index. I need to optimize the code for speed and readability. I tried HashSet but it didn't work at all. Do you have any Suggestions?

public static void main (String[] args) throws java.lang.Exception
    { Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();

        while (t-- > 0) {

            int a = sc.nextInt(); //

            int count = 0;
            int s[] = new int[a];
            int d[] = new int[a];

            for (int i = 0; i < a; i++) {
                s[i] = sc.nextInt();

            }
            for (int j = 0; j < a; j++) {


                d[j] = sc.nextInt();
            }

            for (int i = 0; i < a; i++) {

                    if (s[i] == d[i]) {

                        count++;
                       
                    }


                }


            System.out.println(count);
        }
    }
}

Answer 1

You don't need the third "for" loop do you? Nor do you really need the second array. Think about it...

Answer 2

You are getting suggestions to not compare two arrays due to the way you coded count the number of identical elements between the arrays 's' and 'd' at the same index.

Generally, put business logic in its own procedure:
You get to name and document procedure and parameters.

    /** @return the count of identical elements at the same index 
     * in <code>int</code> arrays <code>a</code> and <code>b</code>. */
    int countOfIdenticalElementsAtSameIndex(int[] a, int[] b) {
        return countOfIdenticalElementsAtSameIndex(a, b, Integer.MAX_VALUE);
    }
    /** @return the count of identical elements at the same index 
     * in <code>int</code> arrays <code>a</code> and <code>b</code>, 
     * for 0 <= index < <code>limit</code>.
     */
    int countOfIdenticalElementsAtSameIndex(int[] a, int[] b, int limit) {
        if (null == a || null == b)
            return 0;
        int count = 0;
        limit = Math.min(Math.min(a.length, b.length), limit)
        for (int i = 0 ; i < limit ; i++)
            if (a[i] == b[i])
                count += 1;
        return count;
    }

Answer 3

• (Said already) here you need only the first array.
• You do not separate the tasks of first reading and then comparing. It would be nice if you could already create functions, "methods."
• Testing the speed of the application can only sensibly be done redirecting a file to System.in as in java MyClass <data.txt. As keyboard input cannot be measured. Then one would see that Scanner has a bit overhead.
• The main thing here is the style, readability. count can be introduced after reading the data here.

Then a tip: you are using an array style introduced to let Java look more like C and C++:

int a[] = ...

But more logical is keeping the type parts together:

int[] a = ...

The C compatibility syntax is a dead giveaway of a new inexperienced developer.

I would have liked to see:

int length = scanner.nextInt();
int[] first = readArray(scanner, length);
int[] second = readArray(scanner, length);
int same = identical(first, second);
System.out.println(...);

There is not much to optimize here.

You could have chosen to read two lines of text, each containing one array.

Answer 4

The structure of the input is not readily apparent from the example, so I wasn't able to rigorously test my changes.
Several ideas:

• make the indentation / spacing consistent
• use for instead of while when the number of iterations is known
• use (++i) instead of (i++) if you only need the incremented value
• use the same iterator name for the same depth of loop nesting (i, j)
• reduce the number of loops by storing only the first half of each subarray
• braces are optional for single statements

public static void main (String[] args) throws java.lang.Exception
{ 
    Scanner sc = new Scanner(System.in);
    int m = sc.nextInt();

    for (int i = 0; i < m; ++i) 
    {
        int n = sc.nextInt();
        int count = 0;
        int first_half[] = new int[n];

        for (int j = 0; j < n; ++j) 
            first_half[j] = sc.nextInt();

        for (int j = 0; j < n; ++j)
            if (first_half[j] == sc.nextInt()) 
                ++count;

        System.out.println(count);
    }
}

Hope that helps. It would be tough to optimize further; look at java.util.Arrays line 787 and you'll see that they aren't much fancier.