diff --git "a/Corpus/TEST_java_C2.csv" "b/Corpus/TEST_java_C2.csv" new file mode 100644--- /dev/null +++ "b/Corpus/TEST_java_C2.csv" @@ -0,0 +1,12637 @@ +C20082,"import java.util.*; +import java.io.*; + +class Frac +{ + public static int gcd(int u, int v) + { + while (v != 0) + { + int t = v; + v = u % v; + u = t; + } + return Math.abs(u); + } + + public int n; + public int d; + + public Frac(int n, int d) + { + int dd = gcd(n, d); + + this.n = n / dd; + this.d = d / dd; + } + + public Frac add(Frac other) + { + int tempn = this.n * other.d + other.n * this.d; + int tempd = this.d * other.d; + + return new Frac(tempn, tempd); + } + + public Frac sub(Frac other) + { + int tempn = this.n * other.d - other.n * this.d; + int tempd = this.d * other.d; + + return new Frac(tempn, tempd); + } + + public Frac mul(Frac other) + { + int tempn = this.n * other.n; + int tempd = this.d * other.d; + + return new Frac(tempn, tempd); + } + + public Frac div(Frac other) + { + int tempn = this.n * other.d; + int tempd = this.d * other.n; + + return new Frac(tempn, tempd); + } + + public double doubl() + { + return ((double) this.n) / this.d; + } + + public boolean eq(Frac other) + { + return this.n == other.n && this.d == other.d; + } + + public String toString() + { + return String.format(""%d/%d"", n, d); + } +} + +class Grid +{ + private int[] grid; + public int xsize; + public int ysize; + public int xstart = 0; + public int ystart = 0; + + public Grid(int xsize, int ysize) + { + this.xsize = xsize; + this.ysize = ysize; + + grid = new int[xsize * ysize]; + } + + public int get(int x, int y) + { + return grid[x + y * xsize]; + } + + public void set(int x, int y, int v) + { + grid[x + y * xsize] = v; + } + + public void write() + { + for (int y = 0; y < ysize; y++) + { + for (int x = 0; x < xsize; x++) + { + System.out.print("""" + get(x,y)); + } + System.out.println(); + } + } + + public Grid rotate() + { + Grid newg = new Grid(ysize, xsize); + for (int x = 0; x < xsize; x++) + { + for (int y = 0; y < ysize; y++) + { + int v = get(x,y); + int newx = ysize - y - 1; + int newy = x; + newg.set(newx, newy, v); + if (v == 2 && (newx % 2) == 1 && (newy % 2) == 1) + { + newg.xstart = newx; + newg.ystart = newy; + } + } + } + + return newg; + } +} + +public class D +{ + public static void main(String[] args) throws IOException + { + Scanner sc = new Scanner(System.in); + + int ncases = sc.nextInt(); + for (int caseno = 0; caseno < ncases; caseno++) + { + int ysize = sc.nextInt() * 2; + int xsize = sc.nextInt() * 2; + int maxdist = sc.nextInt() * 2; + + Grid g = new Grid(xsize, ysize); + + for (int y = 0; y < (ysize / 2); y++) + { + String row = sc.next(); + for (int x = 0; x < (xsize / 2); x++) + { + if (row.charAt(x) == '#') + { + g.set(x*2+0,y*2+0,1); + g.set(x*2+1,y*2+0,1); + g.set(x*2+1,y*2+1,1); + g.set(x*2+0,y*2+1,1); + } + else if (row.charAt(x) == 'X') + { + g.set(x*2+0,y*2+0,2); + g.set(x*2+1,y*2+0,2); + g.set(x*2+1,y*2+1,2); + g.set(x*2+0,y*2+1,2); + g.xstart = x * 2 + 1; + g.ystart = y * 2 + 1; + } + } + } + + int count = 0; + for (int i = 0; i < 4; i++) + { + // System.out.println("""" + g.xstart); + // System.out.println("""" + g.ystart); + // g.write(); + + for (int xdiff = 0; xdiff < maxdist+2; xdiff += 2) + { + for (int ydiff = 2; ydiff < maxdist+2; ydiff += 2) + { + if (xdiff * xdiff + ydiff * ydiff <= maxdist * maxdist) + { + boolean res = testray(g.xstart, g.ystart, xdiff, ydiff, g); + + if (res) + count += 1; + + } + } + } + + g = g.rotate(); + } + + System.out.printf(""Case #%d: %d\n"", caseno+1, count); + } + } + + public static boolean testray(int xstartt, int ystartt, int xdifff, int ydifff, Grid g) + { + //System.out.printf(""%d %d %d %d\n"", xstartt, ystartt, xdifff, ydifff); + + int xmirror = 1; + int ymirror = 1; + + int xgrid = xstartt; + int ygrid = ystartt; + Frac xend = new Frac(xstartt + xdifff, 1); + Frac yend = new Frac(ystartt + ydifff, 1); + + Frac xstart = new Frac(xstartt, 1); + Frac ystart = new Frac(ystartt, 1); + + //System.out.println("""" + xstart); + Frac xdiff = xend.sub(xstart); + Frac ydiff = yend.sub(ystart); + + Frac xslope = xdiff.div(ydiff); + Frac yslope = ydiff.div(xdiff); + + Frac xpos = xstart; + Frac ypos = ystart; + + while (true) + { + if (xpos.eq(xend) && ypos.eq(yend)) + { + break; + } + + int xcorner = xpos.n / xpos.d; + int ycorner = ypos.n / ypos.d; + + Frac yedge = new Frac(ycorner + 1, 1); + Frac xres = xpos.add(xslope.mul(yedge.sub(ypos))); + + Frac xedge = new Frac(xcorner + 1, 1); + Frac yres = ypos.add(yslope.mul(xedge.sub(xpos))); + + double h = (xres.sub(xpos)).doubl(); + double v = (xedge.sub(xpos)).doubl(); + + if (h < v) + { + xpos = xres; + ypos = yedge; + xcorner = xpos.n / xpos.d; + int xmod = xpos.n % xpos.d; + ycorner = ypos.n / ypos.d; + int ymod = ypos.n % ypos.d; + + if (xmod == 0) + { + ygrid += ymirror; + if (g.get(xgrid, ygrid) == 1) + { + ymirror *= -1; + ygrid += ymirror; + } + else if (g.get(xgrid, ygrid) == 2 && (ycorner % 2) == 1) + { + if (xpos.eq(xend) && ypos.eq(yend)) + { + return true; + } + else + { + return false; + } + } + } + else + { + ygrid += ymirror; + if (g.get(xgrid, ygrid) == 1) + { + ymirror *= -1; + ygrid += ymirror; + } + } + } + else if (v < h) + { + xpos = xedge; + ypos = yres; + xcorner = xpos.n / xpos.d; + int xmod = xpos.n % xpos.d; + ycorner = ypos.n / ypos.d; + int ymod = ypos.n % ypos.d; + + xgrid += xmirror; + if (g.get(xgrid, ygrid) == 1) + { + xmirror *= -1; + xgrid += xmirror; + } + } + else + { + xpos = xedge; + ypos = yedge; + xcorner = xpos.n / xpos.d; + int xmod = xpos.n % xpos.d; + ycorner = ypos.n / ypos.d; + int ymod = ypos.n % ypos.d; + + int blockE = g.get(xgrid + xmirror, ygrid); + int blockSE = g.get(xgrid + xmirror, ygrid + ymirror); + int blockS = g.get(xgrid, ygrid + ymirror); + + if (blockE == 2 && blockSE == 2 && blockS == 2) + { + if (xpos.eq(xend) && ypos.eq(yend)) + { + return true; + } + else + { + return false; + } + } + + if (blockE == 2) + blockE = 0; + if (blockSE == 2) + blockSE = 0; + if (blockS == 2) + blockS = 0; + + if (blockE == 0 && blockSE == 0 && blockS == 0) + { + xgrid += xmirror; + ygrid += ymirror; + } + else if (blockE == 1 && blockSE == 0 && blockS == 0) + { + xgrid += xmirror; + ygrid += ymirror; + } + else if (blockE == 1 && blockSE == 0 && blockS == 1) + { + xgrid += xmirror; + ygrid += ymirror; + } + else if (blockE == 0 && blockSE == 0 && blockS == 1) + { + xgrid += xmirror; + ygrid += ymirror; + } + else if (blockE == 0 && blockSE == 1 && blockS == 0) + { + return false; + } + else if (blockE == 1 && blockSE == 1 && blockS == 0) + { + xgrid += xmirror; + ygrid += ymirror; + xmirror *= -1; + xgrid += xmirror; + } + else if (blockE == 0 && blockSE == 1 && blockS == 1) + { + xgrid += xmirror; + ygrid += ymirror; + ymirror *= -1; + ygrid += ymirror; + } + else if (blockE == 1 && blockSE == 1 && blockS == 1) + { + xgrid += xmirror; + ygrid += ymirror; + xmirror *= -1; + ymirror *= -1; + xgrid += xmirror; + ygrid += ymirror; + } + + } + } + return false; + } +}" +C20025,"package j2012qualifier; + +import java.awt.Point; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.util.HashSet; +import java.util.Scanner; +import java.util.Set; + +public class D { + public static String inputDirectory=""src/j2012qualifier/""; + public static String inputFile=""D.in""; + public static String outputFile=""D.out""; + public static PrintWriter output; + public static char[][] room; + public static void main(String[] args) throws FileNotFoundException{ + Scanner s=new Scanner(new File(inputDirectory + inputFile)); + output=new PrintWriter(new File(inputDirectory + outputFile)); + int cases = s.nextInt(); + //size of each square + s.nextLine(); + for(int Case=1;Case<=cases;Case++){ + int H = s.nextInt(); + int W = s.nextInt(); + int D = s.nextInt(); + s.nextLine(); + room = new char[H][W]; + int x=0, y=0; + for(int i=0;i used = new HashSet(); + for(int i=-D; i<=D ;i++) { + for(int j=-D; j<=D; j++) { + int dx = j; + int dy = i; + if (dx == 0 && dy == 0) continue; + if (dx == 0) dy = (int)(dy / Math.sqrt(dy * dy)); + if (dy == 0) dx = (int)(dx / Math.sqrt(dx * dx)); + if(i != 0 && j!=0) { + int gcd = GCD(i, j); + gcd = gcd < 0 ? -gcd : gcd; + dx = j / gcd; + dy = i / gcd; + } + String key = dx+"",""+dy; + if (used.contains(key))continue; + used.add(key); + int lcm = dx*dy; + if ( dx == 0) { + lcm = dy; + } else if(dy == 0){ + lcm = dx; + } + lcm = lcm < 0 ? -lcm : lcm; + int startX = (2*x+1)*lcm; + int startY = (2*y+1)*lcm; + if(castRay(lcm, D * lcm * 2, startX, startY, dx, dy, startX, startY)) { + count++; + } + } + } + + output.printf(""Case #%d: %d\n"", Case, count); + } + output.flush(); + } + + public static int GCD(int a, int b) + { + if (b == 0) return a; + return GCD(b, a % b); + } + + public static boolean castRay(int lcm, double D, int x, int y, int dx, int dy, int gx, int gy) { + //out(D+ "" : (""+x+"",""+y+"") <""+dx+"",""+dy+"">""); + if (D<=0) { + return false; + } + int xSteps=1000, ySteps=1000; + if (dx > 0) { + xSteps = ((x / lcm) * lcm + lcm - x) / dx; + } else if(dx < 0) { + xSteps = (((x - 1) / lcm) * lcm - x) / dx; + } + if (dy > 0) { + ySteps = ((y / lcm) * lcm + lcm - y) / dy; + } else if(dy < 0) { + ySteps = (((y - 1) / lcm) * lcm - y) / dy; + } + int steps = Math.min(xSteps, ySteps); + double distance = steps * Math.sqrt(dx*dx + dy*dy); + if (distance > D) { + return false; + } + int newX = x+dx*steps; + int newY = y+dy*steps; + if (newX == gx && newY == gy) { + return true; + } + + //we are on a vertical line + boolean onVertical = (newX %(2*lcm) == 0); + boolean onHorizontal = (newY %(2*lcm) == 0); + int gridY = newY / (2 * lcm); + int gridX = newX / (2 * lcm); + int newDx = dx; + int newDy = dy; + + if (onVertical && onHorizontal) { + int tX = (dx < 0) ? gridX - 1 : gridX; + int tY = (dy < 0) ? gridY - 1 : gridY; + int cX = (tX == gridX) ? gridX - 1 : gridX; + int cY = (tY == gridY) ? gridY - 1 : gridY; + if(room[tY][tX] == '#') { + if(room[tY][cX] != '#' && room[cY][tX] != '#') { + //light destroyed + return false; + } + if (room[tY][cX] == '#'){ + newDy = -dy; + } + if (room[cY][tX] == '#'){ + newDx = -dx; + } + } + } else if(onVertical) { + gridX += (dx < 0) ? -1 : 0; + if(room[gridY][gridX] == '#') { + newDx = -dx; + } + } else if(onHorizontal) { + gridY += (dy < 0) ? -1 : 0; + if(room[gridY][gridX] == '#') { + newDy = -dy; + } + } + return castRay(lcm, D - distance, newX, newY, newDx, newDy, gx, gy); + } + + public static void out(String s){ + output.println(s); + System.out.println(s); + } +} +" +C20012," +public class CGConst { + public static final int INF = 99999999; + public static final double EPS = 1e-9; + public static final double pi = Math.PI; +} +" +C20069,"package com.brootdev.gcj2012.common; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.PrintWriter; + +public class DataUtils { + + public static int readIntLine(BufferedReader in) throws IOException { + return Integer.valueOf(in.readLine()); + } + + public static long readLongLine(BufferedReader in) throws IOException { + return Long.valueOf(in.readLine()); + } + + public static int[] readIntsArrayLine(BufferedReader in) throws IOException { + String[] numsS = in.readLine().split(""\\s+""); + int[] nums = new int[numsS.length]; + for (int i = 0; i < nums.length; i++) { + nums[i] = Integer.valueOf(numsS[i]); + } + return nums; + } + + public static long[] readLongsArrayLine(BufferedReader in) throws IOException { + String[] numsS = in.readLine().split(""\\s+""); + long[] nums = new long[numsS.length]; + for (int i = 0; i < nums.length; i++) { + nums[i] = Long.valueOf(numsS[i]); + } + return nums; + } + + public static void writeCaseHeader(PrintWriter out, long case_) { + out.print(""Case #""); + out.print(case_ + 1); + out.print("": ""); + } +} +" +C20039,"package jp.funnything.competition.util; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; + +import org.apache.commons.compress.archivers.zip.ZipArchiveEntry; +import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream; +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.FilenameUtils; +import org.apache.commons.io.IOUtils; + +public class Packer { + private static void add( final ZipArchiveOutputStream out , final File file , final int pathPrefix ) { + if ( file.isDirectory() ) { + final File[] children = file.listFiles(); + + if ( children.length > 0 ) { + for ( final File child : children ) { + add( out , child , pathPrefix ); + } + } else { + addEntry( out , file , pathPrefix , false ); + } + } else { + addEntry( out , file , pathPrefix , true ); + } + } + + private static void addEntry( final ZipArchiveOutputStream out , final File file , final int pathPrefix , final boolean isFile ) { + try { + out.putArchiveEntry( new ZipArchiveEntry( file.getPath().substring( pathPrefix ) + ( isFile ? """" : ""/"" ) ) ); + + if ( isFile ) { + final FileInputStream in = FileUtils.openInputStream( file ); + IOUtils.copy( in , out ); + IOUtils.closeQuietly( in ); + } + + out.closeArchiveEntry(); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + public static void pack( final File source , final File destination ) { + try { + final ZipArchiveOutputStream out = new ZipArchiveOutputStream( destination ); + + add( out , source , FilenameUtils.getPath( source.getPath() ).length() ); + + out.finish(); + out.close(); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } +} +" +C20031,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +/** + * + * @author jim + */ +public enum Square { + ME, + MIRROR, + EMPTY; + + public static Square parse(char in) { + if (in == '#') return MIRROR; + else if (in == '.') return EMPTY; + else if (in == 'X') return ME; + else return null; + } +} +" +C20003,"import java.io.*; +import java.util.*; + + +public class D { + + public static class Pair { + public int r; + public int c; + + public Pair(int r, int c) { + this.r = r; + this.c = c; + } + + @Override + public boolean equals(Object o) { + if (o == null) + return false; + if (!(o instanceof Pair)) + return false; + + Pair p = (Pair) o; + if (this.r == p.r && this.c == p.c) + return true; + else + return false; + } + } + + static char[][] d = new char[30][]; + static int H; + static int W; + static int D; + static int row; + static int column; + + public static void main(String[] args) throws Exception { + BufferedReader in = new BufferedReader(new FileReader(""D.in"")); + PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(""D.out""))); + + int n = Integer.parseInt(in.readLine()); + for (int i = 0; i < n; ++ i) { + String st = in.readLine(); + String[] input = st.split("" ""); + + H = Integer.parseInt(input[0]); + W = Integer.parseInt(input[1]); + D = Integer.parseInt(input[2]); + + for (int r = 0; r < H; ++ r) + d[r] = in.readLine().toCharArray(); + + for (int r = 0; r < H; ++ r) + for (int c = 0; c < W; ++ c) + if (d[r][c] == 'X') { + row = r; + column = c; + } + + List s = new ArrayList(); + int ans = 0; + for (int r = 1; r < D; ++ r) { + for (int c = 1; c < D; ++ c) { + int gcd = gcd(r, c); + int dr = r / gcd; + int dc = c / gcd; + Pair p = new Pair(dr, dc); + if (!s.contains(p)) { + s.add(p); + if (mapSearch(dr, dc, 1, 1)) + ++ ans; + if (mapSearch(dr, dc, 1, -1)) + ++ ans; + if (mapSearch(dr, dc, -1, 1)) + ++ ans; + if (mapSearch(dr, dc, -1, -1)) + ++ ans; + } + } + } + if (lineSearch(1, 0)) + ++ ans; + if (lineSearch(-1, 0)) + ++ ans; + if (lineSearch(0, 1)) + ++ ans; + if (lineSearch(0, -1)) + ++ ans; + + out.println(""Case #"" + (i + 1) + "": "" + ans); + } + + in.close(); + out.close(); + } + + private static boolean mapSearch(int dr, int dc, int dx, int dy) { + int x = 0; + int y = 0; + int posX = row; + int posY = column; + + while(Math.pow(x, 2) + Math.pow(y, 2) < Math.pow(D, 2)) { + if((x + 0.5) * dr < (y + 0.5) * dc) { + posX += dx; + x += 1; + if(d[posX][posY] == '#'){ + dx = -dx; + posX += dx; + } + } + else if((x + 0.5) * dr > (y + 0.5) * dc) { + posY += dy; + y += 1; + if(d[posX][posY] == '#'){ + dy = -dy; + posY += dy; + } + } + else { + x += 1; + y += 1; + posX += dx; + posY += dy; + if(d[posX][posY]=='#'){ + if(d[posX - dx][posY] == '#' && d[posX][posY - dy] == '#'){ + dx = -dx; + dy = -dy; + posX += dx; + posY += dy; + } + else if(d[posX - dx][posY] == '#'){ + dy = -dy; + posY += dy; + } + else if(d[posX][posY - dy] == '#'){ + dx = -dx; + posX += dx; + } + else{ + return false; + } + } + } + if(d[posX][posY] == 'X' && y * dc == x * dr + && Math.pow(x,2) + Math.pow(y,2) <= Math.pow(D,2)) { + return true; + } + } + + return false; + } + + public static boolean lineSearch(int dx, int dy){ + int posX = row; + int posY = column; + + for(int i = 0; i < D; ++ i){ + posX += dx; + posY += dy; + if(d[posX][posY] == '#'){ + dx = -dx; + dy = -dy; + posX += dx; + posY += dy; + } + if(d[posX][posY] == 'X'){ + return true; + } + } + return false; + } + + private static int gcd (int a, int b) { + if (b == 0) + return a; + else + return gcd(b, a % b); + } + +} +" +C20029,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +/** + * + * @author jim + */ +public class Ray { + + + private final Fraction expiryLengthSquared; + public RayVector vector; + + private FractionPoint currentLocation; + private Fraction xTravelled; + private Fraction yTravelled; + + public Ray(int expiryLengthSquared, RayVector vector, + FractionPoint startLocation) { + this.expiryLengthSquared = new Fraction(expiryLengthSquared); + this.vector = vector; + this.currentLocation = startLocation; + xTravelled = new Fraction(0, 1); + yTravelled = new Fraction(0, 1); + } + + public static FractionPoint locationChangeInSq(FractionPoint enter, RayVector v) { + Fraction xFrac = enter.x.fractionalPart(); + Fraction yFrac = enter.y.fractionalPart(); + Fraction xLen; + Fraction yLen; + if (xFrac.n == 0) { + xLen = new Fraction(1); + yLen = yFrac.n == 0 ? new Fraction(1) : + (v.y < 0 ? yFrac : new Fraction(1).substract(yFrac)); + } + else if (yFrac.n == 0) { + yLen = new Fraction(1); + xLen = xFrac.n == 0 ? new Fraction(1) : + (v.x < 0 ? xFrac : new Fraction(1).substract(xFrac)); + } + else { + yLen = v.y < 0 ? yFrac: new Fraction(1).substract(yFrac); + xLen = v.x < 0 ? xFrac: new Fraction(1).substract(xFrac); + } + Fraction scalar; + if (xLen.multiply(v.getScalarGardient()).compareTo(yLen) > 0) + scalar = yLen.divide(Math.abs(v.y)); + else + scalar = xLen.divide(Math.abs(v.x)); + FractionPoint fp = + new FractionPoint(scalar.multiply(v.x), scalar.multiply(v.y)); + return fp; + } + + public FractionPoint locationChangeInSq() { + return locationChangeInSq(currentLocation, vector); + } + + public boolean createsReflection(Hall h) { +// System.out.println(""\nRay: "" + vector.toString()); + Boolean b = null; + while (b == null) + b = step(h); +// System.out.println(b); + return b; + } + + public Boolean step(Hall h) { + FractionPoint locationChange = locationChangeInSq(); + if (locationChange.x.isInt() || locationChange.y.isInt()) { + FractionPoint changeToMid = new FractionPoint( + locationChange.x.divide(2), + locationChange.y.divide(2)); + FractionPoint midpoint = currentLocation.add(changeToMid); + if (midpoint.equals(h.meLocation)) { + xTravelled = xTravelled.add(changeToMid.x.abs()); + yTravelled = yTravelled.add(changeToMid.y.abs()); + return stillGoing(); + } + } + currentLocation = currentLocation.add(locationChange); + vector = h.processBoundary(currentLocation, vector); + if (vector == null) + return false; + xTravelled = xTravelled.add(locationChange.x.abs()); + yTravelled = yTravelled.add(locationChange.y.abs()); +// System.out.println(""Chng: "" + locationChange); +// System.out.println(""Loc: "" + currentLocation); +// System.out.println(""d: "" + distanceTravelled()); + if (!stillGoing()) + return false; + else + return null; + } + + private Fraction distanceTravelled() { + Fraction f = xTravelled.multiply(xTravelled).add( + yTravelled.multiply(yTravelled)); + return f; + } + + private boolean stillGoing() { + int compare = distanceTravelled().compareTo( + expiryLengthSquared); + return compare <= 0; + } + + public FractionPoint getCurrentLocation() { + return currentLocation; + } +} +" +C20040,"package jp.funnything.competition.util; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; + +import org.apache.commons.io.IOUtils; + +public class QuestionReader { + private final BufferedReader _reader; + + public QuestionReader( final File input ) { + try { + _reader = new BufferedReader( new FileReader( input ) ); + } catch ( final FileNotFoundException e ) { + throw new RuntimeException( e ); + } + } + + public void close() { + IOUtils.closeQuietly( _reader ); + } + + public String read() { + try { + return _reader.readLine(); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + public BigDecimal[] readBigDecimals() { + return readBigDecimals( "" "" ); + } + + public BigDecimal[] readBigDecimals( final String separator ) { + final String[] tokens = readTokens( separator ); + + final BigDecimal[] values = new BigDecimal[ tokens.length ]; + for ( int index = 0 ; index < tokens.length ; index++ ) { + values[ index ] = new BigDecimal( tokens[ index ] ); + } + + return values; + } + + public BigInteger[] readBigInts() { + return readBigInts( "" "" ); + } + + public BigInteger[] readBigInts( final String separator ) { + final String[] tokens = readTokens( separator ); + + final BigInteger[] values = new BigInteger[ tokens.length ]; + for ( int index = 0 ; index < tokens.length ; index++ ) { + values[ index ] = new BigInteger( tokens[ index ] ); + } + + return values; + } + + public int readInt() { + final int[] values = readInts(); + + if ( values.length != 1 ) { + throw new IllegalStateException( ""Try to read single interger, but the line contains zero or multiple values"" ); + } + + return values[ 0 ]; + } + + public int[] readInts() { + return readInts( "" "" ); + } + + public int[] readInts( final String separator ) { + final String[] tokens = readTokens( separator ); + + final int[] values = new int[ tokens.length ]; + for ( int index = 0 ; index < tokens.length ; index++ ) { + values[ index ] = Integer.parseInt( tokens[ index ] ); + } + + return values; + } + + public long readLong() { + final long[] values = readLongs(); + + if ( values.length != 1 ) { + throw new IllegalStateException( ""Try to read single interger, but the line contains zero or multiple values"" ); + } + + return values[ 0 ]; + } + + public long[] readLongs() { + return readLongs( "" "" ); + } + + public long[] readLongs( final String separator ) { + final String[] tokens = readTokens( separator ); + + final long[] values = new long[ tokens.length ]; + for ( int index = 0 ; index < tokens.length ; index++ ) { + values[ index ] = Long.parseLong( tokens[ index ] ); + } + + return values; + } + + public String[] readTokens() { + return readTokens( "" "" ); + } + + public String[] readTokens( final String separator ) { + return read().split( separator ); + } +} +" +C20035,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +/** + * + * @author jim + */ +public class Surround { + + private Square[][] surround; + + public Surround(Square[][] surround) { + this.surround = surround; + } + + public Square get(int x, int y) { + return surround[y][x]; + } + +} +" +C20045,"package jp.funnything.competition.util; + +import java.math.BigDecimal; + +/** + * Utility for BigDeciaml + */ +public class BD { + public static BigDecimal ZERO = BigDecimal.ZERO; + public static BigDecimal ONE = BigDecimal.ONE; + + public static BigDecimal add( final BigDecimal x , final BigDecimal y ) { + return x.add( y ); + } + + public static BigDecimal add( final BigDecimal x , final double y ) { + return add( x , v( y ) ); + } + + public static BigDecimal add( final double x , final BigDecimal y ) { + return add( v( x ) , y ); + } + + public static int cmp( final BigDecimal x , final BigDecimal y ) { + return x.compareTo( y ); + } + + public static int cmp( final BigDecimal x , final double y ) { + return cmp( x , v( y ) ); + } + + public static int cmp( final double x , final BigDecimal y ) { + return cmp( v( x ) , y ); + } + + public static BigDecimal div( final BigDecimal x , final BigDecimal y ) { + return x.divide( y ); + } + + public static BigDecimal div( final BigDecimal x , final double y ) { + return div( x , v( y ) ); + } + + public static BigDecimal div( final double x , final BigDecimal y ) { + return div( v( x ) , y ); + } + + public static BigDecimal mul( final BigDecimal x , final BigDecimal y ) { + return x.multiply( y ); + } + + public static BigDecimal mul( final BigDecimal x , final double y ) { + return mul( x , v( y ) ); + } + + public static BigDecimal mul( final double x , final BigDecimal y ) { + return mul( v( x ) , y ); + } + + public static BigDecimal sub( final BigDecimal x , final BigDecimal y ) { + return x.subtract( y ); + } + + public static BigDecimal sub( final BigDecimal x , final double y ) { + return sub( x , v( y ) ); + } + + public static BigDecimal sub( final double x , final BigDecimal y ) { + return sub( v( x ) , y ); + } + + public static BigDecimal v( final double value ) { + return BigDecimal.valueOf( value ); + } +} +" +C20052,"package jp.funnything.competition.util; + +import java.io.File; +import java.math.BigDecimal; +import java.math.BigInteger; + +import org.apache.commons.io.FileUtils; + +public class CompetitionIO { + private final QuestionReader _reader; + private final AnswerWriter _writer; + + /** + * Default constructor. Use latest ""*.in"" as input + */ + public CompetitionIO() { + this( null , null , null ); + } + + public CompetitionIO( final File input , final File output ) { + this( input , output , null ); + } + + public CompetitionIO( File input , File output , final String format ) { + if ( input == null ) { + for ( final File file : FileUtils.listFiles( new File( ""."" ) , new String[] { ""in"" } , false ) ) { + if ( input == null || file.lastModified() > input.lastModified() ) { + input = file; + } + } + + if ( input == null ) { + throw new RuntimeException( ""No *.in found"" ); + } + } + + if ( output == null ) { + final String inPath = input.getPath(); + + if ( !inPath.endsWith( "".in"" ) ) { + throw new IllegalArgumentException(); + } + + output = new File( inPath.replaceFirst( "".in$"" , "".out"" ) ); + } + + _reader = new QuestionReader( input ); + _writer = new AnswerWriter( output , format ); + } + + public CompetitionIO( final String format ) { + this( null , null , format ); + } + + public void close() { + _reader.close(); + _writer.close(); + } + + public String read() { + return _reader.read(); + } + + public BigDecimal[] readBigDecimals() { + return _reader.readBigDecimals(); + } + + public BigDecimal[] readBigDecimals( final String separator ) { + return _reader.readBigDecimals( separator ); + } + + public BigInteger[] readBigInts() { + return _reader.readBigInts(); + } + + public BigInteger[] readBigInts( final String separator ) { + return _reader.readBigInts( separator ); + } + + /** + * Read line as single integer + */ + public int readInt() { + return _reader.readInt(); + } + + /** + * Read line as multiple integer, separated by space + */ + public int[] readInts() { + return _reader.readInts(); + } + + /** + * Read line as multiple integer, separated by 'separator' + */ + public int[] readInts( final String separator ) { + return _reader.readInts( separator ); + } + + /** + * Read line as single integer + */ + public long readLong() { + return _reader.readLong(); + } + + /** + * Read line as multiple integer, separated by space + */ + public long[] readLongs() { + return _reader.readLongs(); + } + + /** + * Read line as multiple integer, separated by 'separator' + */ + public long[] readLongs( final String separator ) { + return _reader.readLongs( separator ); + } + + /** + * Read line as token list, separated by space + */ + public String[] readTokens() { + return _reader.readTokens(); + } + + /** + * Read line as token list, separated by 'separator' + */ + public String[] readTokens( final String separator ) { + return _reader.readTokens( separator ); + } + + public void write( final int questionNumber , final Object result ) { + _writer.write( questionNumber , result ); + } + + public void write( final int questionNumber , final String result ) { + _writer.write( questionNumber , result ); + } + + public void write( final int questionNumber , final String result , final boolean tee ) { + _writer.write( questionNumber , result , tee ); + } +} +" +C20073,"/* + * Main.java + * + * Created on 14.04.2012, 10:03:46 + * + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package codejam12; + +import qualification.CodeJamQuali; + +/** + * + * @author Besitzer + */ +public class Main { + + /** + * @param args the command line arguments + */ + /*public static void main(String[] args) { + char[] C = new char[26]; + CodeJamQuali CJQ =new CodeJamQuali(); + CJQ.fillDict(""our language is impossible to understand"",""ejp mysljylc kd kxveddknmc re jsicpdrysi"",C); + CJQ.fillDict(""there are twenty six factorial possibilities"",""rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd"",C); + CJQ.fillDict(""so it is okay if you want to just give up"",""de kr kd eoya kw aej tysr re ujdr lkgc jv"",C); + C['z'-'a']='q'; + C['q'-'a']='z'; + System.out.println(""abcdefghijklmnopqrstuvwxyz""); + System.out.println(C); + for(int i =0;i<26;i++)if(C[i]=='z')System.out.println(""found""); + + }*/ + + public static void main(String[] args) { + + CodeJamQuali CJQ =new CodeJamQuali(); + //CJQ.go(""src/qualification/A-small-attempt0.in"", 1); + CJQ.go(""src/qualification/D-large.in"", 4); + //System.out.println(new java.math.BigInteger(""2"").gcd(java.math.BigInteger.ZERO)); + } + +} +" +C20043,"package jp.funnything.competition.util; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; + +import org.apache.commons.compress.archivers.zip.ZipArchiveEntry; +import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream; +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.FilenameUtils; +import org.apache.commons.io.IOUtils; + +public class Packer { + private static void add( final ZipArchiveOutputStream out , final File file , final int pathPrefix ) { + if ( file.isDirectory() ) { + final File[] children = file.listFiles(); + + if ( children.length > 0 ) { + for ( final File child : children ) { + add( out , child , pathPrefix ); + } + } else { + addEntry( out , file , pathPrefix , false ); + } + } else { + addEntry( out , file , pathPrefix , true ); + } + } + + private static void addEntry( final ZipArchiveOutputStream out , final File file , final int pathPrefix , final boolean isFile ) { + try { + out.putArchiveEntry( new ZipArchiveEntry( file.getPath().substring( pathPrefix ) + ( isFile ? """" : ""/"" ) ) ); + + if ( isFile ) { + final FileInputStream in = FileUtils.openInputStream( file ); + IOUtils.copy( in , out ); + IOUtils.closeQuietly( in ); + } + + out.closeArchiveEntry(); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + public static void pack( final File source , final File destination ) { + try { + final ZipArchiveOutputStream out = new ZipArchiveOutputStream( destination ); + + add( out , source , FilenameUtils.getPath( source.getPath() ).length() ); + + out.finish(); + out.close(); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } +} +" +C20083,"import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; + + +public class QuestionD { + + public static void doPuzzle() { + try { + + File questionfile = new File(""D.in""); + BufferedReader questionreader = new BufferedReader(new FileReader(questionfile)); + + File answerfile = new File(""D.out""); + PrintWriter answerwriter = new PrintWriter(new BufferedWriter(new FileWriter(answerfile))); + + String[] params = null; + String question = questionreader.readLine(); + int T = Integer.parseInt(question); + int[] A = new int[T]; + int[] B = new int[T]; + + for (int i = 0; i < T; i++) { + question = questionreader.readLine(); + params = question.split("" ""); + int H = Integer.parseInt(params[0]); + int W = Integer.parseInt(params[1]); + int D = Integer.parseInt(params[2]); + String[] M = new String[H]; + for (int j = 0; j < H; j++) M[j] = questionreader.readLine(); + answerwriter.println(""Case #"" + (i+1) + "": "" + analyze(H, W, D, M)); + } + + answerwriter.close(); + questionreader.close(); + + } catch (FileNotFoundException e) { + e.printStackTrace(); + return; + } catch (IOException e) { + e.printStackTrace(); + return; + } + } + + private static int analyze(int H, int W, int D, String[] M) { + int CX = 0; + int CY = 0; + char[][] realMap = new char[H][W]; + for (int i = 0; i < H; i++) { + for (int j = 0; j < W; j++) { + char c = M[i].charAt(j); + realMap[i][j] = c; + if (c == 'X') { + CX = i; + CY = j; + } + } + } + + boolean[][] virtualMap = new boolean[D*2+1][D*2+1]; + + int answer = 0; + + for (int i = 0; i < D; i++) { + for (int j = 0; j <= D*2; j++) { + if (checkMirror(H, W, D, CX, CY, realMap, virtualMap, i, j)) answer++; + } + } + { + int i = D; + for (int j = 0; j < D; j++) { + if (checkMirror(H, W, D, CX, CY, realMap, virtualMap, i, j)) answer++; + } + for (int j = D*2; j > D; j--) { + if (checkMirror(H, W, D, CX, CY, realMap, virtualMap, i, j)) answer++; + } + } + for (int i = D*2; i > D; i--) { + for (int j = 0; j <= D*2; j++) { + if (checkMirror(H, W, D, CX, CY, realMap, virtualMap, i, j)) answer++; + } + } + + return answer; + } + + private static int[] delta = { 1, -1 }; + private static int[] reverse = { 1, 0 }; + private static boolean checkMirror(int H, int W, int D, int CX, int CY, char[][] realMap, boolean[][] virtualMap, int PX, int PY) { + if (virtualMap[PX][PY]) return false; + + int dx = Math.abs(PX - D); + int dy = Math.abs(PY - D); + if ((D * D) < (dx * dx + dy * dy)) return false; + + dx *= 2; + dy *= 2; + int rx = CX; + int ry = CY; + int drx = (PX > D) ? 0 : 1; + int dry = (PY > D) ? 0 : 1; + int dpx = drx; + int dpy = dry; + + if (dx > dy) { + for (int x = 1, oy = 0; x <= dx; x++) { + int y = (dy * x) / dx; + if ((((dy * x) % dx) == 0) && ((x % 2) == 0) && ((y % 2) == 0)) { + //到達フラグ + if (virtualMap[D+(x/2)*delta[dpx]][D+(y/2)*delta[dpy]]) return false; + virtualMap[D+(x/2)*delta[dpx]][D+(y/2)*delta[dpy]] = true; + //像判定 + if (realMap[rx][ry] == 'X') return true; + oy = y; + continue; + } else if (y > oy) { + oy = y; + if (((dy * x) % dx) == 0) { + if (((x % 2) == 1) && ((y % 2) == 1)) { + //角反射 + if (realMap[rx+delta[drx]][ry+delta[dry]] != '#') { + rx += delta[drx]; + ry += delta[dry]; + } else { + if (realMap[rx+delta[drx]][ry] != '#') rx += delta[drx]; + else drx = reverse[drx]; + if (realMap[rx][ry+delta[dry]] != '#') ry += delta[dry]; + else dry = reverse[dry]; + } + continue; + } + } + if ((y % 2) == 1) { + //y反射 + if (realMap[rx][ry+delta[dry]] != '#') ry += delta[dry]; + else dry = reverse[dry]; + } + } + if ((x % 2) == 1) { + //x反射 + if (realMap[rx+delta[drx]][ry] != '#') rx += delta[drx]; + else drx = reverse[drx]; + } + } + } else { + for (int y = 1, ox = 0; y <= dy; y++) { + int x = (dx * y) / dy; + if ((((dx * y) % dy) == 0) && ((x % 2) == 0) && ((y % 2) == 0)) { + //到達フラグ + if (virtualMap[D+(x/2)*delta[dpx]][D+(y/2)*delta[dpy]]) return false; + virtualMap[D+(x/2)*delta[dpx]][D+(y/2)*delta[dpy]] = true; + //像判定 + if (realMap[rx][ry] == 'X') return true; + ox = x; + continue; + } else if (x > ox) { + ox = x; + if (((dx * y) % dy) == 0) { + if (((x % 2) == 1) && ((y % 2) == 1)) { + //角反射 + if (realMap[rx+delta[drx]][ry+delta[dry]] != '#') { + rx += delta[drx]; + ry += delta[dry]; + } else { + if (realMap[rx+delta[drx]][ry] != '#') rx += delta[drx]; + else drx = reverse[drx]; + if (realMap[rx][ry+delta[dry]] != '#') ry += delta[dry]; + else dry = reverse[dry]; + } + continue; + } + } + if ((x % 2) == 1) { + //x反射 + if (realMap[rx+delta[drx]][ry] != '#') rx += delta[drx]; + else drx = reverse[drx]; + } + } + if ((y % 2) == 1) { + //y反射 + if (realMap[rx][ry+delta[dry]] != '#') ry += delta[dry]; + else dry = reverse[dry]; + } + } + } + + return false; + } + +} + +" +C20023,"package template; + +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; + +public class TestCase { + + private boolean isSolved; + private Object solution; + private Map intProperties; + private Map> intArrayProperties; + private Map>> intArray2DProperties; + private Map doubleProperties; + private Map> doubleArrayProperties; + private Map>> doubleArray2DProperties; + private Map stringProperties; + private Map> stringArrayProperties; + private Map>> stringArray2DProperties; + private Map booleanProperties; + private Map> booleanArrayProperties; + private Map>> booleanArray2DProperties; + private Map longProperties; + private Map> longArrayProperties; + private Map>> longArray2DProperties; + private int ref; + private double time; + + public TestCase() { + initialise(); + } + + private void initialise() { + isSolved = false; + intProperties = new HashMap<>(); + intArrayProperties = new HashMap<>(); + intArray2DProperties = new HashMap<>(); + doubleProperties = new HashMap<>(); + doubleArrayProperties = new HashMap<>(); + doubleArray2DProperties = new HashMap<>(); + stringProperties = new HashMap<>(); + stringArrayProperties = new HashMap<>(); + stringArray2DProperties = new HashMap<>(); + booleanProperties = new HashMap<>(); + booleanArrayProperties = new HashMap<>(); + booleanArray2DProperties = new HashMap<>(); + longProperties = new HashMap<>(); + longArrayProperties = new HashMap<>(); + longArray2DProperties = new HashMap<>(); + ref = 0; + } + + public void setSolution(Object o) { + solution = o; + isSolved = true; + } + + public Object getSolution() { + if (!isSolved) { + Utils.die(""getSolution on unsolved testcase""); + } + + return solution; + } + + public void setRef(int i) { + ref = i; + } + public int getRef() { + return ref; + } + + public void setTime(double d) { + time = d; + } + public double getTime() { + return time; + } + + public void setInteger(String s, Integer i) { + intProperties.put(s, i); + } + + public Integer getInteger(String s) { + return intProperties.get(s); + } + + public void setIntegerList(String s, ArrayList l) { + intArrayProperties.put(s, l); + } + + public void setIntegerMatrix(String s, ArrayList> l) { + intArray2DProperties.put(s, l); + } + + public ArrayList getIntegerList(String s) { + return intArrayProperties.get(s); + } + + public Integer getIntegerListItem(String s, int i) { + return intArrayProperties.get(s).get(i); + } + + public ArrayList> getIntegerMatrix(String s) { + return intArray2DProperties.get(s); + } + + public ArrayList getIntegerMatrixRow(String s, int row) { + return intArray2DProperties.get(s).get(row); + } + + public Integer getIntegerMatrixItem(String s, int row, int column) { + return intArray2DProperties.get(s).get(row).get(column); + } + + public ArrayList getIntegerMatrixColumn(String s, int column) { + ArrayList out = new ArrayList(); + + for(ArrayList row : intArray2DProperties.get(s)) { + out.add(row.get(column)); + } + return out; + } + + + public void setDouble(String s, Double i) { + doubleProperties.put(s, i); + } + + public Double getDouble(String s) { + return doubleProperties.get(s); + } + + public void setDoubleList(String s, ArrayList l) { + doubleArrayProperties.put(s, l); + } + + public void setDoubleMatrix(String s, ArrayList> l) { + doubleArray2DProperties.put(s, l); + } + + public ArrayList getDoubleList(String s) { + return doubleArrayProperties.get(s); + } + + public Double getDoubleListItem(String s, int i) { + return doubleArrayProperties.get(s).get(i); + } + + public ArrayList> getDoubleMatrix(String s) { + return doubleArray2DProperties.get(s); + } + + public ArrayList getDoubleMatrixRow(String s, int row) { + return doubleArray2DProperties.get(s).get(row); + } + + public Double getDoubleMatrixItem(String s, int row, int column) { + return doubleArray2DProperties.get(s).get(row).get(column); + } + + public ArrayList getDoubleMatrixColumn(String s, int column) { + ArrayList out = new ArrayList(); + + for(ArrayList row : doubleArray2DProperties.get(s)) { + out.add(row.get(column)); + } + return out; + } + + + public void setString(String s, String t) { + stringProperties.put(s, t); + } + + public String getString(String s) { + return stringProperties.get(s); + } + + public void setStringList(String s, ArrayList l) { + stringArrayProperties.put(s, l); + } + + public void setStringMatrix(String s, ArrayList> l) { + stringArray2DProperties.put(s, l); + } + + public ArrayList getStringList(String s) { + return stringArrayProperties.get(s); + } + + public String getStringListItem(String s, int i) { + return stringArrayProperties.get(s).get(i); + } + + public ArrayList> getStringMatrix(String s) { + return stringArray2DProperties.get(s); + } + + public ArrayList getStringMatrixRow(String s, int row) { + return stringArray2DProperties.get(s).get(row); + } + + public String getStringMatrixItem(String s, int row, int column) { + return stringArray2DProperties.get(s).get(row).get(column); + } + + public ArrayList getStringMatrixColumn(String s, int column) { + ArrayList out = new ArrayList(); + + for(ArrayList row : stringArray2DProperties.get(s)) { + out.add(row.get(column)); + } + return out; + } + + + public void setBoolean(String s, Boolean b) { + booleanProperties.put(s, b); + } + + public Boolean getBoolean(String s) { + return booleanProperties.get(s); + } + + public void setBooleanList(String s, ArrayList l) { + booleanArrayProperties.put(s, l); + } + + public void setBooleanMatrix(String s, ArrayList> l) { + booleanArray2DProperties.put(s, l); + } + + public ArrayList getBooleanList(String s) { + return booleanArrayProperties.get(s); + } + + public Boolean getBooleanListItem(String s, int i) { + return booleanArrayProperties.get(s).get(i); + } + + public ArrayList> getBooleanMatrix(String s) { + return booleanArray2DProperties.get(s); + } + + public ArrayList getBooleanMatrixRow(String s, int row) { + return booleanArray2DProperties.get(s).get(row); + } + + public Boolean getBooleanMatrixItem(String s, int row, int column) { + return booleanArray2DProperties.get(s).get(row).get(column); + } + + public ArrayList getBooleanMatrixColumn(String s, int column) { + ArrayList out = new ArrayList(); + + for(ArrayList row : booleanArray2DProperties.get(s)) { + out.add(row.get(column)); + } + return out; + } + + public void setLong(String s, Long b) { + longProperties.put(s, b); + } + + public Long getLong(String s) { + return longProperties.get(s); + } + + public void setLongList(String s, ArrayList l) { + longArrayProperties.put(s, l); + } + + public void setLongMatrix(String s, ArrayList> l) { + longArray2DProperties.put(s, l); + } + + public ArrayList getLongList(String s) { + return longArrayProperties.get(s); + } + + public Long getLongListItem(String s, int i) { + return longArrayProperties.get(s).get(i); + } + + public ArrayList> getLongMatrix(String s) { + return longArray2DProperties.get(s); + } + + public ArrayList getLongMatrixRow(String s, int row) { + return longArray2DProperties.get(s).get(row); + } + + public Long getLongMatrixItem(String s, int row, int column) { + return longArray2DProperties.get(s).get(row).get(column); + } + + public ArrayList getLongMatrixColumn(String s, int column) { + ArrayList out = new ArrayList(); + + for(ArrayList row : longArray2DProperties.get(s)) { + out.add(row.get(column)); + } + return out; + } + + + + + + +} +" +C20086,"//input file must be in.txt in this directory +//output file will be out.txt + +import java.io.*; +import java.util.*; +public class D +{ + public static Scanner in; + public static PrintStream out; + + public static void main(String [] args) throws Throwable + { + in = new Scanner(new File(""in.txt"")); + int cases = in.nextInt(); + in.nextLine(); + out = new PrintStream(new File(""out.txt"")); + for (int i = 1; i <= cases; i++) + { + out.print(""Case #"" + i + "": ""); + printResult(); + out.println(); + } + } + public static int gcd(int a, int b) + { + if (b == 0) + return a; + return gcd(b, a % b); + } + public static boolean canSeeImage(int dx, int dy, int lx, int ly, int d, boolean [][] house) + { + //System.out.println(""Trying ("" + dx + "","" + dy + ""):""); + int cx = lx; + int cy = ly; + int sx, sy; + if (dx > 0) + sx = 1; + else + sx = -1; + if (dy > 0) + sy = 1; + else + sy = -1; + dx = Math.abs(dx); + dy = Math.abs(dy); + int i = 0; + int totx = 0; + int toty = 0; + boolean t; + boolean mx,my; + boolean nx = false,ny = false; + while (totx*totx + toty*toty <= d*d) + { + if (dx == 0) + { + my = true; + mx = false; + t = true; + } + else + { + if (dy == 0) + { + mx = true; + my = false; + t = true; + } + else + { + mx = i % dy == 0; + my = i % dx == 0; + t = mx && my && !nx && !ny; + if (mx) + { + mx = nx; + nx = !nx; + } + if (my) + { + my = ny; + ny = !ny; + } + + } + } + + if (t && totx+toty > 0 && cx == lx && cy == ly) + return true; + + //if (mx || my) + // printHouse(lx,ly,cx,cy,house); + + if (mx) + totx++; + if (my) + toty++; + + if (mx && my) + { + if (house[cx + sx][cy + sy]) + { + if (house[cx][cy + sy]) + { + if (house[cx + sx][cy]) + { + sx = -sx; + sy = -sy; + } + else + { + sy = -sy; + cx += sx; + } + } + else + { + if (house[cx + sx][cy]) + { + sx = -sx; + cy += sy; + } + else + { + return false; + } + } + } + else + { + cx += sx; + cy += sy; + } + + } + else + { + if (mx) + { + if (house[cx + sx][cy]) + { + sx = -sx; + } + else + { + cx += sx; + } + } + if (my) + { + if (house[cx][cy + sy]) + { + sy = -sy; + } + else + { + cy += sy; + } + } + } + i++; + } + + return false; + } + public static void printHouse(int lx, int ly, int cx, int cy, boolean [][] house) + { + for (int y = 0; y < house[0].length; y++) + { + for (int x = 0; x < house.length; x++) + { + if (x == cx && y == cy) + { + System.out.print('*'); + } + else if (x == lx && y == ly) + { + System.out.print('X'); + } + else if (house[x][y]) + { + System.out.print('#'); + } + else + { + System.out.print(' '); + } + } + System.out.println(); + } + } + public static int[][] getPossibilities(int d) + { + ArrayList lx = new ArrayList(); + ArrayList ly = new ArrayList(); + + int h, v; + for (int x = -d; x <= d; x++) + { + for (int y = -d; y <= d; y++) + { + h = Math.abs(x); + v = Math.abs(y); + if (gcd(h,v) == 1 && h*h + v*v <= d*d) + { + lx.add(x); + ly.add(y); + } + } + } + + int [][] possibilities = new int [lx.size()][2]; + + for (int i = 0; i < possibilities.length; i++) + { + possibilities[i][0] = lx.get(i); + possibilities[i][1] = ly.get(i); + } + return possibilities; + } + public static void printResult() + { + int h,w,d,lx = 0,ly = 0; + h = in.nextInt(); + w = in.nextInt(); + d = in.nextInt(); + in.nextLine(); + String s; + boolean [][] house = new boolean[w][h]; + for (int y = 0; y < h; y++) + { + s = in.nextLine(); + for (int x = 0; x < w; x++) + { + house[x][y] = s.charAt(x) == '#'; + if (s.charAt(x) == 'X') + { + lx = x; + ly = y; + } + } + } + int [][] poss = getPossibilities(d); + int images = 0; + for (int i = 0; i < poss.length; i++) + { + if (canSeeImage(poss[i][0], poss[i][1], lx, ly, d, house)) + { + images++; + //System.out.println(""True""); + } + //else + //System.out.println(""False""); + } + out.print(images); + } +} +" +C20075,"import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.util.HashSet; +import java.util.Scanner; + +public class CodeJamD +{ + public static void main(String args[]) throws Exception + { + Scanner in = new Scanner(new File(""in.txt"")); + BufferedWriter out = new BufferedWriter(new FileWriter(""out.txt"")); + int cases = in.nextInt(); + for(int casenum = 1;casenum <= cases;casenum++) + { + int H = in.nextInt(); + int W = in.nextInt(); + int D = in.nextInt(); + in.nextLine(); + in.nextLine(); + + boolean x[][] = new boolean[2 * (H - 2)][2 * (W - 2)]; + int R = 0,C = 0; + + for(int n = 0;n < H - 2;n++) + { + String str = in.nextLine(); + for(int i = 0;i < W - 2;i++) + { + boolean b = false; + if(str.charAt(i + 1) == 'X') + { + R = n; + C = i; + b = true; + } + x[n][i] = b; + x[x.length - 1 - n][i] = b; + x[n][x[0].length - 1 - i] = b; + x[x.length - 1 - n][x[0].length - 1 - i] = b; + } + } + in.nextLine(); + + int count = 0; + HashSet set = new HashSet(); + for(int a = -D;a <= D;a++) + { + for(int b = -D;b <= D;b++) + { + if(a * a + b * b > D * D) + continue; + if(a == 0 && b == 0) + continue; + + if(x[(R + a + D * (x.length)) % (x.length)][(C + b + D * (x[0].length)) % (x[0].length)]) + { + int gcf = gcf(a,b); + int a2 = a/gcf; + int b2 = b/gcf; + String s = a2 + "" "" + b2; + + if(!set.contains(s)) + { + set.add(s); + count++; + } + } + } + } + out.write(""Case #"" + casenum + "": "" + count + ""\n""); + } + in.close(); + out.close(); + } + + public static int gcf(int a,int b) + { + if(a<0) + a = -a; + if(b<0) + b = -b; + if (b == 0) return a; + else return (gcf(b, a % b)); + } +}" +C20048,"package jp.funnything.competition.util; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; + +import org.apache.commons.io.IOUtils; + +public class AnswerWriter { + private static final String DEFAULT_FORMAT = ""Case #%d: %s\n""; + + private final BufferedWriter _writer; + private final String _format; + + public AnswerWriter( final File output , final String format ) { + try { + _writer = new BufferedWriter( new FileWriter( output ) ); + _format = format != null ? format : DEFAULT_FORMAT; + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + public void close() { + IOUtils.closeQuietly( _writer ); + } + + public void write( final int questionNumber , final Object result ) { + write( questionNumber , result.toString() , true ); + } + + public void write( final int questionNumber , final String result ) { + write( questionNumber , result , true ); + } + + public void write( final int questionNumber , final String result , final boolean tee ) { + try { + final String content = String.format( _format , questionNumber , result ); + + if ( tee ) { + System.out.print( content ); + System.out.flush(); + } + + _writer.write( content ); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } +} +" +C20074,"package codejam2012.q; + +import java.io.FileInputStream; +import java.io.IOException; +import java.io.PrintStream; +import java.util.Scanner; + +public class D +{ + static int H, W, D; + static char[][] hall; + static int startx, starty; + + static public int test(int dx, int dy, int dirx, int diry) + { +//System.out.println(""test "" + dx + ""/"" + dy + "" "" + dirx + ""/"" + diry); + int hx = startx, hy = starty; + int rx = dy, ry = dx; + int tx = 0, ty = 0; + + while( tx*tx + ty*ty <= D*D ){ + if( hx==startx && hy==starty && tx+ty>0 ){ + if( rx==2*dy && ry==dx+dy ) + return 1; + if( ry==2*dx && rx==dy+dx ) + return 1; + } + if( rx < ry ){ + ry -= rx; + rx = 2*dy; + if( hall[hx+dirx][hy]=='#' ){ + dirx = -dirx; + } else { + hx += dirx; + } + tx++; + } else + if( rx > ry ){ + rx -= ry; + ry = 2*dx; + if( hall[hx][hy+diry]=='#' ){ + diry = -diry; + } else { + hy += diry; + } + ty++; + } else + if( rx==ry ){ + rx = 2*dy; + ry = 2*dx; + if( hall[hx+dirx][hy+diry]!='#' ){ + hx += dirx; + hy += diry; + } else + if( hall[hx+dirx][hy]!='#' && hall[hx][hy+diry]!='#' ){ + return 0; + } else { + if( hall[hx+dirx][hy]=='#' ){ + dirx = -dirx; + } else { + hx += dirx; + } + if( hall[hx][hy+diry]=='#' ){ + diry = -diry; + } else { + hy += diry; + } + } + tx++; + ty++; + } + } + return 0; + } + + static public int multiTest(int x0, int y0, int x1, int y1) + { +//System.out.println(""multitest "" + x0 + ""/"" + y0 + "" "" + x1 + ""/"" + y1) ; + int count = 0; + int x2 = x0+x1; + int y2 = y0+y1; + + if( x2*x2 + y2*y2 <= D*D ){ + count += multiTest(x0, y0, x2, y2); + count += test(x2, y2, +1, +1); + count += test(x2, y2, +1, -1); + count += test(x2, y2, -1, +1); + count += test(x2, y2, -1, -1); + count += multiTest(x2, y2, x1, y1); + } + + return count; + } + + static public void solveOne(int caseNo, Scanner in, PrintStream out) + { + H = in.nextInt(); + W = in.nextInt(); + D = in.nextInt(); + in.nextLine(); + + hall = new char[W][H]; + for( int y=0 ; y testCases; + private int ref; + + public TestCaseSolver(ArrayList tcs, int ref) { + testCases = tcs; + this.ref = ref; + } + + public TestCaseSolver(TestCase tc, int ref) { + ArrayList tcs = new ArrayList<>(); + tcs.add(tc); + testCases = tcs; + this.ref = ref; + } + + public int getRef() { + return ref; + } + + @Override + public void run() { + for (TestCase tc : testCases) { + long startTime = System.nanoTime(); + solve(tc); + long duration = System.nanoTime() - startTime; + double secs = (double) duration / (1000000000d); + tc.setTime(secs); + System.out.println(""Thread "" + ref + "" solved testcase "" + tc.getRef() + "" in "" + String.format(""%.2f"", secs) + "" secs.""); + } + } + + private void solve(TestCase tc) { + int H = tc.getInteger(""H""); + int W = tc.getInteger(""W""); + int D = tc.getInteger(""D""); + ArrayList rows = tc.getStringList(""rows""); + + boolean[][] horizMirrors = new boolean[W+1][H+1]; //mirror from x,y to x+1,y + boolean[][] vertMirrors = new boolean[W + 1][H + 1]; //mirror from x,y to x+1,y + boolean[][] isMirrorCell = new boolean[W][H]; //mirror at x,y + + Pair myLoc = new Pair<>(0, 0); + int myX = 0; + int myY = 0; + for (int i = 0; i < H; i++) { + for (int j = 0; j < W; j++) { + if (rows.get(i).substring(j, j + 1).equals(""X"")) { + myLoc.setO1(j); + myX = j; + myLoc.setO2(H - i - 1); + myY = H - i - 1; + } + if (rows.get(i).substring(j, j + 1).equals(""#"")) { + isMirrorCell[j][H - i - 1] = true; + horizMirrors[j][H - i - 1] = true; + horizMirrors[j][H - i - 1 + 1] = true; + vertMirrors[j][H - i - 1] = true; + vertMirrors[j + 1][H - i - 1] = true; + } + + } + } + Utils.sout(""myLoc "" + myLoc); + Set angles = new HashSet<>(); + + for (int targetx = -D; targetx <= D; targetx++) { + for (int targety = -D; targety <= D; targety++) { + if (targetx == 0 && targety == 0) { + continue; + } + + boolean xflipped = false; + boolean yflipped = false; + + + int subgrid = Math.max(Math.abs(targetx), 1) * Math.max(Math.abs(targety), 1); + subgrid *= 2; + + int mySubX = myX * subgrid + subgrid / 2; + int mySubY = myY * subgrid + subgrid / 2; + + int xloc = mySubX; + int yloc = mySubY; + + double unitStep = Math.sqrt((double)targetx * (double)targetx + (double)targety * (double)targety); + int numStepsAllowed = (int)((double)D * (double)subgrid / unitStep); + + //walk + int steps = 0; + boolean seen = false; + boolean dead = false; + while (steps < numStepsAllowed && !seen && !dead) { + xloc += targetx * (xflipped ? -1 : 1); + yloc += targety * (yflipped ? -1 : 1); + + if (xloc == mySubX && yloc == mySubY) {seen = true;} + + //inner horiz edge + if(yloc % subgrid == 0 && xloc % subgrid != 0) { + if (horizMirrors[xloc / subgrid][yloc / subgrid]) {yflipped = !yflipped;} + } + + //inner vert edge + if(xloc % subgrid == 0 && yloc % subgrid != 0) { + if (vertMirrors[xloc / subgrid][yloc / subgrid]) {xflipped = !xflipped;} + } + + //corner + if(xloc % subgrid == 0 && yloc % subgrid == 0) { + int prevX = xloc - targetx * (xflipped ? -1 : 1); + int prevY = yloc - targety * (yflipped ? -1 : 1); + int nextX = xloc + targetx * (xflipped ? -1 : 1); + int nextY = yloc + targety * (yflipped ? -1 : 1); + + boolean nextBlock = isMirrorCell[nextX / subgrid][nextY / subgrid]; + boolean lastHoriz = horizMirrors[prevX / subgrid][yloc / subgrid]; + boolean lastVert = vertMirrors[xloc / subgrid][prevY / subgrid]; + + + if (lastVert && nextBlock) { + xflipped = !xflipped; + } + + if (lastHoriz && nextBlock) { + yflipped = !yflipped; + } + if (!lastHoriz && !lastVert && nextBlock) { + dead = true; + } + + + } + + + steps++; + + } //end while + + if (seen) { + double angle = Math.atan2((double)targety, (double)targetx); + angles.add(angle); + //System.out.println(""added "" + targetx + "" "" + targety + "" in "" + steps + "" steps "" + (steps * unitStep / subgrid) + "" dist.""); + } + + } //end y target + } //end x target + System.out.println(""total "" + angles.size()); + + tc.setSolution(new Integer(angles.size())); + } + + private double distance(Pair loc1, Pair loc2) { + int x = Math.abs(loc1.getO1() - loc2.getO1()); + int y = Math.abs(loc1.getO2() - loc2.getO2()); + if (y == 0) { + return (double) x; + } + if (x == 0) { + return (double) y; + } + return Math.sqrt((double) (x * x + y * y)); + } +} +" +C20021,"package template; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.util.ArrayList; + +public class TestCaseIO { + + public static ArrayList loadFromFile(String infile) { + //inc checks on #lines, length of splits, etc. + BufferedReader br = Utils.newBufferedReader(infile); + ArrayList tcList = new ArrayList<>(); + + //first line is N, the number of test cases + Integer N = Utils.readInteger(br); + + //cycle through N test cases + for (int x = 0; x < N; x++) { + TestCase tc = new TestCase(); + tc.setRef(x + 1); + + /////////////////////////////////////////////////////////// + //load properties - the bit to customise per problem + ArrayList l = Utils.readIntegerList(br, 3); + tc.setInteger(""H"", l.get(0)); + tc.setInteger(""W"", l.get(1)); + tc.setInteger(""D"", l.get(2)); + tc.setStringList(""rows"", Utils.readMultipleStrings(br, l.get(0))); + + /////////////////////////////////////////////////////////// + + tcList.add(tc); + } + + //confirm end of file + if (Utils.readLn(br) != null) { + Utils.die(""Unexpected text at end of infile""); + } + + return tcList; + } + + public static ArrayList mockUp() { + + ArrayList tcList = new ArrayList<>(); + for (int i = 0; i < 10; i++) { + TestCase tc = new TestCase(); + tc.setRef(i); + + int[] xs = Utils.randomIntegerArray(100, -50, 50, i * 2); + int[] ys = Utils.randomIntegerArray(100, -50, 50, i * 2 + 1); + tc.setIntegerList(""xs"", Utils.arrayToArrayList(xs)); + tc.setIntegerList(""ys"", Utils.arrayToArrayList(ys)); + + tcList.add(tc); + } + return tcList; + } + + public static void writeSolutions(ArrayList tcList, String outfile) { + + BufferedWriter bw = Utils.newBufferedWriter(outfile, false); + + for (int i = 0; i < tcList.size(); i++) { + TestCase tc = tcList.get(i); + Object solution = tc.getSolution(); + String line = ""Case #"" + (i + 1) + "": "" + solution.toString(); + Utils.writeLn(bw, line); + } + + Utils.closeBw(bw); + + } +} +" +C20044,"package jp.funnything.competition.util; + +import java.util.Comparator; + +import com.google.common.base.Objects; + +public class Pair< T1 , T2 > { + public static < T1 extends Comparable< T1 > , T2 extends Comparable< T2 > > Comparator< Pair< T1 , T2 > > getFirstComarator() { + return new Comparator< Pair< T1 , T2 > >() { + @Override + public int compare( final Pair< T1 , T2 > o1 , final Pair< T1 , T2 > o2 ) { + final int c = o1.first.compareTo( o2.first ); + return c != 0 ? c : o1.second.compareTo( o2.second ); + } + }; + } + + public static < T1 extends Comparable< T1 > , T2 extends Comparable< T2 > > Comparator< Pair< T1 , T2 > > getSecondComarator() { + return new Comparator< Pair< T1 , T2 > >() { + @Override + public int compare( final Pair< T1 , T2 > o1 , final Pair< T1 , T2 > o2 ) { + final int c = o1.second.compareTo( o2.second ); + return c != 0 ? c : o1.first.compareTo( o2.first ); + } + }; + } + + public T1 first; + public T2 second; + + public Pair( final Pair< T1 , T2 > that ) { + this.first = that.first; + this.second = that.second; + } + + public Pair( final T1 first , final T2 second ) { + this.first = first; + this.second = second; + } + + @Override + public boolean equals( final Object obj ) { + if ( this == obj ) { + return true; + } + + if ( obj == null || getClass() != obj.getClass() ) { + return false; + } + + final Pair< ? , ? > that = ( Pair< ? , ? > ) obj; + + return Objects.equal( this.first , that.first ) && Objects.equal( this.first , that.first ); + } + + @Override + public int hashCode() { + final int prime = 31; + + int result = 1; + result = prime * result + ( first == null ? 0 : first.hashCode() ); + result = prime * result + ( second == null ? 0 : second.hashCode() ); + + return result; + } + + @Override + public String toString() { + return ""Pair [first="" + first + "", second="" + second + ""]""; + } +} +" +C20066,"package jp.funnything.competition.util; + +import java.util.Comparator; + +import com.google.common.base.Objects; + +public class Pair< T1 , T2 > { + public static < T1 extends Comparable< T1 > , T2 extends Comparable< T2 > > Comparator< Pair< T1 , T2 > > getFirstComarator() { + return new Comparator< Pair< T1 , T2 > >() { + @Override + public int compare( final Pair< T1 , T2 > o1 , final Pair< T1 , T2 > o2 ) { + final int c = o1.first.compareTo( o2.first ); + return c != 0 ? c : o1.second.compareTo( o2.second ); + } + }; + } + + public static < T1 extends Comparable< T1 > , T2 extends Comparable< T2 > > Comparator< Pair< T1 , T2 > > getSecondComarator() { + return new Comparator< Pair< T1 , T2 > >() { + @Override + public int compare( final Pair< T1 , T2 > o1 , final Pair< T1 , T2 > o2 ) { + final int c = o1.second.compareTo( o2.second ); + return c != 0 ? c : o1.first.compareTo( o2.first ); + } + }; + } + + public T1 first; + public T2 second; + + public Pair( final Pair< T1 , T2 > that ) { + this.first = that.first; + this.second = that.second; + } + + public Pair( final T1 first , final T2 second ) { + this.first = first; + this.second = second; + } + + @Override + public boolean equals( final Object obj ) { + if ( this == obj ) { + return true; + } + + if ( obj == null || getClass() != obj.getClass() ) { + return false; + } + + final Pair< ? , ? > that = ( Pair< ? , ? > ) obj; + + return Objects.equal( this.first , that.first ) && Objects.equal( this.first , that.first ); + } + + @Override + public int hashCode() { + final int prime = 31; + + int result = 1; + result = prime * result + ( first == null ? 0 : first.hashCode() ); + result = prime * result + ( second == null ? 0 : second.hashCode() ); + + return result; + } + + @Override + public String toString() { + return ""Pair [first="" + first + "", second="" + second + ""]""; + } +} +" +C20041,"package jp.funnything.competition.util; + +import java.util.Arrays; +import java.util.Iterator; + +/** + * Do NOT change the element in iteration + */ +public class Permutation implements Iterable< int[] > , Iterator< int[] > { + public static int[] fromNumber( long value , final int n ) { + final int[] data = new int[ n ]; + + for ( int index = 0 ; index < n ; index++ ) { + data[ index ] = index; + } + + for ( int index = 1 ; index < n ; index++ ) { + final int pos = ( int ) ( value % ( index + 1 ) ); + + value /= index + 1; + + final int swap = data[ index ]; + data[ index ] = data[ pos ]; + data[ pos ] = swap; + } + + return data; + } + + public static long toNumber( final int[] perm ) { + final int[] data = Arrays.copyOf( perm , perm.length ); + + long c = 0; + + for ( int index = data.length - 1 ; index > 0 ; index-- ) { + int pos = 0; + for ( int index_ = 1 ; index_ <= index ; index_++ ) { + if ( data[ index_ ] > data[ pos ] ) { + pos = index_; + } + } + + final int t = data[ index ]; + data[ index ] = data[ pos ]; + data[ pos ] = t; + + c = c * ( index + 1 ) + pos; + } + + return c; + } + + private final int _n; + private final int[] _data; + private final int[] _count; + int _k; + + public Permutation( final int n ) { + _n = n; + + _data = new int[ n ]; + for ( int index = 0 ; index < n ; index++ ) { + _data[ index ] = index; + } + + _count = new int[ n + 1 ]; + for ( int index = 1 ; index <= n ; index++ ) { + _count[ index ] = index; + } + + _k = 1; + } + + @Override + public boolean hasNext() { + return _k < _n; + } + + @Override + public Iterator< int[] > iterator() { + return this; + } + + @Override + public int[] next() { + final int i = _k % 2 != 0 ? _count[ _k ] : 0; + + final int t = _data[ _k ]; + _data[ _k ] = _data[ i ]; + _data[ i ] = t; + + for ( _k = 1 ; _count[ _k ] == 0 ; _k++ ) { + _count[ _k ] = _k; + } + _count[ _k ]--; + + return _data; + } + + @Override + public void remove() { + } +} +" +C20068,"package com.brootdev.gcj2012.common; + +import java.io.*; + +public class Data { + + public final BufferedReader in; + public final PrintWriter out; + + public Data(String inFile, String outFile) throws IOException { + in = new BufferedReader(new FileReader(inFile)); + out = new PrintWriter(new BufferedWriter(new FileWriter(outFile))); + } + + public int readIntLine() throws IOException { + return DataUtils.readIntLine(in); + } + + public long readLongLine() throws IOException { + return DataUtils.readLongLine(in); + } + + public int[] readIntsArrayLine() throws IOException { + return DataUtils.readIntsArrayLine(in); + } + + public long[] readLongsArrayLine() throws IOException { + return DataUtils.readLongsArrayLine(in); + } + + public void writeCaseHeader(long case_) { + DataUtils.writeCaseHeader(out, case_); + } +} +" +C20017,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package problem.d.hall.of.mirrors; + +import java.io.File; +import java.io.IOException; +import java.io.PrintStream; +import java.util.Scanner; + +/** + * + * @author Park + */ +public class ProblemDHallOfMirrors { + + static int fixD; + static int count = 0; + static int s_X=0;static int s_Y=0; + + /** + * @param args the command line arguments + */ + public static void main(String[] args) throws IOException { + PrintStream out = new PrintStream(new File(""/Users/Park/Desktop/output.txt"")); + Scanner in = new Scanner(new File(""/Users/Park/Desktop/D-small-attempt1.in"")); + int testCase = Integer.parseInt(in.next()); + for (int n = 0; n < testCase; n++) { + int memCount = 0; + int H = Integer.parseInt(in.next()); + int W = Integer.parseInt(in.next()); + int D = Integer.parseInt(in.next()); + int fixH = (2 * H - 3); + int fixW = (2 * W - 3); + fixD = 2 * D; + int h0 = 0; + int w0 = 0; + search: + for (int i = 0; i < H; i++) { + String subMap = in.next(); + for (int j = 0; j < W; j++) { + String X = subMap.substring(j, j + 1); + if (X.equals(""X"")) { + h0 = 2 * i - 1; + w0 = 2 * j - 1; + } + } + } + int d_Left = w0; + int d_Right = fixW - w0-1; + int d_Up = h0; + int d_Down = fixH - h0-1; + double[] chkM = new double[250000]; + count=0; + //Right + calculate(2*d_Right,0,d_Right,d_Up,d_Left,d_Down,chkM); + memCount+=count; + count=0; + //Up + calculate(2*d_Up,0,d_Up,d_Left,d_Down,d_Right,chkM); + memCount+=count; + count=0; + //Left + calculate(2*d_Left,0,d_Left,d_Down,d_Right,d_Up,chkM); + memCount+=count; + count=0; + //Down + calculate(2*d_Down,0,d_Down,d_Right,d_Up,d_Left,chkM); + memCount+=count; + count=0; + + // + + // + out.println(""Case #"" + (n + 1) + "": "" + memCount); + System.out.println(""Case #"" + (n + 1) + "": "" + memCount); + } + in.close(); + out.close(); + } + + public static void calculate(int s_X,int s_Y, int tempx,int dy,int dx,int tempy, double[] chkM) { + boolean chk =true; + for(int i=0;i fixD * fixD) { + return; + }else if(chk){ + chkM[count]=((double)s_Y)/((double)s_X); + count++; + + }else{ + return; + } + calculate(s_X+2 * dx,s_Y,dx,dy,tempx,tempy,chkM); + calculate(s_X,s_Y+2 * dy,tempx,tempy,dx,dy,chkM); + + } +} +" +C20042,"package jp.funnything.prototype; + +import static java.lang.Math.abs; + +import java.io.File; +import java.io.IOException; + +import jp.funnything.competition.util.CompetitionIO; +import jp.funnything.competition.util.Packer; + +import org.apache.commons.io.FileUtils; +import org.apache.commons.math.fraction.Fraction; +import org.apache.commons.math.util.MathUtils; + +public class Runner { + public static void main( final String[] args ) throws Exception { + new Runner().run(); + } + + boolean isValid( final int d , final boolean[][] map , final int ox , final int oy , int dx , int dy ) { + final Fraction fox = new Fraction( ox * 2 + 1 ); + final Fraction foy = new Fraction( oy * 2 + 1 ); + Fraction x = new Fraction( ox * 2 + 1 ); + Fraction y = new Fraction( oy * 2 + 1 ); + + Fraction sumDiffX = new Fraction( 0 ); + Fraction sumDiffY = new Fraction( 0 ); + + for ( ; ; ) { + final Fraction diffX = + new Fraction( dx > 0 ? ( int ) Math.floor( x.doubleValue() + 1 ) : ( int ) Math.ceil( x.doubleValue() - 1 ) ).subtract( x ); + final Fraction diffY = + new Fraction( dy > 0 ? ( int ) Math.floor( y.doubleValue() + 1 ) : ( int ) Math.ceil( y.doubleValue() - 1 ) ).subtract( y ); + + if ( abs( diffX.doubleValue() * dy ) < abs( diffY.doubleValue() * dx ) ) { + x = x.add( diffX ); + y = y.add( diffX.multiply( dy ).divide( dx ) ); + sumDiffX = sumDiffX.add( diffX.abs() ); + sumDiffY = sumDiffY.add( diffX.multiply( dy ).divide( dx ).abs() ); + } else { + y = y.add( diffY ); + x = x.add( diffY.multiply( dx ).divide( dy ) ); + sumDiffY = sumDiffY.add( diffY.abs() ); + sumDiffX = sumDiffX.add( diffY.multiply( dx ).divide( dy ).abs() ); + } + + if ( sumDiffX.multiply( sumDiffX ).add( sumDiffY.multiply( sumDiffY ) ).compareTo( new Fraction( d * d * 2 * 2 ) ) > 0 ) { + return false; + } + + if ( x.equals( fox ) && y.equals( foy ) ) { + return true; + } + + final int nx = x.intValue() / 2 + ( dx > 0 ? 0 : -1 ); + final int ny = y.intValue() / 2 + ( dy > 0 ? 0 : -1 ); + + if ( x.getDenominator() == 1 && x.getNumerator() % 2 == 0 && y.getDenominator() == 1 && y.getNumerator() % 2 == 0 ) { + if ( map[ ny ][ nx ] ) { + final int px = x.intValue() / 2 + ( dx > 0 ? -1 : 0 ); + final int py = y.intValue() / 2 + ( dy > 0 ? -1 : 0 ); + + if ( map[ py ][ nx ] ) { + if ( map[ ny ][ px ] ) { + dx = -dx; + dy = -dy; + } else { + dx = -dx; + } + } else { + if ( map[ ny ][ px ] ) { + dy = -dy; + } else { + return false; + } + } + } + } else { + if ( x.getDenominator() == 1 && x.getNumerator() % 2 == 0 ) { + if ( map[ y.intValue() / 2 ][ nx ] ) { + dx = -dx; + } + } else if ( y.getDenominator() == 1 && y.getNumerator() % 2 == 0 ) { + if ( map[ ny ][ x.intValue() / 2 ] ) { + dy = -dy; + } + } + } + } + } + + void pack() { + try { + final File dist = new File( ""dist"" ); + + if ( dist.exists() ) { + FileUtils.deleteQuietly( dist ); + } + + final File workspace = new File( dist , ""workspace"" ); + + FileUtils.copyDirectory( new File( ""src/main/java"" ) , workspace ); + FileUtils.copyDirectory( new File( ""../../../../CompetitionUtil/Lib/src/main/java"" ) , workspace ); + + Packer.pack( workspace , new File( dist , ""sources.zip"" ) ); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + void run() throws Exception { + final CompetitionIO io = new CompetitionIO(); + + final int t = io.readInt(); + + for ( int index = 0 ; index < t ; index++ ) { + final int[] values = io.readInts(); + final int h = values[ 0 ]; + final int w = values[ 1 ]; + final int d = values[ 2 ]; + + final char[][] map = new char[ h ][]; + for ( int y = 0 ; y < h ; y++ ) { + final char[] l = io.read().toCharArray(); + + if ( l.length != w ) { + throw new RuntimeException( ""assert"" ); + } + + map[ y ] = l; + } + + io.write( index + 1 , solve( d , map ) ); + } + + io.close(); + + pack(); + } + + int solve( final int d , final char[][] map ) { + int count = 0; + + int ox = -1; + int oy = -1; + final boolean[][] parsed = new boolean[ map.length ][]; + + for ( int y = 0 ; y < map.length ; y++ ) { + parsed[ y ] = new boolean[ map[ y ].length ]; + + for ( int x = 0 ; x < map[ y ].length ; x++ ) { + final char c = map[ y ][ x ]; + + if ( c == '#' ) { + parsed[ y ][ x ] = true; + } + + if ( c == 'X' ) { + ox = x; + oy = y; + } + } + } + + for ( int dy = -d ; dy <= d ; dy++ ) { + for ( int dx = -d ; dx <= d ; dx++ ) { + if ( dx == 0 && dy == 0 ) { + continue; + } + + if ( MathUtils.gcd( dx , dy ) != 1 ) { + continue; + } + + if ( dx * dx + dy * dy > d * d ) { + continue; + } + + if ( isValid( d , parsed , ox , oy , dx , dy ) ) { + count++; + } + } + } + + return count; + } +} +" +C20013,"import java.awt.Color; +import java.awt.Graphics2D; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.*; + +import javax.imageio.ImageIO; + +class findRes +{ + double angle; + double x,y; + double d; + int gridx, gridy; + boolean found = false; +} +public class Main { + public static int X, Y, D; + public static char[][] mat; + public static final double [] starts = new double[]{0,Math.PI/2, Math.PI, Math.PI*3/2}; + public static final double EPS = CGConst.EPS; + public static double posx, posy; + public static int dblcmp(double d1, double d2) + { + if(Math.abs(d1-d2) mirrors; + public static void main(String[] args) throws IOException { + FileInputStream fis = new FileInputStream(new File(""in.txt"")); + FileOutputStream fos = new FileOutputStream(new File(""out.txt"")); + Scanner sc = new Scanner(fis); + PrintWriter out = new PrintWriter(fos); + int cases = sc.nextInt(); + for(int cs = 1; cs <= cases; cs++) + { + Y = sc.nextInt(); + X = sc.nextInt(); + D = sc.nextInt(); + mat = new char[Y][X]; + sc.nextLine(); + mirrors = new ArrayList(); + int cnt = 0; + for(int i=0; i used = new TreeSet(new Comparator(){ + + @Override + public int compare(Double arg0, Double arg1) { + arg0 = adjust(arg0); + arg1 = adjust(arg1); + return dblcmp(arg0, arg1); + } + + }); + for(double start : starts) + { + for(double s1 = 0; s1 <=D; s1++) + for(double s2=1; s2<=D; s2++) + { + double r = Math.sqrt(s1*s1+s2*s2); + + if(dblcmp(r,D)<=0) + { + double angle = start + Math.atan(s1/s2); + if(used.contains(angle)) + continue; + else + used.add(angle); + List xlist = new ArrayList(); + List ylist = new ArrayList(); + + double curx = posx, cury = posy; + double curd = D; + int gridx = (int)posx; + int gridy = (int)posy; + while(dblcmp(curd, 0)>0) + { + xlist.add(curx); + ylist.add(cury); + + findRes fr=find(angle, curx, cury, curd,gridx,gridy); + if(fr.found) + { + cnt++; +// double ang=adjust(start + Math.atan(s1/s2)); +// System.out.println(ang); +// for(int i=0; i xlist, List ylist, int size,String name) { + int w = size*X, h = size*Y; + BufferedImage bi = new BufferedImage(w, h,BufferedImage.TYPE_INT_ARGB); + + Graphics2D g = bi.createGraphics(); + for(int i=0; i= Math.PI*2) + arg0 -= Math.PI*2; + while(arg0 < 0) + arg0 += Math.PI*2; + return arg0; + } + final static double[][] sides = new double[][]{ + {0,1,1,1},{1,0,1,1},{0,0,1,0},{0,0,0,1} + }; + final static double [] toadd = new double[]{0,Math.PI,0,Math.PI}; + final static int [][] nextSide = new int[][]{ + {0,1},{1,0},{0,-1},{-1,0} + }; + final static int [][] nextSideTwo = new int[13][2]; + static + { + nextSideTwo[2] = new int[]{1,1}; + nextSideTwo[6] = new int[]{1,-1}; + nextSideTwo[12] = new int[]{-1,-1}; + nextSideTwo[4] = new int[]{-1,1}; + } + private static findRes find(double angle, double curx, double cury, double curd, int gridx, int gridy) + { + Point start = new Point(curx, cury); + Point end = new Point(curx + curd*Math.cos(angle), cury + curd*Math.sin(angle)); + while(gridx >= 0 && gridx < X && gridy >=0 && gridy < Y) + { + if(gridx == (int)posx && gridy == (int)posy) + { + Point ori = new Point(posx, posy); + if(!start.equals(ori)&&CG.intersectSP(start, end, ori)) + { + findRes fr = new findRes(); + fr.found = true; + return fr; + } + } + // center? + List sideList = new ArrayList(); + Point inter = null; + + for(int i=0; i=0 && nextx < X && nexty >=0 && nexty < Y) + { + if(mat[nexty][nextx] == '#') + { + fr.angle = toadd[sideList.get(0)]-angle; + return fr; + } + else + { + gridx = nextx; + gridy = nexty; + start = inter; + } + } + else + { + fr.d = 0; + return fr; + } + } + else if(sideList.size() == 2) + { + boolean [] found = new boolean[3]; + for(int i=0; i=0 && nextx < X && nexty >=0 && nexty < Y) + { + if(mat[nexty][nextx] == '#') + { + found[i] = true; + } + else + found[i] = false; + } + else + found[i] = false; + } + int nextx = gridx+nextSideTwo[(sideList.get(0)+1)*(sideList.get(1)+1)][0]; + int nexty = gridy+nextSideTwo[(sideList.get(0)+1)*(sideList.get(1)+1)][1]; + if(nextx>=0 && nextx < X && nexty >=0 && nexty < Y) + { + if(mat[nexty][nextx] == '#') + { + found[2] = true; + } + else + found[2] = false; + } + else + found[2] = false; + if(found[0] && found[1] && found[2]) + { + fr.angle = angle+Math.PI; + return fr; + } + else if(!found[2]) + { + gridx = nextx; + gridy = nexty; + start = inter; + } + else if(found[0]) + { + gridx += nextSide[sideList.get(1)][0]; + gridy += nextSide[sideList.get(1)][1]; + fr.gridx = gridx; + fr.gridy = gridy; + fr.angle = toadd[sideList.get(0)]-angle; + return fr; + } + else if(found[1]) + { + gridx += nextSide[sideList.get(0)][0]; + gridy += nextSide[sideList.get(0)][1]; + fr.gridx = gridx; + fr.gridy = gridy; + fr.angle = toadd[sideList.get(1)]-angle; + return fr; + } + else + { + fr.d = 0; + return fr; + } + } + else + { + System.out.println(""fuck""); + } + } + findRes fr = new findRes(); + fr.d = 0; + return fr; + } + private static findRes find(double angle, double curx, double cury, double curd) { + + final double MAX = 100; + Point start = new Point(curx, cury); + Point end = new Point(curx + curd*Math.cos(angle), cury + curd*Math.sin(angle)); + if(dblcmp(curx, posx)!=0 || dblcmp(cury, posy) != 0) + { + Point ori = new Point(posx, posy); + double dis = ori.minus(start).abs(); + if(CG.intersectSP(start, end, ori)) + { + boolean found = false; + for(double [] arr:mirrors) + { + + for(int i=0; i interSides = new ArrayList(); + List interMirrors = new ArrayList(); + for(double [] arr:mirrors) + { + + for(int i=0; i used = new TreeSet(); + int rep = -1; + for(Integer side:interSides) + { + if(used.contains(side)) + rep = side; + else + used.add(side); + } + if(used.size() == 4) + res.angle = angle; + else + { + res.angle = toadd[rep]-angle; + } + } + else if(interMirrors.size() == 6) + { + res.angle = angle+Math.PI; + } + else + { + System.out.println(""fuck""); + } + return res; + } +} +" +C20000,"import static java.lang.Math.*; + +import java.io.*; +import java.util.*; + +/** + * @author Chris Dziemborowicz + * @version 2012.0415 + */ +public class HallOfMirrors +{ + public static void main(String[] args) + throws Exception + { + // Get input files + File dir = new File(""/Users/Chris/Documents/UniSVN/code-jam/hall-of-mirrors/data""); + File[] inputFiles = dir.listFiles(new FilenameFilter() { + @Override + public boolean accept(File dir, String name) + { + return name.endsWith("".in""); + } + }); + + // Process each input file + for (File inputFile : inputFiles) { + System.out.printf(""Processing \""%s\""...\n"", inputFile.getName()); + + String outputPath = inputFile.getPath().replaceAll(""\\.in$"", "".out""); + BufferedWriter writer = new BufferedWriter(new FileWriter(outputPath)); + + Scanner scanner = new Scanner(inputFile); + System.out.printf(""Number of test cases: %s\n"", scanner.nextLine()); + + int count = 0; + while (scanner.hasNext()) { + int h = scanner.nextInt(); + int w = scanner.nextInt(); + int d = scanner.nextInt(); + scanner.nextLine(); + String[] map = new String[h]; + for (int i = 0; i < h; i++) { + map[i] = scanner.nextLine(); + } + + String output = String.format(""Case #%d: %d\n"", ++count, process(h, w, d, map)); + + System.out.print(output); + writer.write(output); + } + + writer.close(); + System.out.println(""Done.\n""); + } + + // Compare to reference files (if any) + for (File inputFile : inputFiles) { + System.out.printf(""Verifying \""%s\""...\n"", inputFile.getName()); + + String referencePath = inputFile.getPath().replaceAll(""\\.in$"", "".ref""); + String outputPath = inputFile.getPath().replaceAll(""\\.in$"", "".out""); + + File referenceFile = new File(referencePath); + if (referenceFile.exists()) { + InputStream referenceStream = new FileInputStream(referencePath); + InputStream outputStream = new FileInputStream(outputPath); + + boolean matched = true; + int referenceRead, outputRead; + do { + byte[] referenceBuffer = new byte[4096]; + byte[] outputBuffer = new byte[4096]; + + referenceRead = referenceStream.read(referenceBuffer); + outputRead = outputStream.read(outputBuffer); + + matched = referenceRead == outputRead + && Arrays.equals(referenceBuffer, outputBuffer); + } while (matched && referenceRead != -1); + + if (matched) { + System.out.println(""Verified.\n""); + } else { + System.out.println(""*** NOT VERIFIED ***\n""); + } + } else { + System.out.println(""No reference file found.\n""); + } + } + } + + + public static int process(int h, int w, int d, String[] map) + { + int x = -1, y = -1; + for (int xx = 0; xx < map.length; xx++) { + int yy = map[xx].indexOf('X'); + if (yy != -1) { + x = xx; + y = yy; + } + } + + int count = 0; + for (int i = -100; i <= 100; i++) { + for (int j = -100; j <= 100; j++) { + int gcd = gcd(i, j); + if (gcd == 1 || (i == 0 && abs(j) == 1) || (j == 0 && abs(i) == 1)) { + count += process(map, x, y, i, j, d); + } + } + } + return count; + } + + + public static int process(String[] map, int sx, int sy, int dx, int dy, int d) + { + int x = sx; + int y = sy; + + int xs = 0; + int ys = 0; + + int err = abs(dx) - abs(dy); + + while (true) { + if (err > 0) { + x += dx > 0 ? 1 : -1; + xs++; + err -= 2 * abs(dy); + if (map[x].charAt(y) == '#') { + dx = -dx; + x += dx > 0 ? 1 : -1; + } + } else if (err < 0) { + y += dy > 0 ? 1 : -1; + ys++; + err += 2 * abs(dx); + if (map[x].charAt(y) == '#') { + dy = -dy; + y += dy > 0 ? 1 : -1; + } + } else { + int ox = x; + x += dx > 0 ? 1 : -1; + xs++; + err -= 2 * abs(dy); + + int oy = y; + y += dy > 0 ? 1 : -1; + ys++; + err += 2 * abs(dx); + + if (map[x].charAt(y) == '#') { + if (map[ox].charAt(y) != '#' && map[x].charAt(oy) != '#') { + return 0; + } else if (map[ox].charAt(y) == '#' && map[x].charAt(oy) == '#') { + dx = -dx; + x += dx > 0 ? 1 : -1; + + dy = -dy; + y += dy > 0 ? 1 : -1; + } else if (map[ox].charAt(y) == '#') { + dy = -dy; + y += dy > 0 ? 1 : -1; + } else { + dx = -dx; + x += dx > 0 ? 1 : -1; + } + } + } + + if ((dx == 0 || xs % dx == 0) && (dy == 0 || ys % dy == 0)) { + if (sqrt(xs * xs + ys * ys) > d) { + return 0; + } else if (map[x].charAt(y) == 'X') { + return 1; + } + } + } + } + + + public static int gcd(int a, int b) + { + if (a == 0 || b == 0) { + return -1; + } + + a = abs(a); + b = abs(b); + + while (a != 0 && b != 0) { + if (a > b) { + a %= b; + } else { + b %= a; + } + } + + return a == 0 ? b : a; + } +}" +C20071,"package qual; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.FileReader; +import java.io.FileWriter; +import java.util.ArrayList; +import java.util.List; + + +public class D { + + static class Ray{ + // directions + public static byte U = 0; // up + public static byte L = 1; // left + public static byte C = 2; // left-up (corner) + // for printing + private static char[] SYMB = new char[]{'u', 'l', 'c'}; + + // replace l -> u, u -> l, to build symmetric ray + private static byte[] REPL = new byte[]{L, U, C}; + + private final int mDdeep; + private final int mDlength; + private byte[] mDirs; + private int dL = +1; + private int dU = +1; + private int mC = 0; + + public Ray(int ddeep, int dlength, byte[] dirs){ + mDdeep = ddeep; + mDlength = dlength; + mDirs = dirs; + } + + public Ray(Ray ray){ + mDdeep = ray.mDdeep; + mDlength = ray.mDlength; + mDirs = ray.mDirs; + dL = ray.dL; + dU = ray.dU; + mC = ray.mC; + } + public void revertU(){ + dU *= -1; + } + + public void revertL(){ + dL *= -1; + } + + public Ray(int ddeep, int dlength, int l, int u){ + mDdeep = ddeep; + mDlength = dlength; + + List res = new ArrayList(); + int la = l * 2; + //int ua = u * 2; + int cu = 0; + for (int t = 1; t < la; t += 2){ + if (t * u % l == 0 && t * u / l % 2 == 1) { + // corner move + res.add(Ray.C); + cu++; + } else { + if (t*u / l > 2*cu){ + res.add(Ray.U); + cu++; + } + res.add(Ray.L); + } + } + mDirs = new byte[res.size()]; + for (int i = 0; i < res.size(); i++){ + mDirs[i] = res.get(i); + } + } + + //produce symmetric ray + public Ray symm(){ + byte[] dirs = new byte[mDirs.length]; + for(int i = 0; i < mDirs.length; i++){ + dirs[i] = REPL[mDirs[i]]; + } + return new Ray(mDdeep, mDlength, dirs); + } + + public String toString(){ + StringBuilder res = new StringBuilder(); + for (int i = 0; i < mDirs.length; i++){ + res.append(SYMB[mDirs[i]]); + } + return res.toString(); + } + + public boolean trace(int x, int y, char[][] field){ + int n = 0; + while (true){ + // still parsing + if (mC < mDirs.length){ + byte dir = mDirs[mC]; + int nx = dir == U ? x : x + dL; + int ny = dir == L ? y : y + dU; + if (field[ny][nx] == '#'){ + //mirror processing + if (dir == L){ + revertL(); + } else if (dir == U){ + revertU(); + } else { + // corner processing + char lc = field[y][nx]; + char uc = field[ny][x]; + if (lc == '#' && uc == '#'){ + revertU(); + revertL(); + } else if (lc == '#'){ + y = ny; + revertL(); + } else if (uc == '#'){ + x = nx; + revertU(); + } else { + // destroy ray + return false; + } + } + } else { + x = nx; + y = ny; + } + mC++; + } else { + // we are reach ray's end + // check if we hit X + n++; + if (field[y][x] == 'X' && n*n*mDlength <= mDdeep) return true; + + if (n*n*mDlength < mDdeep){ + // can continue ray + mC = 0; + } else { + // can not reach X + return false; + } + } + } + } + } + public static String printField(char[][] data){ + StringBuilder s = new StringBuilder(); + for (int i = 0; i < data.length; i++){ + for (int j = 0; j < data[i].length; j++){ + s.append(data[i][j]); + } + s.append(""\n""); + } + return s.toString(); + } + public static List createAll(int deep){ + List rays = new ArrayList(); + int ddeep = deep * deep; + boolean [][] points = new boolean[deep + 1][deep]; + for (int l = 1; l <= deep; l++){ + for (int u = 0; u < l; u++){ + // check point not covered already + if (points[l][u]) continue; + // check length + int dlength = l*l + u*u; + if (dlength > ddeep) continue; + + //cover points by this ray + int t = 1; + while (l*t < deep + 1 && u*t < deep){ + points[l*t][u*t] = true; + t++; + } + // build ray and it's symmetric ray + Ray ray = new Ray(ddeep, dlength, l, u); + rays.add(ray); + rays.add(ray.symm()); + } + } + rays.add(new Ray(ddeep, 2, new byte[]{Ray.C})); + int t = rays.size(); + for (int i = 0; i < t; i++){ + Ray r = rays.get(i); + if (r.mDirs.length > 1 || r.mDirs[0] == Ray.C){ + Ray ar = new Ray(r); + ar.revertL(); + ar.revertU(); + rays.add(ar); + } + if (r.mDirs.length > 1 || r.mDirs[0] != Ray.U){ + Ray ar = new Ray(r); + ar.revertL(); + rays.add(ar); + } + if (r.mDirs.length > 1 || r.mDirs[0] != Ray.L){ + Ray ar = new Ray(r); + ar.revertU(); + rays.add(ar); + } + } + return rays; + } + + public static void main(String[] args) throws Exception { + /*List rays = createAll(7); + for (Ray r : rays){ + System.out.println(r); + }*/ + String in_file = ""q/d/l_in.txt""; + String out_file = in_file.replace(""_in.txt"", ""_out.txt""); + BufferedReader in = new BufferedReader(new FileReader(in_file)); + BufferedWriter out = new BufferedWriter(new FileWriter(out_file)); + + int n = Integer.parseInt(in.readLine()); + for (int i = 1; i <= n; i++){ + String[] s = in.readLine().split("" ""); + int h = Integer.parseInt(s[0]); + int w = Integer.parseInt(s[1]); + int d = Integer.parseInt(s[2]); + int x = -1, y = -1; + char[][] field = new char[h][w]; + for (int j = 0; j < h; j++){ + String fline = in.readLine(); + for (int k = 0; k < w; k++){ + field[j][k] = fline.charAt(k); + if (field[j][k] == 'X'){ + x = k; + y = j; + } + } + } + List rays = createAll(d); + int count = 0; + for (Ray r : rays){ + // trace ray + if (r.trace(x, y, field)) { + //System.out.println(r); + count++; + } + } + out.write(""Case #"" + i + "": "" + count + ""\n""); + } + + in.close(); + out.close(); + + } + +} +" +C20010,"import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; +import java.util.Stack; + + +public class codejamp4 { + public static char[] map; + public static void main(String[] args) throws IOException{ + readFile(); + } + + public static int getTriple(int c, int a){ + return (int)Math.floor(Math.sqrt(Math.pow(c, 2)-Math.pow(a, 2))); + } + public static int calcGCF(int a, int b) { + int s; + if (a > b) + s = b; + else + s = a; + for (int i = s; i > 0; i--) { + if ((a%i == 0) && (b%i == 0)) + return i; + } + return -1; + } + public static int mapSearch(char[][] map, int height, int width, int distance, int horizontal, int vertical, + int posX, int posY,int dx,int dy){ + int x = 0; + int y = 0; + while(Math.pow(x, 2)+Math.pow(y, 2)(y+0.5)*horizontal){ + posY+=dy; + y+=1; + if(map[posX][posY]=='#'){ + dy=-dy; + posY+=dy; + } + } + else{ + x+=1; + y+=1; + posX+=dx; + posY+=dy; + if(map[posX][posY]=='#'){ + if(map[posX-dx][posY]=='#' && map[posX][posY-dy]=='#'){ + dx=-dx; + dy=-dy; + posX+=dx; + posY+=dy; + } + else if(map[posX-dx][posY]=='#'){ + dy=-dy; + posY+=dy; + } + else if(map[posX][posY-dy]=='#'){ + dx=-dx; + posX+=dx; + } + else{ + return 0; + } + } + } + if(map[posX][posY]=='X' && y*horizontal==x*vertical && + Math.pow(x,2)+Math.pow(y,2)<=Math.pow(distance,2)){ + return 1; + } + } + return 0; + } + public static int lineSearch(char[][] map, int height, int width, int distance, + int posx, int posy, int dx, int dy){ + if(posx<0 || posy<0) + return 0; + for(int i=1; i<=distance; i++){ + posx+=dx; + posy+=dy; + if(map[posx][posy]=='#'){ + dx=-dx; + dy=-dy; + posx+=dx; + posy+=dy; + } + if(map[posx][posy]=='X'){ + return 1; + } + } + return 0; + } + public static int getResult(char[][] map, int height, int width, int distance){ + int count=0; + int posx=-1; + int posy=-1; + for(int i = 0;i exist=new ArrayList(); + for(int horizontal = 1; horizontal D || performTileMove()) { + userHitLast = false; + break; + } + +// logger.info(String.format(""posX=%f, posY=%f, velX=%f, velY=%f, dist=%f"", +// localX + tileX, localY + tileY, velX, velY, dist)); + } + } + + if (firstRayHit && userHitLast) { + userHits--; + } + + data.out.println(userHits); + } + + private void performLocalMove() { + if (velX > 0) { + distDelta = (1 - localX) / velX; + newLocalY = localY + velY * distDelta; + if (newLocalY >= 0 && newLocalY <= 1) { + newLocalX = 1; + if (velY > 0 && newLocalY >= 1 - currErr) { + newLocalY = 1; + localMoveStatus = LocalMoveStatus.BOTTOMRIGHT; + } else if (velY < 0 && newLocalY <= currErr) { + newLocalY = 0; + localMoveStatus = LocalMoveStatus.TOPRIGHT; + } else { + localMoveStatus = LocalMoveStatus.RIGHT; + } + return; + } + } + if (velX < 0) { + distDelta = - localX / velX; + newLocalY = localY + velY * distDelta; + if (newLocalY >= 0 && newLocalY <= 1) { + newLocalX = 0; + if (velY > 0 && newLocalY >= 1 - currErr) { + newLocalY = 1; + localMoveStatus = LocalMoveStatus.BOTTOMLEFT; + } else if (velY < 0 && newLocalY <= currErr) { + newLocalY = 0; + localMoveStatus = LocalMoveStatus.TOPLEFT; + } else { + localMoveStatus = LocalMoveStatus.LEFT; + } + return; + } + } + if (velY > 0) { + distDelta = (1 - localY) / velY; + newLocalY = 1; + newLocalX = localX + velX * distDelta; + if (velX > 0 && newLocalX >= 1 - currErr) { + newLocalX = 1; + localMoveStatus = LocalMoveStatus.BOTTOMRIGHT; + } else if (velX < 0 && newLocalX <= currErr) { + newLocalX = 0; + localMoveStatus = LocalMoveStatus.BOTTOMLEFT; + } else { + localMoveStatus = LocalMoveStatus.BOTTOM; + } + return; + } + if (velY < 0) { + distDelta = - localY / velY; + newLocalY = 0; + newLocalX = localX + velX * distDelta; + if (velX > 0 && newLocalX >= 1 - currErr) { + newLocalX = 1; + localMoveStatus = LocalMoveStatus.TOPRIGHT; + } else if (velX < 0 && newLocalX <= currErr) { + newLocalX = 0; + localMoveStatus = LocalMoveStatus.TOPLEFT; + } else { + localMoveStatus = LocalMoveStatus.TOP; + } + return; + } + } + + private boolean checkUserHit() { + if (dist == 0 || tileX != userTileX || tileY != userTileY) { + return false; + } + + final double avalDist = D - dist + currErr; + if (Math.abs(velX) <= currErr) { + if (avalDist >= .5 && Math.abs(.5 - localX) <= currErr) { + doUserHit(); + return true; + } + return false; + } + if (Math.abs(velY) <= currErr) { + if (avalDist >= .5 && Math.abs(.5 - localY) <= currErr) { + doUserHit(); + return true; + } + return false; + } + + if (avalDist < Math.sqrt(Math.pow(localX - .5, 2) + Math.pow(localY - .5, 2))) { + return false; + } + + final double a = velY / velX; + final double b = localY - a * localX; + + if (Math.abs(a * .5 + b - .5) <= currErr || Math.abs((.5 - b) / a - .5) <= currErr) { + doUserHit(); + return true; + } + +// final double w = velY / velX; +// final double A = 1.0 / (w * localY - localX); +// final double B = - w * A; +// final double d = Math.abs((A + B) * .5 + 1) / Math.sqrt(A * A + B * B); + +// if (d <= sensDist) { +// doUserHit(); +// return true; +// } + + return false; + } + + private void doUserHit() { + if (! userHitLast) { + userHits++; + if (currentRay == 0) { + firstRayHit = true; + } + +// logger.info(String.format(""Hit! case=%d, ray=%d"", currentCase, currentRay)); + } + userHitLast = true; + } + + private boolean performTileMove() { + localX = newLocalX; + localY = newLocalY; + + switch (localMoveStatus) { + case TOPLEFT: + if (tiles[tileY - 1][tileX - 1] != TileType.MIRROR) { + tileX--; + tileY--; + localX = 1; + localY = 1; + return false; + } else if (tiles[tileY - 1][tileX] != TileType.MIRROR && tiles[tileY][tileX - 1] != TileType.MIRROR) { + return true; + } + break; + case TOPRIGHT: + if (tiles[tileY - 1][tileX + 1] != TileType.MIRROR) { + tileX++; + tileY--; + localX = 0; + localY = 1; + return false; + } else if (tiles[tileY - 1][tileX] != TileType.MIRROR && tiles[tileY][tileX + 1] != TileType.MIRROR) { + return true; + } + break; + case BOTTOMLEFT: + if (tiles[tileY + 1][tileX - 1] != TileType.MIRROR) { + tileX--; + tileY++; + localX = 1; + localY = 0; + return false; + } else if (tiles[tileY + 1][tileX] != TileType.MIRROR && tiles[tileY][tileX - 1] != TileType.MIRROR) { + return true; + } + break; + case BOTTOMRIGHT: + if (tiles[tileY + 1][tileX + 1] != TileType.MIRROR) { + tileX++; + tileY++; + localX = 0; + localY = 0; + return false; + } else if (tiles[tileY + 1][tileX] != TileType.MIRROR && tiles[tileY][tileX + 1] != TileType.MIRROR) { + return true; + } + break; + } + + if (localMoveStatus.isTop) { + if (tiles[tileY - 1][tileX] == TileType.MIRROR) { + velY = -velY; + } else { + tileY--; + localY = 1; + } + } + if (localMoveStatus.isBottom) { + if (tiles[tileY + 1][tileX] == TileType.MIRROR) { + velY = -velY; + } else { + tileY++; + localY = 0; + } + } + if (localMoveStatus.isLeft) { + if (tiles[tileY][tileX - 1] == TileType.MIRROR) { + velX = -velX; + } else { + tileX--; + localX = 1; + } + } + if (localMoveStatus.isRight) { + if (tiles[tileY][tileX + 1] == TileType.MIRROR) { + velX = -velX; + } else { + tileX++; + localX = 0; + } + } + + return false; + } + + private enum TileType { + EMPTY, MIRROR, USER + } + + private enum LocalMoveStatus { + TOP(true, false, false, false), + BOTTOM(false, true, false, false), + LEFT(false, false, true, false), + RIGHT(false, false, false, true), + TOPLEFT(true, false, true, false), + TOPRIGHT(true, false, false, true), + BOTTOMLEFT(false, true, true, false), + BOTTOMRIGHT(false, true, false, true); + + public final boolean isTop; + public final boolean isBottom; + public final boolean isLeft; + public final boolean isRight; + + private LocalMoveStatus(boolean top, boolean bottom, boolean left, boolean right) { + isTop = top; + isBottom = bottom; + isLeft = left; + isRight = right; + } + } +} +" +C20055,"package jp.funnything.competition.util; + +import java.util.Arrays; +import java.util.Iterator; + +/** + * Do NOT change the element in iteration + */ +public class Permutation implements Iterable< int[] > , Iterator< int[] > { + public static int[] fromNumber( long value , final int n ) { + final int[] data = new int[ n ]; + + for ( int index = 0 ; index < n ; index++ ) { + data[ index ] = index; + } + + for ( int index = 1 ; index < n ; index++ ) { + final int pos = ( int ) ( value % ( index + 1 ) ); + + value /= index + 1; + + final int swap = data[ index ]; + data[ index ] = data[ pos ]; + data[ pos ] = swap; + } + + return data; + } + + public static long toNumber( final int[] perm ) { + final int[] data = Arrays.copyOf( perm , perm.length ); + + long c = 0; + + for ( int index = data.length - 1 ; index > 0 ; index-- ) { + int pos = 0; + for ( int index_ = 1 ; index_ <= index ; index_++ ) { + if ( data[ index_ ] > data[ pos ] ) { + pos = index_; + } + } + + final int t = data[ index ]; + data[ index ] = data[ pos ]; + data[ pos ] = t; + + c = c * ( index + 1 ) + pos; + } + + return c; + } + + private final int _n; + private final int[] _data; + private final int[] _count; + int _k; + + public Permutation( final int n ) { + _n = n; + + _data = new int[ n ]; + for ( int index = 0 ; index < n ; index++ ) { + _data[ index ] = index; + } + + _count = new int[ n + 1 ]; + for ( int index = 1 ; index <= n ; index++ ) { + _count[ index ] = index; + } + + _k = 1; + } + + @Override + public boolean hasNext() { + return _k < _n; + } + + @Override + public Iterator< int[] > iterator() { + return this; + } + + @Override + public int[] next() { + final int i = _k % 2 != 0 ? _count[ _k ] : 0; + + final int t = _data[ _k ]; + _data[ _k ] = _data[ i ]; + _data[ i ] = t; + + for ( _k = 1 ; _count[ _k ] == 0 ; _k++ ) { + _count[ _k ] = _k; + } + _count[ _k ]--; + + return _data; + } + + @Override + public void remove() { + } +} +" +C20077,"import java.awt.Point; +import java.util.Scanner; + +public class Mirrors { + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int cases = scan.nextInt(); + for (int trial = 1; trial <= cases; trial++) { + System.out.print(""Case #"" + trial + "": ""); + int height = scan.nextInt() * 2; + int width = scan.nextInt() * 2; + int d = scan.nextInt() * 2; + boolean[][] map = new boolean[height][width]; + scan.nextLine(); + Point myPos = null; + for (int row = 0; row < height; row += 2) { + char[] line = scan.nextLine().toCharArray(); + for (int c = 0; c < line.length; c++) { + int col = c * 2; + map[row][col] = map[row + 1][col] = map[row][col + 1] = map[row + 1][col + 1] = (line[c] == '#'); + if (line[c] == 'X') { + myPos = new Point(col + 1, row + 1); + } + } + } + int count = 0; + for (int dr = -d; dr <= d; dr++) { + for (int dc = -d; dc <= d; dc++) { + if (dr * dr + dc * dc >= d * d || !relPrime(dr, dc)) + continue; + FracVec init = new FracVec(new Frac(dr), new Frac(dc)); + FracVec dm = init; + FracVec next = dm.add(init); + while (next.compareLengthTo(d) <= 0) { + dm = next; + next = dm.add(init); + } + Frac t = Frac.ZERO; + FracVec pos = new FracVec(myPos); + do { + Frac nextRow = pos.row.roundAddSig(dm.row); + Frac nextCol = pos.col.roundAddSig(dm.col); + Frac addRowT = intersectRowTAdd(pos, dm, nextRow); + Frac addColT = intersectColTAdd(pos, dm, nextCol); + Frac addT; + if (dm.row.isZero()) + addT = addColT; + else if (dm.col.isZero()) + addT = addRowT; + else { + if (addRowT.compareTo(addColT) < 0) + addT = addRowT; + else + addT = addColT; + } + t = t.add(addT); + pos = pos.add(dm.multiply(addT)); + if (pos.equals(myPos)) { + count++; + break; + } + if (pos.isCorner()) { + Point farCorn = getMidCorn(pos, dm); + boolean fc = map[farCorn.y][farCorn.x]; + Point vertCorn = getVertCorn(pos, dm); + boolean vc = map[vertCorn.y][vertCorn.x]; + Point horizCorn = getHorizCorn(pos, dm); + boolean hc = map[horizCorn.y][horizCorn.x]; + if (fc) { + boolean found = false; + if (vc) { + dm = dm.flipHoriz(); + found = true; + } + if (hc) { + dm = dm.flipVert(); + found = true; + } + if (!found) + break; + } + } else { + Point cell = pos.getNextCell(dm); + boolean isWall = map[cell.y][cell.x]; + if (isWall) { + if (pos.row.denom == 1) { + assert pos.col.denom > 1; + dm = dm.flipVert(); + } else if (pos.col.denom == 1) { + assert pos.row.denom > 1; + dm = dm.flipHoriz(); + } else + assert false; + } + } + } while (t.compareTo(Frac.ONE) < 0); + } + } + System.out.println(count); + } + } + + private static Point getMidCorn(FracVec pos, FracVec dm) { + return pos.getNextCell(dm); + } + + private static Point getVertCorn(FracVec pos, FracVec dm) { + return pos.getNextCell(dm.flipVert()); + } + + private static Point getHorizCorn(FracVec pos, FracVec dm) { + return pos.getNextCell(dm.flipHoriz()); + } + + private static boolean relPrime(int dr, int dc) { + int gcd = Frac.gcd(dr, dc); + return Math.abs(gcd) == 1; + } + + private static Frac intersectColTAdd(FracVec pos, FracVec dm, Frac nextCol) { + if (nextCol == null) + return null; + else + return nextCol.sub(pos.col).div(dm.col); + } + + private static Frac intersectRowTAdd(FracVec pos, FracVec dm, Frac nextRow) { + if (nextRow == null) + return null; + else + return nextRow.sub(pos.row).div(dm.row); + } +} +" +C20024,"package pl.helman.codejam.Hall; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; + +public class Hall { + + private static int checkSpecialCases(boolean[][] map, int startX, + int startY, int d) { + int ret = 0; + + // horizontal to left + int x = startX, y = startY; + // traveled distance + int a = 0; + while (!map[x][y]) { + x--; + a++; + } + if (2 * a <= d) { + ret++; + } + + x = startX; + y = startY; + // traveled distance + a = 0; + while (!map[x + 1][y]) { + x++; + a++; + } + if (2 * a <= d) { + ret++; + } + + x = startX; + y = startY; + // traveled distance + a = 0; + while (!map[x][y]) { + y--; + a++; + } + if (2 * a <= d) { + ret++; + } + + x = startX; + y = startY; + // traveled distance + a = 0; + while (!map[x][y + 1]) { + y++; + a++; + } + if (2 * a <= d) { + ret++; + } + + return ret; + } + + private static boolean checkRay(boolean[][] map, int startX, int startY, + int d, int dirX, int dirY) { + + int den = Math.abs(dirX * dirY); + int lx = startX * den; + int ly = startY * den; + + int t = 0; + + while (true) { + + // seeking for next lines distance + int lineDistX = dirX < 0 ? (lx % den) : (den - lx % den); + if (lineDistX == 0) { + lineDistX = den; + } + lineDistX = Math.abs(lineDistX / dirX); + + int lineDistY = dirY < 0 ? (ly % den) : (den - ly % den); + if (lineDistY == 0) { + lineDistY = den; + } + lineDistY = Math.abs(lineDistY / dirY); + + // moving to closest line + if (lineDistX < lineDistY) { + lx += lineDistX * dirX; + ly += lineDistX * dirY; + } else { + lx += lineDistY * dirX; + ly += lineDistY * dirY; + } + + if (lx % den == 0 && ly % den == 0) { + // full vector repetition + + // increase traveled distance + t++; + + if (t * t * (dirX * dirX + dirY * dirY) > d * d) { + return false; + } + + // check if it's not starting point + if (lx == startX * den && ly == startY * den) { + + return true; + } + + // corners + int x = lx / den; + int y = ly / den; + + boolean wall = false; + // vertical wall + if ((map[x][y] && map[x][y + 1]) + || (map[x + 1][y] && map[x + 1][y + 1])) { + dirX = -dirX; + wall = true; + } + + // horizontal wall + if ((map[x][y] && map[x + 1][y]) + || (map[x][y + 1] && map[x + 1][y + 1])) { + dirY = -dirY; + wall = true; + } + + if (!wall && map[dirX > 0 ? x + 1 : x][dirY > 0 ? y + 1 : y]) { + // dead corner + return false; + } + + } else { + // possible mirror + if (lx % den == 0 + && map[dirX < 0 ? (lx / den) : ((lx / den) + 1)][(ly / den) + 1]) { + // vertical wall + dirX = -dirX; + } else if (ly % den == 0 + && map[(lx / den) + 1][dirY < 0 ? (ly / den) + : ((ly / den) + 1)]) { + // horizontal wall + dirY = -dirY; + } + } + } + } + + public static int egcd(int a, int b) { + if (a == 0) + return b; + + while (b != 0) { + if (a > b) + a = a - b; + else + b = b - a; + } + + return a; + } + + public static void main(String[] args) throws IOException { + + FileReader fr = new FileReader(""d:\\hall.in""); + BufferedReader br = new BufferedReader(fr); + String s = br.readLine(); + + FileWriter f0 = new FileWriter(""d:\\hall.out""); + + int t = Integer.parseInt(s.trim()); + + for (int i = 1; i <= t; i++) { + s = br.readLine(); + String[] elems = s.split("" ""); + int h = Integer.parseInt(elems[0]); + int w = Integer.parseInt(elems[1]); + int d = Integer.parseInt(elems[2]) * 2; + + int startX = -1; + int startY = -1; + + int ret = 0; + + boolean[][] map = new boolean[2 * w][2 * h]; + + // loading map + for (int y = 0; y < h; y++) { + s = br.readLine(); + for (int x = 0; x < w; x++) { + if (s.charAt(x) == '#') { + map[2 * x][2 * y] = true; + map[2 * x + 1][2 * y] = true; + map[2 * x][2 * y + 1] = true; + map[2 * x + 1][2 * y + 1] = true; + } else { + map[2 * x][2 * y] = false; + map[2 * x + 1][2 * y] = false; + map[2 * x][2 * y + 1] = false; + map[2 * x + 1][2 * y + 1] = false; + } + + if (s.charAt(x) == 'X') { + startX = 2 * x; + startY = 2 * y; + } + } + } + + // special cases + ret = checkSpecialCases(map, startX, startY, d); + + // probable light directions + for (int dirX = -d; dirX <= d; dirX++) { + if (dirX == 0) { + // special case + continue; + } + for (int dirY = -d; dirY <= d; dirY++) { + if (dirY == 0) { + // special case + continue; + } + + if (dirX * dirX + dirY * dirY > d * d) { + // too long + continue; + } + + if (egcd(Math.abs(dirX), Math.abs(dirY)) != 1) { + // there is shorter version + continue; + } + + if (checkRay(map, startX, startY, d, dirX, dirY)) { + //System.out.println("" dirX:"" + dirX + "" dirY:"" + dirY); + ret++; + } + } + + } + + System.out.println(""Case #"" + i + "": "" + ret); + // System.out.println(); + + f0.write(""Case #"" + i + "": "" + ret + ""\r\n""); + } + + fr.close(); + f0.close(); + + } +} +" +C20001,"import java.io.*; +import java.util.*; + +class Mirrors { + + static class Direction { + int x; + int y; + Direction(int a, int b){ + x = a; + y = b; + } + } + + static class Point { + double x; + double y; + Point(double a, double b){ + x = a; + y = b; + } + } + + static class Cell { + int x; + int y; + Cell(int a, int b){ + x = a; + y = b; + } + } + + public static void main(String [] args) throws Exception{ + BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); + int T = Integer.parseInt(in.readLine()); + + for(int i = 0; i < T; i++){ + int ans = 0; + StringTokenizer st = new StringTokenizer(in.readLine()); + int H = Integer.parseInt(st.nextToken()); + int W = Integer.parseInt(st.nextToken()); + int D = Integer.parseInt(st.nextToken()); + char[][] map = new char[H][W]; + + Cell startcel = null; + for(int j = 0; j < H; j++){ + String s = in.readLine(); + for(int k = 0; k < s.length(); k++){ + map[j][k] = s.charAt(k); + if(s.charAt(k)=='X'){ + startcel = new Cell(j,k); + map[j][k]='.'; + } + } + } + + //list of diagonal directions + //hit corner at end + ArrayList directions = new ArrayList(); + for(int j = 0; j <= D/2; j++){ + for(int k = 0; k <= D/2; k++){ + if(Math.sqrt((0.5+j)*(0.5+j)+(0.5+k)*(0.5+k))<=D/2+0.0001){ + int x = 1+2*j; + int y = 1+2*k; + + boolean exists = false; + for(int l = 0; l < directions.size(); l++){ + int x2 = directions.get(l).x; + int y2 = directions.get(l).y; + if((double)x/y<=(double)x2/y2 + 0.0001 && + (double)x/y>=(double)x2/y2 - 0.0001){ + exists = true; + } + } + if(!exists){ + directions.add(new Direction(x,y)); + directions.add(new Direction(x,-y)); + directions.add(new Direction(-x,y)); + directions.add(new Direction(-x,-y)); + } + } + } + } + + //diagonal direction doesn't hit corner + for(int j = 1; j <= D; j++){ + for(int k = 1; k <= D; k++){ + if(Math.sqrt(j*j+k*k)<=D+0.0001){ + int x = j; + int y = k; + + boolean exists = false; + for(int l = 0; l < directions.size(); l++){ + int x2 = directions.get(l).x; + int y2 = directions.get(l).y; + if((double)x/y<=(double)x2/y2 + 0.0001 && + (double)x/y>=(double)x2/y2 - 0.0001){ + exists = true; + } + } + if(!exists){ + directions.add(new Direction(x,y)); + directions.add(new Direction(x,-y)); + directions.add(new Direction(-x,y)); + directions.add(new Direction(-x,-y)); + } + } + } + } + + //straight directions + directions.add(new Direction(0,1)); + directions.add(new Direction(0,-1)); + directions.add(new Direction(1,0)); + directions.add(new Direction(-1,0)); + /* + for(int j = 0; j < directions.size(); j++){ + System.out.println(directions.get(j).x + "" "" + directions.get(j).y); + } +*/ + //for each direction see if it hits X again + for(Direction d : directions){ + Point p = new Point(0.5,0.5); + double traveled = 0; + Direction dir = new Direction(d.x,d.y); + Cell cell = new Cell(startcel.x,startcel.y); + while (traveled<=D){ + + //assume next cell is vertical from this one + double ydir = 1 - p.y; + if(dir.y<0) ydir = -p.y; + + if(dir.y==0) ydir = 0; + double xdir = (ydir==0) ? ((dir.x>0) ? 1 : -1 ): dir.x*ydir/dir.y; + + //System.out.println(traveled + "" ("" + cell.x + "", "" + cell.y + "") "" + xdir + "" "" + ydir + "" "" + p.x + "" "" + p.y); + //check termination + if(cell.x==startcel.x&&cell.y==startcel.y&&(p.x!=0.5||p.y!=0.5)){ + double x1 = 0.5; + double y1 = 0.5; + double x2 = p.x; + double y2 = p.y; + double x3 = p.x + xdir; + double y3 = p.y + ydir; + double area = x1*(y2-y3) + x2*(y3 - y1) + x3*(y1 - y2); + + if(area < 0.0001 && area > -0.0001){ //colinear points + traveled += Math.sqrt((p.x-0.5)*(p.x-0.5) + (p.y-0.5)*(p.y-0.5)); + p.x = 0.5; + p.y = 0.5; + break; + } + } + //corner case + if((p.x+xdir>0.9999&&p.x+xdir<1.0001)&& + (p.y+ydir>0.9999&&p.y+ydir<1.0001)){ //bottom right + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x+1][cell.y+1]=='.'){ + cell.x++; + cell.y++; + p.x = 0; + p.y = 0; + } else if(map[cell.x][cell.y+1]=='.'&& + map[cell.x+1][cell.y]=='.'){ + traveled = 99999; + break; + } else if(map[cell.x][cell.y+1]=='#'&& + map[cell.x+1][cell.y]=='.'){ + dir.x = -dir.x; + cell.x++; + p.x = 1; + p.y = 0; + } else if(map[cell.x][cell.y+1]=='.'&& + map[cell.x+1][cell.y]=='#'){ + dir.y = -dir.y; + cell.y++; + p.x = 0; + p.y = 1; + } else if(map[cell.x][cell.y+1]=='#'&& + map[cell.x+1][cell.y]=='#'){ + dir.y = -dir.y; + dir.x = -dir.x; + p.x = 1; + p.y = 1; + } else { + System.err.println(""error br""); + System.exit(-1); + } + } else if((p.x+xdir>-0.0001&&p.x+xdir<0.0001)&& + (p.y+ydir>0.9999&&p.y+ydir<1.0001)){ //bottom left + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x+1][cell.y-1]=='.'){ + cell.y--; + cell.x++; + p.x = 1; + p.y = 0; + } else if(map[cell.x][cell.y-1]=='.'&& + map[cell.x+1][cell.y]=='.'){ + traveled = 99999; + break; + } else if(map[cell.x][cell.y-1]=='#'&& + map[cell.x+1][cell.y]=='.'){ + dir.x = -dir.x; + cell.x++; + p.x = 0; + p.y = 0; + } else if(map[cell.x][cell.y-1]=='.'&& + map[cell.x+1][cell.y]=='#'){ + dir.y = -dir.y; + cell.y--; + p.x = 1; + p.y = 1; + } else if(map[cell.x][cell.y-1]=='#'&& + map[cell.x+1][cell.y]=='#'){ + dir.y = -dir.y; + dir.x = -dir.x; + p.x = 0; + p.y = 1; + } else { + System.err.println(""error bl""); + System.exit(-1); + } + } else if((p.x+xdir>-0.0001&&p.x+xdir<0.0001)&& + (p.y+ydir>-0.0001&&p.y+ydir<0.0001)){ //top left + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x-1][cell.y-1]=='.'){ + cell.y--; + cell.x--; + p.x = 1; + p.y = 1; + } else if(map[cell.x-1][cell.y]=='.'&& + map[cell.x][cell.y-1]=='.'){ + traveled = 99999; + break; + } else if(map[cell.x-1][cell.y]=='.'&& + map[cell.x][cell.y-1]=='#'){ + dir.x = -dir.x; + cell.x--; + p.x = 0; + p.y = 1; + } else if(map[cell.x-1][cell.y]=='#'&& + map[cell.x][cell.y-1]=='.'){ + dir.y = -dir.y; + cell.y--; + p.x = 1; + p.y = 0; + } else if(map[cell.x-1][cell.y]=='#'&& + map[cell.x][cell.y-1]=='#'){ + dir.y = -dir.y; + dir.x = -dir.x; + p.x = 0; + p.y = 0; + } else { + System.err.println(""error tl""); + System.exit(-1); + } + } else if((p.x+xdir>0.9999&&p.x+xdir<1.0001)&& + (p.y+ydir>-0.0001&&p.y+ydir<0.0001)){ //top right + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x-1][cell.y+1]=='.'){ + cell.y++; + cell.x--; + p.x = 0; + p.y = 1; + } else if(map[cell.x][cell.y+1]=='.'&& + map[cell.x-1][cell.y]=='.'){ + traveled = 99999; + break; + } else if(map[cell.x][cell.y+1]=='#'&& + map[cell.x-1][cell.y]=='.'){ + dir.x = -dir.x; + cell.x--; + p.x = 1; + p.y = 1; + } else if(map[cell.x][cell.y+1]=='.'&& + map[cell.x-1][cell.y]=='#'){ + dir.y = -dir.y; + cell.y++; + p.x = 0; + p.y = 0; + } else if(map[cell.x][cell.y+1]=='#'&& + map[cell.x-1][cell.y]=='#'){ + dir.y = -dir.y; + dir.x = -dir.x; + p.x = 1; + p.y = 0; + } else { + System.err.println(""error tr""); + System.exit(-1); + } + } else if(p.x + xdir>0.9999){ + xdir = 1 - p.x; + ydir = dir.y*xdir/dir.x; + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x][cell.y+1]=='#'){ + dir.x = -dir.x; + p.x = 1; + p.y = p.y + ydir; + } else { + cell.y++; + p.x = 0; + p.y = p.y + ydir; + } + } else if(p.x + xdir<0.0001){ //go to next x cell + xdir = -p.x; + ydir = dir.y*xdir/dir.x; + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x][cell.y-1]=='#'){ + dir.x = -dir.x; + p.x = 0; + p.y = p.y + ydir; + } else { + cell.y--; + p.x = 1; + p.y = p.y + ydir; + } + } else if(p.y + ydir > 0.9999){ //go to next y cell + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x+1][cell.y]=='#'){ + dir.y = -dir.y; + p.y = 1; + p.x = p.x + xdir; + } else { + cell.x++; + p.y = 0; + p.x = p.x + xdir; + } + } else if(p.y + ydir < 0.0001){ //go to next y cell + traveled += Math.sqrt(xdir*xdir + ydir*ydir); + if(map[cell.x-1][cell.y]=='#'){ + dir.y = -dir.y; + p.y = 0; + p.x = p.x + xdir; + } else { + cell.x--; + p.y = 1; + p.x = p.x + xdir; + } + } else { + System.err.println(""error""); + System.exit(-1); + } + } + // System.out.println(traveled + "" "" + d.x + "" "" + d.y); + if(traveled<=D+0.0001&&cell.x==startcel.x&&cell.y==startcel.y&&p.x==0.5&&p.y==0.5){ + ans++; + } + + } + + System.out.println(""Case #""+(i+1)+"": "" + ans); + } + + } + +}" +C20049,"package jp.funnything.competition.util; + +import java.util.Arrays; +import java.util.List; + +import com.google.common.collect.Lists; +import com.google.common.primitives.Ints; +import com.google.common.primitives.Longs; + +public class Prime { + public static class PrimeData { + public int[] list; + public boolean[] map; + + private PrimeData( final int[] values , final boolean[] map ) { + list = values; + this.map = map; + } + } + + public static long[] factorize( long n , final int[] primes ) { + final List< Long > factor = Lists.newArrayList(); + + for ( final int p : primes ) { + if ( n < p * p ) { + break; + } + + while ( n % p == 0 ) { + factor.add( ( long ) p ); + n /= p; + } + } + + if ( n > 1 ) { + factor.add( n ); + } + + return Longs.toArray( factor ); + } + + public static PrimeData prepare( final int n ) { + final List< Integer > primes = Lists.newArrayList(); + + final boolean[] map = new boolean[ n ]; + Arrays.fill( map , true ); + + map[ 0 ] = map[ 1 ] = false; + + primes.add( 2 ); + for ( int composite = 2 * 2 ; composite < n ; composite += 2 ) { + map[ composite ] = false; + } + + for ( int value = 3 ; value < n ; value += 2 ) { + if ( map[ value ] ) { + primes.add( value ); + for ( int composite = value * 2 ; composite < n ; composite += value ) { + map[ composite ] = false; + } + } + } + + return new PrimeData( Ints.toArray( primes ) , map ); + } +} +" +C20034,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import uk.co.epii.codejam.common.AbstractProcessor; + +/** + * + * @author jim + */ +public class HallOfMirrorsProcessor extends AbstractProcessor { + + private static final HashMap> cachedRays = + new HashMap<>(); + + private static int ccase = 0; + + @Override + public String processDatum(Hall datum) { + System.out.println(""Case: "" + (++ccase)); + ArrayList vectors = getVectors(datum.D); + int count = 0; + for (RayVector rv : vectors) { + Ray r = new Ray(datum.D * datum.D, rv, datum.meLocation); + if (r.createsReflection(datum)) + count++; + } + return count + """"; + } + + public static ArrayList getVectors(int maxDistance) { + ArrayList shortest = cachedRays.get(maxDistance); + if (shortest != null) + return shortest; + ArrayList rays = new ArrayList<>(); + for (int x = -maxDistance; x <= maxDistance; x++) { + for (int y = -maxDistance; y <= maxDistance; y++) { + if (x == 0 && y == 0) + continue; + if (x * x + y * y > maxDistance * maxDistance) + continue; + if (Math.abs(Fraction.GCD(x, y)) == 1) + rays.add(new RayVector(x, y)); + } + } + return rays; + } + +} +" +C20036,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +/** + * + * @author jim + */ +public class Fraction implements Comparable { + + public final int n; + public final int d; + + public Fraction(int i) { + this(i, 1); + } + + public Fraction(int n, int d) { + int gcd = GCD(n, d); + if (gcd != 1) { + n /= gcd; + d/= gcd; + } + this.n = n; + this.d = d; + } + + public Fraction (int i, int n, int d) { + this(i * d + n, d); + } + + public Fraction add(Fraction f) { + if (d == f.d) + return new Fraction(n + f.n, d); + else { + return new Fraction(n * f.d + d * f.n, d * f.d); + } + } + + public Fraction substract(Fraction f) { + if (d == f.d) + return new Fraction(n - f.n, d); + else { + return new Fraction(n * f.d - d * f.n, d * f.d); + } + } + + public Fraction multiply(Fraction f) { + return new Fraction(n * f.n, d * f.d); + } + + public Fraction multiply(int i) { + return new Fraction(n * i, d); + } + + public static int GCD ( int a , int b ) + { + if (a == 0) + return b; + while ( b != 0 ) + { + int t = b ; + b = a % b ; + a = t ; + } + return a ; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Fraction) { + return compareTo((Fraction)obj) == 0; + } + return false; + } + + public int compareTo(Fraction f) { + return n * f.d - f.n * d; + } + + public int compareTo(int i) { + return n - i * d; + } + + public boolean isInt() { + return n % d == 0; + } + + public int floor() { + if (n == 0 || (n > 0 == d > 0)) + return n / d; + else + return n / d - 1; + } + + public Fraction abs() { + return new Fraction(Math.abs(n), Math.abs(d)); + } + + public Fraction fractionalPart() { + int N = n % d; + int D = d; + if (D < 0) { + N = -N; + D = -D; + } + while (N < 0) + N += D; + return new Fraction(N, D); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(n); + sb.append(""/""); + sb.append(d); + return sb.toString(); + } + + public Fraction divide(int i) { + return new Fraction(n, d * i); + } + + public Fraction divide(Fraction f) { + return new Fraction(n * f.d, d * f.n); + } + + + +} +" +C20081,"import java.util.Scanner; + +public class Program +{ + static final int RANGE = 50; + static Board board; + static double dist; + + public static void main(String[] args) throws Exception + { + Scanner in = new Scanner(new java.io.FileReader(""in"")); + int t = in.nextInt(); + + for (int test = 0; test < t; test++) + { + board = new Board(in.nextInt(), in.nextInt()); + dist = in.nextInt(); + for (int r = 0; r < board.height; r++) + { + String str = in.next(); + for (int c = 0; c < board.width; c++) + { + char ch = str.charAt(c); + int tile; + if (ch == '.') tile = 0; + else if (ch == '#') tile = 1; + else tile = 2; + + board.set(r, c, tile); + } + } + + int count = 0; + for (int dR = -RANGE; dR <= RANGE; dR++) + { + for (int dC = -RANGE; dC <= RANGE; dC++) + { + if (Calc.gcd(dR, dC) == 1) + { + boolean hit = ray(dR, dC); + if (hit) count++; + } + } + } + System.out.println(""Case #"" + (test + 1) + "": "" + count); + } + } + + static boolean ray(int dR, int dC) + { + Point p = board.player.clone(); + Point v = new Point(new Fraction(dR, 1), new Fraction(dC, 1)); + double d = 0; + + while (d <= dist) + { + Point nP = board.reflect(p, v); + if (nP == null) return false; + + double addD = nP.distance(p); + if (board.hitsPlayer(p, nP) && d + nP.distance(board.player) <= dist) + { + return true; + } + p = nP; + d += addD; + } + return false; + } +} +" +C20038,"import java.io.*; +import java.util.*; +import static java.lang.System.*; + +public class D { + public static void main (String [] args) throws IOException {new D().run();} + public void run() throws IOException{ + Scanner file = new Scanner(new File(""D-large.in"")); + PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(""D4.out""))); + int times = Integer.parseInt(file.nextLine()); + for(int asdf = 0; asdf set = new HashSet(); + for(int x = -XLIM; x<=XLIM; x++) + for(int y = -YLIM; y<=YLIM; y++){ + if( x==0&&y==0)continue; + double xx,yy; + if( x%2==0) xx = x*col+px; + else xx = (x+1)*col-px; + if( y%2==0) yy = y*row+py; + else yy = (y+1)*row-py; + if( Math.sqrt(Math.pow(xx-px,2)+Math.pow(yy-py,2)) <= d) + set.add(Math.atan2(yy-py,xx-px)); + } + int count = 0; + for(double d1 : set) + for(double d2 : set) + if( Math.abs(d1-d2)<1e-5)count++; + if(count != set.size()) System.out.println (""FAIL""); + out.println (""Case #""+(asdf+1)+"": ""+set.size()); + //System.out.println (set); + } + out.close(); + System.exit(0); + } +}" +C20058,"package jp.funnything.competition.util; + +import java.util.List; + +import com.google.common.collect.Lists; + +public class Lists2 { + public static < T > List< T > newArrayListAsArray( final int length ) { + final List< T > list = Lists.newArrayListWithCapacity( length ); + + for ( int index = 0 ; index < length ; index++ ) { + list.add( null ); + } + + return list; + } +} +" +C20011," +public class CG { + + /** get the intersection between a segment (p1, p2), and a project line from the origin + * with an angle. + * @return Point(INF, INF) if there is no intersection + * */ + public static Point intersectSegmentOri(Point p1, Point p2, double angle) + { + Point ori = new Point(0.0, 0.0), out = new Point(Math.cos(angle), + Math.sin(angle)); + Point intersect = new Point(0,0); + int stat = crossPointLL(p1, p2, ori, out, intersect); + + // parallel + if(stat == 0) + return new Point(CGConst.INF, CGConst.INF); + + // check the case of intersect at the wrong side of the project line + if(Math.cos(angle) * (intersect.x) < 0 || Math.sin(angle) * (intersect.y) < 0) + return new Point(CGConst.INF, CGConst.INF); + + // check if the intersection is on the segment + if(intersectSP(p1, p2, intersect)) + return intersect; + return new Point(CGConst.INF, CGConst.INF); + + + } + static boolean intersectSP(Point s0, Point s1, Point p) { + return s0.minus(p).abs() + s1.minus(p).abs() - s1.minus(s0).abs()< CGConst.EPS; // triangle inequality + + } + private static int crossPointLL(Point m0, Point m1, Point n0, Point n1, + Point p) { + if (Math.abs (cross (m1.minus(m0), n1.minus(n0))) > CGConst.EPS) { + // non-parallel => intersect + double h = cross (m1 .minus( m0), n1.minus(n0)); + double k = cross (m1.minus( m0), m1.minus(n0)); + p.copy( n1.minus(n0).mul(k/h).add(n0)); + return 1; // intersect at one point + } + if (Math.abs (cross (m1.minus(m0), n0.minus(m0))) < CGConst.EPS) { // area==0 => same line => intersect + p.copy( m0); // one of the intersection points, or m1, n0, n1, ... + return -1; // intersect at infinitely many points (when 2 parallel lines overlap) + } + return 0; // no intersection points (when two lines are parallel but does not overlap) + + } + private static double cross(Point a, Point b) { + return a.x * b.y - a.y * b.x; + } + public static double distance(Point a, Point b) + { + return a.minus(b).abs(); + } + public static double getAngle(Point a, Point b) + { + return Math.acos(point(a, b)/(a.abs()*b.abs())); + } + private static double point(Point a, Point b) { + + return a.x*b.x + a.y*b.y; + } + static int dblcmp (double a, double b) { + if (Math.abs (a-b) < CGConst.EPS) return 0; + return a < b ? -1 : 1; + } + public static int ccw (Point a, Point b, Point c) { // short version + return dblcmp (cross (b.minus(a), c.minus(a)), 0); + } + // para: s0 and s1 form a segment s + // para: t0 and t1 form a segment t + // return: true if s and t appears like a 'X' + public static boolean properIntersectSS (Point s0, Point s1, Point t0, Point t1) { + return ccw (s0, s1, t0) * ccw (s0, s1, t1) < 0 && + ccw (t0, t1, s0) * ccw (t0, t1, s1) < 0; + } + public static double triArea (Point a, Point b, Point c) { + // centroid = (a + b + c) / 3.0; // centroid of triangle + return Math.abs (cross (b.minus(a), c.minus(a))) * 0.5; // |cross product| / 2 + } + /** check if two segments intersect and find the intersection point + para: + input s0 and s1 form a line s + input t0 and t1 form a line t + output p is the intersection point (if return value != 0) + return: + 1: the segments intersect at exactly one point + -1: the segments intersect improperly, p is ONE OF the intersection points + 0: no intersection points + note: If you are sure the segment intersect and want to find the intersection point, + you can include the statements in the first *if* block only. + */ + public static int crossPointSS( Point s0, Point s1, Point t0, Point t1, Point p) { + if (properIntersectSS (s0, s1, t0, t1)) { + double r = triArea (s0, t0, t1) / triArea (s1, t0, t1); + Point temp = s0.add( (s1.minus(s0)).mul((r / (1+r)))); + p.x = temp.x; + p.y = temp.y; + return 1; + } + if (intersectSP (s0, s1, t0)) { p.copy(t0); return -1; } + if (intersectSP (s0, s1, t1)) { p .copy( t1); return -1; } + if (intersectSP (t0, t1, s0)) { p .copy(s0); return -1; } + if (intersectSP (t0, t1, s1)) { p .copy(s1); return -1; } + return 0; + } +} +" +C20032,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +import uk.co.epii.codejam.common.AbstractMain; + +/** + * + * @author jim + */ +public class Main { + + /** + * @param args the command line arguments + */ + public static void main(String[] args) { + System.err.println(""Hello""); + new AbstractMain(new HallFactory(), + new HallOfMirrorsProcessor()).main(args); + } +} +" +C20033,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +/** + * + * @author jim + */ +public enum RayStep { + EXPIRES, + REFLECTS_HORIZONTALLY, + REFLECTS_VERTICALLY, + INVERTS, + CONTINUES, + HITS; +} +" +C20014," +public class Point { + + public double x, y; + + public Point(double x, double y) + { + this.x = x; + this.y = y; + } + + public Point() { + x=0; y=0; + } + + @Override + public boolean equals(Object arg0) { + Point pt = (Point)arg0; + return CG.dblcmp(pt.x, x) == 0 && CG.dblcmp(pt.y, y) == 0; + } + + public Point minus(Point p) + { + return new Point(x-p.x, y-p.y); + } + public Point add(Point p) + { + return new Point(x+p.x, y+p.y); + } + public Point mul(double n) + { + return new Point(n*x, n*y); + } + public double abs() + { + return Math.sqrt(x*x + y*y); + } + public void copy(Point p) + { + this.x = p.x; + this.y = p.y; + } + +} +" +C20053,"package jp.funnything.competition.util; + +import java.util.Iterator; + +/** + * Do NOT change the element in iteration + */ +public class Combination implements Iterable< int[] > , Iterator< int[] > { + private final int _n; + private final int _k; + private int[] _data; + + public Combination( final int n , final int k ) { + if ( k < 0 || k > n ) { + throw new IllegalArgumentException(); + } + + _n = n; + _k = k; + } + + @Override + public boolean hasNext() { + return _data == null || _data.length > 0 && _data[ 0 ] < _n - _k; + } + + @Override + public Iterator< int[] > iterator() { + return this; + } + + @Override + public int[] next() { + if ( _data == null ) { + _data = new int[ _k ]; + for ( int index = 0 ; index < _k ; index++ ) { + _data[ index ] = index; + } + } else { + int i = 0; + + while ( i < _k - 1 && _data[ i + 1 ] == _data[ i ] + 1 ) { + _data[ i ] = i++; + } + + _data[ i ]++; + } + + return _data; + } + + @Override + public void remove() { + } +} +" +C20046,"package jp.funnything.competition.util; + +import java.math.BigInteger; + +/** + * Utility for BigInteger + */ +public class BI { + public static BigInteger ZERO = BigInteger.ZERO; + public static BigInteger ONE = BigInteger.ONE; + + public static BigInteger add( final BigInteger x , final BigInteger y ) { + return x.add( y ); + } + + public static BigInteger add( final BigInteger x , final long y ) { + return add( x , v( y ) ); + } + + public static BigInteger add( final long x , final BigInteger y ) { + return add( v( x ) , y ); + } + + public static int cmp( final BigInteger x , final BigInteger y ) { + return x.compareTo( y ); + } + + public static int cmp( final BigInteger x , final long y ) { + return cmp( x , v( y ) ); + } + + public static int cmp( final long x , final BigInteger y ) { + return cmp( v( x ) , y ); + } + + public static BigInteger div( final BigInteger x , final BigInteger y ) { + return x.divide( y ); + } + + public static BigInteger div( final BigInteger x , final long y ) { + return div( x , v( y ) ); + } + + public static BigInteger div( final long x , final BigInteger y ) { + return div( v( x ) , y ); + } + + public static BigInteger mod( final BigInteger x , final BigInteger y ) { + return x.mod( y ); + } + + public static BigInteger mod( final BigInteger x , final long y ) { + return mod( x , v( y ) ); + } + + public static BigInteger mod( final long x , final BigInteger y ) { + return mod( v( x ) , y ); + } + + public static BigInteger mul( final BigInteger x , final BigInteger y ) { + return x.multiply( y ); + } + + public static BigInteger mul( final BigInteger x , final long y ) { + return mul( x , v( y ) ); + } + + public static BigInteger mul( final long x , final BigInteger y ) { + return mul( v( x ) , y ); + } + + public static BigInteger sub( final BigInteger x , final BigInteger y ) { + return x.subtract( y ); + } + + public static BigInteger sub( final BigInteger x , final long y ) { + return sub( x , v( y ) ); + } + + public static BigInteger sub( final long x , final BigInteger y ) { + return sub( v( x ) , y ); + } + + public static BigInteger v( final long value ) { + return BigInteger.valueOf( value ); + } +} +" +C20061,"package jp.funnything.competition.util; + +import java.util.Iterator; + +/** + * Do NOT change the element in iteration + */ +public class Combination implements Iterable< int[] > , Iterator< int[] > { + private final int _n; + private final int _k; + private int[] _data; + + public Combination( final int n , final int k ) { + if ( k < 0 || k > n ) { + throw new IllegalArgumentException(); + } + + _n = n; + _k = k; + } + + @Override + public boolean hasNext() { + return _data == null || _data.length > 0 && _data[ 0 ] < _n - _k; + } + + @Override + public Iterator< int[] > iterator() { + return this; + } + + @Override + public int[] next() { + if ( _data == null ) { + _data = new int[ _k ]; + for ( int index = 0 ; index < _k ; index++ ) { + _data[ index ] = index; + } + } else { + int i = 0; + + while ( i < _k - 1 && _data[ i + 1 ] == _data[ i ] + 1 ) { + _data[ i ] = i++; + } + + _data[ i ]++; + } + + return _data; + } + + @Override + public void remove() { + } +} +" +C20087," +import java.io.*; +import java.util.*; + +public class CodeJam2012_Q_D { + + public int calc(int H, int W, int D, String[] mirror) { + int[][] seen = new int[D*2+1][D*2+1]; + int sx=0,sy=0; + for(int i=0; i=0) { + sx = mirror[i].indexOf('X'); + sy = i; + } + for(int j=0; jD*D || (x==0 && y==0)) { + seen[y+D][x+D] = 0; + } + if(seen[y+D][x+D]!=-1) continue; + + int gcd = Math.abs(gcd(x, y)); + int dx = x/gcd; + int dy = y/gcd; + int unit = dx*dy==0? 2:Math.abs(dx*dy)*2; + int cellx = sx; + int celly = sy; + int lx = unit/2; + int ly = unit/2; + int pathMax = x==0? y*unit/dy : x*unit/dx; + int pathCnt = 0; + while(pathCnt0?1:-1)][cellx + (dx>0?1:-1)]) { + //hit a corner + if(!m[celly + (dy>0?1:-1)][cellx] && !m[celly][cellx + (dx>0?1:-1)]) break; + + //reflected with horizontal mirror + if(m[celly + (dy>0?1:-1)][cellx]) { + ndy = -dy; + } else { + ny = celly+(dy>0?1:-1); + nly = ly==0?unit:0; + } + + //reflected with vertical mirror + if(m[celly][cellx + (dx>0?1:-1)]) { + ndx = -dx; + } else { + nx = cellx+(dx>0?1:-1); + nlx = lx==0?unit:0; + } + + } else { + nx = cellx+(dx>0?1:-1); + ny = celly+(dy>0?1:-1); + nlx = lx==0?unit:0; + nly = ly==0?unit:0; + } + } else if(ly%unit==0) { + //reflected with horizontal mirror + if(m[celly + (dy>0?1:-1)][cellx]) { + ndy = -dy; + } else { + ny = celly+(dy>0?1:-1); + nly = ly==0?unit:0; + } + + } else if(lx%unit==0) { + //reflected with vertical mirror + if(m[celly][cellx + (dx>0?1:-1)]) { + ndx = -dx; + } else { + nx = cellx+(dx>0?1:-1); + nlx = lx==0?unit:0; + } + } + cellx=nx; + celly=ny; + dx=ndx; + dy=ndy; + lx=nlx; + ly=nly; + } + if(seen[y+D][x+D]==-1) seen[y+D][x+D]=0; + } + } + + int cnt=0; + for(int[] s1 : seen) + for(int s2 : s1) + cnt += s2; + return cnt; + } + + public int gcd(int a, int b) { + return b==0? a : gcd(b, a%b); + } + + public static void main(String[] args) { + try{ +// (new CodeJam2012_Q_D()).exec(""D-small-attempt0.in"", ""2012_Q_D-small.out""); + (new CodeJam2012_Q_D()).exec(""D-large.in"", ""2012_Q_D-large.out""); + }catch(Exception ex) { + + } + } + + public final void exec(String inFileName, String outFileName) throws Exception{ + BufferedReader inReader = new BufferedReader(new FileReader(inFileName)); + PrintWriter outWriter = new PrintWriter(new BufferedWriter(new FileWriter(outFileName))); + int caseNums=0; + caseNums = Integer.parseInt(inReader.readLine()); + + for(int i=0; i { + public static final Frac ZERO = new Frac(0); + public static final Frac ONE = new Frac(1); + public final int num, denom; + + public Frac(int num) { + this(num, 1); + } + + public Frac(int num, int denom) { + if (denom == 0) { + if (num < 0) + this.num = -1; + else if (num > 0) + this.num = 1; + else + this.num = 0; + this.denom = 0; + } else { + int gcd; + if (denom < 0) { + gcd = -Math.abs(gcd(num, denom)); + } else { + gcd = Math.abs(gcd(num, denom)); + } + this.num = num / gcd; + this.denom = denom / gcd; + } + } + + public Frac add(Frac other) { + return new Frac(num * other.denom + denom * other.num, denom + * other.denom); + } + + public Frac mult(Frac other) { + return new Frac(num * other.num, denom * other.denom); + } + + public Frac sub(Frac other) { + return new Frac(num * other.denom - denom * other.num, denom + * other.denom); + } + + public Frac div(Frac other) { + return new Frac(num * other.denom, denom * other.num); + } + + public Frac neg() { + return new Frac(-num, denom); + } + + public Frac inv() { + return new Frac(denom, num); + } + + @Override + public boolean equals(Object other) { + return other instanceof Frac && equals((Frac) other); + } + + @Override + public int hashCode() { + return (31 + num) * 31 + denom; + } + + public boolean equals(Frac other) { + return num == other.num && denom == other.denom; + } + + public boolean equals(int o) { + return denom == 1 && num == o; + } + + @Override + public String toString() { + if (denom == 1) + return Integer.toString(num); + else + return num + ""/"" + denom; + } + + @Override + public int compareTo(Frac o) { + return num * o.denom - o.num * denom; + } + + public static int gcd(int a, int b) { + if (b == 0) { + return a; + } else { + return gcd(b, a % b); + } + } + + public Frac roundAddSig(Frac sgn) { + if (sgn.num > 0) + return roundAddUp(); + else if (sgn.num < 0) + return roundAddDown(); + else + return null; + } + + public Frac roundAddUp() { + if (num < 0) + return new Frac((num + 1) / denom); + else + return new Frac(num / denom + 1); + } + + public Frac roundAddDown() { + if (num > 0) + return new Frac((num - 1) / denom); + else + return new Frac(num / denom - 1); + } + + public int roundDownAddSmallUp() { + if (num < 0) + return (num - denom + 1) / denom; + else + return num / denom; + } + + public int roundDownAddSmallDown() { + if (num < 0) + return num / denom - 1; + else + return (num - 1) / denom; + } + + public boolean isZero() { + return num == 0; + } + + public int sgn() { + if (num < 0) + return -1; + else if (num > 0) + return 1; + else + return 0; + } +} +" +C20047,"package jp.funnything.competition.util; + +public class Prof { + private long _start; + + public Prof() { + reset(); + } + + private long calcAndReset() { + final long ret = System.currentTimeMillis() - _start; + + reset(); + + return ret; + } + + private void reset() { + _start = System.currentTimeMillis(); + } + + @Override + public String toString() { + return String.format( ""Prof: %f (s)"" , calcAndReset() / 1000.0 ); + } + + public String toString( final String head ) { + return String.format( ""%s: %f (s)"" , head , calcAndReset() / 1000.0 ); + } +} +" +C20007,"package qualificationRound; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; + +public class P4 { + public static String[] map; + public static int x = 0, y = 0; + + public static int calGCD(int n, int m) { + if (m == 0) + return n; + if (n == 0) + return m; + if (m < n) { + int tmp = m; + m = n; + n = tmp; + } + while (n != 0) { + int tmp = m % n; + m = n; + n = tmp; + } + return m; + } + + public static boolean check(double unit_x, double unit_y, int step) { + boolean ret = false; + double start_x = x - 0.5, start_y = y - 0.5; + double tmp_x = start_x, tmp_y = start_y; + for (int i = 1; i <= step; ++i) { + tmp_x += unit_x; + tmp_y += unit_y; + if (Math.abs(tmp_x - start_x) < 1E-9 + && Math.abs(tmp_y - start_y) < 1E-9) { + if (i == step) + return true; + else + return false; + } + + int int_x = (int) Math.round(tmp_x); + int int_y = (int) Math.round(tmp_y); + + if (Math.abs(tmp_x - int_x) < 1E-9 + && Math.abs(tmp_y - int_y) < 1E-9) { + if (unit_x > 0) + int_x = int_x + 1; + if (unit_y > 0) + int_y = int_y + 1; + if (map[int_x].charAt(int_y) == '#') { + if (map[int_x - (int) Math.signum(unit_x)].charAt(int_y) == '#' + && map[int_x].charAt(int_y + - (int) Math.signum(unit_y)) == '#') { + unit_x = -unit_x; + unit_y = -unit_y; + } else if (map[int_x - (int) Math.signum(unit_x)] + .charAt(int_y) == '#') { + unit_y = -unit_y; + } else if (map[int_x].charAt(int_y + - (int) Math.signum(unit_y)) == '#') { + unit_x = -unit_x; + } else { + return false; + } + } + } else if (Math.abs(tmp_x - int_x) < 1E-9) { + if (unit_x > 0) + int_x = int_x + 1; + int_y = (int) Math.ceil(tmp_y); + if (map[int_x].charAt(int_y) == '#') + unit_x = -unit_x; + } else if (Math.abs(tmp_y - int_y) < 1E-9) { + if (unit_y > 0) + int_y = int_y + 1; + int_x = (int) Math.ceil(tmp_x); + if (map[int_x].charAt(int_y) == '#') + unit_y = -unit_y; + } + } + + return ret; + } + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new FileReader(""D-large.in"")); + FileWriter fw = new FileWriter(""out.txt""); + int t = Integer.parseInt(br.readLine()); + for (int c = 1; c <= t; ++c) { + args = br.readLine().split("" ""); + int h = Integer.parseInt(args[0]); + int w = Integer.parseInt(args[1]); + int d = Integer.parseInt(args[2]); + int ans = 0; + map = new String[h]; + for (int j = 0; j < h; ++j) { + map[j] = br.readLine(); + if (map[j].indexOf('X') != -1) { + x = j; + y = map[j].indexOf('X'); + } + } + + for (int i = x - d; i <= x + d; ++i) { + for (int j = y - d; j <= y + d; ++j) { + int dx = x - i, dy = y - j; + if (dx * dx + dy * dy > d * d || (dx == 0 && dy == 0)) + continue; + + double unit_x, unit_y; + int gcd = calGCD(Math.abs(dx), Math.abs(dy)); + int step; + if (dx != 0 && dy != 0) + step = 2 * Math.abs(dx) * Math.abs(dy) /gcd; + else if (dx == 0) { + step = 2 * Math.abs(dy); + } else { + step = 2 * Math.abs(dx); + } + + unit_x = (double) dx / step; + unit_y = (double) dy / step; + + if (check(unit_x, unit_y, step)) + ans++; + } + } + fw.append(""Case #"" + c + "": "" + ans + ""\n""); + System.out.println(""Case #"" + c + "": "" + ans); + } + br.close(); + fw.close(); + } +} +" +C20028,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +import java.awt.Point; + +/** + * + * @author jim + */ +public class Hall { + public final int H; + public final int W; + public final int D; + public final FractionPoint meLocation; + private final Square[][] floor; + + public Hall(int H, int W, int D, FractionPoint meLocation, Square[][] floor) { + this.H = H; + this.W = W; + this.D = D; + this.meLocation = meLocation; + this.floor = floor; + } + + public RayVector processBoundary(FractionPoint fp, RayVector v) { + switch (getStep(fp, v)) { + case CONTINUES: + return v; + case EXPIRES: + return null; + case REFLECTS_HORIZONTALLY: + return new RayVector(-v.x, v.y); + case REFLECTS_VERTICALLY: + return new RayVector(v.x, -v.y); + case INVERTS: + return new RayVector(-v.x, -v.y); + default: + throw new IllegalArgumentException(""The getStep has returned "" + + ""an invalid result""); + } + } + + public RayStep getStep(FractionPoint fp, RayVector v) { + boolean xIsInt = fp.x.isInt(); + boolean yIsInt = fp.y.isInt(); + if (xIsInt && yIsInt) { + Surround surround = getSurround(new Point(fp.x.floor(), fp.y.floor())); + int xIndex = v.x > 0 ? 1 : 0; + int yIndex = v.y > 0 ? 1 : 0; + Square entering = surround.get(xIndex, yIndex); + if (entering != Square.MIRROR) + return RayStep.CONTINUES; + else if (surround.get(v.x > 0 ? 1 : 0, v.y > 0 ? 0 : 1) == Square.MIRROR && + surround.get(v.x > 0 ? 0 : 1, v.y > 0 ? 1 : 0) == Square.MIRROR) + return RayStep.INVERTS; + else if (surround.get(v.x > 0 ? 1 : 0, v.y > 0 ? 0 : 1) != Square.MIRROR && + surround.get(v.x > 0 ? 0 : 1, v.y > 0 ? 1 : 0) != Square.MIRROR) + return RayStep.EXPIRES; + else { + if ((surround.get(0, 0) == Square.MIRROR && surround.get(0, 1) == Square.MIRROR) || + (surround.get(1, 0) == Square.MIRROR && surround.get(1, 1) == Square.MIRROR)) + return RayStep.REFLECTS_HORIZONTALLY; + else + return RayStep.REFLECTS_VERTICALLY; + } + } + else if (xIsInt) { + Square entering = getSquare( + fp.x.floor() + (v.x > 0 ? 0 : -1), fp.y.floor()); + if (entering == Square.MIRROR) + return RayStep.REFLECTS_HORIZONTALLY; + else + return RayStep.CONTINUES; + } + else if (yIsInt) { + int x = fp.x.floor(); + int y = fp.y.floor() + (v.y > 0 ? 0 : -1); + Square entering = getSquare(x, y); + if (entering == Square.MIRROR) + return RayStep.REFLECTS_VERTICALLY; + else + return RayStep.CONTINUES; + } + else + throw new IllegalArgumentException(""You are not at a boundary!""); + } + + public Surround getSurround(Point p) { + Square[][] surround = new Square[2][]; + surround[0] = new Square[2]; + surround[1] = new Square[2]; + surround[0][0] = getSquare(p.x - 1, p.y - 1); + surround[1][1] = getSquare(p); + surround[1][0] = getSquare(p.x - 1, p.y); + surround[0][1] = getSquare(p.x, p.y - 1); + return new Surround(surround); + } + + public Square getSquare(int x, int y) { + return floor[y][x]; + } + + public Square getSquare(Point p) { + return getSquare(p.x, p.y); + } + +} +" +C20022,"package template; + +//standard libraries potentially used: +//Apache commons http://http://commons.apache.org/ +//Google Guava http://code.google.com/p/guava-libraries/ + +import java.util.ArrayList; + + +public class Template { + + public static void main(String[] args) { + + //test(); + //Utils.die(""Done testing""); + + String folder = ""C:\\Users\\Paul Thomson\\Documents\\CodeJam\\HallOfMirrors\\""; + Utils.logfile = folder + ""log.txt""; + String infile = folder + ""data.in""; + String outfile = infile.substring(0, infile.lastIndexOf(""."")) + "".out""; + ArrayList tcList = TestCaseIO.loadFromFile(infile); + //ArrayList tcList = TestCaseIO.mockUp(); + + int numThreads = 1; + if (numThreads == 1) { + TestCaseSolver tcSolver = new TestCaseSolver(tcList, 1); + tcSolver.run(); + } else { + //split into separate lists + ArrayList> tcSubLists = new ArrayList<>(); + for (int i = 0; i < numThreads; i++) { + tcSubLists.add(new ArrayList()); + } + + int i = 0; + for (TestCase tc : tcList) { + tcSubLists.get(i).add(tc); + i++; + if (i == numThreads) { + i = 0; + } + } + + //run each sublist in its own thread + ArrayList threadList = new ArrayList<>(); + int ref = 1; + for (ArrayList tcl : tcSubLists) { + TestCaseSolver tcs = new TestCaseSolver(tcl, ref); + Thread h = new Thread(tcs); + threadList.add(h); + h.start(); + ref++; + } + + //wait for completion + for (Thread h : threadList) { + try { + h.join(); + } catch (InterruptedException ex) { + Utils.die(""InterruptedException waiting for threads""); + } + } + + } + + TestCaseIO.writeSolutions(tcList, outfile); + + double totalTime = 0; + for (TestCase tc : tcList) { + totalTime += tc.getTime(); + } + double avTime = totalTime / (double)tcList.size(); + Utils.sout(""Total compute time "" + String.format(""%.2f"", totalTime) + "" secs.""); + Utils.sout(""Average compute time "" + String.format(""%.2f"", avTime) + "" secs.""); + Utils.sout(""Done.""); + } + + public static void test() { + + } +} +" +C20016,"// Author: Alejandro Sotelo Arevalo +package qualification; + +import java.awt.*; +import java.awt.geom.*; +import java.io.*; +import java.util.*; + +public class D_HallOfMirrors { + //-------------------------------------------------------------------------------- + private static String ID=""D""; + private static String NAME=""large""; + private static boolean STANDARD_OUTPUT=false; + //-------------------------------------------------------------------------------- + public static void main(String[] args) throws Throwable { + BufferedReader reader=new BufferedReader(new FileReader(new File(""data/""+ID+""-""+NAME+"".in""))); + if (!STANDARD_OUTPUT) System.setOut(new PrintStream(new File(""data/""+ID+""-""+NAME+"".out""))); + for (int c=1,T=Integer.parseInt(reader.readLine()); c<=T; c++) { + String w[]=reader.readLine().trim().split("" +""); + int H=Integer.parseInt(w[0]),W=Integer.parseInt(w[1]),D=Integer.parseInt(w[2]); + Point point=null; + Collection mirrors=new ArrayList(); + char[][] hall=new char[H][]; + for (int y=0; y mirrors, int D) { + int count=0; + for (int i=0; i<=D; i++) for (int j=1; j<=D; j++) if (gcd(i,j)==1) { + for (int k=0; k<4; k++) { + double minimum=simulateAngle(new Particle(point.x,point.y,new Angle(k==0?i:(k==1?-j:(k==2?-i:j)),k==0?j:(k==1?i:(k==2?-j:-i)))),mirrors,D); + if (minimum<1E-12) count++; + } + } + return count++; + } + private static long gcd(long a, long b) { + return b==0?a:gcd(b,a%b); + } + private static double simulateAngle(Particle point, Collection mirrors, double distance) { + //System.out.println(""Simulation with x=""+point.x+"",y=""+point.y+"",angle=""+point.angle.getValue()+"",distance=""+distance); + Angle angle=point.angle; + double x=point.x,y=point.y,d=distance,walked=0; + double result=Double.POSITIVE_INFINITY; + while (d>0) { + double best=d; + double nextX=x+d*angle.cos(),nextY=y+d*angle.sin(); + Angle nextAngle=angle; + Collection collisions=new ArrayList(); + for (Point mirror:mirrors) { + Collision collision=collision(new Particle(x,y,angle),mirror); + if (collision!=null) { + double dist=collision.distance(x,y); + if (eq(dist,0)) { + continue; + } + if (le(dist,best)) { + collisions.clear(); + } + if (leq(dist,best)) { + collisions.add(collision); + best=dist; + } + } + } + boolean destroyRay=collisions.isEmpty(); + if (collisions.size()==1) { + Collision collision=collisions.iterator().next(); + nextX=collision.x; + nextY=collision.y; + if (collision.isCorner()==-1) { + nextAngle=reflection(collision.side,angle); + } + else { + destroyRay=collision.insideMirror(angle); + } + } + else if (collisions.size()==2) { + Iterator iterator=collisions.iterator(); + Collision c1=iterator.next(),c2=iterator.next(); + nextX=c1.x; + nextY=c1.y; + if (c1.mirror.x==c2.mirror.x) { + nextAngle=reflection(leq(x,c1.mirror.x)?3:1,angle); + } + else if (c1.mirror.y==c2.mirror.y) { + nextAngle=reflection(leq(y,c1.mirror.y)?4:2,angle); + } + else { + // The angle doesn't change + } + } + else if (collisions.size()==3) { + Collision collision=collisions.iterator().next(); + nextX=collision.x; + nextY=collision.y; + nextAngle=new Angle(-angle.x,-angle.y); + } + if (ge(walked,0)) result=Math.min(result,Line2D.ptSegDistSq(x,y,nextX,nextY,point.x,point.y)); + walked+=destroyRay?d:Point2D.distance(x,y,nextX,nextY); + d=destroyRay?0:d-Point2D.distance(x,y,nextX,nextY); + x=nextX; + y=nextY; + angle=nextAngle; + //System.out.println("" nextX=""+x+""nextY=""+y+""result=""+result+"";""+walked); + } + return result; + } + private static Angle reflection(int side, Angle angle) { + int x=angle.x,y=angle.y; + switch (side) { + case 1: + case 3: + return new Angle(-x,y); + case 2: + case 4: + return new Angle(x,-y); + } + return angle; + } + private static Collision collision(Particle point, Point mirror) { + Angle angle=point.angle; + double xp=point.getX(),yp=point.getY(); + double xm=mirror.getX(),ym=mirror.getY(); + Collision result=null; + if (angle.y==0&&angle.x>0) { + result=leq(xp,xm-0.5)&&geq(yp,ym-0.5)&&leq(yp,ym+0.5)?new Collision(xm-0.5,yp,mirror,3):null; + } + else if (angle.y==0&&angle.x<0) { + result=geq(xp,xm+0.5)&&geq(yp,ym-0.5)&&leq(yp,ym+0.5)?new Collision(xm+0.5,yp,mirror,1):null; + } + else if (angle.x==0&&angle.y>0) { + result=leq(yp,ym-0.5)&&geq(xp,xm-0.5)&&leq(xp,xm+0.5)?new Collision(xp,ym-0.5,mirror,4):null; + } + else if (angle.x==0&&angle.y<0) { + result=geq(yp,ym+0.5)&&geq(xp,xm-0.5)&&leq(xp,xm+0.5)?new Collision(xp,ym+0.5,mirror,2):null; + } + else { + double ma=angle.tan(),mb=angle.atan(); + double xc=xp+angle.x,yc=yp+angle.y; + double x1=xm-0.5,y1=yp+ma*(x1-xp); + double x2=xm+0.5,y2=yp+ma*(x2-xp); + double y3=ym-0.5,x3=xp+mb*(y3-yp); + double y4=ym+0.5,x4=xp+mb*(y4-yp); + Collection collection=new ArrayList(4); + if (geq(y1,ym-0.5)&&leq(y1,ym+0.5)&&(xc>xp)==(x1>xp)) collection.add(new Collision(x1,y1,mirror,3)); + if (geq(y2,ym-0.5)&&leq(y2,ym+0.5)&&(xcyp)==(y3>yp)) collection.add(new Collision(x3,y3,mirror,4)); + if (geq(x4,xm-0.5)&&leq(x4,xm+0.5)&&(yc=b-EPSILON; + } + private static boolean le(double a, double b) { + return ab+EPSILON; + } + private static class Particle extends Point2D { + private double x; + private double y; + private Angle angle; + public Particle(double x, double y, Angle angle) { + this.x=x; + this.y=y; + this.angle=angle; + } + public double getX() { + return x; + } + public double getY() { + return y; + } + public void setLocation(double x, double y) { + this.x=x; + this.y=y; + } + } + private static class Collision extends Point2D { + private double x; + private double y; + private Point mirror; + private int side; + public Collision(double x, double y, Point mirror, int side) { + this.x=x; + this.y=y; + this.mirror=mirror; + this.side=side; + } + public int isCorner() { + double xm=mirror.getX(),ym=mirror.getY(); + if (eq(distance(xm+0.5,ym-0.5),0)) return 1; + if (eq(distance(xm+0.5,ym+0.5),0)) return 2; + if (eq(distance(xm-0.5,ym+0.5),0)) return 3; + if (eq(distance(xm-0.5,ym-0.5),0)) return 4; + return -1; + } + public boolean insideMirror(Angle angle) { + double xp=x+0.5*angle.cos(),yp=y+0.5*angle.sin(); + double xm=mirror.getX(),ym=mirror.getY(); + return geq(xp,xm-0.5)&&leq(xp,xm+0.5)&&geq(yp,ym-0.5)&&leq(yp,ym+0.5); + } + public double getX() { + return x; + } + public double getY() { + return y; + } + public void setLocation(double x, double y) { + this.x=x; + this.y=y; + } + } + private static class Angle { + private int x; + private int y; + private double r; + public Angle(int x, int y) { + this.x=x; + this.y=y; + r=Math.sqrt(1.0*x*x+1.0*y*y); + } + public double tan() { + return 1.0*y/x; + } + public double atan() { + return 1.0*x/y; + } + public double cos() { + return 1.0*x/r; + } + public double sin() { + return 1.0*y/r; + } + @SuppressWarnings(""unused"") + public double getDegrees() { + return Math.toDegrees(Math.atan2(y,x)); + } + @SuppressWarnings(""unused"") + public double getRadians() { + return Math.atan2(y,x); + } + } +} +" +C20072,"/* + * CodeJamTester1A.java + * + * Created on 28.07.2008, 14:20:39 + * + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package qualification; +import java.util.*; +import java.io.*; +import java.math.*; + +/** + * + * @author Besitzer + */ +public class CodeJamQuali { + int testcases; + String dict=""yhesocvxduiglbkrztnwjpfmaq""; + BufferedReader BR; + BigInteger ZERO =BigInteger.ZERO; + BigInteger ONE =BigInteger.ONE; + BigInteger TWO =new BigInteger(""2""); + BigInteger THREE =new BigInteger(""3""); + + public void sort(long[] a){ + for(int i=0;imax){max=a[j];minAt=j;} + } + //System.out.println(""maxAT:""+minAt+"" max: ""+max); + if(minAt>-1){ + long buf =a[i]; + a[i]=a[minAt]; + a[minAt]=buf; + } + } + } + + public void fillDict(String E, String G, char[] C){ + for(int i=0;i1 ? incbound :1; + for(int i =0;i=3*p-2){ + ok++; + }else{ + if(cur>=incbound)incable++; + } + } + S=S0){ + buf= (6*cur-4*prev)%1000; + if(buf<0)buf=(10000+buf)%1000; + prev=cur;cur=buf; + n0--; + // abuse periority of the pairs + if((prev==144)&&(cur==752)&&(n-n0!=4)){ + System.out.println(n-n0-4); + n0=n0%(n-n0-4); + } + } + String S= """"+(cur+999)%1000; + while(S.length()<3)S=""0""+S; + return S; + } + @SuppressWarnings(""fallthrough"") + public String testCase4() throws IOException{ + String[] SA= BR.readLine().split("" ""); + int H = Integer.parseInt(SA[0]); + int W = Integer.parseInt(SA[1]); + int D = Integer.parseInt(SA[2]); + char[][] F = new char[H][]; + int startx=-1,starty=-1; + int reflCount =0; + for(int i=0;i0)&&(rayLives)){ + int diff = (abuf + 2*b)-(bbuf +2*a); + if (diff>=0){bbuf +=2*a;} + if (diff<=0){abuf +=2*b;} + diff=diff>0 ?1:(diff<0 ?-1:0); + switch(diff){ + case -1:if(F[px+sx][py]=='#'){sx=-sx;}else{px+=sx;}break; + case 1:if(F[px][py+sy]=='#'){sy=-sy;}else{py+=sy;}break; + case 0:if(F[px+sx][py+sy]=='.') + { + px+=sx;py+=sy; + }else{ + if((F[px+sx][py]=='.')&&((F[px][py+sy]=='.'))){rayLives=false;} + boolean xbuf =F[px+sx][py]=='#'; + if(F[px][py+sy]=='#') {sy=-sy;}else{py+=sy;} + if(xbuf) {sx=-sx;}else{px+=sx;} + } break; + } + //System.out.println(a+"" ""+b+ "" ""+raylength+"" ""); + if((rayLives)&&(abuf ==(2*a-1)*b) && ((bbuf ==(2*b-1)*a)||(b==0))){ + abuf=-b;bbuf=-a; + if((px==startx)&&(py==starty)){ + reflCount++;rayLives=false; + //System.out.println(""Found:"" +a+"" ""+ b+"" ""+ sx2+"" ""+sy2); + } + iterations--; + } + + } + } + } + return """"+reflCount; + } + + public void go(String filename,int exerciseNr){ + java.io.File F = new java.io.File(filename); + try{ + BR = new BufferedReader(new FileReader(F)); + BufferedWriter BW= new BufferedWriter(new FileWriter(new File(""output.txt""))); + int cases = Integer.parseInt(BR.readLine()); + for(int i=0;i d * d) { + --djMax; + } + } + p: for (int dj = -djMax; dj <= djMax; dj++) { + if (di == 0 && dj == 0) { + continue; + } +// System.err.println(""TRACE "" + di + "" "" + dj); + int i = 0, j = 0; + int cci = ci, ccj = cj; + boolean fi = false, fj = false; + while (true) { +// System.err.print(""AT ("" + i + "" "" + j + "") REALLY ("" + (fi ? cci - i : cci + i) + "" "" + (fj ? ccj - j : ccj + j) + "")""); + int diff = abs((2 * i + signum(di)) * dj) - abs((2 * j + signum(dj)) * di); + if (diff > 0) { + int nj = j + signum(dj); +// System.err.println("" GO 0 "" + signum(dj)); + if (wall(wall, cci, ccj, fi, fj, i, nj)) { + ccj = flip(ccj, fj, j, nj); + fj = !fj; +// System.err.println(""VERTICAL WALL""); + } + j = nj; + } else if (diff < 0) { + int ni = i + signum(di); +// System.err.println("" GO "" + signum(di) + "" 0""); + if (wall(wall, cci, ccj, fi, fj, ni, j)) { + cci = flip(cci, fi, i, ni); + fi = !fi; +// System.err.println(""HORIZONTAL WALL""); + } + i = ni; + } else { + int ni = i + signum(di); + int nj = j + signum(dj); +// System.err.println("" GO "" + signum(di) + "" "" + signum(dj)); + if (wall(wall, cci, ccj, fi, fj, ni, nj)) { + if (wall(wall, cci, ccj, fi, fj, ni, j)) { + if (wall(wall, cci, ccj, fi, fj, i, nj)) { + cci = flip(cci, fi, i, ni); + fi = !fi; + ccj = flip(ccj, fj, j, nj); + fj = !fj; +// System.err.println(""GOOD CORNER""); + } else { + cci = flip(cci, fi, i, ni); + fi = !fi; +// System.err.println(""HORIZONTAL WALL""); + } + } else { + if (wall(wall, cci, ccj, fi, fj, i, nj)) { + ccj = flip(ccj, fj, j, nj); + fj = !fj; +// System.err.println(""VERTICAL WALL""); + } else { +// System.err.println(""BAD CORNER""); + continue p; + } + } + } + i = ni; + j = nj; + } + int ri = fi ? cci - i : cci + i; + int rj = fj ? ccj - j : ccj + j; + if (i == di && j == dj) { + if (ri == ci && rj == cj) { +// System.err.println(""IMAGE "" + di + "" "" + dj); + ++ans; + } else { +// System.err.println(""NOTHING "" + di + "" "" + dj); + } + break; + } + if (ri == ci && rj == cj && i * dj == j * di) { +// System.err.println(""BAD PERSON""); + continue p; + } + } + } + } + printCase(); + out.println(ans); + } + + static boolean wall(boolean wall[][], int ci, int cj, boolean fi, boolean fj, int i, int j) { + return wall[fi ? ci - i : ci + i][fj ? cj - j : cj + j]; + } + + static int flip(int c, boolean f, int x, int nx) { + return f ? c - x - nx : c + x + nx; + } + + static void printCase() { + out.print(""Case #"" + test + "": ""); + } + + static void printlnCase() { + out.println(""Case #"" + test + "":""); + } + + static int nextInt() throws IOException { + return parseInt(next()); + } + + static long nextLong() throws IOException { + return parseLong(next()); + } + + static double nextDouble() throws IOException { + return parseDouble(next()); + } + + static String next() throws IOException { + while (tok == null || !tok.hasMoreTokens()) { + tok = new StringTokenizer(in.readLine()); + } + return tok.nextToken(); + } + + public static void main(String[] args) { + try { + in = new BufferedReader(new InputStreamReader(System.in)); + out = new PrintWriter(new OutputStreamWriter(System.out)); + int tests = nextInt(); + for (test = 1; test <= tests; test++) { + solve(); + } + in.close(); + out.close(); + } catch (Throwable e) { + e.printStackTrace(); + exit(1); + } + } +}" +C20084,"package google.codejam2012.qualification; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.util.StringTokenizer; + +import static java.lang.Math.*; + +final class BinaryMatrix { + + private int[] data; + + public BinaryMatrix(int height, int width) { + data = new int[height]; + } + + public void set(int row, int col) { + data[row] |= 1 << col; + } + + public boolean isEmpty(int row, int col) { + return (data[row] & (1 << col)) == 0; + } +} + +public strictfp class HallOfMirrors { + + static private double eps = 1e-8; + + static private int gcd(int a, int b) { + while (a > 0 & b > 0) { + if (b > 0) a %= b; + if (a > 0) b %= a; + } + return a + b; + } + + // - simple reflections checker + static private boolean isSimpleReflectionVisible(BinaryMatrix hall, int row, int col, int dr, int dc, int dist) { + dist -= 1; + row += dr; + col += dc; + while(dist >= 0 & hall.isEmpty(row, col)) { + row += dr; + col += dc; + dist -= 2; + } + return dist >= 0; + } + + static private double euclideanDistance(double dx, double dy) { + return sqrt(dx * dx + dy * dy); + } + + static private boolean isReflectionVisible(BinaryMatrix hall, int row, int col, double distance, double ax, double ay) { + int r = row; + int c = col; + double distPassed = 0.0; + double x = c + 0.5; + double y = r + 0.5; + int dr = ay > 0 ? 1 : -1; + int dc = ax > 0 ? 1 : -1; + while (distPassed < distance + eps) { + double nx = ax > 0 ? (int) (x + eps) + 1.0 : (int) (x - eps); + double ny = ay > 0 ? (int) (y + eps) + 1.0 : (int) (y - eps); + double scenario = abs((x - nx) / ax) - abs((y - ny) / ay); + // - corner + if (abs(scenario) < eps) { + r += dr; + c += dc; + distPassed += euclideanDistance(x - nx, y - ny); + x = nx; + y = ny; + if (!hall.isEmpty(r, c)) { + if (!hall.isEmpty(r - dr, c) & !hall.isEmpty(r, c - dc)) { + distPassed += distPassed; + break; + } + // - x + else if (!hall.isEmpty(r - dr, c)) { + ax = -ax; + dc = -dc; + c += dc; + } + // - y + else if (!hall.isEmpty(r, c - dc)) { + ay = -ay; + dr = -dr; + r += dr; + } + else { + distPassed += distance + eps; + break; + } + } + } + // - x + else if (scenario < 0) { + c += dc; + ny = y + abs((x - nx) * ay / ax) * dr; + distPassed += euclideanDistance(x - nx, y - ny); + x = nx; + y = ny; + // - reflect + if (!hall.isEmpty(r, c)) { + ax = -ax; + dc = -dc; + c += dc; + } + } + // - y + else { + r += dr; + nx = x + abs((y - ny) * ax / ay) * dc; + distPassed += euclideanDistance(x - nx, y - ny); + x = nx; + y = ny; + if (!hall.isEmpty(r, c)) { + ay = -ay; + dr = -dr; + r += dr; + } + } + // - check termination condition + if (r == row & c == col) { + double cx = c + 0.5; + double cy = r + 0.5; + if (abs((x - cx) / ax - (y - cy) / ay) < eps) { + distPassed += euclideanDistance(cx - x, cy - y); + break; + } + } + } + return distPassed < distance + eps; + } + + static private int getVisibleReflectionsCount(BinaryMatrix hall, int row, int col, int distance) { + int result = 0; + // - check simple (up / down / left / right) reflections + // -- up + if (isSimpleReflectionVisible(hall, row, col, -1, 0, distance)) result++; + // -- down + if (isSimpleReflectionVisible(hall, row, col, 1, 0, distance)) result++; + // -- left + if (isSimpleReflectionVisible(hall, row, col, 0, -1, distance)) result++; + // -- right + if (isSimpleReflectionVisible(hall, row, col, 0, 1, distance)) result++; + + // - check other kinds of reflections using ray tracing method + for (int ax = 1; ax <= 250; ax++) + for (int ay = 1; ay <= 250; ay++) + if (gcd(ax, ay) == 1) { + if (isReflectionVisible(hall, row, col, distance, ax, ay)) result++; + if (isReflectionVisible(hall, row, col, distance, -ax, ay)) result++; + if (isReflectionVisible(hall, row, col, distance, ax, -ay)) result++; + if (isReflectionVisible(hall, row, col, distance, -ax, -ay)) result++; + } + + return result; + } + + static public void main(String[] args) { + try { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in), 64 << 10); + int testsNumber = Integer.parseInt(br.readLine().trim()); + for (int test = 1; test <= testsNumber; test++) { + // - read test data + StringTokenizer tokenizer = new StringTokenizer(br.readLine()); + int height = Integer.parseInt(tokenizer.nextToken()); + int width = Integer.parseInt(tokenizer.nextToken()); + int distance = Integer.parseInt(tokenizer.nextToken()); + BinaryMatrix hall = new BinaryMatrix(height, width); + int initialRow = 0; + int initialCol = 0; + for (int i = 0; i < height; i++) { + String s = br.readLine(); + for (int j = 0; j < width; j++) { + if (s.charAt(j) == '#') { + hall.set(i, j); + } + else if (s.charAt(j) == 'X'){ + initialRow = i; + initialCol = j; + } + } + } + int result = getVisibleReflectionsCount(hall, initialRow, initialCol, distance); + System.out.println(""Case #"" + test + "": "" + result); + } + } + catch (Exception e) { + System.err.println(""Error:"" + e.getMessage()); + } + } +}" +C20027,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +import java.awt.Point; +import java.util.ArrayList; +import uk.co.epii.codejam.common.DatumConverter; + +/** + * + * @author jim + */ +public class HallFactory implements DatumConverter { + + @Override + public Hall getNext(ArrayList list) { + String[] specification = list.remove(0).split("" ""); + int H = Integer.parseInt(specification[0]); + int W = Integer.parseInt(specification[1]); + int D = Integer.parseInt(specification[2]); + FractionPoint meLocation = null; + Square[][] floor = new Square[H][]; + for (int y = H - 1; y >= 0; y--) { + floor[y] = new Square[W]; + String line = list.remove(0); + for (int x = 0; x < W; x++) { + Square s = Square.parse(line.charAt(x)); + if (s == Square.ME) + meLocation = new FractionPoint( + new Fraction(x, 1, 2), new Fraction(y, 1 , 2)); + floor[y][x] = s; + } + } + return new Hall(H, W, D, meLocation, floor); + } + +} +" +C20009,"package com.forthgo.google.g2012r0; + +import com.forthgo.math.Helper; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.Scanner; + +/** + * Created by Xan Gregg. + * Date: 4/14/12 + */ +public class ProblemD { + private static final int SELF = 2; + private static final int MIRROR = 1; + + public static void main(String[] args) { + try { + Scanner in = new Scanner(new File(""D.in"")); + PrintWriter out = new PrintWriter(new FileWriter(""D.out"")); + //PrintWriter out = new PrintWriter(System.out); + int t = in.nextInt(); + for (int i = 0; i < t; i++) { + int h = in.nextInt(); + int w = in.nextInt(); + int d = in.nextInt(); + int k = solve(in, h, w, d); + out.printf(""Case #%d: %d%n"", i + 1, k); + out.flush(); + } + + } catch (IOException e) { + throw new RuntimeException(); + } + + } + + private static int solve(Scanner in, int H, int W, int D) { + in.nextLine(); + int [][] cell = new int[W][H]; + int count = 0; + int x = 0; + int y = 0; + for (int i = 0; i < H; i++) { + String row = in.nextLine(); + for (int j = 0; j < W; j++) { + if (row.charAt(j) == '#') + cell[j][i] = MIRROR; + else if (row.charAt(j) == 'X') { + cell[j][i] = SELF; + x = j; + y = i; + } + else if (row.charAt(j) != '.') { + throw new RuntimeException(); + } + } + } + for (int i = 1; i < W; i++) { + if (cell[x + i][y] == MIRROR) { + if (2 * i - 1 <= D) + count++; + break; + } + } + for (int i = 1; i < W; i++) { + if (cell[x - i][y] == MIRROR) { + if (2 * i - 1 <= D) + count++; + break; + } + } + for (int i = 1; i < H; i++) { + if (cell[x][y + i] == MIRROR) { + if (2 * i - 1 <= D) + count++; + break; + } + } + for (int i = 1; i < H; i++) { + if (cell[x][y - i] == MIRROR) { + if (2 * i - 1 <= D) + count++; + break; + } + } + //room.offset(x, y); + + for (int xdir = 1; xdir <= D; xdir++) { + int my = (int) Math.sqrt(D * D - xdir * xdir); + for (int ydir = 1; ydir <= my; ydir++) { + if (gcd(xdir, ydir) == 1) { + int k = (int) (D / Math.sqrt(xdir * xdir + ydir * ydir)); + for (int xsign = -1; xsign <= 1; xsign += 2) + for (int ysign = -1; ysign <= 1; ysign += 2) + count += countPaths(cell, x, y, k * xdir, k * ydir, xsign, ysign); + } + } + } + return count; + } + + private static int countPaths(int [][] cell, int x, int y, int xdir, int ydir, int xsign, int ysign) { + int dx = 0; + int dy = 0; + while (dx <= xdir && dy < ydir || dx < xdir && dy <= ydir) { + int x2next = 2 * dx + 1; + int y2next = x2next * ydir / xdir; + if (y2next == 2 * dy + 1 && y2next * xdir == ydir * x2next) { + int xcell = cell[x + xsign][y]; + int ycell = cell[x][y + ysign]; + int xycell = cell[x + xsign][y + ysign]; + // corner + if (xycell == MIRROR && xcell == MIRROR && ycell == MIRROR) { + xsign = -xsign; + ysign = -ysign; + } + else if (xycell == MIRROR && xcell == MIRROR && ycell != MIRROR) { + y += ysign; + xsign = -xsign; + } + else if (xycell == MIRROR && xcell != MIRROR && ycell == MIRROR) { + x += xsign; + ysign = -ysign; + } + else if (xycell == MIRROR && xcell != MIRROR && ycell != MIRROR) { + return 0; // kills beam + } + else if (xycell != MIRROR) { + // pass through + x += xsign; + y += ysign; + } + else + throw new RuntimeException(); + dx++; + dy++; + } + + else if (y2next < 2 * dy + 1) { + // next x cell + if (cell[x + xsign][y] == MIRROR) { + xsign = -xsign; + } + else { + // empty + x += xsign; + } + dx++; + } + else if (y2next >= 2 * dy + 1) { + // next y cell + if (cell[x][y + ysign] == MIRROR) { + ysign = -ysign; + } + else { + // empty + y += ysign; + } + dy++; + } + else + throw new RuntimeException(); + if (dx > xdir || dy > ydir) + break; + if (cell[x][y] == SELF) { + if ((2 * dy) * xdir == ydir * (2 * dx)) { +// System.out.printf(""%2d %2d %2d %2d %2d %2d %6.3f%n"", xdir, ydir, dx, dy, xsign, ysign, Math.sqrt(dx * dx + dy * dy)); + return 1; + } + } + } + return 0; + } + + public static int gcd(int a, int b) { + if (a < 0 || b < 0) + return -1; + while (b != 0) { + int x = a % b; + a = b; + b = x; + } + return a; + } +} +" +C20060,"package jp.funnything.competition.util; + +import java.math.BigInteger; + +/** + * Utility for BigInteger + */ +public class BI { + public static BigInteger ZERO = BigInteger.ZERO; + public static BigInteger ONE = BigInteger.ONE; + + public static BigInteger add( final BigInteger x , final BigInteger y ) { + return x.add( y ); + } + + public static BigInteger add( final BigInteger x , final long y ) { + return add( x , v( y ) ); + } + + public static BigInteger add( final long x , final BigInteger y ) { + return add( v( x ) , y ); + } + + public static int cmp( final BigInteger x , final BigInteger y ) { + return x.compareTo( y ); + } + + public static int cmp( final BigInteger x , final long y ) { + return cmp( x , v( y ) ); + } + + public static int cmp( final long x , final BigInteger y ) { + return cmp( v( x ) , y ); + } + + public static BigInteger div( final BigInteger x , final BigInteger y ) { + return x.divide( y ); + } + + public static BigInteger div( final BigInteger x , final long y ) { + return div( x , v( y ) ); + } + + public static BigInteger div( final long x , final BigInteger y ) { + return div( v( x ) , y ); + } + + public static BigInteger mod( final BigInteger x , final BigInteger y ) { + return x.mod( y ); + } + + public static BigInteger mod( final BigInteger x , final long y ) { + return mod( x , v( y ) ); + } + + public static BigInteger mod( final long x , final BigInteger y ) { + return mod( v( x ) , y ); + } + + public static BigInteger mul( final BigInteger x , final BigInteger y ) { + return x.multiply( y ); + } + + public static BigInteger mul( final BigInteger x , final long y ) { + return mul( x , v( y ) ); + } + + public static BigInteger mul( final long x , final BigInteger y ) { + return mul( v( x ) , y ); + } + + public static BigInteger sub( final BigInteger x , final BigInteger y ) { + return x.subtract( y ); + } + + public static BigInteger sub( final BigInteger x , final long y ) { + return sub( x , v( y ) ); + } + + public static BigInteger sub( final long x , final BigInteger y ) { + return sub( v( x ) , y ); + } + + public static BigInteger v( final long value ) { + return BigInteger.valueOf( value ); + } +} +" +C20004,"import java.util.*; + +public class D +{ + public static boolean wall[][]; + public static int X; + public static int Y; + + public static int[] dxs; + public static int[] dys; + + public static void main(String[] args) + { + Scanner in = new Scanner(System.in); + int T = in.nextInt(); + + for(int c = 1; c <= T; c++){ + int H = in.nextInt(); + int W = in.nextInt(); + int D = in.nextInt(); + + dxs = new int[4]; + dys = new int[4]; + + dxs[0] = dxs[1] = 1; + dxs[2] = dxs[3] = -1; + dys[0] = dys[2] = 1; + dys[1] = dys[3] = -1; + + wall = new boolean[H][W]; + + int mex, mey; + mex = 0; + mey = 0; + + in.nextLine(); + for(int i = 0; i < H; i++){ + String line = in.nextLine(); + for(int j = 0; j < W; j++){ + switch( line.charAt(j)){ + case '#': + wall[i][j] = true; + break; + case 'X': + mex = j; + mey = i; + case '.': + wall[i][j] = false; + break; + } + } + }//done reading input. + + int count = 0; + + //check NESW + int nd = 1, ed = 1, sd = 1, wd = 1; + while(!wall[mey][mex+ed]) ed++; + while(!wall[mey][mex-wd]) wd++; + while(!wall[mey+nd][mex]) nd++; + while(!wall[mey-sd][mex]) sd++; + + if(2*ed-1 <= D) count++; + if(2*wd-1 <= D) count++; + if(2*sd-1 <= D) count++; + if(2*nd-1 <= D) count++; + + for(int x = 1; x <= D; x++) + for(int y = 1; y <= D; y++){ + if(x*x + y*y > D*D) + continue; + + + for(int d = 0; d < 4; d++){ + + int posx = mex; + int posy = mey; + int dx = dxs[d]; + int dy = dys[d]; + + boolean fail = false; + + int distx = 0; + int disty = 0; + + + + for(int s = 1; s <= 2*x*y && !fail; s++){ + distx += dx; + disty += dy; + + //System.out.println(""distx = "" + distx +""; disty = "" + disty); + + if(s < 2*x*y && distx == 0 && disty == 0) + fail = true; + + if((s % x == 0) && ( (s/x) % 2 == 1) + && (s % y == 0) && ( (s/y) % 2 == 1)){ + if(!wall[posy + dy][posx + dx]){ + posy += dy; + posx += dx; + }else if(wall[posy][posx + dx] && wall[posy + dy][posx]){ + dx *= -1; + dy *= -1; + } + else if(wall[posy][posx + dx]){ + dx *= -1; + posy += dy; + } + else if(wall[posy + dy][posx]){ + posx += dx; + dy *= -1; + } + else{ + fail = true; + } + } + else if((s % x == 0) && ( (s/x) % 2 == 1)){ + if(wall[posy][posx + dx]) + dx *= -1; + else + posx += dx; + } + else if((s % y == 0) && ( (s/y) % 2 == 1)){ + if(wall[posy + dy][posx]) + dy *= -1; + else + posy += dy; + } + } + + if(!fail && posx == mex && posy == mey){ + //System.out.println(""x = "" + x +""; y = "" + y); + count++; + } + } + } + System.out.println(""Case #"" + c +"": "" + count); + } + } +}" +C20005,"package gcj; + +import com.sun.org.apache.xerces.internal.impl.xs.opti.DefaultXMLDocumentHandler; + +import java.util.*; +import java.io.*; + +public class HallOfMirrors { + final static String PROBLEM_NAME = ""mirrors""; + final static String WORK_DIR = ""D:\\Gcj\\"" + PROBLEM_NAME + ""\\""; + + int H, W, D; + double stX, stY; + int res = 0; + String[] map; + + int gcd(int a, int b) { + while (a>0 && b>0) + if (a>b) a %= b; else b %= a; + return a + b; + } + + final double EPS = 1e-10; + + double getT(double cur, int V) { + cur *= 2; V *= 2; + if (V == 0) + return 1e100; + if (V > 0) { + double want = Math.ceil(cur + EPS); + return (want - cur) / V; + } else { + double want = Math.floor(cur - EPS); + return (want - cur) / V; + } + } + + boolean isInteger(double x) { + return Math.abs(x - Math.floor(x)) <= EPS || Math.abs(x - Math.ceil(x)) <= EPS; + } + + boolean inMirror(double x, double y) { + int xx = (int)Math.floor(x); + int yy = (int)Math.floor(y); + return map[xx].charAt(yy) == '#'; + } + + void process(int dx, int dy) { + double curX = stX, curY = stY; + double dist = 0.0; + while (true) { + double t1 = getT(curX, dx); + double t2 = getT(curY, dy); + double t = Math.min(t1, t2); + + double nextX = curX + t * dx; + double nextY = curY + t * dy; + + double piece = Math.sqrt((nextX - curX) * (nextX - curX) + (nextY - curY) * (nextY - curY)); + dist += piece; + if (dist > D + EPS) + return; + + if (Math.abs(nextX - stX) <= EPS && Math.abs(nextY - stY) <= EPS) { + res++; + return; + } + + curX = nextX; + curY = nextY; + + boolean fx = isInteger(nextX); + boolean fy = isInteger(nextY); + + if (fx && fy) { + // corner + // A B + // C D + boolean A = inMirror(nextX - EPS, nextY - EPS); + boolean B = inMirror(nextX - EPS, nextY + EPS); + boolean C = inMirror(nextX + EPS, nextY - EPS); + boolean D = inMirror(nextX + EPS, nextY + EPS); + + int cnt = (A ? 1 : 0) + (B ? 1 : 0) + (C ? 1 : 0) + (D ? 1 : 0); + if (cnt == 3) { + dx = -dx; + dy = -dy; + } else if ((A && B && !C && !D) || (!A && !B && C & D)) { + dx = -dx; + } else if ((A && C && !B && !D) || (!A && !C && B && D)) { + dy = -dy; + } else if (inMirror(nextX + (dx > 0 ? EPS : -EPS), nextY + (dy > 0 ? EPS : -EPS))) { + return; + } else { + // just continue; + } + } else if (fx && !fy) { + // horizontal + if (dx != 0 && inMirror(nextX + (dx > 0 ? EPS : -EPS), nextY)) + dx = -dx; + } else if (!fx && fy) { + // vertical + if (dy != 0 && inMirror(nextX, nextY + (dy > 0 ? EPS : -EPS))) + dy = -dy; + } else { + // nothing + } + } + } + + void solve(Scanner sc, PrintWriter pw) { + H = sc.nextInt(); + W = sc.nextInt(); + D = sc.nextInt(); + map = new String[H]; + for (int i=0; i 0 && dx*dx + dy*dy <= D * D && gcd(Math.abs(dx), Math.abs(dy)) == 1) { + process(dx, dy); + } + + pw.println(res); + } + + public static void main(String[] args) throws Exception { + Scanner sc = new Scanner(new FileReader(WORK_DIR + ""input.txt"")); + PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + ""output.txt"")); + int caseCnt = sc.nextInt(); + for (int caseNum=0; caseNum 0 ? ( int ) Math.floor( x.doubleValue() + 1 ) : ( int ) Math.ceil( x.doubleValue() - 1 ) ).subtract( x ); + final Fraction diffY = + new Fraction( dy > 0 ? ( int ) Math.floor( y.doubleValue() + 1 ) : ( int ) Math.ceil( y.doubleValue() - 1 ) ).subtract( y ); + + if ( abs( diffX.doubleValue() * dy ) < abs( diffY.doubleValue() * dx ) ) { + x = x.add( diffX ); + y = y.add( diffX.multiply( dy ).divide( dx ) ); + sumDiffX = sumDiffX.add( diffX.abs() ); + sumDiffY = sumDiffY.add( diffX.multiply( dy ).divide( dx ).abs() ); + } else { + y = y.add( diffY ); + x = x.add( diffY.multiply( dx ).divide( dy ) ); + sumDiffY = sumDiffY.add( diffY.abs() ); + sumDiffX = sumDiffX.add( diffY.multiply( dx ).divide( dy ).abs() ); + } + + if ( sumDiffX.multiply( sumDiffX ).add( sumDiffY.multiply( sumDiffY ) ).compareTo( new Fraction( d * d * 2 * 2 ) ) > 0 ) { + return false; + } + + if ( x.equals( fox ) && y.equals( foy ) ) { + return true; + } + + final int nx = x.intValue() / 2 + ( dx > 0 ? 0 : -1 ); + final int ny = y.intValue() / 2 + ( dy > 0 ? 0 : -1 ); + + if ( x.getDenominator() == 1 && x.getNumerator() % 2 == 0 && y.getDenominator() == 1 && y.getNumerator() % 2 == 0 ) { + if ( map[ ny ][ nx ] ) { + final int px = x.intValue() / 2 + ( dx > 0 ? -1 : 0 ); + final int py = y.intValue() / 2 + ( dy > 0 ? -1 : 0 ); + + if ( map[ py ][ nx ] ) { + if ( map[ ny ][ px ] ) { + dx = -dx; + dy = -dy; + } else { + dx = -dx; + } + } else { + if ( map[ ny ][ px ] ) { + dy = -dy; + } else { + return false; + } + } + } + } else { + if ( x.getDenominator() == 1 && x.getNumerator() % 2 == 0 ) { + if ( map[ y.intValue() / 2 ][ nx ] ) { + dx = -dx; + } + } else if ( y.getDenominator() == 1 && y.getNumerator() % 2 == 0 ) { + if ( map[ ny ][ x.intValue() / 2 ] ) { + dy = -dy; + } + } + } + } + } + + void pack() { + try { + final File dist = new File( ""dist"" ); + + if ( dist.exists() ) { + FileUtils.deleteQuietly( dist ); + } + + final File workspace = new File( dist , ""workspace"" ); + + FileUtils.copyDirectory( new File( ""src/main/java"" ) , workspace ); + FileUtils.copyDirectory( new File( ""../../../../CompetitionUtil/Lib/src/main/java"" ) , workspace ); + + Packer.pack( workspace , new File( dist , ""sources.zip"" ) ); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + void run() throws Exception { + final CompetitionIO io = new CompetitionIO(); + + final int t = io.readInt(); + + for ( int index = 0 ; index < t ; index++ ) { + final int[] values = io.readInts(); + final int h = values[ 0 ]; + final int w = values[ 1 ]; + final int d = values[ 2 ]; + + final char[][] map = new char[ h ][]; + for ( int y = 0 ; y < h ; y++ ) { + final char[] l = io.read().toCharArray(); + + if ( l.length != w ) { + throw new RuntimeException( ""assert"" ); + } + + map[ y ] = l; + } + + io.write( index + 1 , solve( d , map ) ); + } + + io.close(); + + pack(); + } + + int solve( final int d , final char[][] map ) { + int count = 0; + + int ox = -1; + int oy = -1; + final boolean[][] parsed = new boolean[ map.length ][]; + + for ( int y = 0 ; y < map.length ; y++ ) { + parsed[ y ] = new boolean[ map[ y ].length ]; + + for ( int x = 0 ; x < map[ y ].length ; x++ ) { + final char c = map[ y ][ x ]; + + if ( c == '#' ) { + parsed[ y ][ x ] = true; + } + + if ( c == 'X' ) { + ox = x; + oy = y; + } + } + } + + for ( int dy = -d ; dy <= d ; dy++ ) { + for ( int dx = -d ; dx <= d ; dx++ ) { + if ( dx == 0 && dy == 0 ) { + continue; + } + + if ( MathUtils.gcd( dx , dy ) != 1 ) { + continue; + } + + if ( dx * dx + dy * dy > d * d ) { + continue; + } + + if ( isValid( d , parsed , ox , oy , dx , dy ) ) { + count++; + } + } + } + + return count; + } +} +" +C20006,"package problemD; + +import java.io.File; +import java.io.FileNotFoundException; +import java.util.Scanner; + +public class ProblemD { + static Rational posX = null; + static Rational posY = null; + + static Rational tarX = null; + static Rational tarY = null; + + static boolean[][] array = null; + + public static void main(String[] args) throws FileNotFoundException { + // Scanner sc = new Scanner(new File(""D-practice.in"")); + // Scanner sc = new Scanner(new File(""D-small.in"")); + Scanner sc = new Scanner(new File(""D-large.in"")); + int cases = sc.nextInt(); + for (int i = 1; i <= cases; i++) { + // do case things here + int H = sc.nextInt(); + int W = sc.nextInt(); + int D = sc.nextInt(); + D *= 2; + array = new boolean[H][W]; + for (int j = 0; j < H; j++) { + String s = sc.next(); + for (int k = 0; k < W; k++) { + array[j][k] = (s.charAt(k) == '#'); + if (s.charAt(k) == 'X') { + posX = new Rational(2 * k + 1, 1); + posY = new Rational(2 * j + 1, 1); + tarX = posX; + tarY = posY; + } + } + } + int count = 0; + boolean checked[][] = new boolean[2 * D + 1][2 * D + 1]; + for (int j = 2; j <= D; j += 2) { + for (int x = -j; x <= j; x += 2) { + if (D + j >= 0 && D + j < checked.length && D + x >= 0 + && D + x < checked.length) { + if (!checked[D + j][D + x]) { + if (followRay(j, x, D)) { + count++; + } + int k = 1; + while (D + (k * j) >= 0 + && D + (k * j) < checked.length + && D + (k * x) >= 0 + && D + (k * x) < checked.length) { + checked[D + (k * j)][D + (k * x)] = true; + k++; + } + } + } + if (D + j >= 0 && D + j < checked.length && D + x >= 0 + && D + x < checked.length) { + if (!checked[D + x][D + j]) { + if (followRay(x, j, D)) { + count++; + } + int k = 1; + while (D + (k * j) >= 0 + && D + (k * j) < checked.length + && D + (k * x) >= 0 + && D + (k * x) < checked.length) { + checked[D + (k * x)][D + (k * j)] = true; + k++; + } + } + } + + if (D - j >= 0 && D - j < checked.length && D + x >= 0 + && D + x < checked.length) { + if (!checked[D - j][D + x]) { + if (followRay(-j, x, D)) { + count++; + } + int k = 1; + while (D - (k * j) >= 0 + && D - (k * j) < checked.length + && D + (k * x) >= 0 + && D + (k * x) < checked.length) { + checked[D - (k * j)][D + (k * x)] = true; + k++; + } + } + } + if (D - j >= 0 && D - j < checked.length && D + x >= 0 + && D + x < checked.length) { + if (!checked[D + x][D - j]) { + if (followRay(x, -j, D)) { + count++; + } + int k = 1; + while (D - (k * j) >= 0 + && D - (k * j) < checked.length + && D + (k * x) >= 0 + && D + (k * x) < checked.length) { + checked[D + (k * x)][D - (k * j)] = true; + k++; + } + } + } + } + } + // System.out.println(count); + System.out.format(""Case #%d: %d\n"", i, count); + } + } + + private static boolean followRay(int dirX, int dirY, int max) { + double distance = 0; + posX = tarX; + posY = tarY; + distance += step(dirX, dirY); + while (distance <= max) { + if (tarX.equals(posX) && tarY.equals(posY)) { + return true; + } + // check mirror, adjust direction + if (dirX == 0) { + if (posY.n == 1 && posY.z % 2 == 0) { + int y = posY.z / 2; + if (y >= array.length || y == 0) { + return false; + } + int x = posX.z / posX.n / 2; + if (dirY > 0 && array[y][x] || dirY < 0 && array[y - 1][x]) { + dirY = -1 * dirY; + } + } + } else if (dirY == 0) { + if (posX.n == 1 && posX.z % 2 == 0) { + int x = posX.z / 2; + if (x >= array[0].length || x == 0) { + return false; + } + int y = posY.z / posY.n / 2; + if (dirX > 0 && array[y][x] || dirX < 0 && array[y][x - 1]) { + dirX = -1 * dirX; + } + } + } + if (posX.n == 1 && posX.z % 2 == 0) { + if (posY.n == 1 && posY.z % 2 == 0) { + // corner + int x = posX.z / 2; + int y = posY.z / 2; + boolean mirrored = false; + if (dirX > 0) { + if (array[y][x] && array[y - 1][x]) { + dirX = -1 * dirX; + mirrored = true; + } + } else { + if (array[y][x - 1] && array[y - 1][x - 1]) { + dirX = -1 * dirX; + mirrored = true; + } + } + if (dirY > 0) { + if (array[y][x] && array[y][x - 1]) { + dirY = -1 * dirY; + mirrored = true; + } + } else { + if (array[y - 1][x] && array[y - 1][x - 1]) { + dirY = -1 * dirY; + mirrored = true; + } + } + if (!mirrored) { + if (dirX > 0) { + if (dirY > 0) { + if (array[y][x]) { + return false; + } + } else { + if (array[y - 1][x]) { + return false; + } + } + } else { + if (dirY > 0) { + if (array[y][x - 1]) { + return false; + } + } else { + if (array[y - 1][x - 1]) { + return false; + } + } + } + } + } else { + int x = posX.z / 2; + if (x >= array[0].length || x == 0) { + return false; + } + int y = posY.z / posY.n / 2; + if (dirX > 0 && array[y][x] || dirX < 0 && array[y][x - 1]) { + dirX = -1 * dirX; + } + } + } else if (posY.n == 1 && posY.z % 2 == 0) { + int y = posY.z / 2; + if (y >= array.length || y == 0) { + return false; + } + int x = posX.z / posX.n / 2; + if (dirY > 0 && array[y][x] || dirY < 0 && array[y - 1][x]) { + dirY = -1 * dirY; + } + } + + distance += step(dirX, dirY); + } + return false; + } + + // steps until the next coord becomes integer + private static double step(int dirX, int dirY) { + if (dirY == 0) { + if (dirX > 0) { + posX = posX.plus(Rational.one); + } else { + posX = posX.minus(Rational.one); + } + return 1; + } + if (dirX == 0) { + if (dirY > 0) { + posY = posY.plus(Rational.one); + } else { + posY = posY.minus(Rational.one); + } + return 1; + } + + if (posX.n == 1) { + Rational distY = posY.fractal(); + Rational speed = new Rational(Math.abs(dirY), Math.abs(dirX)); + if (dirY > 0) { + distY = Rational.one.minus(distY); + } + if (distY.equals(Rational.zero)) { + distY = Rational.one; + } + if (distY.minus(speed).positive()) { + if (dirX > 0) { + posX = posX.plus(Rational.one); + } else { + posX = posX.minus(Rational.one); + } + if (dirY > 0) { + posY = posY.plus(speed); + } else { + posY = posY.minus(speed); + } + return Math.sqrt(1 + speed.times(speed).value()); + } else { + if (dirY > 0) { + posY = posY.plus(distY); + } else { + posY = posY.minus(distY); + } + Rational distX = distY.divides(speed); + if (dirX > 0) { + posX = posX.plus(distX); + } else { + posX = posX.minus(distX); + } + return Math.sqrt(distY.times(distY).value() + + distX.times(distX).value()); + } + } else { + Rational distX = posX.fractal(); + Rational speed = new Rational(Math.abs(dirX), Math.abs(dirY)); + if (dirX > 0) { + distX = Rational.one.minus(distX); + } + if (distX.minus(speed).positive()) { + if (dirY > 0) { + posY = posY.plus(Rational.one); + } else { + posY = posY.minus(Rational.one); + } + if (dirX > 0) { + posX = posX.plus(speed); + } else { + posX = posX.minus(speed); + } + return Math.sqrt(1 + speed.times(speed).value()); + } else { + if (dirX > 0) { + posX = posX.plus(distX); + } else { + posX = posX.minus(distX); + } + Rational distY = distX.divides(speed); + if (dirY > 0) { + posY = posY.plus(distY); + } else { + posY = posY.minus(distY); + } + return Math.sqrt(distY.times(distY).value() + + distX.times(distX).value()); + } + } + } + + // private static void out(boolean[] array) { + // System.out.println(Arrays.toString(array)); + // } + // + // private static void out(boolean[][] array) { + // int count = 0; + // for (boolean[] a : array) { + // System.out.print(count++ + "":""); + // out(a); + // } + // } + + private static class Rational { + static final Rational one = new Rational(1, 1); + static final Rational zero = new Rational(0, 1); + + public int z; + public int n; + + // create and initialize a new Rational object + public Rational(int z, int n) { + if (n == 0) { + throw new RuntimeException(""Denominator is zero""); + } + int g = gcd(z, n); + this.z = z / g; + this.n = n / g; + + } + + // return string representation of (this) + public String toString() { + if (n == 1) { + return z + """"; + } else { + return z + ""/"" + n; + } + } + + // return (this * b) + public Rational times(Rational b) { + return new Rational(this.z * b.z, this.n * b.n); + } + + // return (this + b) + public Rational plus(Rational b) { + int z = (this.z * b.n) + (this.n * b.z); + int n = this.n * b.n; + return new Rational(z, n); + } + + // return (this - b) + public Rational minus(Rational b) { + int z = (this.z * b.n) - (this.n * b.z); + int n = this.n * b.n; + return new Rational(z, n); + } + + // return fractal amount + public Rational fractal() { + return new Rational(z % n, n); + } + + // return (1 / this) + public Rational reciprocal() { + return new Rational(n, z); + } + + // return (this / b) + public Rational divides(Rational b) { + return this.times(b.reciprocal()); + } + + public boolean positive() { + return z * n >= 0; + } + + public boolean equals(Rational r) { + return r.z == this.z && r.n == this.n; + } + + public double value() { + return 1.0 * z / n; + } + + private int gcd(int m, int n) { + if (0 == n) + return m; + else + return gcd(n, m % n); + } + } +} +" +C20067,"import java.io.*; +import java.util.*; + +public class Solution { + + + private StringTokenizer st; + private BufferedReader in; + private PrintWriter out; + + final String file = ""D-large""; + + public void solve() throws IOException { + int tests = nextInt(); + for (int test = 0; test < tests; ++test) { + int n = nextInt(); + int m = nextInt(); + int d = nextInt(); + char[][] f = new char[n][m]; + int x0 = -1, y0 = -1; + for (int i = 0; i < n; ++i) { + f[i] = next().toCharArray(); + for (int j = 0; j < m; ++j) { + if (f[i][j] == 'X') { + x0 = i; + y0 = j; + } + } + } + int ans = 0; + for (int dx = -d; dx <= d; ++dx) { + for (int dy = -d; dy <= d; ++dy) { + if ((dx != 0 || dy != 0) && dx * dx + dy * dy <= d * d && raytrace(x0, y0, x0 + dx, y0 + dy, f, 0.)) { +// System.err.println(dx + "" "" + dy); + ans++; + } + } + } + System.err.printf(""Case #%d: %d%n"", test + 1, ans); + out.printf(""Case #%d: %d%n"", test + 1, ans); + } + } + + final double EPS = 1e-8; + + private boolean raytrace(int x0, int y0, int x1, int y1, char[][] f, double t) { + double firstt = Double.POSITIVE_INFINITY; + int dx = x1 - x0; + int dy = y1 - y0; + double tx = Double.POSITIVE_INFINITY; + for (int i = Math.max(0, Math.min(x0, x1)); i < f.length && i <= Math.max(x0, x1); ++i) { + for (int j = Math.max(0, Math.min(y0, y1)); j < f[0].length && j <= Math.max(y0, y1); ++j) { + if (f[i][j] == 'X') { + double tt = dx != 0 ? (double)(i - x0) / dx : (double)(j - y0) / dy; + if (Math.abs(x0 + dx * tt - i) < EPS && Math.abs(y0 + dy * tt - j) < EPS) { + tx = tt; + } + } + if (f[i][j] != '#') { + continue; + } + double minx = dx == 0 ? Double.NEGATIVE_INFINITY : Math.min((i - 0.5 - x0) / dx, (i + 0.5 - x0) / dx); + double maxx = dx == 0 ? Double.POSITIVE_INFINITY : Math.max((i - 0.5 - x0) / dx, (i + 0.5 - x0) / dx); + double miny = dy == 0 ? Double.NEGATIVE_INFINITY : Math.min((j - 0.5 - y0) / dy, (j + 0.5 - y0) / dy); + double maxy = dy == 0 ? Double.POSITIVE_INFINITY : Math.max((j - 0.5 - y0) / dy, (j + 0.5 - y0) / dy); + if (maxx < miny - EPS || maxy < minx - EPS) { + continue; + } + double tt = Math.max(minx, miny); + if (tt > t + EPS) { + firstt = Math.min(firstt, tt); + } + } + } + if (firstt > 1.) { + return x1 >= 0 && x1 < f.length && y1 >= 0 && y1 < f[0].length && f[x1][y1] == 'X'; + } + if (tx > t + EPS && tx < firstt) { + return false; + } + int sx = Integer.signum(dx); + int sy = Integer.signum(dy); + double x = x0 + dx * firstt - 0.5; + double y = y0 + dy * firstt - 0.5; + int rx = (int)Math.round(x); + int ry = (int)Math.round(y); + if (Math.abs(rx - x) < EPS && Math.abs(ry - y) < EPS) { + if (dx == 0 || dy == 0) { + throw new AssertionError(); + } + boolean f11 = get(f, rx + (1 + sx) / 2, ry + (1 + sy) / 2); + boolean f01 = get(f, rx + (1 - sx) / 2, ry + (1 + sy) / 2); + boolean f10 = get(f, rx + (1 + sx) / 2, ry + (1 - sy) / 2); + if (get(f, rx + (1 - sx) / 2, ry + (1 - sy) / 2) || !f11 && !f01 && !f10) { + throw new AssertionError(); + } + if (!f11) { + return raytrace(x0, y0, x1, y1, f, firstt); + } + if (f01 && f10 && f11) { + return raytrace(2 * rx + 1 - x0, 2 * ry + 1 - y0, 2 * rx + 1 - x1, 2 * ry + 1 - y1, f, firstt); + } + if (f10 && f11) { + return raytrace(2 * rx + 1 - x0, y0, 2 * rx + 1 - x1, y1, f, firstt); + } + if (f01 && f11) { + return raytrace(x0, 2 * ry + 1 - y0, x1, 2 * ry + 1 - y1, f, firstt); + } + return false; + } + if (Math.abs(rx - x) < EPS) { + return raytrace(2 * rx + 1 - x0, y0, 2 * rx + 1 - x1, y1, f, firstt); + } + if (Math.abs(ry - y) < EPS) { + return raytrace(x0, 2 * ry + 1 - y0, x1, 2 * ry + 1 - y1, f, firstt); + } + throw new AssertionError(); + } + + private boolean get(char[][] f, int i, int j) { + return i >= 0 && i < f.length && j >= 0 && j < f[0].length && f[i][j] == '#'; + } + + public void run() throws IOException { + in = new BufferedReader(new FileReader(file + "".in"")); + out = new PrintWriter(file + "".out""); + eat(""""); + + solve(); + + out.close(); + } + + void eat(String s) { + st = new StringTokenizer(s); + } + + String next() throws IOException { + while (!st.hasMoreTokens()) { + String line = in.readLine(); + if (line == null) { + return null; + } + eat(line); + } + return st.nextToken(); + } + + int nextInt() throws IOException { + return Integer.parseInt(next()); + } + + long nextLong() throws IOException { + return Long.parseLong(next()); + } + + double nextDouble() throws IOException { + return Double.parseDouble(next()); + } + + public static void main(String[] args) throws IOException { + Locale.setDefault(Locale.US); + new Solution().run(); + } + +}" +C20008,"import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + + +public class SimpleMirrors { + public static void main(String[] args) throws IOException { + BufferedReader in = new BufferedReader(new FileReader(args[0])); + PrintWriter out = new PrintWriter(args[1]); + + // number of testcases + String sCount = in.readLine(); + int count = Integer.parseInt(sCount); + + for(int idx=1; idx<=count; idx++) { + String[] parts = in.readLine().split("" ""); + int h = Integer.parseInt(parts[0]); + int w = Integer.parseInt(parts[1]); + int d = Integer.parseInt(parts[2]); + + int x = -1, y = -1; + + // small dataset => just find the ""X"" + for(int i=0; i -1) { + y = 10*i - 5; + x = 10*p - 5; + } + } + + out.println(""Case #"" + idx + "": "" + process(10*(h-2), 10*(w-2), 10*d, x, y)); + + } + + out.close(); + } + + private static int process(int h, int w, int d, int ox, int oy) { + System.out.println(""h="" + h + "", w="" + w + "", d="" + d + "", ox="" + ox + "", oy="" + oy); + + MirrorSet ms = new MirrorSet( + Arrays.asList(new Mirror[] { + new Mirror(Facing.POS, Orient.HORIZ, 0, 0, w), + new Mirror(Facing.NEG, Orient.HORIZ, h, 0, w), + new Mirror(Facing.POS, Orient.VERT, 0, 0, h), + new Mirror(Facing.NEG, Orient.VERT, w, 0, h), + }), + ox, + oy, + d, + w, + h + ); + + Set pts = ms.transitiveImages(); + Set angles = ms.angles(pts); + System.out.println("" "" + pts.size() + "": "" + pts); + System.out.println("" "" + angles.size() + "": "" + angles); + + return angles.size(); + } + + + private static class MirrorSet { + private final Collection mirrors; + private final int ox, oy, limit, w, h; + + public MirrorSet(Collection mirrors, int ox, int oy, int limit, int w, int h) { + this.mirrors = mirrors; + this.ox = ox; + this.oy = oy; + this.limit = limit; + this.w = w; + this.h = h; + } + + public Set images(Set in) { + HashSet out = new HashSet(); + + for(Point i : in) { + for(Mirror m : mirrors) { + Point o = m.image(i); + if(o != null && ! in.contains(o) && + Math.sqrt((ox-o.x)*(ox-o.x) + (oy-o.y)*(oy-o.y)) <= limit) out.add(o); + } + } + + return out; + } + + public Set transitiveImages() { + Set im = new HashSet(); + im.add(new Point(ox, oy)); + Set newer; + do { + newer = images(im); + im.addAll(newer); + } while(newer.size() > 0); + + return im; + } + + public Set angles(Set in) { + Set out = new HashSet(); + + for(Point i : in) { + if(i.x != ox || i.y != oy) + out.add(Math.atan2(i.y-oy, i.x-ox)); + } + + return out; + } + } + + private static enum Facing { + POS, NEG + } + + private static enum Orient { + VERT, HORIZ + } + + private static class Mirror { + private final Facing facing; + private final Orient orient; + private final int pos, start, stop; + + public Mirror(Facing facing, Orient orient, int pos, int start, int stop) { + this.facing = facing; + this.orient = orient; + this.pos = pos; + this.start = start; + this.stop = stop; + } + + public Point image(Point p) { + switch(orient) { + case VERT: + if(facing == Facing.POS && p.x >= pos || facing == Facing.NEG && p.x <= pos) { + return new Point(2 * pos - p.x, p.y); + } else return null; + + + case HORIZ: + if(facing == Facing.POS && p.y >= pos || facing == Facing.NEG && p.y <= pos) { + return new Point(p.x, 2 * pos - p.y); + } else return null; + + } + + return null; + } + } + + private static class Point { + public final int x, y; + + public Point(int x, int y) { + this.x = x; + this.y = y; + } + + @Override + public boolean equals(Object obj) { + return obj instanceof Point && ((Point)obj).x == x && ((Point)obj).y == y; + } + + @Override + public int hashCode() { + return (x << 16) ^ y; + } + + @Override + public String toString() { + return ""("" + x + "", "" + y + "")""; + } + } + +}" +C20063,"package jp.funnything.competition.util; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; + +import org.apache.commons.io.IOUtils; + +public class AnswerWriter { + private static final String DEFAULT_FORMAT = ""Case #%d: %s\n""; + + private final BufferedWriter _writer; + private final String _format; + + public AnswerWriter( final File output , final String format ) { + try { + _writer = new BufferedWriter( new FileWriter( output ) ); + _format = format != null ? format : DEFAULT_FORMAT; + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } + + public void close() { + IOUtils.closeQuietly( _writer ); + } + + public void write( final int questionNumber , final Object result ) { + write( questionNumber , result.toString() , true ); + } + + public void write( final int questionNumber , final String result ) { + write( questionNumber , result , true ); + } + + public void write( final int questionNumber , final String result , final boolean tee ) { + try { + final String content = String.format( _format , questionNumber , result ); + + if ( tee ) { + System.out.print( content ); + System.out.flush(); + } + + _writer.write( content ); + } catch ( final IOException e ) { + throw new RuntimeException( e ); + } + } +} +" +C20015,"package qualification; + +import java.io.*; +import java.util.Scanner; + +/** + * @author Roman Elizarov + */ +public class D { + public static void main(String[] args) throws IOException { + new D().go(); + } + + Scanner in; + PrintWriter out; + + private void go() throws IOException { + in = new Scanner(new File(""src\\qualification\\d.in"")); + out = new PrintWriter(new File(""src\\qualification\\d.out"")); + int t = in.nextInt(); + for (int tn = 1; tn <= t; tn++) { + System.out.println(""Case #"" + tn); + out.println(""Case #"" + tn + "": "" + solveCase()); + } + in.close(); + out.close(); + } + + int h; + int w; + int d; + char[][] c; + + int a00 = 1; + int a01; + int a10; + int a11 = 1; + int b0; + int b1; + + char get(int x, int y) { + return c[a00 * x + a01 * y + b0][a10 * x + a11 * y + b1]; + } + + void printC() { + System.out.println(""--- C ---""); + for (int i = 0; i < h; i++) { + for (int j = 0; j < w; j++) + System.out.print(c[i][j]); + System.out.println(); + } + } + + void printV(String hdr) { + System.out.println(""--- "" + hdr + "" ---""); + for (int y = 3; y >= -4; y--) { + System.out.print(y == 0 ? ""_"" : "" ""); + for (int x = 0; x <= 5; x++) + try { + System.out.print(get(x, y)); + } catch (ArrayIndexOutOfBoundsException e) { + System.out.print('?'); + } + System.out.println(); + } + } + + // Rotate 90 deg ccw around point (0.5, 0.5) + void rotateCCW() { + int d00 = -a01; + int d01 = a00; + int d10 = -a11; + int d11 = a10; + a00 = d00; + a01 = d01; + a10 = d10; + a11 = d11; + } + + // Rotate 90 deg cw around point (0.5, 0.5) + void rotateCW() { + int d00 = a01; + int d01 = -a00; + int d10 = a11; + int d11 = -a10; + a00 = d00; + a01 = d01; + a10 = d10; + a11 = d11; + } + + // Mirror around x = p + void mirrorX(int p) { + b0 += a00 * (2 * p - 1); + b1 += a10 * (2 * p - 1); + a00 = -a00; + a10 = -a10; + } + + // Mirror around y = q + void mirrorY(int q) { + b0 += a01 * (2 * q - 1); + b1 += a11 * (2 * q - 1); + a01 = -a01; + a11 = -a11; + } + + // Mirror around y = 0.5 + void mirrorYC() { + a01 = -a01; + a11 = -a11; + } + + private int solveCase() { + h = in.nextInt(); + w = in.nextInt(); + d = in.nextInt(); + c = new char[h][]; + for (int i = 0; i < h; i++) { + c[i] = in.next().toCharArray(); + assert c[i].length == w; + } + printC(); + find: + for (b0 = 0; b0 < h; b0++) + for (b1 = 0; b1 < w; b1++) + if (c[b0][b1] == 'X') + break find; + int cnt = 0; + for (int i = 0; i < 4; i++) { + cnt += solveRay(1, 1); + cnt += solveRangeX(1, 1, -1, 1, 1); + rotateCCW(); + } + return cnt; + } + + // (0.5, 0.5) -> (x, y) + int solveRay(int x, int y) { + int cnt = 0; + if (y <= 0) { + mirrorYC(); + cnt = solveRay(x, -y + 1); + mirrorYC(); + return cnt; + } + if (!possible(x, y)) + return 0; + assert x > 0; + switch (get(x, y)) { + case '#': + char c1 = get(x - 1, y); + char c2 = get(x, y - 1); + if (c1 == '#' && c2 == '#') { + // reflected straight back + if (good2(x, y)) + cnt++; + } else if (c1 == '#') { + mirrorY(y); + cnt = solveRay(x, y); + mirrorY(y); + } else if (c2 == '#') { + mirrorX(x); + cnt = solveRay(x, y); + mirrorX(x); + } // otherwise -> destroyed + break; + case 'X': + if (x == y) { + if (good(x, y)) + cnt++; + break; + } + // fall-through + case '.': + if (x < y) + cnt = solveRay2(2 * x - 1, 2 * y - 1, x, y + 1); + else if (x > y) + cnt = solveRay2(2 * x - 1, 2 * y - 1, x + 1, y); + else // x == y + cnt = solveRay(x + 1, y + 1); + break; + default: + assert false; + } + return cnt; + } + + int solveRay2(int x0, int y0, int x, int y) { + if (!possible(x, y)) + return 0; + int cnt = 0; + int ccw; + switch (get(x, y)) { + case '#': + ccw = ccw(x0, y0, 2 * x - 1, 2 * y - 1); + if (ccw > 0) { + mirrorY(y); + cnt = solveRay2(x0, y0, x, y); + mirrorY(y); + } else if (ccw < 0) { + mirrorX(x); + cnt = solveRay2(x0, y0, x, y); + mirrorX(x); + } else + cnt = solveRay(x, y); // hit corner + break; + case 'X': + if (ccw(x0, y0, x, y) == 0) { + if (good(x, y)) + cnt++; + break; + } + case '.': + ccw = ccw(x0, y0, 2 * x + 1, 2 * y + 1); + if (ccw > 0) + cnt = solveRay2(x0, y0, x + 1, y); + else if (ccw < 0) + cnt = solveRay2(x0, y0, x, y + 1); + else + cnt = solveRay(x + 1, y + 1); // hit corner + break; + default: + assert false; + } + return cnt; + } + + // (0.5, 0.5) -> (p, y') between (x0, y0) and (x1, y1) vectors + int solveRangeX(int p, int x0, int y0, int x1, int y1) { + //printV(""solveRangeX("" + p + "","" + x0 + "","" + y0 + "","" + x1 + "","" + y1 + "")""); + assert ccw(x0, y0, x1, y1) > 0; + if (p > d) + return 0; + int q = projectRay(p, x0, y0); + assert ccw(2 * p - 1, 2 * q - 1, x0, y0) >= 0; + assert ccw(x1, y1, 2 * p - 1, 2 * q + 1) >= 0; + int cnt = 0; + switch (get(p, q)) { + case '#': + mirrorX(p); + cnt += solveRangeX(p, x0, y0, x1, y1); + mirrorX(p); + break; + case 'X': + if (ccw(x0, y0, p, q) > 0 && ccw(p, q, x1, y1) > 0) { + if (good(p, q)) + cnt++; + cnt += solveRangeX(p, x0, y0, p, q); + cnt += solveRangeX(p, p, q, x1, y1); + break; + } + // fall-through + case '.': + if (q <= 0 && ccw(x0, y0, 2 * p + 1, 2 * q - 1) > 0) { + if (ccw(2 * p + 1, 2 * q - 1, x1, y1) > 0) { + cnt += solveRangeY(q, x0, y0, 2 * p + 1, 2 * q - 1); + cnt += solveRay(p + 1, q); + x0 = 2 * p + 1; + y0 = 2 * q - 1; + } else { + cnt += solveRangeY(q, x0, y0, x1, y1); + break; + } + } + if (q >= 0 && ccw(2 * p + 1, 2 * q + 1, x1, y1) > 0) { + if (ccw(x0, y0, 2 * p + 1, 2 * q + 1) > 0) { + cnt += solveRangeY(q + 1, 2 * p + 1, 2 * q + 1, x1, y1); + cnt += solveRay(p + 1, q + 1); + x1 = 2 * p + 1; + y1 = 2 * q + 1; + } else { + cnt += solveRangeY(q + 1, x0, y0, x1, y1); + break; + } + } + cnt += solveRangeX(p + 1, x0, y0, x1, y1); + break; + default: + assert false; + } + return cnt; + } + + private boolean possible(int x, int y) { + return sqr(2 * x - 1) + sqr(2 * y - 1) <= sqr(2 * d); + } + + private boolean good(int x, int y) { + return sqr(x) + sqr(y) <= sqr(d); + } + + boolean good2(int x, int y) { + return sqr(2 * x - 1) + sqr(2 * y - 1) <= sqr(d); + } + + int solveRangeY(int q, int x0, int y0, int x1, int y1) { + //printV(""solveRangeY("" + q + "","" + x0 + "","" + y0 + "","" + x1 + "","" + y1 + "")""); + int cnt; + if (q <= 0) { + rotateCCW(); + cnt = solveRangeX(-q + 1, -y0, x0, -y1, x1); + rotateCW(); + } else { + rotateCW(); + cnt = solveRangeX(q, y0, -x0, y1, -x1); + rotateCCW(); + } + return cnt; + } + + static int projectRay(int p, int x0, int y0) { + return div(x0 + y0 * (2 * p - 1), 2 * x0); + } + + static int div(int a, int b) { + assert b > 0; + return a >= 0 ? a / b : -((-a + b - 1)/ b); + } + + static int ccw(int x0, int y0, int x1, int y1) { + return x0 * y1 - x1 * y0; + } + + static int sqr(int x) { + return x * x; + } +} +" +C20050,"package jp.funnything.competition.util; + +public enum Direction { + UP , DOWN , LEFT , RIGHT; + + public int dx() { + switch ( this ) { + case UP: + case DOWN: + return 0; + case LEFT: + return -1; + case RIGHT: + return 1; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public int dy() { + switch ( this ) { + case UP: + return -1; + case DOWN: + return 1; + case LEFT: + case RIGHT: + return 0; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public Direction reverese() { + switch ( this ) { + case UP: + return DOWN; + case DOWN: + return UP; + case LEFT: + return RIGHT; + case RIGHT: + return LEFT; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public Direction turnLeft() { + switch ( this ) { + case UP: + return LEFT; + case DOWN: + return RIGHT; + case LEFT: + return DOWN; + case RIGHT: + return UP; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public Direction turnRight() { + switch ( this ) { + case UP: + return RIGHT; + case DOWN: + return LEFT; + case LEFT: + return UP; + case RIGHT: + return DOWN; + default: + throw new RuntimeException( ""assert"" ); + } + } +} +" +C20085,"import java.util.Scanner; +import java.io.IOException; +import java.util.Arrays; +import java.util.ArrayList; +import java.io.PrintStream; +import java.io.OutputStream; +import java.io.FileOutputStream; +import java.io.PrintWriter; +import java.io.FileInputStream; +import java.io.InputStream; + +/** + * Built using CHelper plug-in + * Actual solution is at the top + */ +public class Main { + public static void main(String[] args) { + InputStream inputStream; + try { + inputStream = new FileInputStream(""D-large.in""); + } catch (IOException e) { + throw new RuntimeException(e); + } + OutputStream outputStream; + try { + outputStream = new FileOutputStream(""gcj4.out""); + } catch (IOException e) { + throw new RuntimeException(e); + } + Scanner in = new Scanner(inputStream); + PrintWriter out = new PrintWriter(outputStream); + GCJ4 solver = new GCJ4(); + solver.solve(1, in, out); + out.close(); + } +} + +class GCJ4 { + int[] DX = {1,1,-1,-1}; + int[] DY = {1,-1,1,-1}; + double EPS = 1e-9; + public void solve(int testNumber, Scanner in, PrintWriter out) { + int cases = in.nextInt(); + for(int caseNum =0;caseNum1)continue; + int dx = DX[k]; + int dy = DY[k]; + if(dx==-1 && x==0 || dy==-1 && y==0)continue; + if(x==0)dx=0; + if(y==0)dy=0; + double dist = 0; + int curX = SX; + int curY = SY; + int ddx = 0; + int ddy = 0; + //debug(""NEXT"",x,y); + while(ddx*ddx+ddy*ddy<=D*D) { + //if(x==3 && y==7)debug(ddx,ddy); + boolean goRight = false; + boolean goUp = false; + if(y==0)goRight = true; + else if(x==0)goUp = true; + else { + int minAnchor = Math.min(ddx/x,ddy/y); + int fromAnchorX = ddx-x*minAnchor; + int fromAnchorY = ddy-y*minAnchor; + if(x%2==1 && y%2==1 && fromAnchorX==(x+1)/2-1 && fromAnchorY==(y+1)/2-1) { + goRight = goUp = true; + } + else { + if(GeomLib.cross2D(0.,0.,x,y,ddx+.5,ddy+.5)>0) { + goRight = true; + } + else goUp = true; + } + } + int nextX = curX; + int nextY = curY; + if(goRight) { + nextX+=dx; + } + if(goUp) { + nextY+=dy; + } + if(m[nextY].charAt(nextX)=='#') { + if(goUp && goRight) { + if(m[curY].charAt(nextX)=='#' && m[nextY].charAt(curX)=='#') { + int ma = Math.min(ddx/x,ddy/y); + double fx = x*ma; + double fy = y*ma; + double smx = x*.5; + double smy = y*.5; + if(Math.sqrt(fx*fx+fy*fy)+Math.sqrt(smx*smx+smy*smy)-EPS readIntegerList(BufferedReader br) { + return readIntegerList(br, null); + } + + public static ArrayList readIntegerList(BufferedReader br, Integer expectedLength) { + String[] s = readLn(br).split("" ""); + ArrayList l = new ArrayList<>(); + for (int x = 0; x < s.length; x++) { + l.add(new Integer(s[x])); + } + if (expectedLength != null) { + if (l.size() != expectedLength.intValue()) { + die(""Incorrect length in readIntegerList""); + } + } + return l; + } + + public static ArrayList readMultipleIntegers(BufferedReader br, Integer rows) { + ArrayList l = new ArrayList<>(); + for (int x = 0; x < rows; x++) { + String s = readLn(br); + l.add(new Integer(s)); + } + return l; + } + + public static ArrayList> readIntegerMatrix(BufferedReader br, Integer rows) { + return readIntegerMatrix(br, rows, null); + } + + public static ArrayList> readIntegerMatrix(BufferedReader br, Integer rows, Integer expectedLength) { + ArrayList> l = new ArrayList<>(); + for (int x = 0; x < rows.intValue(); x++) { + l.add(readIntegerList(br, expectedLength)); + } + return l; + } + + public static Double readDouble(BufferedReader br) { + return new Double(readLn(br)); + } + + public static ArrayList readDoubleList(BufferedReader br) { + return readDoubleList(br, null); + } + + public static ArrayList readDoubleList(BufferedReader br, Integer expectedLength) { + String[] s = readLn(br).split("" ""); + ArrayList l = new ArrayList<>(); + for (int x = 0; x < s.length; x++) { + l.add(new Double(s[x])); + } + if (expectedLength != null) { + if (l.size() != expectedLength.intValue()) { + die(""Incorrect length in readDoubleList""); + } + } + return l; + } + + public static ArrayList readMultipleDoubles(BufferedReader br, Integer rows) { + ArrayList l = new ArrayList<>(); + for (int x = 0; x < rows; x++) { + String s = readLn(br); + l.add(new Double(s)); + } + return l; + } + + public static ArrayList> readDoubleMatrix(BufferedReader br, Integer rows) { + return readDoubleMatrix(br, rows, null); + } + + public static ArrayList> readDoubleMatrix(BufferedReader br, Integer rows, Integer expectedLength) { + ArrayList> l = new ArrayList<>(); + for (int x = 0; x < rows.intValue(); x++) { + l.add(readDoubleList(br, expectedLength)); + } + return l; + } + + public static Long readLong(BufferedReader br) { + return new Long(readLn(br)); + } + + public static ArrayList readLongList(BufferedReader br) { + return readLongList(br, null); + } + + public static ArrayList readLongList(BufferedReader br, Integer expectedLength) { + String[] s = readLn(br).split("" ""); + ArrayList l = new ArrayList<>(); + for (int x = 0; x < s.length; x++) { + l.add(new Long(s[x])); + } + if (expectedLength != null) { + if (l.size() != expectedLength.intValue()) { + die(""Incorrect length in readLongList""); + } + } + return l; + } + + public static ArrayList readMultipleLongs(BufferedReader br, Integer rows) { + ArrayList l = new ArrayList<>(); + for (int x = 0; x < rows; x++) { + String s = readLn(br); + l.add(new Long(s)); + } + return l; + } + + public static ArrayList> readLongMatrix(BufferedReader br, Integer rows) { + return readLongMatrix(br, rows, null); + } + + public static ArrayList> readLongMatrix(BufferedReader br, Integer rows, Integer expectedLength) { + ArrayList> l = new ArrayList<>(); + for (int x = 0; x < rows.intValue(); x++) { + l.add(readLongList(br, expectedLength)); + } + return l; + } + + public static String readString(BufferedReader br) { + return new String(readLn(br)); + } + + public static ArrayList readStringList(BufferedReader br) { + return readStringList(br, null); + } + + public static ArrayList readStringList(BufferedReader br, Integer expectedLength) { + String[] s = readLn(br).split("" ""); + ArrayList l = new ArrayList<>(); + for (int x = 0; x < s.length; x++) { + l.add(new String(s[x])); + } + if (expectedLength != null) { + if (l.size() != expectedLength.intValue()) { + die(""Incorrect length in readStringList""); + } + } + return l; + } + + public static ArrayList readMultipleStrings(BufferedReader br, Integer rows) { + ArrayList l = new ArrayList<>(); + for (int x = 0; x < rows; x++) { + String s = readLn(br); + l.add(new String(s)); + } + return l; + } + + public static ArrayList> readStringMatrix(BufferedReader br, Integer rows) { + return readStringMatrix(br, rows, null); + } + + public static ArrayList> readStringMatrix(BufferedReader br, Integer rows, Integer expectedLength) { + ArrayList> l = new ArrayList<>(); + for (int x = 0; x < rows.intValue(); x++) { + l.add(readStringList(br, expectedLength)); + } + return l; + } + + public static Boolean readBoolean(BufferedReader br) { + return new Boolean(readLn(br)); + } + + public static ArrayList readBooleanList(BufferedReader br) { + return readBooleanList(br, null); + } + + public static ArrayList readBooleanList(BufferedReader br, Integer expectedLength) { + String[] s = readLn(br).split("" ""); + ArrayList l = new ArrayList<>(); + for (int x = 0; x < s.length; x++) { + l.add(new Boolean(s[x])); + } + if (expectedLength != null) { + if (l.size() != expectedLength.intValue()) { + die(""Incorrect length in readBooleanList""); + } + } + return l; + } + + public static ArrayList readMultipleBooleans(BufferedReader br, Integer rows) { + ArrayList l = new ArrayList<>(); + for (int x = 0; x < rows; x++) { + String s = readLn(br); + l.add(new Boolean(s)); + } + return l; + } + + public static ArrayList> readBooleanMatrix(BufferedReader br, Integer rows) { + return readBooleanMatrix(br, rows, null); + } + + public static ArrayList> readBooleanMatrix(BufferedReader br, Integer rows, Integer expectedLength) { + ArrayList> l = new ArrayList<>(); + for (int x = 0; x < rows.intValue(); x++) { + l.add(readBooleanList(br, expectedLength)); + } + return l; + } + + public static void closeBr(BufferedReader br) { + try { + br.close(); + } catch (IOException ex) { + die(""Exception in closeBr""); + } + + } + + public static void die(String reason) { + sout(""Die: "" + reason); + System.exit(0); + } + + public static void sout(String s) { + System.out.println(s); + } + + public static void sout(int i) { + System.out.println(i); + } + + public static void sout(Object o) { + System.out.println(o); + } + + public static void log(String line) { + BufferedWriter bw = newBufferedWriter(logfile, true); + writeLn(bw, line); + closeBw(bw); + } + + public static void clearFile(String filename) { + BufferedWriter bw = newBufferedWriter(filename, false); + closeBw(bw); + } + + public static int minInt(ArrayList l) { + int i = l.get(0).intValue(); + for (Integer j : l) { + if (j.intValue() < i) { + i = j.intValue(); + } + } + return i; + } + + public static int maxInt(ArrayList l) { + int i = l.get(0).intValue(); + for (Integer j : l) { + if (j.intValue() > i) { + i = j.intValue(); + } + } + return i; + } + + public static String joinArray(ArrayList l, String delim) { + String s = """"; + for (int i = 0; i < l.size(); i++) { + s += l.get(i).toString(); + if (i < (l.size() - 1)) { + s += delim; + } + } + return s; + } + + public static ArrayList splitToChars(String source) { + ArrayList chars = new ArrayList<>(); + for (int i = 0; i < source.length(); i++) { + chars.add(source.substring(i, i + 1)); + } + return chars; + } + + public static ArrayList> allPairs(int lower1, int upper1, int lower2, int upper2, int style) { + //Style: + //0 all pairs + //1 (1) <= (2) + //2 (1) < (2) + + ArrayList> out = new ArrayList<>(); + + for (int index1 = lower1; index1 <= upper1; index1++) { + for (int index2 = lower2; index2 <= upper2; index2++) { + ArrayList thisPair = new ArrayList<>(); + thisPair.add(new Integer(index1)); + thisPair.add(new Integer(index2)); + + switch (style) { + case 0: + out.add(thisPair); + break; + case 1: + if (index1 <= index2) { + out.add(thisPair); + } + break; + case 2: + if (index1 < index2) { + out.add(thisPair); + } + break; + default: + die(""Unrecognised case in allPairs""); + } + + + } + } + + return out; + } + + public static ArrayList> cloneALALI(ArrayList> in) { + ArrayList> out = new ArrayList<>(); + for (ArrayList inALI : in) { + ArrayList outALI = new ArrayList<>(inALI); + out.add(outALI); + } + return out; + } + + public static int[][] cloneInt2D(int[][] in) { + if (in.length == 0) {return new int[0][0];} + + int[][] out = new int[in.length][]; + for (int i = 0; i < in.length; i++) { + out[i] = new int[in[i].length]; + System.arraycopy(in[i], 0, out[i], 0, in[i].length); + } + return out; + } + + public static double[][] cloneDouble2D(double[][] in) { + if (in.length == 0) {return new double[0][0];} + + double[][] out = new double[in.length][]; + for (int i = 0; i < in.length; i++) { + out[i] = new double[in[i].length]; + System.arraycopy(in[i], 0, out[i], 0, in[i].length); + } + return out; + } + + public static ArrayList> allPerms(int n) { + //returns an arraylist of arraylists of integers + //showing all permutations of Integers 0 to n-1 + //works realistically up to n=10 + if (n == 0) { + return new ArrayList>(); + } + return allPerms_recurse(n, n); + } + + public static ArrayList> allPerms_recurse(int level, int n) { + if (level == 1) { + ArrayList single = new ArrayList<>(); + single.add(new Integer(n - level)); + ArrayList> list = new ArrayList<>(); + list.add(single); + return list; + } + + ArrayList> prev = allPerms_recurse(level - 1, n); + ArrayList> out = new ArrayList<>(); + + + for (int placeAt = 0; placeAt < level; placeAt++) { + //clone prev + ArrayList> prevClone = cloneALALI(prev); + + //insert + for (ArrayList prevItem : prevClone) { + prevItem.add(placeAt, new Integer(n - level)); + } + + //append to out + out.addAll(prevClone); + } + return out; + } + + public static ArrayList> allCombs(int n) { + //returns an arraylist of arraylists of integers + //showing all combinations of Integers 0 to n-1 + //works realistically up to n=7 + if (n == 0) { + return new ArrayList>(); + } + return allCombs_recurse(n, n); + } + + public static ArrayList> nCombs(int count, int n) { + //returns an arraylist of arraylists of integers + //showing all combinations of Integers 0 to n-1 --- of length ""count"" + //i.e. base ""n"" counting up to (n^count - 1). In order. + if (count == 0) { + return new ArrayList>(); + } + return allCombs_recurse(count, n); + } + + public static ArrayList> allCombs_recurse(int level, int n) { + if (level == 1) { + ArrayList> list = new ArrayList<>(); + for (int i = 0; i < n; i++) { + ArrayList single = new ArrayList<>(); + single.add(new Integer(i)); + list.add(single); + } + return list; + } + + ArrayList> prev = allCombs_recurse(level - 1, n); + ArrayList> out = new ArrayList<>(); + + + for (int initial = 0; initial < n; initial++) { + //clone prev + ArrayList> prevClone = cloneALALI(prev); + + //insert + for (ArrayList prevItem : prevClone) { + prevItem.add(0, new Integer(initial)); + } + + //append to out + out.addAll(prevClone); + } + return out; + } + + public static ArrayList grepFull(ArrayList inList, String pattern) { + //pattern must match full text + ArrayList outList = new ArrayList<>(); + for (String s : inList) { + if (s.matches(pattern)) { + outList.add(new String(s)); + } + } + + return outList; + } + + public static int[] randomIntegerArray(int count, int low, int high, long seed) { + //a list of ""count"" ints from low to high inclusive. + Random rng = new Random(); + if (seed != -1) { + rng.setSeed(seed); + } + int[] out = new int[count]; + for (int x = 0; x < count; x++) { + out[x] = rng.nextInt(high - low + 1) + low; + } + return out; + } + + public static double[] randomDoubleArray(int count, double low, double high, long seed) { + //a list of ""count"" ints from low inclusive to high exclusive. + Random rng = new Random(); + if (seed != -1) { + rng.setSeed(seed); + } + double[] out = new double[count]; + for (int x = 0; x < count; x++) { + out[x] = rng.nextDouble() * (high - low) + low; + } + return out; + } + + public static int[] randomPermutation(int count, long seed) { + //random permutation of the array 0..(count-1). + Random rng = new Random(); + if (seed != -1) { + rng.setSeed(seed); + } + + int[] out = new int[count]; + for (int x = 0; x < count; x++) { + out[x] = x; + } + for (int x = 0; x < count - 1; x++) { + int takeFrom = rng.nextInt(count - x) + x; + int tmp = out[takeFrom]; + out[takeFrom] = out[x]; + out[x] = tmp; + } + return out; + } + + public static ArrayList randomiseArray(ArrayList in, long seed) { + //alternatively, Collections.shuffle(in, new Random(seed)) + ArrayList out = new ArrayList(); + int[] r = randomPermutation(in.size(), seed); + for (int i : r) { + out.add(in.get(i)); + } + return out; + } + + public static ArrayList arrayToArrayList(int[] in) { + ArrayList out = new ArrayList<>(); + for (int i : in) { + out.add(i); + } + return out; + } + + public static ArrayList arrayToArrayList(double[] in) { + ArrayList out = new ArrayList<>(); + for (double d : in) { + out.add(d); + } + return out; + } + + public static int[] arrayListToArrayInt(ArrayList in) { + int[] out = new int[in.size()]; + int x = 0; + for (Integer i : in) { + out[x] = i.intValue(); + x++; + } + return out; + } + + public static double[] arrayListToArrayDouble(ArrayList in) { + double[] out = new double[in.size()]; + int x = 0; + for (Double d : in) { + out[x] = d.doubleValue(); + x++; + } + return out; + } + + public static String toString(int[] in) { + if (in.length == 0) { + return ""[]""; + } + String s = ""[""; + for (int x = 0; x < in.length - 1; x++) { + s += in[x] + "", ""; + } + s += in[in.length - 1] + ""]""; + return s; + } + + public static String toString(double[] in) { + if (in.length == 0) { + return ""[]""; + } + String s = ""[""; + for (int x = 0; x < in.length - 1; x++) { + s += in[x] + "", ""; + } + s += in[in.length - 1] + ""]""; + return s; + } + + public static String toString(int[][] in) { + if (in.length == 0) { + return ""[]""; + } + String s = ""[""; + for (int x = 0; x < in.length - 1; x++) { + s += toString(in[x]) + "", ""; + } + s += toString(in[in.length - 1]) + ""]""; + return s; + } + + public static String toString(double[][] in) { + if (in.length == 0) { + return ""[]""; + } + String s = ""[""; + for (int x = 0; x < in.length - 1; x++) { + s += toString(in[x]) + "", ""; + } + s += toString(in[in.length - 1]) + ""]""; + return s; + } +} +" +C20062,"package jp.funnything.competition.util; + +public enum Direction { + UP , DOWN , LEFT , RIGHT; + + public int dx() { + switch ( this ) { + case UP: + case DOWN: + return 0; + case LEFT: + return -1; + case RIGHT: + return 1; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public int dy() { + switch ( this ) { + case UP: + return -1; + case DOWN: + return 1; + case LEFT: + case RIGHT: + return 0; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public Direction reverese() { + switch ( this ) { + case UP: + return DOWN; + case DOWN: + return UP; + case LEFT: + return RIGHT; + case RIGHT: + return LEFT; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public Direction turnLeft() { + switch ( this ) { + case UP: + return LEFT; + case DOWN: + return RIGHT; + case LEFT: + return DOWN; + case RIGHT: + return UP; + default: + throw new RuntimeException( ""assert"" ); + } + } + + public Direction turnRight() { + switch ( this ) { + case UP: + return RIGHT; + case DOWN: + return LEFT; + case LEFT: + return UP; + case RIGHT: + return DOWN; + default: + throw new RuntimeException( ""assert"" ); + } + } +} +" +C20059,"package jp.funnything.competition.util; + +import java.io.File; +import java.math.BigDecimal; +import java.math.BigInteger; + +import org.apache.commons.io.FileUtils; + +public class CompetitionIO { + private final QuestionReader _reader; + private final AnswerWriter _writer; + + /** + * Default constructor. Use latest ""*.in"" as input + */ + public CompetitionIO() { + this( null , null , null ); + } + + public CompetitionIO( final File input , final File output ) { + this( input , output , null ); + } + + public CompetitionIO( File input , File output , final String format ) { + if ( input == null ) { + for ( final File file : FileUtils.listFiles( new File( ""."" ) , new String[] { ""in"" } , false ) ) { + if ( input == null || file.lastModified() > input.lastModified() ) { + input = file; + } + } + + if ( input == null ) { + throw new RuntimeException( ""No *.in found"" ); + } + } + + if ( output == null ) { + final String inPath = input.getPath(); + + if ( !inPath.endsWith( "".in"" ) ) { + throw new IllegalArgumentException(); + } + + output = new File( inPath.replaceFirst( "".in$"" , "".out"" ) ); + } + + _reader = new QuestionReader( input ); + _writer = new AnswerWriter( output , format ); + } + + public CompetitionIO( final String format ) { + this( null , null , format ); + } + + public void close() { + _reader.close(); + _writer.close(); + } + + public String read() { + return _reader.read(); + } + + public BigDecimal[] readBigDecimals() { + return _reader.readBigDecimals(); + } + + public BigDecimal[] readBigDecimals( final String separator ) { + return _reader.readBigDecimals( separator ); + } + + public BigInteger[] readBigInts() { + return _reader.readBigInts(); + } + + public BigInteger[] readBigInts( final String separator ) { + return _reader.readBigInts( separator ); + } + + /** + * Read line as single integer + */ + public int readInt() { + return _reader.readInt(); + } + + /** + * Read line as multiple integer, separated by space + */ + public int[] readInts() { + return _reader.readInts(); + } + + /** + * Read line as multiple integer, separated by 'separator' + */ + public int[] readInts( final String separator ) { + return _reader.readInts( separator ); + } + + /** + * Read line as single integer + */ + public long readLong() { + return _reader.readLong(); + } + + /** + * Read line as multiple integer, separated by space + */ + public long[] readLongs() { + return _reader.readLongs(); + } + + /** + * Read line as multiple integer, separated by 'separator' + */ + public long[] readLongs( final String separator ) { + return _reader.readLongs( separator ); + } + + /** + * Read line as token list, separated by space + */ + public String[] readTokens() { + return _reader.readTokens(); + } + + /** + * Read line as token list, separated by 'separator' + */ + public String[] readTokens( final String separator ) { + return _reader.readTokens( separator ); + } + + public void write( final int questionNumber , final Object result ) { + _writer.write( questionNumber , result ); + } + + public void write( final int questionNumber , final String result ) { + _writer.write( questionNumber , result ); + } + + public void write( final int questionNumber , final String result , final boolean tee ) { + _writer.write( questionNumber , result , tee ); + } +} +" +C20064,"package jp.funnything.competition.util; + +public class Prof { + private long _start; + + public Prof() { + reset(); + } + + private long calcAndReset() { + final long ret = System.currentTimeMillis() - _start; + + reset(); + + return ret; + } + + private void reset() { + _start = System.currentTimeMillis(); + } + + @Override + public String toString() { + return String.format( ""Prof: %f (s)"" , calcAndReset() / 1000.0 ); + } + + public String toString( final String head ) { + return String.format( ""%s: %f (s)"" , head , calcAndReset() / 1000.0 ); + } +} +" +C20076,"import java.io.*; +import java.math.*; +import java.util.*; + +public class D { + + final static boolean DEBUG = true; + + class S implements Comparable { + int a; + int [] b; + + public int compareTo(S s) { + if (a != s.a) + return a - s.a; + else + return b[0] - s.b[0]; + } + + boolean merge(S s) { + if (a == s.a && b[1] >= s.b[0]) { + b[0] = Math.min(b[0], s.b[0]); + b[1] = Math.max(b[1], s.b[1]); + return true; + } else + return false; + } + public String toString() { + return ""a="" + a + ""; b="" + Arrays.toString(b); + } + } + + void add(List L, int a, int b1, int b2) { + S m = new S(); + m.a = a; m.b = new int [] { b1, b2 }; + L.add(m); + } + + List normalize(List L) { + List tmp = new ArrayList(); + Collections.sort(L); + S c = null; + for (S s : L) { + if (c == null) + c = s; + else { + if (!c.merge(s)) { + tmp.add(c); + c = s; + } + } + } + assert(c != null); + tmp.add(c); + return tmp; + } + + public Object solve () throws IOException { + int ZZ = 300; + + int H = 2 * sc.nextInt(); + int W = 2 * sc.nextInt(); + int D = 2 * sc.nextInt(); + + int MH = H-4, MW = W-4; + + int [] ME = null; + S[] LV,UV,LH,UH; + { + List _LH = new ArrayList(); + List _LV = new ArrayList(); + List _UH = new ArrayList(); + List _UV = new ArrayList(); + + add(_LV, 0, -1, MH+1); + add(_UV, MW, -1, MH+1); + add(_LH, 0, -1, MW+1); + add(_UH, MH, -1, MW+1); + + sc.nextLine(); + for (int i = 0; i < MH/2; ++i) { + char [] R = sc.nextChars(); + for (int j = 0; j < MW/2; ++j) { + char z = R[j+1]; + if (z == 'X') + ME = new int [] { 2*j+1, 2*i+1 }; + if (z == '#') { + int vl = 2*i, vu = 2*i+2, hl = 2*j, hu = 2*j+2; + int dvl = 0, dvu = 0, dhl = 0, dhu = 0; + if (vl == 0) ++dvl; if(vu == MH) ++dvu; if (hl == 0) ++dhl; if (hu == MW) ++dhu; + add(_LV, hu, vl-dvl, vu+dvu); + add(_UV, hl, vl-dvl, vu+dvu); + add(_LH, vu, hl-dhl, hu+dhu); + add(_UH, vl, hl-dhl, hu+dhu); + } + } + } + sc.nextLine(); + + _LV = normalize(_LV); + _UV = normalize(_UV); + _LH = normalize(_LH); + _UH = normalize(_UH); + + LV = _LV.toArray(new S[0]); + UV = _UV.toArray(new S[0]); + LH = _LH.toArray(new S[0]); + UH = _UH.toArray(new S[0]); + } + + int cnt = 0; + for (int ax = -ZZ; ax <= ZZ; ++ax) + for (int ay = -ZZ; ay <= ZZ; ++ay) + if (gcd(ax, ay) == 1) { + double d = 0, px = ME[0], py = ME[1]; + int tax = ax, tay = ay; + while (d < D) { + X slv = new X(), suv = new X(), slh = new X(), suh = new X(); + if (tax < 0) slv = T(LV, px, py, tax, tay, ME[0], ME[1], MH); + if (tax > 0) suv = T(UV, px, py, tax, tay, ME[0], ME[1], MH); + if (tay < 0) slh = T(LH, py, px, tay, tax, ME[1], ME[0], MW); + if (tay > 0) suh = T(UH, py, px, tay, tax, ME[1], ME[0], MW); + + double minvd = 1e20, minhd = 1e20, mind = 1e20; + minvd = Math.min(slv.d, minvd); + minvd = Math.min(suv.d, minvd); + minhd = Math.min(slh.d, minhd); + minhd = Math.min(suh.d, minhd); + mind = Math.min(minvd, minhd); + + d += Math.sqrt(mind); + if (d > D + seps) + break; + + if (slv.d == mind && slv.kill) { + if (slv.me) + ++cnt; + break; } + if (suv.d == mind && suv.kill) { + if (suv.me) + ++cnt; + break; } + if (slh.d == mind && slh.kill) { + if (slh.me) + ++cnt; + break; } + if (suh.d == mind && suh.kill) { + if (suh.me) + ++cnt; + break; } + + if (Math.abs(minvd - minhd) < eps) { + if (d < D/2.0 + seps) + ++cnt; + break; + } + + if (slv.d == mind) { px = slv.pa; py = slv.pb; tax = slv.aa; tay = slv.ab; }; + if (suv.d == mind) { px = suv.pa; py = suv.pb; tax = suv.aa; tay = suv.ab; }; + if (slh.d == mind) { px = slh.pb; py = slh.pa; tax = slh.ab; tay = slh.aa; }; + if (suh.d == mind) { px = suh.pb; py = suh.pa; tax = suh.ab; tay = suh.aa; }; + } + } + + return cnt; + } + + class X { + double pa, pb, d = 1e20; + int aa, ab; + boolean me = false, kill = false; + + public String toString() { + if (d == 1e20) + return ""NO""; + if (me) + return ""ME; d="" + d; + else if (kill) + return ""KILL; d="" + d; + return ""d="" + Math.sqrt(d) + ""; pa="" + pa + ""; pb="" + pb + ""; aa="" + aa + ""ab="" + ab; + } + } + + double eps = 1e-9; + double seps = Math.sqrt(eps); + + X T(S[] L, double pa, double pb, int aa, int ab, double mea, double meb, int M) { + double aaa = Math.abs(aa); + double nab = ab/aaa, naa = aa/aaa; + + double dme = 1e20; + double tme = (mea - pa)/naa; + if (tme > 0 && Math.abs(meb - (tme*nab + pb)) < eps) + dme = (mea-pa)*(mea-pa) + (meb-pb)*(meb-pb); + + X x = new X(); + + int P = -1, Q = L.length; + int p = P, q = Q, m; + while (q - p > 1) { + m = (p+q)/2; if (m == P) ++m; + if (L[m].a > pa) + q = m; + else + p = m; + } + + int z = naa > 0 ? q : p; + int da = naa > 0 ? 1 : -1; + int db = nab > 0 ? 1 : -1; + + for (; ; z += da) { + S s = L[z]; + double t = Math.abs(s.a - pa); + // double sa = pa + t * naa; + double sb = pb + t * nab; + + double d = (s.a-pa)*(s.a-pa) + (sb-pb)*(sb-pb); + if (d > dme) { + x.me = x.kill = true; + x.d = dme; + return x; + } + if (sb < -eps || sb > M + eps) + return x; + if (Math.abs(sb - s.b[(1-db)/2]) < eps) { + x.kill = true; + x.d = d; + return x; + } + if (sb > s.b[0] && sb < s.b[1]) { + x.pa = s.a; x.pb = sb; x.aa = -aa; x.ab = ab; x.d = d; + return x; + } + } + + //throw new Error(""NO WAY!""); + } + + int gcd (int a, int b) { + a = Math.abs(a); b = Math.abs(b); + if (a*b != 0) + return BigInteger.valueOf(a).gcd(BigInteger.valueOf(b)).intValue(); + else + return a+b; + } + + void init () { + } + + //////////////////////////////////////////////////////////////////////////////////// + + public D () throws IOException { + init(); + int N = sc.nextInt(); + start(); + for (int n = 1; n <= N; ++n) + print(""Case #"" + n + "": "" + solve()); + exit(); + } + + static MyScanner sc; + static long t; + + static void print (Object o) { + System.out.println(o); + if (DEBUG) + System.err.println(o + "" ("" + ((millis() - t) / 1000.0) + "")""); + } + + static void exit () { + if (DEBUG) { + System.err.println(); + System.err.println((millis() - t) / 1000.0); + } + System.exit(0); + } + + static void run () throws IOException { + sc = new MyScanner (); + new D(); + } + + public static void main(String[] args) throws IOException { + run(); + } + + static long millis() { + return System.currentTimeMillis(); + } + + static void start() { + t = millis(); + } + + static class MyScanner { + String next() throws IOException { + newLine(); + return line[index++]; + } + + char [] nextChars() throws IOException { + return next().toCharArray(); + } + + double nextDouble() throws IOException { + return Double.parseDouble(next()); + } + + int nextInt() throws IOException { + return Integer.parseInt(next()); + } + + long nextLong() throws IOException { + return Long.parseLong(next()); + } + + String nextLine() throws IOException { + line = null; + return r.readLine(); + } + + + String [] nextStrings() throws IOException { + line = null; + return r.readLine().split("" ""); + } + + int [] nextInts() throws IOException { + String [] L = nextStrings(); + int [] res = new int [L.length]; + for (int i = 0; i < L.length; ++i) + res[i] = Integer.parseInt(L[i]); + return res; + } + + + long [] nextLongs() throws IOException { + String [] L = nextStrings(); + long [] res = new long [L.length]; + for (int i = 0; i < L.length; ++i) + res[i] = Long.parseLong(L[i]); + return res; + } + + boolean eol() { + return index == line.length; + } + + ////////////////////////////////////////////// + + private final BufferedReader r; + + MyScanner () throws IOException { + this(new BufferedReader(new InputStreamReader(System.in))); + } + + MyScanner(BufferedReader r) throws IOException { + this.r = r; + } + + private String [] line; + private int index; + + private void newLine() throws IOException { + if (line == null || index == line.length) { + line = r.readLine().split("" ""); + index = 0; + } + } + } + + static class MyWriter { + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + + void print(Object o) { + pw.print(o); + } + + void println(Object o) { + pw.println(o); + } + + void println() { + pw.println(); + } + + public String toString() { + return sw.toString(); + } + } + + char [] toArray (Character [] C) { + char [] c = new char[C.length]; + for (int i = 0; i < C.length; ++i) + c[i] = C[i]; + return c; + } + + char [] toArray (Collection C) { + char [] c = new char[C.size()]; int i = 0; + for (char z : C) + c[i++] = z; + return c; + } + + Object [] toArray(int [] a) { + Object [] A = new Object[a.length]; + for (int i = 0; i < A.length; ++i) + A[i] = a[i]; + return A; + } + + String toString(Object [] a) { + StringBuffer b = new StringBuffer(); + for (Object o : a) + b.append("" "" + o); + return b.toString().trim(); + } + + String toString(int [] a) { + return toString(toArray(a)); + } +} +" +C20026,"import java.io.*; +import java.util.*; +import java.math.*; + +class D +{ + private static final boolean DEBUG_ON = true; + private static final boolean ECHO_ON = true; + + private static BufferedReader input; + private static BufferedWriter output; + + private static final int INF = Integer.MAX_VALUE / 2; + private static final int MOD = 10007; + + private static int H, W, D, row, col; + + public static int gcd(int n, int m) {return (0 == m) ? (n) : gcd(m, n % m);} + + public static int sqrt(int X) + { + int answer = 1, interval = 1; + for (int i = String.valueOf(X).length() / 2; i > 0; i--) {interval *= 10;} + while (interval >= 1) + { + while ((answer * answer) <= X) {answer += interval;} + answer -= interval; + interval /= 10; + } + return answer; + } + + public static void main(String[] args) + { + try + { + input = new BufferedReader(new FileReader(args[0] + "".in"")); + output = new BufferedWriter(new FileWriter(args[0] + "".out"")); + + String line = input.readLine(); + int testcases = getInt(line, 0); + + for (int testcase = 1; testcase <= testcases; testcase++) + { + char[][] real = getCharMatrix(input); + + HashSet valid = new HashSet(); + + for (int i = row - D; i <= row + D; i++) + { + int range = sqrt((D * D) - ((i - row) * (i - row))); + + for (int j = col - range; j <= col + range; j++) + { + int diffX = i - row; + int diffY = j - col; + if (0 == diffX && 0 == diffY) {continue;} + + int gcd = gcd(Math.abs(diffX), Math.abs(diffY)); + int direction = (((diffX/gcd) + D) << 16) + ((diffY/gcd) + D); + if (valid.contains(direction)) {continue;} + + int x = 100 * row + 50; + int y = 100 * col + 50; + + for (int k = 0; k < 100; k++) + { + int nextX = x + diffX; + int nextY = y + diffY; + int xCell = x / 100; + int yCell = y / 100; + int nextXCell = nextX / 100; if (0 == nextX % 100) {nextXCell = (nextX + diffX) / 100;} + int nextYCell = nextY / 100; if (0 == nextY % 100) {nextYCell = (nextY + diffY) / 100;} + + if (xCell == nextXCell && yCell == nextYCell) {x = nextX; y = nextY;} + else if (xCell != nextXCell && yCell == nextYCell) + { + if ('#' != real[nextXCell][nextYCell]) {x = nextX; y = nextY;} + else + { + diffX = -diffX; + if (nextXCell < xCell) {x = (100 * (nextXCell + 1)) - (x - (100 * (nextXCell + 1)));} + else {x = (100 * nextXCell) + ((100 * nextXCell) - x);} + x = x + diffX; y = y + diffY; + } + } + else if (xCell == nextXCell && yCell != nextYCell) + { + if ('#' != real[nextXCell][nextYCell]) {x = nextX; y = nextY;} + else + { + diffY = -diffY; + if (nextYCell < yCell) {y = (100 * (nextYCell + 1)) - (y - (100 * (nextYCell + 1)));} + else {y = (100 * nextYCell) + ((100 * nextYCell) - y);} + x = x + diffX; y = y + diffY; + } + } + else + { + int cornerX = -1, cornerY = -1; + + if (nextXCell < xCell && nextYCell < yCell) {cornerX = 100 * (nextXCell + 1); cornerY = 100 * (nextYCell + 1);} + else if (nextXCell > xCell && nextYCell < yCell) {cornerX = 100 * nextXCell; cornerY = 100 * (nextYCell + 1);} + else if (nextXCell < xCell && nextYCell > yCell) {cornerX = 100 * (nextXCell + 1); cornerY = 100 * nextYCell;} + else if (nextXCell > xCell && nextYCell > yCell) {cornerX = 100 * nextXCell; cornerY = 100 * nextYCell;} + + if ('#' == real[nextXCell][nextYCell] && '#' == real[xCell][nextYCell] && '#' == real[nextXCell][yCell]) + { + diffX = -diffX; diffY = -diffY; + if (nextXCell < xCell) {x = (100 * (nextXCell + 1)) - (x - (100 * (nextXCell + 1)));} + else {x = (100 * nextXCell) + ((100 * nextXCell) - x);} + if (nextYCell < yCell) {y = (100 * (nextYCell + 1)) - (y - (100 * (nextYCell + 1)));} + else {y = (100 * nextYCell) + ((100 * nextYCell) - y);} + x = x + diffX; y = y + diffY; + } + else if ('#' == real[nextXCell][nextYCell] && '#' == real[xCell][nextYCell] && '#' != real[nextXCell][yCell]) + { + diffY = -diffY; + if (nextYCell < yCell) {y = (100 * (nextYCell + 1)) - (y - (100 * (nextYCell + 1)));} + else {y = (100 * nextYCell) + ((100 * nextYCell) - y);} + x = x + diffX; y = y + diffY; + } + else if ('#' == real[nextXCell][nextYCell] && '#' != real[xCell][nextYCell] && '#' == real[nextXCell][yCell]) + { + diffX = -diffX; + if (nextXCell < xCell) {x = (100 * (nextXCell + 1)) - (x - (100 * (nextXCell + 1)));} + else {x = (100 * nextXCell) + ((100 * nextXCell) - x);} + x = x + diffX; y = y + diffY; + } + else if ('#' != real[nextXCell][nextYCell] && '#' == real[xCell][nextYCell] && '#' == real[nextXCell][yCell]) + { + if ((cornerX - x) * (nextY - y) == (nextX - x) * (cornerY - y)) {x = nextX; y = nextY;} // passing corner + else + { + diffX = -diffX; diffY = -diffY; + if (nextXCell < xCell) {x = (100 * (nextXCell + 1)) - (x - (100 * (nextXCell + 1)));} + else {x = (100 * nextXCell) + ((100 * nextXCell) - x);} + if (nextYCell < yCell) {y = (100 * (nextYCell + 1)) - (y - (100 * (nextYCell + 1)));} + else {y = (100 * nextYCell) + ((100 * nextYCell) - y);} + x = x + diffX; y = y + diffY; + } + } + else if ('#' == real[nextXCell][nextYCell] && '#' != real[xCell][nextYCell] && '#' != real[nextXCell][yCell]) + { + if ((cornerX - x) * (nextY - y) == (nextX - x) * (cornerY - y)) {break;} // hitting corner + else if (Math.abs((cornerX - x) * (nextY - y)) < Math.abs((nextX - x) * (cornerY - y))) // hitting Y + { + diffY = -diffY; + if (nextYCell < yCell) {y = (100 * (nextYCell + 1)) - (y - (100 * (nextYCell + 1)));} + else {y = (100 * nextYCell) + ((100 * nextYCell) - y);} + x = x + diffX; y = y + diffY; + } + else + { + diffX = -diffX; + if (nextXCell < xCell) {x = (100 * (nextXCell + 1)) - (x - (100 * (nextXCell + 1)));} + else {x = (100 * nextXCell) + ((100 * nextXCell) - x);} + x = x + diffX; y = y + diffY; + } + } + else if ('#' != real[nextXCell][nextYCell] && '#' == real[xCell][nextYCell] && '#' != real[nextXCell][yCell]) + { + if (Math.abs((cornerX - x) * (nextY - y)) <= Math.abs((nextX - x) * (cornerY - y))) {x = nextX; y = nextY;} + else + { + diffY = -diffY; + if (nextYCell < yCell) {y = (100 * (nextYCell + 1)) - (y - (100 * (nextYCell + 1)));} + else {y = (100 * nextYCell) + ((100 * nextYCell) - y);} + x = x + diffX; y = y + diffY; + } + } + else if ('#' != real[nextXCell][nextYCell] && '#' != real[xCell][nextYCell] && '#' == real[nextXCell][yCell]) + { + if (Math.abs((cornerX - x) * (nextY - y)) >= Math.abs((nextX - x) * (cornerY - y))) {x = nextX; y = nextY;} + else + { + diffX = -diffX; + if (nextXCell < xCell) {x = (100 * (nextXCell + 1)) - (x - (100 * (nextXCell + 1)));} + else {x = (100 * nextXCell) + ((100 * nextXCell) - x);} + x = x + diffX; y = y + diffY; + } + } + else if ('#' != real[nextXCell][nextYCell] && '#' != real[xCell][nextYCell] && '#' != real[nextXCell][yCell]) {x = nextX; y = nextY;} + } + + if ((100 * row + 50) == x && (100 * col + 50) == y) {valid.add(direction); break;} + } + } + } + + String result = ""Case #"" + testcase + "": "" + valid.size(); + output(result); + } + + input.close(); + output.close(); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + + public static int getInt(String line, int index) {return Integer.parseInt(getString(line, index));} + public static long getLong(String line, int index) {return Long.parseLong(getString(line, index));} + public static double getDouble(String line, int index) {return Double.parseDouble(getString(line, index));} + public static String getString(String line, int index) + { + line = line.trim(); + while (index > 0) {line = line.substring(line.indexOf(' ') + 1); index--;} + + if ((-1) == line.indexOf(' ')) {return line;} + else {return line.substring(0, line.indexOf(' '));} + } + + public static int[] getIntArray(String line) + { + String[] strings = getStringArray(line); + int[] numbers = new int[strings.length]; + for (int i = 0; i < strings.length; i++) {numbers[i] = Integer.parseInt(strings[i]);} + return numbers; + } + public static long[] getLongArray(String line) + { + String[] strings = getStringArray(line); + long[] numbers = new long[strings.length]; + for (int i = 0; i < strings.length; i++) {numbers[i] = Long.parseLong(strings[i]);} + return numbers; + } + public static double[] getDoubleArray(String line) + { + String[] strings = getStringArray(line); + double[] numbers = new double[strings.length]; + for (int i = 0; i < strings.length; i++) {numbers[i] = Double.parseDouble(strings[i]);} + return numbers; + } + public static String[] getStringArray(String line) {return line.trim().split(""(\\s)+"", 0);} + + public static int[] getIntArray(String line, int begin, int end) + { + String[] strings = getStringArray(line, begin, end); + int[] numbers = new int[end - begin]; + for (int i = begin; i < end; i++) {numbers[i - begin] = Integer.parseInt(strings[i - begin]);} + return numbers; + } + public static long[] getLongArray(String line, int begin, int end) + { + String[] strings = getStringArray(line, begin, end); + long[] numbers = new long[end - begin]; + for (int i = begin; i < end; i++) {numbers[i - begin] = Long.parseLong(strings[i - begin]);} + return numbers; + } + public static double[] getDoubleArray(String line, int begin, int end) + { + String[] strings = getStringArray(line, begin, end); + double[] numbers = new double[end - begin]; + for (int i = begin; i < end; i++) {numbers[i - begin] = Double.parseDouble(strings[i - begin]);} + return numbers; + } + public static String[] getStringArray(String line, int begin, int end) + { + String[] lines = line.trim().split(""(\\s)+"", 0); + String[] results = new String[end - begin]; + for (int i = begin; i < end; i++) {results[i - begin] = lines[i];} + return results; + } + + public static char[][] getCharMatrix(BufferedReader input) throws Exception + { + String line = input.readLine(); + H = getInt(line, 0); + W = getInt(line, 1); + D = getInt(line, 2); + char[][] matrix = new char[H][W]; + for (int i = 0; i < H; i++) + { + line = input.readLine(); + for (int j = 0; j < W; j++) + { + char c = matrix[i][j] = line.charAt(j); + if ('X' == c) {row = i; col = j;} + } + } + return matrix; + } + public static int[][] getIntMatrix(BufferedReader input) throws Exception + { + String line = input.readLine(); + int R = getInt(line, 0); + int C = getInt(line, 1); + int[][] matrix = new int[R][C]; + for (int i = 0; i < R; i++) + { + line = input.readLine(); + for (int j = 0; j < C; j++) {matrix[i][j] = getInt(line, j);} + } + return matrix; + } + + public static boolean[][] newBooleanMatrix(int R, int C, boolean value) + { + boolean[][] matrix = new boolean[R][C]; + for (int i = 0; i < R; i++) for(int j = 0; j < C; j++) {matrix[i][j] = value;} + return matrix; + } + public static char[][] newCharMatrix(int R, int C, char value) + { + char[][] matrix = new char[R][C]; + for (int i = 0; i < R; i++) for(int j = 0; j < C; j++) {matrix[i][j] = value;} + return matrix; + } + public static int[][] newIntMatrix(int R, int C, int value) + { + int[][] matrix = new int[R][C]; + for (int i = 0; i < R; i++) for(int j = 0; j < C; j++) {matrix[i][j] = value;} + return matrix; + } + public static long[][] newLongMatrix(int R, int C, long value) + { + long[][] matrix = new long[R][C]; + for (int i = 0; i < R; i++) for(int j = 0; j < C; j++) {matrix[i][j] = value;} + return matrix; + } + public static double[][] newDoubleMatrix(int R, int C, double value) + { + double[][] matrix = new double[R][C]; + for (int i = 0; i < R; i++) for(int j = 0; j < C; j++) {matrix[i][j] = value;} + return matrix; + } + + public static void output(String s) throws Exception + { + if (ECHO_ON) {System.out.println(s);} + output.write(s); + output.newLine(); + } + + public static String toKey(boolean[] array) + { + StringBuffer buffer = new StringBuffer(array.length + "",""); + for (int i = 0; i < array.length / 16; i++) + { + char c = 0; + for (int j = 0; j < 16; j++) + { + c <<= 1; if (array[i * 16 + j]) {c += 1;} + } + buffer.append(c + """"); + } + char c = 0; + for (int j = 0; j < (array.length % 16); j++) + { + c <<= 1; if (array[(array.length / 16) * 16 + j]) {c += 1;} + } + buffer.append(c + """"); + return buffer.toString(); + } + public static String toKey(int[] array, int bit) + { + StringBuffer buffer = new StringBuffer(array.length + "",""); + if (bit > 16) + { + for (int i = 0; i < array.length; i++) + { + char c1 = (char)(array[i] >> 16); + char c2 = (char)(array[i] & 0xFFFF); + buffer.append("""" + c1 + c2); + } + } + else + { + int n = 16 / bit; + for (int i = 0; i < array.length / n; i++) + { + char c = 0; + for (int j = 0; j < n; j++) + { + c <<= bit; c += array[i * n + j]; + } + buffer.append(c + """"); + } + char c = 0; + for (int j = 0; j < (array.length % n); j++) + { + c <<= bit; c += array[(array.length / n) * n + j]; + } + buffer.append(c + """"); + } + return buffer.toString(); + } + + public static void debug(String s) + {if (DEBUG_ON) {System.out.println(s);}} + public static void debug(String s0, double l0) + {if (DEBUG_ON) {System.out.println(s0+"" = ""+l0);}} + public static void debug(String s0, double l0, String s1, double l1) + {if (DEBUG_ON) {System.out.println(s0+"" = ""+l0+""; ""+s1+"" = ""+l1);}} + public static void debug(String s0, double l0, String s1, double l1, String s2, double l2) + {if (DEBUG_ON) { System.out.println(s0+"" = ""+l0+""; ""+s1+"" = ""+l1+""; ""+s2+"" = ""+l2);}} + public static void debug(String s0, double l0, String s1, double l1, String s2, double l2, String s3, double l3) + {if (DEBUG_ON) {System.out.println(s0+"" = ""+l0+""; ""+s1+"" = ""+l1+""; ""+s2+"" = ""+l2+""; ""+s3+"" = ""+l3);}} + public static void debug(String s0, double l0, String s1, double l1, String s2, double l2, String s3, double l3, String s4, double l4) + {if (DEBUG_ON) {System.out.println(s0+"" = ""+l0+""; ""+s1+"" = ""+l1+""; ""+s2+"" = ""+l2+""; ""+s3+"" = ""+l3+""; ""+s4+"" = ""+l4);}} + + public static void debug(boolean[] array) {if (DEBUG_ON) {debug(array, "" "");}} + public static void debug(boolean[] array, String separator) + { + if (DEBUG_ON) + { + StringBuffer buffer = new StringBuffer(); + for (int i = 0; i < array.length - 1; i++) {buffer.append((array[i] == true ? ""1"" : ""0"") + separator);} + buffer.append((array[array.length - 1] == true) ? ""1"" : ""0""); + System.out.println(buffer.toString()); + } + } + public static void debug(boolean[][] array) {if (DEBUG_ON) {debug(array, "" "");}} + public static void debug(boolean[][] array, String separator) + {if (DEBUG_ON) {for (int i = 0; i < array.length; i++) {debug(array[i], separator);}}} + + public static void debug(char[] array) {if (DEBUG_ON) {debug(array, "" "");}} + public static void debug(char[] array, String separator) + { + if (DEBUG_ON) + { + StringBuffer buffer = new StringBuffer(); + for (int i = 0; i < array.length - 1; i++) {buffer.append(array[i] + separator);} + buffer.append(array[array.length - 1]); + System.out.println(buffer.toString()); + } + } + public static void debug(char[][] array) {if (DEBUG_ON) {debug(array, "" "");}} + public static void debug(char[][] array, String separator) + {if (DEBUG_ON) {for (int i = 0; i < array.length; i++) {debug(array[i], separator);}}} + + public static void debug(int[] array) {if (DEBUG_ON) {debug(array, "" "");}} + public static void debug(int[] array, String separator) + { + if (DEBUG_ON) + { + StringBuffer buffer = new StringBuffer(); + for (int i = 0; i < array.length - 1; i++) {buffer.append(array[i] + separator);} + buffer.append(array[array.length - 1]); + System.out.println(buffer.toString()); + } + } + public static void debug(int[][] array) {if (DEBUG_ON) {debug(array, "" "");}} + public static void debug(int[][] array, String separator) + {if (DEBUG_ON) {for (int i = 0; i < array.length; i++) {debug(array[i], separator);}}} +} +" +C20078,"import java.awt.Point; + +public class FracVec { + public final Frac row, col; + + public FracVec(Frac row, Frac col) { + this.row = row; + this.col = col; + } + + public FracVec(Point pos) { + row = new Frac(pos.y); + col = new Frac(pos.x); + } + + public FracVec flipHoriz() { + return new FracVec(row, col.neg()); + } + + public FracVec flipVert() { + return new FracVec(row.neg(), col); + } + + public boolean isCorner() { + return row.denom == 1 && col.denom == 1; + } + + public FracVec add(FracVec other) { + return new FracVec(row.add(other.row), col.add(other.col)); + } + + public FracVec sub(FracVec other) { + return new FracVec(row.sub(other.row), col.sub(other.col)); + } + + public FracVec neg() { + return new FracVec(row.neg(), col.neg()); + } + + public boolean equals(FracVec other) { + return row.equals(other.row) && col.equals(other.col); + } + + public boolean equals(Point p) { + return row.equals(p.y) && col.equals(p.x); + } + + @Override + public boolean equals(Object other) { + return other instanceof FracVec && equals((FracVec) other); + } + + @Override + public int hashCode() { + return (31 + row.hashCode()) * 31 + col.hashCode(); + } + + public String toString() { + return ""( "" + row + "", "" + col + "" )""; + } + + public FracVec multiply(Frac scalar) { + return new FracVec(row.mult(scalar), col.mult(scalar)); + } + + public int compareLengthTo(int d) { + return row.mult(row).add(col.mult(col)).compareTo(new Frac(d * d)); + } + + public Point getNextCell(FracVec dm) { + int resRow, resCol; + if (dm.row.sgn() < 0) { + resRow = row.roundDownAddSmallDown(); + } else { + resRow = row.roundDownAddSmallUp(); + } + if (dm.col.sgn() < 0) + resCol = col.roundDownAddSmallDown(); + else + resCol = col.roundDownAddSmallUp(); + return new Point(resCol, resRow); + } +} +" +C20057,"package jp.funnything.competition.util; + +import java.util.Arrays; +import java.util.List; + +import com.google.common.collect.Lists; +import com.google.common.primitives.Ints; +import com.google.common.primitives.Longs; + +public class Prime { + public static class PrimeData { + public int[] list; + public boolean[] map; + + private PrimeData( final int[] values , final boolean[] map ) { + list = values; + this.map = map; + } + } + + public static long[] factorize( long n , final int[] primes ) { + final List< Long > factor = Lists.newArrayList(); + + for ( final int p : primes ) { + if ( n < p * p ) { + break; + } + + while ( n % p == 0 ) { + factor.add( ( long ) p ); + n /= p; + } + } + + if ( n > 1 ) { + factor.add( n ); + } + + return Longs.toArray( factor ); + } + + public static PrimeData prepare( final int n ) { + final List< Integer > primes = Lists.newArrayList(); + + final boolean[] map = new boolean[ n ]; + Arrays.fill( map , true ); + + map[ 0 ] = map[ 1 ] = false; + + primes.add( 2 ); + for ( int composite = 2 * 2 ; composite < n ; composite += 2 ) { + map[ composite ] = false; + } + + for ( int value = 3 ; value < n ; value += 2 ) { + if ( map[ value ] ) { + primes.add( value ); + for ( int composite = value * 2 ; composite < n ; composite += value ) { + map[ composite ] = false; + } + } + } + + return new PrimeData( Ints.toArray( primes ) , map ); + } +} +" +C20030,"/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package uk.co.epii.codejam.hallofmirrors; + +/** + * + * @author jim + */ +public class RayVector { + + public final int x; + public final int y; + + public RayVector(int x, int y) { + this.x = x; + this.y = y; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof RayVector) { + RayVector v = (RayVector)obj; + if (v.x * y == v.y * x) + return true; + } + return false; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 41 * hash + this.x; + hash = 41 * hash + this.y; + return hash; + } + + public Fraction getScalarGardient() { + return new Fraction(Math.abs(y), Math.abs(x)); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(""(""); + sb.append(x); + sb.append("",""); + sb.append(y); + sb.append("")""); + return sb.toString(); + } + +} +" +C20002,"import java.util.*; +import java.io.*; +import java.math.*; +import java.awt.*; +import static java.lang.Math.*; +import static java.lang.Integer.parseInt; +import static java.lang.Double.parseDouble; +import static java.lang.Long.parseLong; +import static java.lang.System.*; +import static java.util.Arrays.*; +import static java.util.Collection.*; + +public class D +{ + static int gcd(int a, int b) { return b == 0 ? a : a == 0 ? b : gcd(b, a%b); } + public static void main(String[] args) throws IOException + { + BufferedReader br = new BufferedReader(new InputStreamReader(in)); + int T = parseInt(br.readLine()); + for(int t = 0; t++ < T; ) + { + String[] line = br.readLine().split("" ""); + int H = parseInt(line[0]), W = parseInt(line[1]), D = parseInt(line[2]); + char[][] G = new char[H][]; + for(int h = 0; h < H; h++) + G[h] = br.readLine().toCharArray(); + int X = 0, Y = 0; + outer:for(Y = 0; Y < H; Y++) + for(X = 0; X < W; X++) + if(G[Y][X] == 'X') + break outer; + int count = 0; + for(int i = -D; i <= D; i++) + { + for(int j = -D; j <= D; j++) + { + int dx = i, dy = j, scale = 2 * Math.abs((dx == 0 ? 1 : dx) * (dy == 0 ? 1 : dy)), x0, y0, x, y; + int steps = (int)Math.floor(scale * D / Math.sqrt(dx * dx + dy * dy)); + if(gcd(Math.abs(dx), Math.abs(dy)) != 1) + continue; + x0 = x = X * scale + scale / 2; + y0 = y = Y * scale + scale / 2; + do + { + steps -= 1; + if(x % scale == 0 && y % scale == 0) + { + // at a corner + int dxi = dx > 0 ? 1 : -1, dyi = dy > 0 ? 1 : -1; + int xi = (x / scale) - (dxi + 1) / 2, yi = (y / scale) - (dyi + 1) / 2; + if(G[yi+dyi][xi+dxi] == '#') + { + if(G[yi+dyi][xi] != '#' && G[yi][xi+dxi] != '#') + steps = -1; // kill the light + if(G[yi+dyi][xi] == '#') + dy *= -1; + if(G[yi][xi+dxi] == '#') + dx *= -1; + } else ; + // otherwise step as normal + } else if(x % scale == 0) { + int xi = x / scale, yi = y / scale; + if(G[yi][xi] == '#' || G[yi][xi-1] == '#') + dx *= -1; + } else if(y % scale == 0) { + int xi = x / scale, yi = y / scale; + if(G[yi][xi] == '#' || G[yi-1][xi] == '#') + dy *= -1; + } else ; + // smooth sailing + x += dx; + y += dy; + } while(steps >= 0 && !(x == x0 && y == y0)); + if(steps >= 0) + ++count; + } + } + out.println(""Case #"" + t +"": "" + count) ; + } + } +} +" +C20056,"package jp.funnything.competition.util; + +import java.math.BigDecimal; + +/** + * Utility for BigDeciaml + */ +public class BD { + public static BigDecimal ZERO = BigDecimal.ZERO; + public static BigDecimal ONE = BigDecimal.ONE; + + public static BigDecimal add( final BigDecimal x , final BigDecimal y ) { + return x.add( y ); + } + + public static BigDecimal add( final BigDecimal x , final double y ) { + return add( x , v( y ) ); + } + + public static BigDecimal add( final double x , final BigDecimal y ) { + return add( v( x ) , y ); + } + + public static int cmp( final BigDecimal x , final BigDecimal y ) { + return x.compareTo( y ); + } + + public static int cmp( final BigDecimal x , final double y ) { + return cmp( x , v( y ) ); + } + + public static int cmp( final double x , final BigDecimal y ) { + return cmp( v( x ) , y ); + } + + public static BigDecimal div( final BigDecimal x , final BigDecimal y ) { + return x.divide( y ); + } + + public static BigDecimal div( final BigDecimal x , final double y ) { + return div( x , v( y ) ); + } + + public static BigDecimal div( final double x , final BigDecimal y ) { + return div( v( x ) , y ); + } + + public static BigDecimal mul( final BigDecimal x , final BigDecimal y ) { + return x.multiply( y ); + } + + public static BigDecimal mul( final BigDecimal x , final double y ) { + return mul( x , v( y ) ); + } + + public static BigDecimal mul( final double x , final BigDecimal y ) { + return mul( v( x ) , y ); + } + + public static BigDecimal sub( final BigDecimal x , final BigDecimal y ) { + return x.subtract( y ); + } + + public static BigDecimal sub( final BigDecimal x , final double y ) { + return sub( x , v( y ) ); + } + + public static BigDecimal sub( final double x , final BigDecimal y ) { + return sub( v( x ) , y ); + } + + public static BigDecimal v( final double value ) { + return BigDecimal.valueOf( value ); + } +} +" +C20018,"package template; + +import java.util.Objects; + +public class Pair implements Comparable>{ + private T1 o1; + private T2 o2; + + public Pair(T1 o1, T2 o2) { + this.o1 = o1; + this.o2 = o2; + } + + + @Override + public boolean equals(Object other) { + if (!(other instanceof Pair)) {return false;} + return (compareTo((Pair)other) == 0); + } + + @Override + public int compareTo(Pair other) { + int c1 = ((Comparable) o1).compareTo(other.getO1()); + if (c1 != 0) {return c1;} + int c2 = ((Comparable) o2).compareTo(other.getO2()); + return c2; + } + + @Override + public int hashCode() { + int hash = 5; + hash = 83 * hash + Objects.hashCode(this.o1); + hash = 83 * hash + Objects.hashCode(this.o2); + return hash; + } + + @Override + public String toString() + { + return ""["" + o1 + "", "" + o2 + ""]""; + } + + public T1 getO1() { + return o1; + } + + public void setO1(T1 o1) { + this.o1 = o1; + } + + public T2 getO2() { + return o2; + } + + public void setO2(T2 o2) { + this.o2 = o2; + } +} +" +C20051,"package jp.funnything.competition.util; + +import java.util.List; + +import com.google.common.collect.Lists; + +public class Lists2 { + public static < T > List< T > newArrayListAsArray( final int length ) { + final List< T > list = Lists.newArrayListWithCapacity( length ); + + for ( int index = 0 ; index < length ; index++ ) { + list.add( null ); + } + + return list; + } +} +"