Commit 67310848 by andreas.fried

### Add Speedcenter testcases.

parent 19948c3b
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \ No newline at end of file
 /** * Linear congruence generator for pseudo random numbers. */ class LCG { public int a; public int c; public int m; public int val; public LCG initWithDefault(int seed){ return init(2147483629, 2147483587, 2147483647, seed); } public LCG initWithDefault2(int seed){ return init(2147480707, 2147480707, 2147482367, seed); } public LCG init(int a_, int c_, int m_, int startVal) { a = a_; c = c_; m = m_; val = startVal; return this; } public int nextVal() { return val = (a * val + c) % m; } /* util functions */ public int abs(int v) { if (v >= 0) return v; return -v; } public void runTest() { int i = 0; while (i < 100) { i = i + 1; System.out.println(abs(nextVal())); } /*System.out.println(-2147483648 / -1);*/ } /** * @param min minimum number * @param max exclusive range end */ public int nextRange(int min, int max){ return nextVal() % (max - min) + min; } } /* Adapted from: https://en.wikipedia.org/wiki/Lehmer_random_number_generator */ class LehmerRandom { public int M; /* 2^31 - 1 (A large prime number) */ public int A; /* Prime root of M, passes statistical tests and produces a full cycle */ public int Q; /* M / A (To avoid overflow on A * seed) */ public int R; /* M % A (To avoid overflow on A * seed) */ public int seed; public LehmerRandom init(int seed){ this.M = 2147483647; this.A = 16807; this.Q = 127773; this.R = 2836; this.seed = seed; return this; } public LehmerRandom initWithDefault(){ return init(2147480677); } public int random() { int hi = seed / Q; int lo = seed % Q; int test = A * lo - R * hi; if (test <= 0) test = test + M; seed = test; return test; } public int next(){ return random(); } /** * @param min minimum number * @param max exclusive range end */ public int nextRange(int min, int max){ return next() % (max - min) + min; } public int[] intArray(int size, int min, int maxEx){ int[] arr = new int[size]; int i = 0; while (i < size){ arr[i] = nextRange(min, maxEx); i = i + 1; } return arr; } public boolean nextBoolean(){ return next() % 2 == 0; } public boolean[] booleanArray(int size){ boolean[] arr = new boolean[size]; int i = 0; while (i < size){ arr[i] = nextBoolean(); i = i + 1; } return arr; } public void shuffleIntArray(int[] arr, int size) { int i = size - 1; while (i > 0){ int index = nextRange(0, i + 1); int a = arr[index]; arr[index] = arr[i]; arr[i] = a; i = i - 1; } } } /** * Calculate the tensor product for a dimension of 7 */ class BigTensorProduct { public static void main(String[] args) throws Exception { BigTensorProduct prod = new BigTensorProduct(); prod.run(15, false, System.in.read()); } public void run(int n, boolean outputMatrix, int seed){ LCG random = new LCG().initWithDefault2(seed); int sum = 0; int[] indezes = new int[7]; int j = 0; while (j < 7){ indezes[j] = 0; j = j + 1; } int[][][][][][][] arr = randomIntArray(n, seed + 1); int[][] vectors = randomMatrix(7, n, seed + 2); while (indezes[0] < n) { while (indezes[1] < n) { while (indezes[2] < n) { while (indezes[3] < n) { while (indezes[4] < n) { while (indezes[5] < n) { while (indezes[6] < n) { int val = 1; int i = 0; while (i < 7){ val = val * vectors[i][indezes[i]]; i = i + 1; } if (outputMatrix){ System.out.println(arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]][indezes[6]]); } sum = sum + val * arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]][indezes[6]]; indezes[6] = indezes[6] + 1; } indezes[6] = 0; indezes[5] = indezes[5] + 1; } indezes[5] = 0; indezes[4] = indezes[4] + 1; } indezes[4] = 0; indezes[3] = indezes[3] + 1; } indezes[3] = 0; indezes[2] = indezes[2] + 1; } indezes[2] = 0; indezes[1] = indezes[1] + 1; } indezes[1] = 0; indezes[0] = indezes[0] + 1; } System.out.println(sum); } public void runWithNumbers(int n, boolean outputMatrix, int seed){ LCG random = new LCG().initWithDefault2(seed); Number sum = new Number().init(0); int[] indezes = new int[7]; int j = 0; while (j < 7){ indezes[j] = 0; j = j + 1; } Number[][][][][][][] arr = randomNumberArray(n, seed + 1); Number[][] vectors = randomNumberMatrix(7, n, seed + 2); while (indezes[0] < n) { while (indezes[1] < n) { while (indezes[2] < n) { while (indezes[3] < n) { while (indezes[4] < n) { while (indezes[5] < n) { while (indezes[6] < n) { Number val = new Number().init(1); int i = 0; while (i < 7){ val = val.mul(vectors[i][indezes[i]]); i = i + 1; } if (outputMatrix){ System.out.println(arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]][indezes[6]].val); } sum = sum.add(val.mul(arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]][indezes[6]])); indezes[6] = indezes[6] + 1; } indezes[6] = 0; indezes[5] = indezes[5] + 1; } indezes[5] = 0; indezes[4] = indezes[4] + 1; } indezes[4] = 0; indezes[3] = indezes[3] + 1; } indezes[3] = 0; indezes[2] = indezes[2] + 1; } System.out.println(sum.val); indezes[2] = 0; indezes[1] = indezes[1] + 1; } indezes[1] = 0; indezes[0] = indezes[0] + 1; } System.out.println(sum.val); } public int[][] randomMatrix(int number, int n, int seed){ LehmerRandom random = new LehmerRandom().init(seed); int[][] ret = new int[number][]; int i = 0; while (i < number){ ret[i] = new int[n]; int j = 0; while (j < n){ ret[i][j] = random.next(); j = j + 1; } i = i + 1; } return ret; } public Number[][] randomNumberMatrix(int number, int n, int seed){ LehmerRandom random = new LehmerRandom().init(seed); Number[][] ret = new Number[number][]; int i = 0; while (i < number){ ret[i] = new Number[n]; int j = 0; while (j < n){ ret[i][j] = new Number().init(random.next()); j = j + 1; } i = i + 1; } return ret; } public int[][][][][][][] randomIntArray(int n, int seed){ LCG lcg = new LCG().initWithDefault(seed); int[][][][][][][] arr = new int[n][][][][][][]; int[] indezes = new int[7]; while (indezes[0] < n) { arr[indezes[0]] = new int[n][][][][][]; while (indezes[1] < n) { arr[indezes[0]][indezes[1]] = new int[n][][][][]; while (indezes[2] < n) { arr[indezes[0]][indezes[1]][indezes[2]] = new int[n][][][]; while (indezes[3] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]] = new int[n][][]; while (indezes[4] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]] = new int[n][]; while (indezes[5] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]] = new int[n]; while (indezes[6] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]][indezes[6]] = lcg.nextVal(); indezes[6] = indezes[6] + 1; } indezes[6] = 0; indezes[5] = indezes[5] + 1; } indezes[5] = 0; indezes[4] = indezes[4] + 1; } indezes[4] = 0; indezes[3] = indezes[3] + 1; } indezes[3] = 0; indezes[2] = indezes[2] + 1; } indezes[2] = 0; indezes[1] = indezes[1] + 1; } indezes[1] = 0; indezes[0] = indezes[0] + 1; } return arr; } public Number[][][][][][][] randomNumberArray(int n, int seed){ LCG lcg = new LCG().initWithDefault(seed); Number[][][][][][][] arr = new Number[n][][][][][][]; int[] indezes = new int[7]; while (indezes[0] < n) { arr[indezes[0]] = new Number[n][][][][][]; while (indezes[1] < n) { arr[indezes[0]][indezes[1]] = new Number[n][][][][]; while (indezes[2] < n) { arr[indezes[0]][indezes[1]][indezes[2]] = new Number[n][][][]; while (indezes[3] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]] = new Number[n][][]; while (indezes[4] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]] = new Number[n][]; while (indezes[5] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]] = new Number[n]; while (indezes[6] < n) { arr[indezes[0]][indezes[1]][indezes[2]][indezes[3]][indezes[4]][indezes[5]][indezes[6]] = new Number().init(lcg.nextRange(-1000, 1000)); indezes[6] = indezes[6] + 1; } indezes[6] = 0; indezes[5] = indezes[5] + 1; } indezes[5] = 0; indezes[4] = indezes[4] + 1; } indezes[4] = 0; indezes[3] = indezes[3] + 1; } indezes[3] = 0; indezes[2] = indezes[2] + 1; } indezes[2] = 0; indezes[1] = indezes[1] + 1; } indezes[1] = 0; indezes[0] = indezes[0] + 1; } return arr; } } class Number { public int val; public Number init(int val){ this.val = val; return this; } public Number mul(Number other){ return new Number().init(other.val * val); } public Number add(Number other){ return new Number().init(other.val + val); } }
 class Math { public int pow(int v, int exp){ if (exp < 0){ return 1 / pow(v, -exp); } else if (exp == 0){ return 1; } else { int ret = 1; while (exp > 0){ if (exp % 2 == 0){ v = v * v; exp = exp / 2; } else { ret = ret * v; exp = exp - 1; } } return ret; } } public int factorial(int val){ int ret = 1; int sign = signum(val); if (val < 0){ val = -val; } if (val == 0){ return 1; } while (val > 0){ ret = ret * val; val = val - 1; } return ret * sign; } public int min(int s, int t){ if (s < t){ return s; } return t; } public int max(int s, int t){ if (s > t){ return s; } return t; } public int lengthInChars(int num){ int len = 1; if (num < 0){ len = len + 1; num = -num; } while (num > 10){ num = num / 10; len = len + 1; } return len; } public int signum(int num){ if (num == 0){ return 0; } if (num < 0){ return -1; } return 1; } public int abs(int num){ if (num < 0){ return -num; } return num; } } /* Adapted from the following source: The Computer Language Benchmarks Game http://benchmarksgame.alioth.debian.org/ contributed by Jarkko Miettinen */ class binarytrees { public int minDepth; public static void main(String[] args){ new binarytrees().init().run(19); } public binarytrees init(){ minDepth = 4; return this; } public void run(int n){ int maxDepth = 0; if (minDepth + 2 > n){ maxDepth = minDepth + 2; } else { maxDepth = n; } int stretchDepth = maxDepth + 1; int check = bottomUpTree(0,stretchDepth).itemCheck(); /*System.out.println("stretch tree of depth "+stretchDepth+"\t check: " + check);*/ System.out.println(stretchDepth); System.out.println(check); TreeNode longLivedTree = bottomUpTree(0,maxDepth); int depth = minDepth; while (depth <= maxDepth){ int iterations = new Math().pow(2, maxDepth - depth + minDepth); check = 0; int i = 1; while (i <= iterations){ check = check + (bottomUpTree(i,depth)).itemCheck(); check = check + (bottomUpTree(-i,depth)).itemCheck(); i = i + 1; } /*System.out.println((iterations*2) + "\t trees of depth " + depth + "\t check: " + check);*/ System.out.println(iterations * 2); System.out.println(depth); System.out.println(check); depth = depth + 2; } /*System.out.println("long lived tree of depth " + maxDepth + "\t check: "+ longLivedTree.itemCheck());*/ System.out.println(maxDepth); System.out.println(longLivedTree.itemCheck()); } public TreeNode bottomUpTree(int item, int depth){ if (depth>0){ return new TreeNode().init2( bottomUpTree(2*item-1, depth-1) , bottomUpTree(2*item, depth-1) , item ); } else { return new TreeNode().init(item); } } } class TreeNode { public TreeNode left; public TreeNode right; public int item; public TreeNode init(int item){ this.item = item; return this; } public TreeNode init2(TreeNode left, TreeNode right, int item){ this.left = left; this.right = right; this.item = item; return this; } public int itemCheck(){ if (left==null) return item; else return item + left.itemCheck() - right.itemCheck(); } }
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \ No newline at end of file
 /* * conways_game_of_life.mj -- Plays Conway's Game of Life. * * This is a simulator for Conway's Game of Life [1]. To get the maximum fun * out of it, you need a video terminal that understands ANSI escape sequences. * Then, piping the output of this program through a filter as explained in * `hello_world.mj` will show you a fancy animation of the game. If you cannot * get access to a terminal (emulator) that is capable of this, you can set the * variable `HAVE_ANSI` near the beginning of `main` to `false`. Then, the * output will not use ANSI escape codes but look rather sad. You'll probably * also want to reduce the iteration count in this case. Here are all * variables that you might want to tweak. * * - `HAVE_ANSI` -- whether ANSI escape codes are supported by the terminal * - `LINES` -- number of lines available on the terminal * - `COLUMNS` -- number of columns available on the terminal * - `ITERATIONS` -- number of iterations to play * - `RANDOM_SEED` -- random seed for initializing the game * * Since MiniJava has no way to suspend, this program deliberately uses an * inefficient strategy to print the output (knowing that terminals are * *really* slow at interpreting ANSI escape codes). This means that the * program will eat all your CPU while it is running. The update rate is about * alright on my PC but if your computer is much faster or much slower, you * might not enjoy the animation very much. * * [1] https://en.wikipedia.org/wiki/Conway's_Game_of_Life * */ class CWGOLMain { public static void main(String[] args) throws Exception { boolean HAVE_ANSI = true; int LINES = 24; int COLUMNS = 80; int ITERATIONS = 50000; int RANDOM_SEED = System.in.read(); Game g = new Game(); g.init(LINES - 2, COLUMNS / 2 - 1); LCG lcg = new LCG(); lcg.init(RANDOM_SEED); int i = 0; while (i < g.rows()) { int j = 0; while (j < g.columns()) { if (lcg.next() % 8 == 0) { g.set(i, j); } j = j + 1; } i = i + 1; } BoardPrinter bp = new BoardPrinter(); bp.init();