exec/AllToAllConnected.input.java

+import lib.UnweightedGraph;
+
+class AllToAllConnected {
+
+    public UnweightedGraph G;
+
+    public static void main(String[] args) throws Exception {
+	new AllToAllConnected().run();
+    }
+
+    public void run() throws Exception {
+        G = new UnweightedGraph();
+        G.loadFromStdin();
+
+	int u = 0;
+	while (u < G.numberOfNodes() / 256) { /* checking all nodes takes too long */
+            boolean connectedToAll = true;
+            int v = 0;
+            while (v < G.numberOfNodes()) {
+                connectedToAll = connectedToAll && isConnected(u, v);
+                v = v + 1;
+            }
+            if (connectedToAll) {
+                System.out.println(1);
+            } else {
+                System.out.println(0);
+            }
+            u = u + 1;
+        }
+    }
+
+    public boolean isConnected(int s, int t) {
+        buildConnectedArray(s);
+        return scanned[t];
+    }
+
+    public boolean[] scanned;
+    public void buildConnectedArray(int s) {
+        scanned = new boolean[G.numberOfNodes()];
+        int u = 0;
+        while (u < G.numberOfNodes()) {
+            scanned[u] = false;
+            u = u + 1;
+        }
+        connectionScan(s);
+    }
+
+    public void connectionScan(int u) {
+        scanned[u] = true;
+        int e = G.firstEdge(u);
+        while (e < G.firstInvalidEdge(u)) {
+            int v = G.edgeTarget(e);
+            if (!scanned[v] && u != v) {
+                connectionScan(v);
+            }
+            e = e + 1;
+        }
+    }
+}
\ No newline at end of file

exec/MinHeapTest.java

+import lib.MinHeap;
+
+class MinHeapTest {
+
+    public static void main(String[] args) {
+        MinHeap heap = new MinHeap();
+
+        /* populate it */
+        heap.insert(60);
+        System.out.println(heap.minKey());
+        heap.insert(10);
+        System.out.println(heap.minKey());
+        heap.insert(5);
+        System.out.println(heap.minKey());
+        heap.insert(20);
+        System.out.println(heap.minKey());
+
+        /* now make it empty again */
+        System.out.println(heap.deleteMin());
+        System.out.println(heap.deleteMin());
+        System.out.println(heap.deleteMin());
+        System.out.println(heap.deleteMin());
+
+        /* now do both */
+        heap.insert(100);
+        System.out.println(heap.deleteMin());
+        heap.insert(100);
+        heap.insert(90);
+        System.out.println(heap.deleteMin());
+        heap.insert(80);
+        heap.insert(70);
+        System.out.println(heap.deleteMin());
+        System.out.println(heap.deleteMin());
+        System.out.println(heap.deleteMin());
+
+        /* test decreaseKey */
+        int handle1 = heap.insert(100);
+        int handle2 = heap.insert(50);
+        heap.decreaseKey(handle2, 40);
+        heap.decreaseKey(handle1, 10);
+        System.out.println(heap.deleteMin());
+        System.out.println(heap.deleteMin());
+    }
+}
\ No newline at end of file

exec/SegmentationFault.invalid.java

-class A {
-
-    public int i;
-
-    public static void main(String[] args) {
-        A a = null;
-        int i = a.i;
-    }
-}
\ No newline at end of file

exec/array_index_access_order.mj

@@ -6,7 +6,7 @@ class B {
             i[x] = (x = x + 1);
         }
         x = -1;
-        while(x < 4) {
+        while(x < 3) {
             System.out.println(i[(x = x + 1)]);
         }
 

exec/lib/MinHeap.java

+package lib;
+
+public class MinHeap {
+
+    public MinHeapEntry[] heap;
+    public int heapSize;
+    public int heapCapacity;
+
+    public int insert(int key) {
+        int handle = heapSize;
+
+        MinHeapEntry entry = new MinHeapEntry();
+        entry.key = key;
+        entry.handle = handle;
+        if (heapSize == heapCapacity) growHeap();
+        heap[handle] = entry;
+        heapSize = heapSize + 1;
+
+        siftDown(handle);
+        return handle;
+    }
+
+    public void decreaseKey(int handle, int key) {
+        /* find our element */
+        int i = 0;
+        boolean found = false;
+        while (i < heapSize && !found) {
+            if (heap[i].handle == handle) {
+                found = true;
+            }
+            i = i + 1;
+        }
+        i = i - 1;
+
+        /* then change the key and restore heap property */
+        heap[i].key = key;
+        siftUp(i);
+    }
+
+    public int minKey() {
+        return heap[0].key;
+    }
+
+    public int deleteMin() {
+        int key = heap[0].key;
+
+        int i = 1;
+        while (i < heapSize) {
+            heap[i - 1] = heap[i];
+            i = i + 1;
+        }
+        heapSize = heapSize - 1;
+        if (heapSize > 0) siftUp(0);
+
+        return key;
+    }
+
+    /* private methods */
+    public void growHeap() {
+        int newCapacity = 0;
+        if (heapCapacity == 0) {
+            newCapacity = 1;
+        } else {
+            newCapacity = heapCapacity * 2;
+        }
+
+        MinHeapEntry[] newHeap = new MinHeapEntry[newCapacity];
+        int i = 0;
+        while (i < heapCapacity) {
+            newHeap[i] = heap[i];
+            i = i + 1;
+        }
+
+        heapCapacity = newCapacity;
+        heap = newHeap;
+    }
+
+    public void siftUp(int pos) {
+        int currentKey = heap[pos].key;
+        int lhsChild = 2 * pos + 1;
+        int rhsChild = 2 * pos + 2;
+
+        if (rhsChild < heapSize) {
+            int lhsKey = heap[lhsChild].key;
+            int rhsKey = heap[rhsChild].key;
+
+            if (lhsKey < currentKey || rhsKey < currentKey) {
+                int swapPosition = rhsChild;
+                if (lhsKey < rhsKey) {
+                    swapPosition = lhsChild;
+                }
+                swap(pos, swapPosition);
+                siftUp(swapPosition);
+            }
+
+            return;
+        }
+
+        if (lhsChild < heapSize) {
+            if (heap[pos].key > heap[lhsChild].key) {
+                swap(pos, lhsChild);
+                siftUp(lhsChild);
+            }
+        }
+    }
+
+    public void siftDown(int pos) {
+        if (pos <= 0) return;
+        int parentPos = (pos - 1) / 2;
+        if (heap[parentPos].key > heap[pos].key) {
+            swap(parentPos, pos);
+            siftDown(parentPos);
+        }
+    }
+
+    public void swap(int a, int b) {
+        MinHeapEntry tmp = heap[a];
+        heap[a] = heap[b];
+        heap[b] = tmp;
+    }
+}
+
+class MinHeapEntry {
+
+    public int handle;
+    public int key;
+}
\ No newline at end of file

exec/lib/UnweightedGraph.java

+package lib;
+
+public class UnweightedGraph {
+
+    public int firstEdge(int u) {
+        return nodes[u];
+    }
+
+    public int firstInvalidEdge(int u) {
+        return nodes[u + 1];
+    }
+
+    public int edgeTarget(int e) {
+        return edges[e];
+    }
+
+    public int numberOfNodes() {
+        return numberOfNodes;
+    }
+
+    public int numberOfEdges() {
+        return numberOfEdges;
+    }
+
+    /**
+     * Reads unweighted graphs in METIS format.
+     */
+    public void loadFromStdin() throws Exception {
+        numberOfNodes = readIntFromStdin();
+        numberOfEdges = readIntFromStdin() * 2;
+        readIntFromStdin(); /* new line */
+        nodes = new int[numberOfNodes + 1];
+        edges = new int[numberOfEdges];
+
+        int u = 0;
+        int e = 0;
+        while (u < numberOfNodes) {
+            int v;
+            while ((v = readIntFromStdin()) != -1) {
+                edges[e] = v - 1;
+                e = e + 1;
+            }
+            u = u + 1;
+            nodes[u] = e;
+        }
+    }
+
+    /* private */
+
+    public int numberOfNodes;
+    public int[] nodes;
+    public int numberOfEdges;
+    public int[] edges;
+    public boolean endedOnNewLine;
+
+    /**
+     * @return the next integer or a negative integer if a new line character is read.
+     */
+    public int readIntFromStdin() throws Exception {
+        if (endedOnNewLine) {
+            endedOnNewLine = false;
+            return -1;
+        }
+        int ch;
+        while (((ch = System.in.read()) < 48 || ch > 57) && ch != 10);
+        if (ch == 10) return -1;
+        int num = 0;
+        while (48 <= ch && ch <= 57) {
+            num = num * 10 + (ch - 48);
+            ch = System.in.read();
+        }
+        if (ch == 10) endedOnNewLine = true;
+        return num;
+    }
+}
\ No newline at end of file