First time when we test a Java Code nothing displayed on the Message etc..

[sdgun]

Description

First time when we test a Java Code nothing displayed on the Message etc..

Steps

Go to : https://qa.arena.topcoder.com/longcontest/?module=ViewActiveContests
Login via Valid User
Register for the contest
Click Submit
Select : Python
Enter a valid code with class name
Click Submit

Open the problem from the same user
Clear the code
Enter the Java code
Select the language as JAVA
Click Test Example

Nothing happens

Code:

import java.util.Arrays;

public class SnowCleaning {
private long startTime = System.nanoTime(), elapsedTime;
static long TIMEOUT0 = 19250, TIMEOUT1 = 19750, totSteps;
static boolean timeControl = true;
private static final double saWeight = Math.sqrt(2);
private static final int border = 2;
private int gridSpacing = 1, maxSteps = 40000, boardSize, salary, snowFine, day, numWorkers, numSnow, addedWorkers, totAddedSnow;
private final long multiplier = 0x5DEECE66DL, addend = 0xBL, mask = (1L << 48) - 1;
private final long[] timeTotalPerDay = new long[1 << 11], time1PerDay = new long[1 << 11], time2PerDay = new long[1 << 11];
private long seed = 19720909;
private final int[] pSnow = new int[1 << 12], pWorkersOrg = new int[1 << 7], pWorkersDest = new int[1 << 7], pWorkersDestCandCount = new int[1 << 7], cutPerRow = new int[1 << 6], knownSnow = new int[1 << 12];
private final int[][] pWorkersDestCand = new int[1 << 7][1 << 3], pointToWorkerDist = new int[1 << 12][1 << 7];
private final boolean[] pHasSnow = new boolean[1 << 12], pWillSnow = new boolean[1 << 12], dayHadSnow = new boolean[1 << 11];
private final boolean[][] pSnowFallDay = new boolean[1 << 11][1 << 12];
private final double[] log = new double[1 << 14];
private final Path[] path = new Path[1 << 7];

public int init(int boardSize, int salary, int snowFine) {
    for (int y1 = 0; y1 < boardSize; y1++) {
        for (int x1 = 0; x1 < boardSize; x1++) {
            int p1 = point(x1, y1);
            int p1s12 = p1 << 12;
            for (int y2 = y1; y2 < boardSize; y2++) {
                int dy = abs(y1 - y2);
                for (int x2 = 0; x2 < boardSize; x2++) {
                    int p2 = point(x2, y2);
                    int dxy = abs(x1 - x2) + dy;
                    Path.dist[p1s12 | p2] = Path.dist[(p2 << 12) | p1] = dxy == 0 ? 1 : dxy;
                }
            }
        }
    }
    for (int i = 0; i < 100; i++) {
        path[i] = new Path();
    }
    for (int i = 0; i < 16384; i++) {
        log[i] = Math.log((i + 0.5) / 16384);
    }
    this.boardSize = boardSize;
    this.salary = salary;
    totSteps = 0;
    for (int i = 0; i < pointToWorkerDist.length; i++) {
        Arrays.fill(pointToWorkerDist[i], 1000);
    }
    elapsedTime += System.nanoTime() - startTime;
    return this.snowFine = snowFine;
}

public String[] nextDay(int[] snowFalls) {
    int limit = 100;
    int [] test_a = new int [limit];
    for (int i = 0 ; i>-1 ; i ++) test_a[i % limit] = i;

    startTime = System.nanoTime();
    if (timeControl && elapsedTime > TIMEOUT1 * 1000000) return new String[0];
    initDay();
    processSnowFall(snowFalls);
    int morningNumSnow = numSnow;
    int morningWorkers = numWorkers;
    adjustSpeed();
    moveWorkers();
    clearSnow();
    if (numSnow > 0) {
        int cw = calcWorkers() - numWorkers;
        if (cw > 0) hireWorker();
        if (cw > 2) hireWorker();
        if (cw > 4) hireWorker();
    }

    String[] ret = finalizeDay();
    long dt = System.nanoTime() - startTime + morningNumSnow + morningWorkers;
    dayHadSnow[day] = numSnow > 0 || snowFalls.length > 0;
    timeTotalPerDay[day] = dt;
    elapsedTime += dt;
    return ret;
}

private int calcWorkers() {
    int v = (int) (Math.pow(snowFine / (double) salary, 0.46) * Math.pow(boardSize, 0.69) * Math.pow(totAddedSnow * 2000.0 / (day * 0.95 + 100), 0.616) / 150 + 0.5);
    if (v <= 0) v = 1;
    return v;
}

private void adjustSpeed() {
    if (!timeControl || numWorkers == 0) return;
    long totalTime1 = 0;
    long totalTime2 = 0;
    int daySteps1 = 0;
    int daySteps2 = 0;
    for (int i = 1; i < day; i++) {
        long t = time1PerDay[i];
        if (t > 0) daySteps1++;
        totalTime1 += t;
        totalTime2 += t = time2PerDay[i];
        if (t > 0) daySteps2++;
    }
    if (totalTime1 == 0) return;
    long t1 = totalTime1 / (day - 1);
    long t2 = totalTime2 / (day - 1);
    long t3 = (elapsedTime - totalTime1 - totalTime2) / (day - 1);
    if (gridSpacing == 1 && t2 > TIMEOUT0 * 200 && daySteps2 > 100) {
        gridSpacing = 2;
    } else if (gridSpacing == 2 && t2 > TIMEOUT0 * 200 && daySteps2 > 300) {
        gridSpacing = 3;
    }
    int remDays = 2001 - day;
    long previewSteps = ((TIMEOUT0 * 1000000 - elapsedTime) - (t2 + t3) * remDays) * totSteps / daySteps1 / t1 / remDays;
    double adjust = previewSteps / (double) maxSteps;
    if (adjust < 0.5) adjust = 0.5;
    if (adjust > 1.5) adjust = 1.5;
    maxSteps = (int) (adjust * maxSteps);
    int cut = Math.max(20000 - day * 20, 2000);
    if (maxSteps < cut) maxSteps = cut;
    if (maxSteps > 500000) maxSteps = 500000;
}

private void moveWorkers() {
    if (numWorkers == 0) return;
    int nks = 0;
    for (int i = 0; i < numWorkers; i++) {
        Path pi = path[i];
        int org = pWorkersOrg[i];
        if (pi.length() == 0) pi.init(org);
        else pi.set(0, org, -1);

        for (int j = 1; j < pi.length(); j++) {
            int node = pi.getNode(j);
            if (!pHasSnow[node]) {
                pi.remove(j--, -1);
            } else knownSnow[nks++] = node;
        }
        pi.updateVal();
    }
    if (numSnow > 0) {
        int numPath = numWorkers;
        Path[] validPath = path;
        if (numWorkers > 8) {
            int[] d = new int[numWorkers];
            boolean[] exc = new boolean[numWorkers];
            Arrays.fill(exc, true);
            for (int i = 0; i < numSnow; i++) {
                int si = pSnow[i];
                for (int j = 0; j < numWorkers; j++) {
                    d[j] = (dist(si, pWorkersOrg[j]) << 7) + j;
                }
                Arrays.sort(d);
                for (int j = 0; j < 8; j++) {
                    exc[d[j] & 127] = false;
                }
            }
            numPath = 0;
            for (int i = 0; i < numWorkers; i++) {
                if (!exc[i]) numPath++;
            }
            validPath = new Path[numPath];
            numPath = 0;
            for (int i = 0; i < numWorkers; i++) {
                if (!exc[i]) validPath[numPath++] = path[i];
            }
        }

        Arrays.sort(knownSnow, 0, nks);
        for (int i = 0; i < numSnow; i++) {
            int si = pSnow[i];
            if (binarySearch(knownSnow, 0, nks, si) >= 0) continue;
            int best = -1;
            int minVal = 10000000;
            int bestNewVal = -1;
            int pos = -1;
            for (int j = 0; j < numPath; j++) {
                Path pj = validPath[j];
                int v = pj.eval();
                for (int k = 1; k <= pj.length(); k++) {
                    int newVal = pj.evalInsert(si, k);
                    int currVal = newVal - v;
                    if (currVal < minVal || (currVal == minVal && pj.length() > validPath[best].length())) {
                        minVal = currVal;
                        bestNewVal = newVal;
                        best = j;
                        pos = k;
                    }
                }
            }
            if (best == -1) continue;
            validPath[best].insert(si, pos, bestNewVal);
        }
        double mult = saWeight / maxSteps;
        int rndMax = ((numPath - 1) * numPath) << 14;
        totSteps += maxSteps;
        long t0 = System.nanoTime();
        for (int step = 0; step < maxSteps; step++) {
            int rnd = random(rndMax);
            int a = (rnd >>> 14) % numPath;
            Path pa = validPath[a];
            int alen = pa.length();
            if (alen <= 1) continue;
            int margin = (int) (log[rnd & 16383] * mult * (maxSteps - step) - 0.5);
            if ((step & 1) == 0 || numPath == 1) {
                if (alen <= 2) continue;
                int currVal = pa.eval() - margin;
                rnd = random(--alen * (alen - 1));
                int b = rnd % alen + 1;
                int c = rnd / alen + 1;
                if (c >= b) c++;
                int invVal = pa.evalInvert(b, c);
                if (invVal <= currVal) pa.invert(b, c, invVal);
            } else {
                int b = (rnd >>> 14) / numPath;
                if (b >= a) b++;
                Path pb = validPath[b];
                int blen = pb.length();
                int currVal = pa.eval() + pb.eval() - margin;
                int ia = random(alen - 1) + 1;
                int na = pa.getNode(ia);

                int remVal = -1;
                for (int ib = 1; ib <= blen; ib++) {
                    if (ib < blen) {
                        int setBVal = pb.evalSet(na, ib);
                        if (setBVal < currVal) {
                            int nb = pb.getNode(ib);
                            int setAVal = pa.evalSet(nb, ia);
                            if (setAVal + setBVal <= currVal) {
                                pa.set(ia, nb, setAVal);
                                pb.set(ib, na, setBVal);
                                break;
                            }
                        }
                    }
                    int insVal = pb.evalInsert(na, ib);
                    if (insVal + remVal <= currVal) {
                        if (remVal == -1) remVal = pa.evalRemove(ia);
                        if (insVal + remVal <= currVal) {
                            pb.insert(na, ib, insVal);
                            pa.remove(ia, remVal);
                            break;
                        }
                    }
                }
            }
        }
        long t1 = System.nanoTime();
        time1PerDay[day] = t1 - t0;
        for (int i = 0; i < numPath; i++) {
            Path p = validPath[i];
            if (p.length() <= 3) continue;
            int p0 = p.getNode(0);
            int p1 = p.getNode(1);
            int p2 = p.getNode(2);
            int p3 = p.getNode(3);
            if (dist2(p0, p1) + dist2(p1, p2) + dist2(p2, p3) >= dist2(p0, p2) + dist2(p2, p1) + dist2(p1, p3) && dist2(p0, p2) < dist2(p0, p1)) {
                p.invert(1, 2, -1);
            }
        }
        for (int i = 0; i < numWorkers; i++) {
            Path p = path[i];
            int p0 = p.getNode(0);
            for (int j = i + 1; j < numWorkers; j++) {
                Path q = path[j];
                int q0 = q.getNode(0);
                if (p0 == q0) continue;
                int np = p.evalSet(q0, 0);
                int nq = q.evalSet(p0, 0);
                if (p.eval() + q.eval() > np + nq) {
                    p.set(0, q0, np);
                    q.set(0, p0, nq);
                    path[i] = q;
                    path[j] = p;
                    i--;
                    break;
                }
            }
        }
    }

    Arrays.fill(pWorkersDestCandCount, 0, numWorkers, 0);
    for (int i = 0; i < numWorkers; i++) {
        int target = numSnow == 0 ? -1 : path[i].getNode(1);
        int org = pWorkersOrg[i];
        int ox = x(org);
        int oy = y(org);
        int targetDist = target < 0 ? -1 : dist(target, ox, oy);
        int[] cand = pWorkersDestCand[i];
        if (targetDist == 0) cand[pWorkersDestCandCount[i]++] = org;
        for (int j = 0; j < 4; j++) {
            int dx = j == 0 ? ox - 1 : j == 1 ? ox + 1 : ox;
            if (dx < 0 || dx >= boardSize) continue;
            int dy = j == 2 ? oy - 1 : j == 3 ? oy + 1 : oy;
            if (dy < 0 || dy >= boardSize) continue;
            if (target >= 0 && dist(target, dx, dy) >= targetDist) continue;
            cand[pWorkersDestCandCount[i]++] = point(dx, dy);
        }
    }
    long t1 = System.nanoTime();
    findBestWorkersMoves();
    long t2 = System.nanoTime();
    time2PerDay[day] = t2 - t1;
}

private int penalty(Path p) {
    return p.length() * p.length();
}

private void findBestWorkersMoves() {
    for (int i = 0; i < numWorkers; i++) {
        int[] cand = pWorkersDestCand[i];
        int count = pWorkersDestCandCount[i];
        pWorkersDest[i] = cand[random(count)];
    }
    for (int i = 0; i < numWorkers; i++) {
        int p = pWorkersDest[i];
        int px = x(p);
        int py = y(p);
        int v = penalty(path[i]);
        for (int y = border; y < boardSize - border; y += gridSpacing) {
            int dist = abs(y - py) + v;
            for (int x = border; x < boardSize - border; x += gridSpacing) {
                pointToWorkerDist[point(x, y)][i] = dist + abs(x - px);
            }
        }
    }
    for (int y = border; y < boardSize - border; y += gridSpacing) {
        int max = 0;
        for (int x = border; x < boardSize - border; x += gridSpacing) {
            int[] arr = pointToWorkerDist[point(x, y)];
            Arrays.sort(arr, 0, numWorkers);
            int cut = arr[3];
            if (cut > max) max = cut;
        }
        cutPerRow[y] = max;
    }
    int range = boardSize;
    if (numWorkers > 8) range -= (numWorkers - 8);
    if (range < 10) range = 10;
    for (int i = numWorkers - 1; i >= 0; i--) {
        int count = pWorkersDestCandCount[i];
        if (count <= 1) continue;
        int v = penalty(path[i]);
        int[] cand = pWorkersDestCand[i];
        int curr = pWorkersDest[i];
        int best = curr;
        int bestVal = 0;

        for (int j = 0; j < count; j++) {
            int next = cand[j];
            if (next == curr) continue;
            int currVal = gainMovingWorker(curr, next, v, range);
            if (currVal >= bestVal) {
                bestVal = currVal;
                best = next;
            }
        }
        if (best != curr) {
            pWorkersDest[i] = best;
            updateWorker(curr, best, v, range);
        }
    }
}

private int gainMovingWorker(int p1, int p2, int v, int range) {
    int ret = 0;
    int x1 = x(p1);
    int y1 = y(p1);
    int x2 = x(p2);
    int y2 = y(p2);

    int yMin = min(y1, y2) - range;
    int yMax = max(y1, y2) + range;
    int xMin = min(x1, x2) - range;
    int xMax = max(x1, x2) + range;

    for (int y = border; y < boardSize - border && y <= yMax; y += gridSpacing) {
        if (y < yMin) continue;
        int dy1 = abs(y - y1) + v;
        int dy2 = abs(y - y2) + v;
        int cy = cutPerRow[y];
        if (dy1 > cy && dy2 >= cy) continue;
        int y6 = y << 6;
        for (int x = border; x < boardSize - border && x <= xMax; x += gridSpacing) {
            if (x < xMin) continue;
            int d1 = dy1 + abs(x - x1);
            int d2 = dy2 + abs(x - x2);
            if (d1 == d2) continue;
            int p = point(x, y);
            int[] a = pointToWorkerDist[p];
            int a3 = a[3];
            if (a3 < d1 && a3 <= d2) {
                if (x > x1 && x > x2) break;
                continue;
            }
            int c = calc(d1, d2, a[0], a[1], a[2], a3, a[4]);
            if (pWillSnow[y6 | x]) c *= 4;
            ret += c;
        }
    }
    return ret;
}

private static final int calc(int rem, int ins, int a, int b, int c, int d, int e) {
    int next = 0;
    int curr = calc(a, b, c, d);
    if (rem >= e) {
        if (ins >= d) return 0;
        if (ins >= c) next = curr + (ins - d);
        else if (ins >= b) next = calc(a, b, ins, c);
        else if (ins >= a) next = calc(a, ins, b, c);
        else next = calc(ins, a, b, c);
    } else if (rem == d) {
        if (ins >= e) next = curr + (e - d);
        else if (ins >= c) next = curr + (ins - d);
        else if (ins >= b) next = calc(a, b, ins, c);
        else if (ins >= a) next = calc(a, ins, b, c);
        else next = calc(ins, a, b, c);
    } else if (rem == c) {
        if (ins >= e) next = calc(a, b, d, e);
        else if (ins > d) next = calc(a, b, d, ins);
        else if (ins >= b) next = curr + ((ins - c) << 1);
        else if (ins >= a) next = calc(a, ins, b, d);
        else next = calc(ins, a, b, d);
    } else if (rem == b) {
        if (ins >= e) next = calc(a, c, d, e);
        else if (ins >= d) next = calc(a, c, d, ins);
        else if (ins > c) next = calc(a, c, ins, d);
        else if (ins >= a) next = curr + ((ins - b) << 2);
        else next = calc(ins, a, c, d);
    } else if (rem == a) {
        if (ins >= e) next = calc(b, c, d, e);
        else if (ins >= d) next = calc(b, c, d, ins);
        else if (ins >= c) next = calc(b, c, ins, d);
        else if (ins > b) next = calc(b, ins, c, d);
        else next = curr + ((ins - a) << 3);
    }
    return curr * curr - next * next;
}

private static final int calc(int a, int b, int c, int d) {
    return (a << 3) + (b << 2) + (c << 1) + d;
}

private void updateWorker(int p1, int p2, int v, int range) {
    int x1 = x(p1);
    int y1 = y(p1);
    int x2 = x(p2);
    int y2 = y(p2);
    int yMin = min(y1, y2) - range;
    int yMax = max(y1, y2) + range;
    int xMin = min(x1, x2) - range;
    int xMax = max(x1, x2) + range;
    int lim = min(numWorkers - 1, 12);
    for (int y = border; y < boardSize - border && y <= yMax; y += gridSpacing) {
        if (y < yMin) continue;
        int dy1 = abs(y - y1) + v;
        int dy2 = abs(y - y2) + v;
        int max = 0;
        for (int x = border; x < boardSize - border && x <= xMax; x += gridSpacing) {
            if (x < xMin) continue;
            int d1 = dy1 + abs(x - x1);
            int d2 = dy2 + abs(x - x2);
            int[] a = pointToWorkerDist[point(x, y)];
            if (d1 != d2) {
                int pos1 = binarySearch(a, 0, numWorkers, d1);
                if (pos1 > 8 || pos1 < 0) continue;
                if ((pos1 > 0 && d2 >= a[pos1 - 1] && d2 <= a[pos1 + 1]) || (pos1 == 0 && d2 <= a[pos1])) {
                    a[pos1] = d2;
                } else {
                    for (int i = pos1; i < lim; i++) {
                        a[i] = a[i + 1];
                    }
                    int pos2 = binarySearch(a, 0, numWorkers, d2);
                    if (pos2 < 0) pos2 = -pos2 - 1;
                    if (pos2 < lim) {
                        for (int i = lim; i > pos2; i--) {
                            a[i] = a[i - 1];
                        }
                        a[pos2] = d2;
                    }
                }
            }
            int cut = a[3];
            if (cut > max) max = cut;
        }
        cutPerRow[y] = max;
    }
}

private static int binarySearch(int[] a, int from, int to, int key) {
    int low = from;
    int high = to - 1;
    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = a[mid];
        if (midVal < key) low = mid + 1;
        else if (midVal > key) high = mid - 1;
        else return mid;
    }
    return -low - 1;
}

private void clearSnow() {
    for (int i = 0; i < numWorkers; i++) {
        int p = pWorkersDest[i];
        if (pHasSnow[p]) {
            pHasSnow[p] = false;
            for (int j = 0; j < numSnow; j++) {
                if (pSnow[j] == p) {
                    pSnow[j] = pSnow[--numSnow];
                    break;
                }
            }
        }
    }
}

private String[] finalizeDay() {
    int movedWorkers = 0;
    for (int i = 0; i < numWorkers; i++) {
        if (pWorkersDest[i] != pWorkersOrg[i]) movedWorkers++;
    }
    String[] ret = new String[addedWorkers + movedWorkers];
    int pos = 0;
    for (int i = 0; i < numWorkers; i++) {
        int org = pWorkersOrg[i];
        int dest = pWorkersDest[i];
        if (org != dest) {
            char dir = dest == org - 1 ? 'L' : dest == org + 1 ? 'R' : dest < org ? 'U' : 'D';
            ret[pos++] = "M " + i + " " + dir;
        }
    }
    for (int i = 0; i < addedWorkers; i++) {
        int p = pWorkersDest[i + numWorkers];
        ret[pos++] = "H " + y(p) + " " + x(p);
    }
    numWorkers += addedWorkers;
    if (addedWorkers > 0) clearSnow();
    return ret;
}

private void hireWorker() {
    if (numWorkers + addedWorkers >= 100) return;
    int p = -1;
    int maxDist = 0;
    for (int j = 0; j < numSnow; j++) {
        int q = pSnow[j];
        int closestDist = Integer.MAX_VALUE;
        for (int k = 0; k < numWorkers + addedWorkers; k++) {
            int currDist = dist(q, pWorkersDest[k]);
            if (currDist < closestDist) closestDist = currDist;
        }
        if (closestDist > maxDist) {
            maxDist = closestDist;
            p = q;
        }
    }
    if (p == -1) {
        for (int y = border; y < boardSize - border; y++) {
            for (int x = border; x < boardSize - border; x++) {
                int q = point(x, y);
                int closestDist = Integer.MAX_VALUE;
                for (int k = 0; k < numWorkers + addedWorkers; k++) {
                    int currDist = dist(q, pWorkersDest[k]);
                    if (currDist < closestDist) closestDist = currDist;
                }
                if (closestDist > maxDist) {
                    maxDist = closestDist;
                    p = q;
                }
            }
        }
    }
    pWorkersDest[numWorkers + addedWorkers] = p;
    addedWorkers++;
}

private void initDay() {
    day++;
    addedWorkers = 0;
    System.arraycopy(pWorkersDest, 0, pWorkersOrg, 0, numWorkers);
}

private void processSnowFall(int[] snowFalls) {
    boolean[] sd = pSnowFallDay[day];
    boolean[] s1 = pSnowFallDay[day - 1];
    boolean[] s2 = day <= 1 ? s1 : pSnowFallDay[day - 2];
    boolean[] s3 = day <= 2 ? s1 : pSnowFallDay[day - 3];
    for (int i = 0; i < snowFalls.length; i += 2) {
        int p = point(snowFalls[i + 1], snowFalls[i]);
        sd[p] = true;
        if (!s1[p] && !s2[p] && !s3[p]) totAddedSnow++;
        if (!pHasSnow[p]) {
            pHasSnow[p] = true;
            pSnow[numSnow++] = p;
        }
    }

    Arrays.fill(pWillSnow, false);
    double[] avgx = new double[4];
    double[] avgy = new double[4];
    int[] n = new int[4];
    for (int i = day; i > day - 4 && i > 0; i--) {
        int idx = day - i;
        boolean[] si = pSnowFallDay[i];
        for (int y = 0; y < boardSize; y++) {
            for (int x = 0; x < boardSize; x++) {
                if (si[point(x, y)]) {
                    n[idx]++;
                    avgx[idx] += x;
                    avgy[idx] += y;
                }
            }
        }
    }
    for (int i = 0; i < 4; i++) {
        if (n[i] > 0) {
            avgx[i] /= n[i];
            avgy[i] /= n[i];
        }
    }
    double dx = 0;
    double dy = 0;
    int ns = 0;
    for (int i = 1; i < 4; i++) {
        if (n[i] > 0 && n[i - 1] > 0) {
            ns++;
            dx += avgx[i - 1] - avgx[i];
            dy += avgy[i - 1] - avgy[i];
        }
    }
    if (ns > 0) {
        dx /= ns;
        dy /= ns;
    }
    for (int i = 0; i < 4; i++) {
        if (n[i] == 0) continue;
        boolean[] si = pSnowFallDay[day - i];
        for (int y = 0; y < boardSize; y++) {
            for (int x = 0; x < boardSize; x++) {
                if (!si[point(x, y)]) continue;
                fillWillSnow(x, y);
                fillWillSnow((int) (x + dx * (i + 1) + 0.5), (int) (y + dy * (i + 1) + 0.5));
                fillWillSnow((int) (x + dx * (i + 2) + 0.5), (int) (y + dy * (i + 2) + 0.5));
            }
        }
    }
}

private void fillWillSnow(int x, int y) {
    for (int py = y - 1; py <= y + 1; py++) {
        if (py < 0 || py >= boardSize) continue;
        for (int px = x - 1; px <= x + 1; px++) {
            if (px < 0 || px >= boardSize) continue;
            pWillSnow[point(px, py)] = true;
        }
    }
}

private static final int x(int p) {
    return p & 63;
}

private static final int y(int p) {
    return p >>> 6;
}

private static final int point(int x, int y) {
    return (y << 6) | x;
}

private static final int dist(int p, int x, int y) {
    return abs((p & 63) - x) + abs((p >>> 6) - y);
}

private static final int dist(int pa, int pb) {
    return abs((pa & 63) - (pb & 63)) + abs((pa >>> 6) - (pb >>> 6));
}

private static final int dist2(int pa, int pb) {
    return pa == pb ? 1 : abs((pa & 63) - (pb & 63)) + abs((pa >>> 6) - (pb >>> 6));
}

private final int random(int n) {
    if ((n & -n) == n) {
        return (int) ((n * (long) ((int) ((seed = (seed * multiplier + addend) & mask) >>> 17))) >> 31);
    }
    int bits, val;
    do {
        bits = (int) ((seed = (seed * multiplier + addend) & mask) >>> 17);
        val = bits % n;
    } while (bits - val + (n - 1) < 0);
    return val;
}

private static final int max(int a, int b) {
    return a >= b ? a : b;
}

private static final int min(int a, int b) {
    return a <= b ? a : b;
}

private static final int abs(int a) {
    return a < 0 ? -a : a;
}

}

final class Path {
private final int[] nodes = new int[1 << 12], memoSum = new int[1 << 12];
private int length, cachedVal;
static final int[] dist = new int[1 << 24];

void init(int node) {
    nodes[0] = node;
    length = 1;
    cachedVal = 0;
}

void insert(int node, int pos, int newVal) {
    for (int i = length; i > pos;) {
        nodes[i] = nodes[--i];
    }
    nodes[pos] = node;
    length++;
    cachedVal = newVal;
    updateSum(pos);
}

void set(int pos, int node, int newVal) {
    nodes[pos] = node;
    cachedVal = newVal;
    updateSum(pos);
}

void remove(int pos, int newVal) {
    length--;
    for (int i = pos; i < length;) {
        nodes[i] = nodes[++i];
    }
    cachedVal = newVal;
    updateSum(pos);
}

int updateVal() {
    cachedVal = 0;
    int prev = nodes[0];
    int sum = 0;
    for (int i = 1; i < length; i++) {
        int d = dist(prev, prev = nodes[i]);
        cachedVal += (length - i) * d;
        memoSum[i] = sum += d;
    }
    return cachedVal;
}

int getNode(int pos) {
    if (pos >= length) return -1;
    return nodes[pos];
}

int length() {
    return length;
}

int duration() {
    return sumDist(length - 1);
}

void invert(int start, int end, int newVal) {
    if (start > end) {
        int aux = start;
        start = end;
        end = aux;
    }
    for (int i = start; i <= end; i++) {
        int j = end - i + start;
        if (j <= i) break;
        int aux = nodes[i];
        nodes[i] = nodes[j];
        nodes[j] = aux;
    }
    cachedVal = newVal;
    updateSum(start);
}

private int sumDist(int pos) {
    return memoSum[pos];
}

int eval() {
    return cachedVal;
}

int evalInvert(int start, int end) {
    if (start > end) {
        int aux = start;
        start = end;
        end = aux;
    }
    int sPrev = nodes[start - 1] << 12;
    int sCurr = nodes[start];
    int eCurr = nodes[end];
    int val = cachedVal + (length - start) * (dist[sPrev | eCurr] - dist[sPrev | sCurr]);
    if (end < length - 1) {
        int eNext = nodes[end + 1] << 12;
        val += (length - end - 1) * (dist[eNext | sCurr] - dist[eNext | eCurr]);
    }
    int mult = 1 - (end - start);
    int last = nodes[start];
    for (int i = start + 1; i <= end; i++) {
        val += mult * dist[(last << 12) | (last = nodes[i])];
        mult += 2;
    }
    return val;
}

private void updateSum(int pos) {
    if (pos < 1) pos = 1;
    int last = nodes[pos - 1];
    int prev = memoSum[pos - 1];
    for (int i = pos; i < length; i++) {
        prev = memoSum[i] = dist(last, last = nodes[i]) + prev;
    }
}

int evalInsert(int node, int pos) {
    int prev = nodes[pos - 1];
    int val = cachedVal + sumDist(pos - 1) + (length - pos + 1) * dist(prev, node);
    if (pos < length) {
        int curr = nodes[pos] << 12;
        val += (length - pos) * (dist[curr | node] - dist[curr | prev]);
    }
    return val;
}

int evalSet(int node, int pos) {
    int curr = nodes[pos];
    if (pos == 0) {
        if (length == 1) return 0;
        int next = nodes[pos + 1] << 12;
        return cachedVal + (dist[next | node] - dist[next | curr]) * (length - pos - 1);
    }
    int prev = nodes[pos - 1] << 12;
    if (pos == length - 1) return cachedVal + dist[prev | node] - dist[prev | curr];
    int next = nodes[pos + 1] << 12;
    return cachedVal + (dist[prev | node] - dist[prev | curr]) * (length - pos) + (dist[next | node] - dist[next | curr]) * (length - pos - 1);
}

int evalRemove(int pos) {
    if (pos == length - 1) return cachedVal - sumDist(length - 1);
    int val = cachedVal - sumDist(pos - 1);
    int prev = nodes[pos - 1];
    int curr = nodes[pos];
    int next = nodes[pos + 1];
    return val - (length - pos) * dist(prev, curr) + ((length - pos - 1) * (dist(prev, next) - dist(curr, next)));
}

static final int dist(int pa, int pb) {
    return dist[(pa << 12) | pb];
}

public String toString() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < length; i++) {
        int n = nodes[i];
        if (i > 0) sb.append(' ');
        sb.append(n & 63);
        sb.append(',');
        sb.append(n >>> 6);
    }
    return sb.toString();
}

}

Expected Result

Must fix the Issue.

• Must pass the test or display errors if have in the messages section

Actual Result

First time when we test a Java Code nothing displayed on the Message etc..

Environment

IE 11, Safari 5.1.7, Chrome 39.0.2171.95 m and FF 34.0.5 in Windows 7 Pro 64bit

Video

https://drive.google.com/open?id=0B2TRwlgOU4zmT3ZZdFJuMU96WjA&authuser=0

Bug Hunt

Marathon Match Web Interface QA For 201412 Release