I have given you question input,ouutput read and g...

Below is one clean, self-contained solution in Java 8 that prints the side length of the smallest axis-parallel square whose four corners all belong to the given set of points.
It works in O(N²) time ( N ≤ 100 ) and O(N) extra space.

java
import java.util.*;

/**
 * Reads N points (x, y) and prints the side-length of the
 * smallest square that can be formed with its sides parallel
 * to the X- and Y-axes and with all four corner points present
 * in the input set.  Prints -1 if no such square exists.
 */
public class Main {
    /** Encodes an (x, y) pair into one long for fast HashSet look-ups */
    private static long key(int x, int y) {
        return ( ( (long) x ) << 32 ) ^ ( y & 0xffffffffL );
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        if (!sc.hasNextInt())                // nothing to read
            return;

        int n = sc.nextInt();
        int[] xs = new int[n];
        int[] ys = new int[n];

        /*  store every point in a hash-set for O(1) existence tests  */
        Set<Long> points = new HashSet<>();
        for (int i = 0; i < n; i++) {
            xs[i] = sc.nextInt();
            ys[i] = sc.nextInt();
            points.add(key(xs[i], ys[i]));
        }

        int best = Integer.MAX_VALUE;        // smallest side found so far

        /*  try every unordered pair of points as a possible diagonal  */
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {

                int dx = xs[i] - xs[j];
                int dy = ys[i] - ys[j];

                /* they must be diagonal corners of an axis-parallel square */
                if (dx == 0 || dy == 0 || Math.abs(dx) != Math.abs(dy))
                    continue;

                /* check if the other two corners exist */
                if (points.contains(key(xs[i], ys[j])) &&
                    points.contains(key(xs[j], ys[i]))) {

                    best = Math.min(best, Math.abs(dx));   // dx == dy
                }
            }
        }

        System.out.println(best == Integer.MAX_VALUE ? -1 : best);
    }
}

Why it works

1. Axis-parallel square property
   For an axis-aligned square with side d we can label the corners
   $(x,\,y),\,(x+d,\,y),\,(x,\,y+d),\,(x+d,\,y+d)$.
   Any diagonal pair among these four points has equal horizontal and vertical distance: $|dx| = |dy| = d$.

2. Algorithm

   • Iterate through every unordered pair of input points $P_i, P_j$.
   • If $|dx| ≠ |dy|$ or either coordinate is equal, they cannot be a diagonal of an axis-parallel square – skip.
   • Otherwise the two missing corners are $(x_i,\,y_j)$ and $(x_j,\,y_i)$; test for their presence in O(1) time using the hash-set.
   • Track the minimum side length found.

3. Complexities

   • Time: $\binom{N}{2} = O(N²)$ pairs, and N ≤ 100 ⇒ negligible.
   • Space: one HashSet storing all N points ⇒ $O(N)$.

If at least one square exists, its side length is printed; otherwise -1 is output.

Here’s a drop-in replacement for the solveSqrs method (plus one tiny helper) that fits the template you showed.
Just paste this inside TestClass where the comment “// WRITE YOUR CODE HERE” currently is, and remove (or ignore) the main method you no longer need.

java
/** packs an (x,y) pair into one long so look-ups are O(1) */
private static long key(int x, int y) {
    return (((long) x) << 32) ^ (y & 0xffffffffL);
}

private static void solveSqrs(int[] xcods, int[] ycods) {

    int n = xcods.length;

    // Put every point in a hash-set for constant-time membership checks.
    java.util.HashSet<Long> points = new java.util.HashSet<>(n * 2);
    for (int i = 0; i < n; i++) {
        points.add(key(xcods[i], ycods[i]));
    }

    // Reset the global “smallest” sentinel in case this is called repeatedly.
    smallest = Integer.MAX_VALUE;

    /* Try every unordered pair of points as a possible diagonal of an
       axis-parallel square.  For such a square the horizontal and vertical
       distances between the two diagonal points must be equal and non-zero. */
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {

            int dx = xcods[i] - xcods[j];
            int dy = ycods[i] - ycods[j];

            // Must form a non-degenerate diagonal with |dx| == |dy|.
            if (dx == 0 || dy == 0 || Math.abs(dx) != Math.abs(dy)) {
                continue;
            }

            // The other two corners of the candidate square.
            if (points.contains(key(xcods[i], ycods[j])) &&
                points.contains(key(xcods[j], ycods[i]))) {

                smallest = Math.min(smallest, Math.abs(dx)); // dx == dy
            }
        }
    }

    // If no square exists, leave “smallest” untouched (9999) or set it to –1
    // depending on how the platform expects “no solution” to be signalled.
    if (smallest == Integer.MAX_VALUE) {
        smallest = -1;      // comment this line out if 9999 is the desired sentinel
    }
}

How it works

1. Hash-set for O(1) look-ups 
   Each point is encoded into a single long (key(x,y)) so we can test for the presence of any coordinate pair quickly.

2. Enumerate all diagonals 
   With ≤ 100 points, the naïve O(N²) pair check is easily fast enough. For an axis-parallel square the diagonal’s horizontal and vertical offsets are equal (and non-zero). The other two required corner points are then $(x_i,\,y_j)$ and $(x_j,\,y_i)$.

3. Update smallest 
   Keep the minimum side length seen. If no square exists, the method leaves smallest at its sentinel value (changeable to -1 as shown).

Below is a drop-in implementation of leastBouttonPress (and two tiny helpers).
Insert all three methods inside TestClass and remove/ignore any main method the platform provided.

java
/** Returns true if every digit of num is available on the keypad */
private static boolean canType(int num, boolean[] ok) {
    if (num == 0) return ok[0];
    while (num > 0) {
        int d = num % 10;
        if (!ok[d]) return false;
        num /= 10;
    }
    return true;
}

/** Returns the number of decimal digits in num (handles 0 correctly) */
private static int digitLen(int num) {
    return (num == 0) ? 1 : (int) Math.log10(num) + 1;
}

/**
 * @param n     total stations (1 … n)
 * @param d     count of functioning digit buttons
 * @param digits[] list of those functioning digits
 * @param pres  current station
 * @param dest  destination station
 * @return      minimum button presses required
 */
static int leastBouttonPress(int n, int d, int digits[], int pres, int dest) {

    /* mark the usable digits */
    boolean[] ok = new boolean[10];
    for (int i = 0; i < d; i++) ok[digits[i]] = true;

    /* 1) use only F/B buttons                                     */
    int best = Math.abs(dest - pres);

    /* 2) try every station s that can be typed, then F/B to dest  */
    for (int s = 1; s <= n; s++) {
        if (canType(s, ok)) {
            int presses = digitLen(s) + 1               // digits of s + Enter
                         + Math.abs(dest - s);          // F/B from s to dest
            best = Math.min(best, presses);
        }
    }
    return best;
}

How it works

• Option 1 – press F or B |pres − dest| times.
• Option 2 – pick any station s whose digits all work, type it (digitLen(s) presses) plus Enter (1 press), then adjust with F/B |dest − s| times.
  The loop considers every 1 ≤ s ≤ N and keeps the minimum total presses.

The overall time is O(N · log N) (≤ 10 000 stations → negligible) and uses O(1) extra space aside from the digit table.