Determine if a function is bijective Concise Problem Specification

Given an integer \$n\$ and a function \$f : X \to X \$ where \$X = \{1,2,3,..,n\}\$ Determine whether the given function is a bijective function or not.

Definition:

According to Wikipedia:


  In mathematics, a bijection, bijective function or one-to-one correspondence is a function between the elements of two sets, where each element of one set is paired with exactly one element of the other set, and each element of the other set is paired with exactly one element of the first set.


Constraints

\$1\le n \le 20 \$

Input format

There are  lines in the input. 
The first line contains a single positive integer \$n\$. 
The second line contains  space separated integers, the values of \$f(1)\$ , \$f(2)\$ ... ,  \$f(n)\$, respectively.

Output Format

On a single line, output "YES" if  is bijective. Otherwise, output "NO".

Solution

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Solution {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        Set&lt;Integer&gt; codomain = new HashSet&lt;Integer&gt;();

        for (int i = 0; i &lt; n; i++) {
            int y = in.nextInt();
            codomain.add(y);
        }

        System.out.println(codomain.size() == n ? "YES" : "NO");

        in.close();

    }

}


Comments

I am still relatively new to Java and would appreciate any comments on the above regarding improvements to my code.
Your code looks nice. The only suggestion I have is to separate the bijection check out of the main, and make it, say, a static method. All in all, I had this in mind:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class FunctionUtils {

    public static boolean isBijection(final Map&lt;Integer, Integer&gt; function) {
        final Set&lt;Integer&gt; domain = new HashSet&lt;&gt;(function.keySet());
        final Set&lt;Integer&gt; range  = new HashSet&lt;&gt;(function.values());
        return range.equals(domain);
    }

    public static void main(String[] args) {
        final Map&lt;Integer, Integer&gt; function = new HashMap&lt;&gt;();

        try (final Scanner in = new Scanner(System.in)) {
            final int n = in.nextInt();

            for (int i = 1; i &lt;= n; i++) {
                function.put(i, in.nextInt());
            }

            System.out.println("Bijection: " + isBijection(function));
        }
    }
}


Hope that helps.

Edit

Validating general bijections \$f \colon X \to Y\$ is not any harder:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;

public class FunctionUtils {

    public static &lt;E&gt; boolean isBijection(final Map&lt;E, E&gt; function) {
        return function.size() == new HashSet&lt;&gt;(function.values()).size();
    }

    public static void main(String[] args) {
        final Map&lt;Integer, Integer&gt; function = new HashMap&lt;&gt;();

        try (final Scanner in = new Scanner(System.in)) {
            final int n = in.nextInt();

            for (int i = 1; i &lt;= n; i++) {
                function.put(i, in.nextInt());
            }

            System.out.println("Function:  " + function);
            System.out.println("Bijection: " + isBijection(function));
        }
    }
}