Language: Java

public class Main {

    public static void main(String[] args) {
        Solver solver = new Solver();
    }

    static class Solver {
        IO io;

        public Solver() {
            this.io = new IO();
            try {
                solve();
            } finally {
                io.close();
            }
        }

        /****************************** START READING HERE ********************************/

        void solve() {
            int n = io.nextInt();
            int[] a = new int[n];
            for (int i=0; i<n; i++) {
                a[i] = io.nextInt();
            }
            long mincost = Long.MAX_VALUE;
            for (int val=-100; val<=100; val++) {
                long cost = 0;
                for (int i=0; i<n; i++) {
                    cost += (a[i] - val) * (a[i] - val);
                }
                mincost = Math.min(cost, mincost);
            }
            io.println(mincost);
        }

        /************************** UTILITY CODE BELOW THIS LINE **************************/

        class Point {
            int y;
            int x;

            public Point(int y, int x) {
                this.y = y;
                this.x = x;
            }
        }

        class IDval implements Comparable<IDval> {
            int id;
            long val;

            public IDval(int id, long val) {
                this.val = val;
                this.id = id;
            }

            @Override
            public int compareTo(IDval o) {
                if (this.val < o.val) return -1;
                if (this.val > o.val) return 1;
                return this.id - o.id;
            }
        }

        private List<Integer>[] toGraph(IO io, int n) {
            List<Integer>[] g = new ArrayList[n+1];
            for (int i=1; i<=n; i++) g[i] = new ArrayList<>();
            for (int i=1; i<=n-1; i++) {
                int a = io.nextInt();
                int b = io.nextInt();
                g[a].add(b);
                g[b].add(a);
            }
            return g;
        }

        private class IO extends PrintWriter {
            private InputStreamReader r;
            private static final int BUFSIZE = 1 << 15;
            private char[] buf;
            private int bufc;
            private int bufi;
            private StringBuilder sb;

            public IO() {
                super(new BufferedOutputStream(System.out));
                r = new InputStreamReader(System.in);

                buf = new char[BUFSIZE];
                bufc = 0;
                bufi = 0;
                sb = new StringBuilder();
            }

            private void fillBuf() throws IOException {
                bufi = 0;
                bufc = 0;
                while(bufc == 0) {
                    bufc = r.read(buf, 0, BUFSIZE);
                    if(bufc == -1) {
                        bufc = 0;
                        return;
                    }
                }
            }

            private boolean pumpBuf() throws IOException {
                if(bufi == bufc) {
                    fillBuf();
                }
                return bufc != 0;
            }

            private boolean isDelimiter(char c) {
                return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
            }

            private void eatDelimiters() throws IOException {
                while(true) {
                    if(bufi == bufc) {
                        fillBuf();
                        if(bufc == 0) throw new RuntimeException("IO: Out of input.");
                    }

                    if(!isDelimiter(buf[bufi])) break;
                    ++bufi;
                }
            }

            public String next() {
                try {
                    sb.setLength(0);

                    eatDelimiters();
                    int start = bufi;

                    while(true) {
                        if(bufi == bufc) {
                            sb.append(buf, start, bufi - start);
                            fillBuf();
                            start = 0;
                            if(bufc == 0) break;
                        }

                        if(isDelimiter(buf[bufi])) break;
                        ++bufi;
                    }

                    sb.append(buf, start, bufi - start);

                    return sb.toString();
                } catch(IOException e) {
                    throw new RuntimeException("IO.next: Caught IOException.");
                }
            }

            public int nextInt() {
                try {
                    int ret = 0;

                    eatDelimiters();

                    boolean positive = true;
                    if(buf[bufi] == '-') {
                        ++bufi;
                        if(!pumpBuf()) throw new RuntimeException("IO.nextInt: Invalid int.");
                        positive = false;
                    }

                    boolean first = true;
                    while(true) {
                        if(!pumpBuf()) break;
                        if(isDelimiter(buf[bufi])) {
                            if(first) throw new RuntimeException("IO.nextInt: Invalid int.");
                            break;
                        }
                        first = false;

                        if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                            if(ret < -214748364) throw new RuntimeException("IO.nextInt: Invalid int.");
                            ret *= 10;
                            ret -= (int)(buf[bufi] - '0');
                            if(ret > 0) throw new RuntimeException("IO.nextInt: Invalid int.");
                        } else {
                            throw new RuntimeException("IO.nextInt: Invalid int.");
                        }

                        ++bufi;
                    }

                    if(positive) {
                        if(ret == -2147483648) throw new RuntimeException("IO.nextInt: Invalid int.");
                        ret = -ret;
                    }

                    return ret;
                } catch(IOException e) {
                    throw new RuntimeException("IO.nextInt: Caught IOException.");
                }
            }

            public long nextLong() {
                try {
                    long ret = 0;

                    eatDelimiters();

                    boolean positive = true;
                    if(buf[bufi] == '-') {
                        ++bufi;
                        if(!pumpBuf()) throw new RuntimeException("IO.nextLong: Invalid long.");
                        positive = false;
                    }

                    boolean first = true;
                    while(true) {
                        if(!pumpBuf()) break;
                        if(isDelimiter(buf[bufi])) {
                            if(first) throw new RuntimeException("IO.nextLong: Invalid long.");
                            break;
                        }
                        first = false;

                        if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                            if(ret < -922337203685477580L) throw new RuntimeException("IO.nextLong: Invalid long.");
                            ret *= 10;
                            ret -= (long)(buf[bufi] - '0');
                            if(ret > 0) throw new RuntimeException("IO.nextLong: Invalid long.");
                        } else {
                            throw new RuntimeException("IO.nextLong: Invalid long.");
                        }

                        ++bufi;
                    }

                    if(positive) {
                        if(ret == -9223372036854775808L) throw new RuntimeException("IO.nextLong: Invalid long.");
                        ret = -ret;
                    }

                    return ret;
                } catch(IOException e) {
                    throw new RuntimeException("IO.nextLong: Caught IOException.");
                }
            }

            public double nextDouble() {
                return Double.parseDouble(next());
            }

        }
    }

}





Compiler output:
Main.java:79: error: cannot find symbol
        private class IO extends PrintWriter {
                                 ^
  symbol:   class PrintWriter
  location: class Solver
Main.java:67: error: cannot find symbol
        private List<Integer>[] toGraph(IO io, int n) {
                ^
  symbol:   class List
  location: class Solver
Main.java:80: error: cannot find symbol
            private InputStreamReader r;
                    ^
  symbol:   class InputStreamReader
  location: class Solver.IO
Main.java:97: error: cannot find symbol
            private void fillBuf() throws IOException {
                                          ^
  symbol:   class IOException
  location: class Solver.IO
Main.java:109: error: cannot find symbol
            private boolean pumpBuf() throws IOException {
                                             ^
  symbol:   class IOException
  location: class Solver.IO
Main.java:120: error: cannot find symbol
            private void eatDelimiters() throws IOException {
                                                ^
  symbol:   class IOException
  location: class Solver.IO
Main.java:15: error: cannot find symbol
                io.close();
                  ^
  symbol:   method close()
  location: variable io of type Solver.IO
Main.java:35: error: cannot find symbol
            io.println(mincost);
              ^
  symbol:   method println(long)
  location: variable io of type Solver.IO
Main.java:68: error: cannot find symbol
            List<Integer>[] g = new ArrayList[n+1];
            ^
  symbol:   class List
  location: class Solver
Main.java:68: error: cannot find symbol
            List<Integer>[] g = new ArrayList[n+1];
                                    ^
  symbol:   class ArrayList
  location: class Solver
Main.java:69: error: cannot find symbol
            for (int i=1; i<=n; i++) g[i] = new ArrayList<>();
                                                ^
  symbol:   class ArrayList
  location: class Solver
Main.java:88: error: cannot find symbol
                super(new BufferedOutputStream(System.out));
                          ^
  symbol:   class BufferedOutputStream
  location: class Solver.IO
Main.java:89: error: cannot find symbol
                r = new InputStreamReader(System.in);
                        ^
  symbol:   class InputStreamReader
  location: class Solver.IO
Main.java:154: error: cannot find symbol
                } catch(IOException e) {
                        ^
  symbol:   class IOException
  location: class Solver.IO
Main.java:199: error: cannot find symbol
                } catch(IOException e) {
                        ^
  symbol:   class IOException
  location: class Solver.IO
Main.java:244: error: cannot find symbol
                } catch(IOException e) {
                        ^
  symbol:   class IOException
  location: class Solver.IO
16 errors