Datasets:

buelfhood

/

S_Exp

like 0

A11759

A12565

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.*; public class B { public static void main(String[] args) { Scanner s = new Scanner(System.in); int cases = s.nextInt(); for (int i=1; i<=cases; i++) { int n = s.nextInt(); int surprising = s.nextInt(); int p = s.nextInt(); int number = 0; for (int j=0; j<n; j++) { int t = s.nextInt(); int m = t/3; int remind = t%3; if ((remind == 0)&&(t!=0)) { if (m>=p) number++; else if ((m+1) >= p) { surprising--; if (surprising >=0) number++; } } if (t==0) if (t >= p) number++; if (remind == 1) { if ((m+1) >= p) number++; } if (remind == 2) { if ((m+1) >= p) number++; else if ((m+2) >= p) { surprising--; if (surprising >=0) number++; } } } System.out.println("Case #" + i + ": " + number); } } }

A11759

A11607

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

public class Runner { public static void main(String args[]) throws Exception { BaseSolution bs = (BaseSolution) Class.forName(args[0]).newInstance(); bs.start(args[1]); } }

A11759

A12981

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.util.ArrayList; public class GJ_QR_B { public static int solve(int N, int S, int p, int[] t){ int[][] s = new int[31][2]; for (int i=0; i<31; i++){ if(i%3 == 0){ if (3*p <= i) s[i][0] = 1; if ( (p>=2 && 3*(p-1) == i) || 3*(p-1) < i) s[i][1] = 1; } if(i%3 == 1){ if ( (p>=1 && 3*p-2 == i) || 3*p-2 < i) s[i][0] = 1; if ( (p>=2 && 3*p-2 == i) || 3*p-2 < i) s[i][1] = 1; } if(i%3 == 2){ if ( (p>=1 && 3*p-1 == i) || 3*p-1 < i) s[i][0] = 1; if ( (p>=2 && 3*p-4 == i) || 3*p-4 < i) s[i][1] = 1; } //System.out.println(i+":"+s[i][0]+"+"+s[i][1]); } ArrayList<Integer> a01 = new ArrayList<Integer>(); ArrayList<Integer> a11 = new ArrayList<Integer>(); ArrayList<Integer> a10 = new ArrayList<Integer>(); ArrayList<Integer> a00 = new ArrayList<Integer>(); for (int i=0; i<t.length; i++){ if (s[t[i]][0] == 1 && s[t[i]][1] == 0) a10.add(i); if (s[t[i]][0] == 0 && s[t[i]][1] == 1) a01.add(i); if (s[t[i]][0] == 1 && s[t[i]][1] == 1) a11.add(i); if (s[t[i]][0] == 0 && s[t[i]][1] == 0) a00.add(i); /* if (s[t[i]][0] == 1) System.out.println(" "+t[i]+":"+p+":"); if (s[t[i]][1] == 1) System.out.println(" "+t[i]+":"+p+":(*)"); */ } int res = a11.size(); if (S <= a01.size()) res += S + a10.size(); else if (S <= a01.size() + a11.size()) res += a01.size() + a10.size(); else res += a01.size()+ a10.size() ; System.out.println("N="+N+", S="+S+" : (a01)"+a01.size()+" : (a11)"+a11.size()+" : (a10)"+a10.size()+" : (a00)"+a00.size() + " ==> "+ res); return res; } public static void main(String[] args) throws NumberFormatException, IOException { java.io.BufferedReader stdin = new java.io.BufferedReader(new java.io.InputStreamReader(new FileInputStream("B-small-attempt2.in"))); java.io.BufferedWriter stdout = new java.io.BufferedWriter(new OutputStreamWriter(new FileOutputStream("B-small-attempt2.out"))); int T = Integer.parseInt(stdin.readLine()); //T = 1; for (int ii=0; ii<T; ii++){ String str = stdin.readLine(); String[] words = str.split(" "); int N = Integer.parseInt(words[0]); int[] in = new int[N]; for (int j = 0; j<N; j++) in[j] = Integer.parseInt(words[3+j]); System.out.print("Case #" + (1+ii) +" "); int res = solve(N, Integer.parseInt(words[1]), Integer.parseInt(words[2]), in); stdout.write("Case #" + (1+ii)+": " +res+'\n'); } stdout.close(); } }

A11759

A11053

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; public class B { private static final String FILE = "B-small-attempt0"; private static final boolean SAVE_OUT = true; public static void main(String[] args) throws IOException { BufferedReader in = createReader(); FileWriter out; if (SAVE_OUT) { out = new FileWriter(FILE+".out"); } int t = Integer.parseInt(in.readLine()); int c = 0; while (t-- > 0) { String row = in.readLine(); String[] split = row.split(" "); int n = Integer.parseInt(split[0]); int s = Integer.parseInt(split[1]); int p = Integer.parseInt(split[2]); int num = 0; for (int i = 0; i < n; ++i) { int k = Integer.parseInt(split[i+3]); if (k == 0) { num += p == 0 ? 1 : 0; } else if (k == 1) { num += p <= 1 ? 1 : 0; } else if (3*p-2 <= k) { ++num; } else if (3*p-4 <= k && s > 0) { ++num; --s; } } String res = String.format("Case #%d: %d", ++c, num); System.out.println(res); if (SAVE_OUT) { out.append(res); out.append("\n"); } } if (SAVE_OUT) { out.close(); } } private static BufferedReader createReader() throws FileNotFoundException { return new BufferedReader(new FileReader(FILE+".in")); } }

A11759

A10048

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; /** * template class for code jam Contest * * @author Tudor * */ public class Main { public static final String INPUT_FILE = "src/in.txt"; public static final String OUTPUT_FILE = "out.txt"; java.io.BufferedWriter br; /* * the number of tests */ int tests; /* * the size of the test */ int n; int s; int p; /* * the array */ int[] notes; public static void main(String args[]) { Main classMain = new Main(); try { Scanner scanner = new Scanner(new File(Main.INPUT_FILE)); classMain.br = new java.io.BufferedWriter(new FileWriter(Main.OUTPUT_FILE)); classMain.setData(scanner); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * method to set the initial data and run the tests * @param br the reader obtained from file */ public void setData(Scanner scanner) { try { tests = scanner.nextInt(); // System.out.println("Tests " + tests); for (int i = 0; i < tests; i++) { n = scanner.nextInt(); s = scanner.nextInt(); p = scanner.nextInt(); notes = new int[n]; for (int j=0; j<n; j++) { notes[j] = scanner.nextInt(); } solve(i + 1); } br.close(); } catch (Exception e) { e.printStackTrace(); } } /** * method to solve the problem * @param testNr the index of the test */ public void solve(int testNr) { int result = 0; try { for (int i=0; i<n; i++) { if (notes[i] >= (3 * p - 2)) result++; else if (notes[i] >= (3 * p - 4)) if (s > 0 && notes[i] > 0) { result++; s--; } } br.write("Case #" + testNr + ": " + result + "\n"); } catch (IOException e) { e.printStackTrace(); } } }

A11759

A10944

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package jam2; import java.util.Scanner; /** * * @author clary35 */ public class Jam2 { Jam2() { int[] totals = new int[10000]; System.out.println("Input:"); Scanner scan = new Scanner(System.in); int cases = scan.nextInt(); for (int i = 0; i < cases; i++) { // Read case data int N = scan.nextInt(); int S = scan.nextInt(); int p = scan.nextInt(); for (int k = 0; k < N; k++) { int temp = scan.nextInt(); totals[k] = temp; } // Process case int overs = 0; for (int k = 0; k < N; k++) { int themant = (int) Math.floor(totals[k] / 3); double thefrac = totals[k] / 3.0 - themant; // System.out.println("Mant: " + themant); // System.out.println("Frac: " + thefrac); if(p == 0 && totals[k] == 0){ overs++; } if (totals[k] > 0.9999999) { if (thefrac < 0.000000001) { if (themant >= (p)) { overs++; } else { if (themant >= (p - 1) && S > 0) { overs++; S = S - 1; } } } else { // Inte heltalsmedel if (thefrac * 3 > 1.99999999) { // Increase one without special, increase two with special if (themant >= p) { overs++; } else { if (themant >= (p - 1)) { overs++; } else { if (themant >= (p - 2) && S > 0) { overs++; S = S - 1; } } } } else { // Increase with with special only if (themant >= p) { overs++; } else { if (themant >= (p - 1)) { overs++; } } } } } } System.out.println("Case #" + (i + 1) + ": " + overs); } } /** * @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here Jam2 jm = new Jam2(); } }

A11759

A12769

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package b; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.text.AttributedCharacterIterator; import java.util.Arrays; import java.util.StringTokenizer; public class Main { public static void main(String[] args) { InputStream inputStream; try { inputStream = new FileInputStream("input.txt"); } catch (IOException e) { throw new RuntimeException(e); } OutputStream outputStream; try { outputStream = new FileOutputStream("output.txt"); } catch (IOException e) { throw new RuntimeException(e); } InputReader in = new InputReader(inputStream); PrintWriter out = new PrintWriter(outputStream); Dancing solver = new Dancing(); int testCases = in.nextInt(); for (int i = 1; i <= testCases; i++) solver.solve(i, in, out); out.close(); } } class InputReader { private BufferedReader reader; private StringTokenizer tokenizer; public InputReader(InputStream stream) { reader = new BufferedReader(new InputStreamReader(stream)); tokenizer = null; } public String next() { while (tokenizer == null || !tokenizer.hasMoreTokens()) { try { tokenizer = new StringTokenizer(reader.readLine()); } catch (IOException e) { throw new RuntimeException(e); } } return tokenizer.nextToken(); } public boolean haveNextInCurrentLine() { return (tokenizer != null && tokenizer.hasMoreTokens()); } public int nextInt() { return Integer.parseInt(next()); } } class Dancing { static final int IMPOSSIBLE = 0, POSSIBLE = 1, ACHIEVED = 2; public void solve(int testCase, InputReader in, PrintWriter out) { int n = in.nextInt(); int s = in.nextInt(); int p = in.nextInt(); int[] t = new int[n]; for (int i = 0; i < n; i++) { t[i] = in.nextInt(); } System.out.println("Case #" + testCase + ": " + n + " " + s + " " + p + " " + Arrays.toString(t)); int result = n; if (p > 0) { int possible = 0; int achieved = 0; for (int i = 0; i < n; i++) { System.out .println("n: " + (i + 1) + " = " + getResult(t[i], p)); switch (getResult(t[i], p)) { case ACHIEVED: achieved++; break; case POSSIBLE: possible++; break; } } result = achieved + Math.min(possible, s); } out.println("Case #" + testCase + ": " + result); System.out.println("Case #" + testCase + ": " + result); } private int getResult(int sum, int p) { if (sum < p) return IMPOSSIBLE; int third = sum / 3; if (third >= p) return ACHIEVED; if (sum % 3 == 0) { if ((sum - 2) / 3 + 2 >= p) return POSSIBLE; } else { if (third + 1 >= p) return ACHIEVED; else if ((sum - 2) / 3 + 2 >= p) return POSSIBLE; } return IMPOSSIBLE; } }

A11759

A11030

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package fixjava; import java.util.ArrayList; /** * String splitter, this fixes the problem that String.split() has of losing the last token if it's empty. It also uses * CharSequences rather than allocating new String objects. */ public class Split { /** * String splitter, this fixes the problem that String.split() has of losing the last token if it's empty. It also uses * CharSequences rather than allocating new String objects. */ public static ArrayList<CharSequence> splitAsList(String str, String sep) { int strLen = str.length(); int sepLen = sep.length(); assert sepLen > 0; ArrayList<CharSequence> parts = new ArrayList<CharSequence>(); for (int curr = 0; curr <= strLen;) { // Look for next token int next = str.indexOf(sep, curr); // Read to end if none if (next < 0) next = strLen; // Add next token parts.add(str.subSequence(curr, next)); // Move to end of separator, or past end of string if we're at the end // (by stopping when curr <= strLen rather than when curr < strLen, // we avoid the problem inherent in the Java standard libraries of // dropping the last field if it's empty; fortunately // str.indexOf(sep, curr) still works when curr == str.length() // without throwing an index out of range exception). curr = next + sepLen; } return parts; } public static CharSequence[] splitAsArray(String str, String sep) { ArrayList<CharSequence> list = splitAsList(str, sep); CharSequence[] arr = new CharSequence[list.size()]; list.toArray(arr); return arr; } public static ArrayList<String> splitAsListOfString(String str, String sep) { ArrayList<CharSequence> list = splitAsList(str, sep); ArrayList<String> listOfString = new ArrayList<String>(list.size()); for (CharSequence cs : list) listOfString.add(cs.toString()); return listOfString; } /** For compatibility only, slower because it creates new String objects for each CharSequence */ public static String[] split(String str, String sep) { ArrayList<CharSequence> list = splitAsList(str, sep); String[] arr = new String[list.size()]; for (int i = 0; i < list.size(); i++) arr[i] = list.get(i).toString(); return arr; } // public static void main(String[] args) { // System.out.println(splitAsList("", "\t")); // System.out.println(splitAsList("\t", "\t")); // System.out.println(splitAsList("a\t", "\t")); // System.out.println(splitAsList("\ta", "\t")); // System.out.println(splitAsList("\ta\t", "\t")); // System.out.println(splitAsList("a\tb", "\t")); // System.out.println(splitAsList("a\tb\t", "\t")); // System.out.println(splitAsList("\ta\tb", "\t")); // System.out.println(splitAsList("", "SEP")); // System.out.println(splitAsList("SEP", "SEP")); // System.out.println(splitAsList("aSEP", "SEP")); // System.out.println(splitAsList("SEPaSEPb", "SEP")); // System.out.println(splitAsList("aSEPbSEP", "SEP")); // } }

A11759

A12205

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package qualification; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class B { String solve(Scanner in) throws IOException { int N = in.nextInt(), S = in.nextInt(), p = in.nextInt(), count = 0, need_surprise = 0; for(int i = 0; i < N; i++) { int t = in.nextInt(); if((t+2)/3 >= p) count++; else if(2 <= t && t <= 28 && (t+4)/3 >= p) need_surprise++; } count += Math.min(S, need_surprise); return ""+count; } /*************************************************************************************************/ public static void main(String[] args) throws IOException { for(File f : new File(".").listFiles()) if(f.isFile() && f.getName().startsWith(B.class.getSimpleName() + "-") && f.getName().endsWith(".in")) { Scanner in = new Scanner(new FileReader(f)); PrintWriter out = new PrintWriter(new FileWriter(f.getName() + ".out")); int cases = in.nextInt(); in.nextLine(); for(int caseno = 1; caseno <= cases; caseno++) out.printf("Case #%d: %s%n", caseno, new B().solve(in)); out.close(); } } }

A11759

A12578

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.IOException; import java.util.HashMap; import java.util.List; import java.util.Map; public class SpeakingTongues extends JamProblem { Map<Character, Character> map = new HashMap<>(); public static void main(String[] args) throws IOException { SpeakingTongues p = new SpeakingTongues(); p.prepare(); p.go(); } void prepare() { map.put('y', 'a'); map.put('e', 'o'); map.put('q', 'z'); String[] from = new String[3]; String[] to = new String[3]; to[0] = "ejp mysljylc kd kxveddknmc re jsicpdrysi"; to[1] = "rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd"; to[2] = "de kr kd eoya kw aej tysr re ujdr lkgc jv"; from[0] = "our language is impossible to understand"; from[1] = "there are twenty six factorial possibilities"; from[2] = "so it is okay if you want to just give up"; for (int i = 0; i < to.length; i++) { char[] t = to[i].toCharArray(); char[] f = from[i].toCharArray(); for (int j = 0; j < f.length; j++) { char fc = f[j]; char tc = t[j]; map.put(tc, fc); } } for (char c = 'a'; c <= 'z'; c++) { if (map.containsKey(c)) { continue; } for (char c2 = 'a'; c2 <= 'z'; c2++) { if (map.containsValue(c2)) { continue; } map.put(c,c2); } } } @Override String solveCase(JamCase jamCase) { StringBuilder b = new StringBuilder(); STCase ca = (STCase) jamCase; char[] chars = ca.str.toCharArray(); for (int i = 0; i < chars.length; i++) { char c = chars[i]; b.append(map.get(c)); } return b.toString(); } @Override JamCase parseCase(List<String> file, int line) { STCase ca = new STCase(); ca.lineCount = 1; ca.str = file.get(line); return ca; } } class STCase extends JamCase { String str; }

A11759

A10514

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.*; public class B { public static void main(String[] args) { Scanner in = new Scanner(System.in); int T = in.nextInt(); for (int t = 1; t <= T; ++t) { int N = in.nextInt(); int S = in.nextInt(); int P = in.nextInt(); int withoutS = 0; // those that got it without an S int withS = 0; // those that need an S for (int n = 0; n < N; ++n) { int val = in.nextInt(); if (val/3 >= P || (val/3 == P-1 && val%3 != 0)) ++withoutS; else if (!(val/3 == 0 && val%3 <= 1) && ((val/3 == P-1 && val%3 == 0) || (val/3 == P-2 && val%3 == 2))) ++withS; } int ans = withoutS + Math.min(withS, S); System.out.printf("Case #%d: %d\n", t, ans); } } } /* 4 3 1 5 15 13 11 3 0 8 23 22 21 2 1 1 8 0 6 2 8 29 20 8 18 18 21 */

A11759

A12875

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package er.dream.codejam.helpers; import java.io.File; import java.util.List; public abstract class ProblemSolver { protected FileHandler fileHandler = new FileHandler(); protected abstract List<String> handleInput(); public void execute(){ File[] files = fileHandler.listFiles(); for(File f : files){ long start = System.currentTimeMillis(); fileHandler.loadFile(f); List<String> results = handleInput(); fileHandler.writeOutput(results); fileHandler.closeConnection(); long stop = System.currentTimeMillis(); System.out.println("File "+f.getName()+" took me "+(stop-start)+"ms"); } } }

A11759

A11038

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/** * */ package fixjava; public class ConcurrentCounter { private int count = 0; public synchronized int getAndIncrement() { return count++; } }

A11759

A12362

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package inout; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileWriter; import java.io.IOException; /** * * @author Hasier Rodriguez */ public final class Out { private Out() { } public static void write(String path, int n, String result) throws FileNotFoundException, IOException { File f = new File(path); BufferedWriter br = new BufferedWriter(new FileWriter(f, true)); String out = "Case #" + n + ": " + result; br.write(out); System.out.println(out); br.newLine(); br.flush(); br.close(); } }

A11759

A11280

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.Arrays; public class B { public static void main(String[] args) throws Exception { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); int n = Integer.parseInt(in.readLine()); for (int m = 0; m < n; m++) { String[] parts = in.readLine().split(" "); int googlers = Integer.parseInt(parts[0]); int s = Integer.parseInt(parts[1]); int p = Integer.parseInt(parts[2]); int[] scores = new int[googlers]; for (int i = 0; i < googlers; i++) { scores[i] = Integer.parseInt(parts[i + 3]); } Arrays.sort(scores); int winners = 0; for (int score : scores) { int j1 = score / 3 + 1; int[] judge = { j1, j1, j1 }; int sum = j1 * 3; for (int i = 0; sum > score; i++) { judge[i % 3]--; sum--; } if (judge[2] >= p) { winners++; continue; } if (judge[2] == p - 1 && s > 0) { if (judge[0] == judge[2] && judge[0] != 0) { winners++; s--; continue; } if (judge[1] == judge[2] && judge[1] != 0) { winners++; s--; continue; } } } System.out.println("Case #" + (m + 1) + ": " + winners); } } }

A11759

A10806

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.FileReader; import java.io.BufferedReader; import java.io.FileWriter; import java.io.BufferedWriter; public class DancingGooglers { /** * @param args */ public static void main(String[] args) { try{ //read file FileReader filein = new FileReader(args[0]); BufferedReader in = new BufferedReader(filein); //write file FileWriter fileout = new FileWriter("output.txt"); BufferedWriter out = new BufferedWriter(fileout); //process data int numcases = Integer.valueOf(in.readLine()).intValue(); for(int i=0; i<numcases; i++){ String[] casedata = in.readLine().split(" "); int numgooglers = Integer.valueOf(casedata[0]); int totalsurprises = Integer.valueOf(casedata[1]); int bestresult = Integer.valueOf(casedata[2]); int[][] googlers = new int[numgooglers][5]; int surprises = 0; for(int j=0; j<numgooglers; j++){ googlers[j][0] = Integer.valueOf(casedata[3+j])/3; int max = googlers[j][0]; int min = googlers[j][0]; googlers[j][1] = (Integer.valueOf(casedata[3+j])-googlers[j][0])/2; if(googlers[j][1] > max) max = googlers[j][1]; if(googlers[j][1] < min) min = googlers[j][1]; googlers[j][2] = Integer.valueOf(casedata[3+j])-googlers[j][0]-googlers[j][1]; if(googlers[j][2] > max) max = googlers[j][2]; if(googlers[j][2] < min) min = googlers[j][2]; googlers[j][0] = max; googlers[j][1] = Integer.valueOf(casedata[3+j]) - max -min; googlers[j][2] = min; googlers[j][3] = max - min; if(max - min > 1) surprises++; } while(surprises < totalsurprises){ int test = 0; for(int j=0; j<numgooglers; j++){ if(googlers[j][3] < 2 && googlers[j][0] == bestresult - 1 && googlers[j][1] > 0 ){ surprises++; googlers[j][0]++; googlers[j][1]--; googlers[j][3] = 2; test = 1; break; } } if(test == 0) break; } int result = 0; for(int j=0; j<numgooglers; j++){ if(googlers[j][0] >= bestresult){ result++; } } out.write("Case #" + (i+1) + ": " + result + "\n"); } //Close the output stream out.close(); //Close the input stream in.close(); }catch (Exception e){//Catch exception if any System.err.println("Error: " + e.getMessage()); } } }

A11759

A10259

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.HashMap; import java.util.Map; public class DancingWithGooglers { public static void main(String[] args) throws IOException { String msg = ""; BufferedReader br = null; String sCurrentLine = null; Map<String, String> map = new HashMap<String, String>(); br = new BufferedReader(new FileReader("test")); sCurrentLine = br.readLine(); int x = 0; if (sCurrentLine != null) { while ((sCurrentLine = br.readLine()) != null) { int qualifiedGooglers = 0; msg = ""; String[] eachTestCase = sCurrentLine.split(" "); int noOfGooglers = Integer.parseInt(eachTestCase[0]); int noOfSurprises = Integer.parseInt(eachTestCase[1]); int minReqd = Integer.parseInt(eachTestCase[2]); int[] googlersPoint = new int[noOfGooglers]; int k = 0; for (int i = 3; i < eachTestCase.length; i++) { int j = Integer.parseInt(eachTestCase[i]); googlersPoint[k++] = j; } for (int i = 0; i < noOfGooglers; i++) { if (googlersPoint[i] == 0) { if (minReqd == 0) qualifiedGooglers++; } else if ((googlersPoint[i] + 2) / 3 >= minReqd) { qualifiedGooglers++; } else if (noOfSurprises > 0) { if ((googlersPoint[i] + 4) / 3 >= minReqd) { qualifiedGooglers++; noOfSurprises--; } } } x++; msg += "Case #" + x + ": " + qualifiedGooglers; System.out.println(msg); } } } }

A11759

A13096

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package problemb; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; /** * * @author Dr. Reda M. Hussien */ public class ProblemB { /** * @param args the command line arguments */ public static void main(String[] args) throws FileNotFoundException, IOException { // TODO code application logic here String DataFile = "E:\\B-small-attempt5.in"; FileReader fileReader; fileReader = new FileReader(DataFile); BufferedReader br = new BufferedReader(fileReader); int N, S, P, ti, x, r, googlers, surprise; String[] values; String nextLine = br.readLine(); int T = Integer.parseInt(nextLine); for (int i = 0; i < T; i++) { googlers = 0; surprise = 0; values = br.readLine().split(" "); N = Integer.parseInt(values[0]); S = Integer.parseInt(values[1]); P = Integer.parseInt(values[2]); for (int n = 3; n < N + 3; n++) { ti = Integer.parseInt(values[n]); x = ti / 3; r = ti % 3; switch (r) { case 0: if (x >= P) { googlers++; } else { // check for surprise case: if (S > 0 && x > 0 && x + 1 >= P) { googlers++; S--; } } break; case 1: if (x >= P || x + 1 >= P) { googlers++; } else { // surprise case: if (S > 0 && x + 1 >= P) { googlers++; S--; } } break; case 2: if (x + 1 >= P || x >= P) { googlers++; } else { if (S > 0 && x + 2 >= P) { googlers++; S--; } } break; } } System.out.println("Case #" + (i + 1) + ": " + googlers); } } }

A11759

A11887

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.*; import java.io.*; public class B { public static void main(String[] args) { int n = 0; int[] m = null; int[] s = null; int[] p = null; int[][] t = null; try { File file = new File(args[0]); Scanner sc = new Scanner(file); n = sc.nextInt(); m = new int[n]; s = new int[n]; p = new int[n]; t = new int[n][]; for(int i=0;i<n;i++) { m[i] = sc.nextInt(); s[i] = sc.nextInt(); p[i] = sc.nextInt(); t[i] = new int[m[i]]; for(int j=0;j<m[i];j++) { t[i][j] = sc.nextInt(); } } } catch(FileNotFoundException e) { e.printStackTrace(); } for (int i=0;i<n;i++) { int b1 = p[i] * 3 - 2; int b2 = p[i] * 3 - 4; int good = 0;int suprise = 0; for (int j=0;j<m[i];j++) { if (t[i][j] < p[i]) { continue; } if (t[i][j] >= b1) { good++; } else if (t[i][j] >= b2) { suprise++; } } int res; if (suprise > s[i]) { res = good + s[i]; } else { res = good + suprise; } System.out.println("Case #" + (i+1) + ": " + res); } } }

A11759

A11829

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.util.Arrays; /** * Created with IntelliJ IDEA. * User: vikash * Date: 14/04/12 * Time: 9:51 AM * To change this template use File | Settings | File Templates. */ public class DancingGooglers { static int[][] getPossibleCombinations(int totalPoints) { int averagePoint = totalPoints / 3; int remainder = totalPoints % 3; int[][] possibleCombinations; if (totalPoints >= 2 && totalPoints <= 28) { possibleCombinations = new int[2][3]; if (remainder == 0) { possibleCombinations[1] = new int[]{averagePoint, averagePoint, averagePoint}; possibleCombinations[0] = new int[]{averagePoint + 1, averagePoint, averagePoint - 1}; } else if (remainder == 1) { possibleCombinations[1] = new int[]{averagePoint + 1, averagePoint, averagePoint}; possibleCombinations[0] = new int[]{averagePoint + 1, averagePoint + 1, averagePoint - 1}; } else { //remainder == 2 possibleCombinations[1] = new int[]{averagePoint + 1, averagePoint + 1, averagePoint}; possibleCombinations[0] = new int[]{averagePoint + 2, averagePoint, averagePoint}; } } else { possibleCombinations = new int[1][3]; if (totalPoints == 0) { possibleCombinations[0] = new int[]{0, 0, 0}; } else if (totalPoints == 1) { possibleCombinations[0] = new int[]{1, 0, 0}; } else if (totalPoints == 29) { possibleCombinations[0] = new int[]{10, 10, 9}; } else if (totalPoints == 30) { possibleCombinations[0] = new int[]{10, 10, 10}; } } return possibleCombinations; } static boolean isBestScoreMet(int[] possibleCombination, int bestScore) { for (int i = 0; i < possibleCombination.length; i++) { return possibleCombination[i] >= bestScore; } return false; } static boolean isSurprisingTriplet(int[] possibleCombination) { for (int i = 0; i < possibleCombination.length; i++) { for (int j = i + 1; j < possibleCombination.length; j++) { return Math.abs(possibleCombination[i] - possibleCombination[j]) == 2; } } return false; } public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new FileReader("/Users/vikash/DancingGooglersIn.txt")); BufferedWriter bw = new BufferedWriter(new FileWriter("/Users/vikash/DancingGooglersOut.txt")); int testCases = Integer.parseInt(br.readLine()); int currentTest = 1; while (currentTest <= testCases) { String[] numbers = br.readLine().split(" "); int numberOfGooglers = Integer.parseInt(numbers[0]); int numberOfSurprisingTriplets = Integer.parseInt(numbers[1]); int minBestResult = Integer.parseInt(numbers[2]); int[] googlersTotalScore = new int[numberOfGooglers]; for (int i = 3; i < numbers.length; i++) { googlersTotalScore[i - 3] = Integer.parseInt(numbers[i]); } Arrays.sort(googlersTotalScore); int qualifyingGooglers = 0; boolean minConditionMet = false; int optionalSurprisingTriplets = 0; for (int i = 0; i < googlersTotalScore.length; i++) { // if (minConditionMet) { // qualifyingGooglers++; // } else { int[][] possibleCombinations = getPossibleCombinations(googlersTotalScore[i]); boolean isBestResultMet = isBestScoreMet(possibleCombinations[0], minBestResult); if (isBestResultMet && numberOfSurprisingTriplets <= 0 && optionalSurprisingTriplets == 0) { if (possibleCombinations.length == 2) { isBestResultMet = isBestScoreMet(possibleCombinations[1], minBestResult); } } if (isBestResultMet) { if(numberOfSurprisingTriplets<=0) { optionalSurprisingTriplets--; } qualifyingGooglers++; if (googlersTotalScore[i]/3 >= minBestResult) { minConditionMet = true; } } if (possibleCombinations.length == 2 && numberOfSurprisingTriplets > 0) { numberOfSurprisingTriplets--; if(!isBestResultMet) { optionalSurprisingTriplets++; } } // } } bw.write("Case #" + currentTest + ": " + qualifyingGooglers); bw.newLine(); currentTest++; } bw.close(); br.close(); } }

A11759

A10228

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package codejam2; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.PrintStream; import java.util.Date; import java.util.Scanner; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public abstract class CodejamRunner { public static final int NUM_WORKERS = 4; public static final int TIMEOUT_MINUTES = 10; // Default behavior is to get number of test cases that follow public int preparse(Scanner s) { String line = s.nextLine(); return new Scanner(line).nextInt(); } public abstract CodejamCase parseCase(Scanner s); public void run(String[] args) { Date start = new Date(); // Set up worker threads ExecutorService es = Executors.newFixedThreadPool(args.length > 0 ? NUM_WORKERS : 1); // Read in file one test at a time and put in work queue try { Scanner s = new Scanner(new FileInputStream(args.length > 0 ? args[0] : "sample")); PrintStream o = args.length > 0 ? new PrintStream(new FileOutputStream(args[0]+ ".output")) : System.out; int numTests = preparse(s); final CodejamCase[] tests = new CodejamCase[numTests]; for (int i = 0; i < numTests; i++) { final int id = i; tests[id] = parseCase(s); es.execute(new Runnable() { @Override public void run() { tests[id].compute(); System.err.print(id + " "); } }); } // Wait until work queue is empty try { es.shutdown(); if (!es.awaitTermination(TIMEOUT_MINUTES, TimeUnit.MINUTES)) { System.err.println("Timeout! " + es.shutdownNow().size() + " tests incomplete."); } } catch (InterruptedException e) { System.err.println("Interrupted!"); e.printStackTrace(); } // Output results for (int i = 0; i < numTests; i++) { o.println("Case #" + (i+1) + ": " + tests[i].getOutput()); } } catch (IOException e) { System.err.println("IO error!"); e.printStackTrace(); } System.err.println("\nExecution time: " + (new Date().getTime() - start.getTime()) + "(ms)"); System.exit(0); } public static String padInt(int num, int len) { String s = "00000000000" + String.valueOf(num); return s.substring(s.length()-4); } }

A11759

A10946

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.DataInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; public class ProblemB { public static void main(String[] args) throws IOException{ FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String result =""; int num = Integer.parseInt(br.readLine()); for (int i = 0; i < num; i++) { result += "Case #"+(i+1)+": "; String input[] = br.readLine().split(" "); int numGooglers = Integer.parseInt(input[0]); int numSurprising = Integer.parseInt(input[1]); int p = Integer.parseInt(input[2]); int greaterThanP = 0; int surprisingGreaterThanP = 0; for (int j = 0; j < numGooglers; j++) { int googler = Integer.parseInt(input[j + 3]); if (googler >= p + 2*(p-1)) greaterThanP++; else if(googler >= p + 2*(p-2) && googler >= p) surprisingGreaterThanP++; } result += (greaterThanP+(int)Math.min(numSurprising, surprisingGreaterThanP)); if (i != num - 1) result += "\n"; } PrintWriter out = new PrintWriter(new BufferedWriter( new FileWriter(new File("out.txt")))); out.print(result); out.flush(); out.close(); System.out.print(result); } }

A11759

A12334

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package com.google.codejam; import java.io.File; import java.io.IOException; import java.util.List; import com.google.common.base.CharMatcher; import com.google.common.base.Function; import com.google.common.base.Splitter; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.io.Files; import com.google.gdata.util.common.base.Charsets; public class ProblemB { public static void main (String [] args) throws IOException { if (args.length != 1) { System.err.println("Usage: ProblemB inputfile"); return; } String filename = args[0]; List<String> inputLines = Files.readLines(new File(filename), Charsets.US_ASCII); int T = Integer.parseInt(inputLines.get(0)); List<String> testCases = inputLines.subList(1, inputLines.size()); assert(T == testCases.size()); for (int i = 0; i < testCases.size(); i++) { processLine(testCases, i); } } private static void processLine(List<String> testCases, int i) { String line = testCases.get(i); List<Integer> lineContents = Lists.newArrayList(Iterables.transform(Splitter.on(CharMatcher.WHITESPACE).split(line), new Function<String, Integer>() { @Override public Integer apply(String input) { return Integer.parseInt(input); } })); int numGooglers = lineContents.get(0); int numSurprising = lineContents.get(1); int targetBestResult = lineContents.get(2); List<Integer> scores = lineContents.subList(3, lineContents.size()); assert(numGooglers == scores.size()); int maxNumGooglers = 0; int numGooglersWithSurprise = 0; for (int score : scores) { if (((score + 2) / 3) >= targetBestResult) { // This is equivalent to ciel(score/3) >= targetBestResult maxNumGooglers++; } else if ((score + 4) / 3 >= targetBestResult && score > 0) { numGooglersWithSurprise++; } } maxNumGooglers += Math.min(numGooglersWithSurprise, numSurprising); System.out.println("Case #" + (i+1) + ": " + maxNumGooglers); } }

A11759

A10167

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.PrintStream; import java.util.Scanner; /** * @author: Ahmad Medhat Othman * @codeJame: AMedOs * @topCoder: AMedOs * @email :amedhat.cs@gmail.com * */ public class B { public static void main(String[] args) throws Exception { // Input file //A-small.in //A-large.in String in = "B-small-attempt2.in"; FileInputStream fin = new FileInputStream(in); Scanner scn = new Scanner(fin); // Output file String out = "B.out"; FileOutputStream fout = new FileOutputStream (out); PrintStream ps = new PrintStream(fout); int T=0; T = scn.nextInt(); int t,i,k=0; int n,s,p,num,rem,res=0; for (t=1 ; t<= T ; t++) { res=0; n = scn.nextInt(); s = scn.nextInt(); p = scn.nextInt(); for (i=0;i<n;i++){ k = scn.nextInt(); num = k/3; rem = k%3; if (num >=p){ res++; } else{ if (rem == 0){ if (num+1 >= p && s>0 && num>0){ res++; s--; } } if (rem == 1){ if (num+1 >= p){ res++; } } if (rem == 2){ if (num+1 >=p){ res++; } else if (num+2 >= p && s>0){ res++; s--; } } } } ps.println("Case #" + t + ": " + res); } fout.close(); fin.close(); System.out.println("Done:......."); System.exit(0); } }

A11759

A10432

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package Parser; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.io.Reader; public class MyReader { public String[] taskArray; public int currentString; public MyReader(String fileName) { // TODO Auto-generated constructor stub String taskString = readString(fileName); if (taskString.indexOf('\r') == -1) { taskArray = taskString.split("\n"); } else { taskArray = taskString.split("\r\n"); } currentString = 0; } public String readString(String fileName) { StringBuffer buffer = new StringBuffer(); try { File file = new File(fileName); FileInputStream fis = new FileInputStream(file); InputStreamReader isr = new InputStreamReader(fis); Reader in = new BufferedReader(isr); int ch; while ((ch = in.read()) > -1) { buffer.append((char) ch); } in.close(); return buffer.toString(); } catch (IOException e) { return ""; } } public String read() { return taskArray[currentString++]; } }

A11759

A12999

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package qualification.q1; import java.util.HashMap; import java.util.Map; /** * Created by IntelliJ IDEA. * User: ofer * Date: 14/04/12 * Time: 17:10 * To change this template use File | Settings | File Templates. */ public class Q1Solver { private Map<Character,Character> mapping; public Q1Solver(){ mapping = new HashMap<Character, Character>(); mapping.put('y','a'); mapping.put('n','b'); mapping.put('f','c'); mapping.put('i','d'); mapping.put('c','e'); mapping.put('w','f'); mapping.put('l','g'); mapping.put('b','h'); mapping.put('k','i'); mapping.put('u','j'); mapping.put('o','k'); mapping.put('m','l'); mapping.put('x','m'); mapping.put('s','n'); mapping.put('e','o'); mapping.put('v','p'); mapping.put('z','q'); mapping.put('p','r'); mapping.put('d','s'); mapping.put('r','t'); mapping.put('j','u'); mapping.put('g','v'); mapping.put('t','w'); mapping.put('h','x'); mapping.put('a','y'); mapping.put('q','z'); mapping.put(' ',' '); } public String convertString(String encrypted){ StringBuilder resString = new StringBuilder(""); for (int i = 0 ; i < encrypted.length() ; i++){ char decryptedChar = mapping.get(encrypted.charAt(i)); resString.append(decryptedChar); } return resString.toString(); } }

A11759

A12606

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package codejam; import java.io.*; public class Dancing { private final int[] total_scores; private final int superising_count; public Dancing(int[] total_scores, int superising_count) { this.total_scores = total_scores; this.superising_count = superising_count; } public static void main(String[] args) throws IOException { InputStream is; if (args.length > 0) { is = new FileInputStream(args[0]); }else{ is = System.in; } BufferedReader inputReader = new BufferedReader(new InputStreamReader(is)); String firstLine = inputReader.readLine(); int count_of_cases = Integer.parseInt(firstLine); for (int idx_of_case = 1; idx_of_case <= count_of_cases; idx_of_case++) { String caseLine = inputReader.readLine(); String[] numbers = caseLine.split(" "); int numbers_of_googler = Integer.parseInt(numbers[0]); int superising_count = Integer.parseInt(numbers[1]); int at_least = Integer.parseInt(numbers[2]); int[] total_scores = new int[numbers_of_googler]; for (int idx = 0; idx < numbers_of_googler; idx++) { total_scores[idx] = Integer.parseInt(numbers[3+idx]); } int count = new Dancing(total_scores, superising_count).count_of_greater_than(at_least); System.out.println(String.format("Case #%d: %d", idx_of_case, count)); } } public int count_of_greater_than(int at_least) { int supersed_count = 0; int count=0; for (int idx = 0; idx < total_scores.length; idx++) { int score = total_scores[idx]; int max_score = 0; int average = score / 3; if (average * 3 == score) { max_score = average; }else{ max_score = average+1; } if (max_score >= at_least) { count++; }else{ int left = score - at_least; if (left > 0 && supersed_count < superising_count ) { if ((left / 2) * 2 == left && at_least - left / 2 == 2) { supersed_count++; count++; } if (left == 2 * at_least -3 ) { supersed_count++; count++; } } } } return count; } }

A11759

A11391

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.PriorityQueue; /* * constraints * input: * testcases 1<= T <= 100 * surprising triplets 0<=S<=N * desired at least result p 0<=p<=10 * total points for each googler 0<=ti<= 30 * * small * N is between 1 and 3 * large * N is between 1 and 100 */ public class DancingScores { public int numTestCases = -1; public ArrayList<Googler> contestants=null; public int numGooglers = -1; public int surpriseTrips = -1; public int p=-1; public ArrayList<Googler> answer; /** * @param args */ public static void main(String[] args) throws IOException{ StopWatch s = new StopWatch(); s.start(); DancingScores ds = new DancingScores(); ds.parse("B-small-attempt4.in"); // ds.parse("data.txt"); s.stop(); System.out.println("elapsed time in milliseconds: " + s.getElapsedTime()); } public void parse(String filename) throws IOException{ FileReader inputStream = null; FileWriter outputStream = null; BufferedReader br = null; PrintWriter pw = null; try{ inputStream = new FileReader(filename); outputStream = new FileWriter("result.txt"); br = new BufferedReader(inputStream); pw = new PrintWriter(outputStream); numTestCases = Integer.parseInt(br.readLine()); for(int i=1;i<=numTestCases;i++){ String inputLine = br.readLine(); pw.println("Case #"+i+": "+solve(inputLine)); // pw.println(inputLine); // // for(Googler g: contestants){ // pw.print(g.score1>=p); // pw.print(" "); // pw.print(g); // } // // pw.println(); } } finally{ if(inputStream != null){ inputStream.close(); } if(outputStream != null){ outputStream.close(); } } } public int solve(String inputLine){ String[] tokens = inputLine.split("[ ]+"); numGooglers = Integer.parseInt(tokens[0]); surpriseTrips = Integer.parseInt(tokens[1]); p = Integer.parseInt(tokens[2]); contestants = new ArrayList<Googler>(numGooglers); for(int j=3;j<tokens.length;j++){ Googler goog = new Googler(j-3,Integer.parseInt(tokens[j])); contestants.add(goog); System.out.println(); } // for(Googler goog:contestants){ // if(goog.checkState()) // System.out.println("true"); // else // System.out.println("false"); // } // for(String token:tokens){ // i++; // //System.out.println("token is "+token); // } //System.out.println("stop "+i+" tokens"); ArrayList<Googler> pass = new ArrayList<Googler>(); PriorityQueue<Googler> fail = new PriorityQueue<Googler>(); //separate those that already pass for(Googler person: contestants){ if(person.passes(p)) pass.add(person); else fail.offer(person); } //sort failed based on their best result (want highest to add) //use remaining surprises to try and make them match System.out.println(surpriseTrips); while(fail.peek()!=null && surpriseTrips>0){ Googler next = fail.peek(); next.modify(); if(next.passes(p)){ pass.add(next); } surpriseTrips--; fail.remove(); } // for(Googler goog: pass){ // //System.out.println(goog); // } // for(Googler goog:contestants){ // if(goog.checkState()) // System.out.println("true"); // else // System.out.println("false"); // } // answer = pass; return pass.size(); } }

A11759

A12425

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; public class DancingGooglers { private static final String IN_FILE = "B-small.in"; private static final String OUT_FILE = "B-small_output.txt"; public static void main(String[] args) { try { BufferedReader br = new BufferedReader(new FileReader(IN_FILE)); BufferedWriter bw = new BufferedWriter(new FileWriter(OUT_FILE)); String line = br.readLine(); final int T_CASES = Integer.parseInt(line); for (int t = 1; t <= T_CASES; t++) { line = br.readLine(); String parts[] = line.split(" "); final int N = Integer.parseInt(parts[0]); // number of Googlers final int S = Integer.parseInt(parts[1]); // number of surprising triplets of scores final int P = Integer.parseInt(parts[2]); // best result of at least p int[] totalPoints = new int[N]; for (int i = 0; i < N; i++) { totalPoints[i] = Integer.parseInt(parts[i + 3]); } int result = processCase(N, S, P, totalPoints); bw.write("Case #" + t + ": " + result); bw.newLine(); } bw.close(); br.close(); } catch (IOException e) { e.printStackTrace(); } } private static int processCase(int n, int s, int p, int[] totalPoints) { int result = 0; for (int t : totalPoints) { switch (p) { case 0: result++; break; case 1: if (t >= 1) { result++; } break; default: // p is between 2 to 10 if (t >= 3 * p - 2) { result++; } else if (s > 0 && t >= 3 * p - 4) { s--; result++; } break; } } return result; } }

A11759

A10803

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package qualification.Dancing; import java.io.*; import qualification.Tongues.Tongues; /** * * @author farshid */ public class Interface { public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException, IOException { String inPath, outPath; IO.println("Enter input path:"); inPath = IO.readln(); IO.println("Enter output path:"); outPath = IO.readln(); IO.println("Solving..."); Dancing d = new Dancing(); FileInputStream fis = new FileInputStream(inPath); InputStreamReader in = new InputStreamReader(fis, "UTF-8"); BufferedReader reader = new BufferedReader(in); FileOutputStream fos = new FileOutputStream(outPath); OutputStreamWriter out = new OutputStreamWriter(fos, "UTF-8"); BufferedWriter writer = new BufferedWriter(out); int count = Integer.parseInt(reader.readLine()); int[] output = new int[count]; for (int i = 0; i < count; i++) { output[i] = d.solve(reader.readLine()); } reader.close(); for (int i = 0; i < count; i++) { writer.write("Case #" + (i + 1) + ": " + output[i]); writer.newLine(); } writer.close(); IO.println("Done."); IO.readln(); } }

A11759

A12356

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package dancing.with.the.googlers; import java.io.*; import java.util.ArrayList; import java.util.StringTokenizer; /** * * @author Palash */ public class DancingWithTheGooglers { /** * @param args the command line arguments */ static int NoOfGooglers; static int surprisingResults; static int pi; static int count; private static String inputFile = "C:/Users/Palash/Desktop/B-small-attempt2 (1).in"; private static String outputFile = "C:/Users/Palash/Desktop/Output.txt"; public static void main(String[] args) { // TODO code application logic here count = 0; readFile(); } public static void readFile() { int totalLines =0; try { FileInputStream fis = new FileInputStream(inputFile); DataInputStream dis = new DataInputStream(fis); BufferedReader br = new BufferedReader(new InputStreamReader(dis)); ArrayList<Integer> scores = new ArrayList<Integer>(); String str; StringTokenizer st; while( (str = br.readLine()) != null) { NoOfGooglers = -1; surprisingResults = -1; pi = -1; scores.clear(); st = new StringTokenizer(str, " \n"); scores.clear(); while( st.hasMoreTokens()) { if( totalLines == 0 ) { totalLines = Integer.parseInt(str); break; } if( NoOfGooglers == -1) { NoOfGooglers = Integer.parseInt(st.nextToken()); continue; } if(surprisingResults == -1) { surprisingResults = Integer.parseInt(st.nextToken()); continue; } if(pi == -1) { pi = Integer.parseInt(st.nextToken()); continue; } scores.add(Integer.parseInt(st.nextToken())); } if ( pi != -1) { int passPi = findProbabilityPi(NoOfGooglers, surprisingResults, pi, scores); writeFile(passPi); } } } catch(IOException | NumberFormatException e) { System.out.println("error is " +e.getMessage()); } } public static void writeFile(int passPi) { String line=""; try{ // Create file FileWriter fstream = new FileWriter(outputFile,true); count++; try (BufferedWriter out = new BufferedWriter(fstream)) { line = "Case #"+count+": "+passPi; out.write(line); out.newLine(); } } catch(Exception e) { System.out.println("error is " +e.getMessage()); } } public static int findProbabilityPi(int NoOfGooglers, int surprisingResults,int pi,ArrayList<Integer>scores) { int passPi = 0; NoOfGooglers = 3; for(int sc : scores) { if( sc % NoOfGooglers == 0) { if( (sc/3) == 0 && pi != 0) continue; if( sc/NoOfGooglers >= pi) { passPi++; continue; } if( surprisingResults>0 ) { if( (sc/NoOfGooglers)+1 >= pi) { passPi++; surprisingResults--; continue; } } } else if( (sc+1) % NoOfGooglers == 0) { if( (sc+1)/NoOfGooglers >= pi) { passPi++; continue; } } else if( (sc-1) % NoOfGooglers == 0) { if( (((sc-1)/NoOfGooglers)+1) >= pi) { passPi++; continue; } } if(surprisingResults > 0) { if( (sc+2) % NoOfGooglers == 0) { if( (sc+2)/NoOfGooglers >= pi) { passPi++; surprisingResults--; continue; } } else if( (sc-2) % NoOfGooglers == 0) { if( (((sc-2)/NoOfGooglers)+2) >= pi) { passPi++; surprisingResults--; continue; } } } } return passPi; } }

A11759

A10651

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package dancingwiththegooglers; import java.io.BufferedReader; import java.io.DataInputStream; import java.io.FileInputStream; import java.io.InputStreamReader; /** * * @author Kholoud */ public class DancingWithTheGooglers { /** * @param args the command line arguments */ public static void main(String[] args) { try { FileInputStream ifstream = new FileInputStream("C:\\Users\\Kholoud\\Downloads\\B-small-attempt1.in"); DataInputStream in = new DataInputStream(ifstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); int n = Integer.parseInt( br.readLine()); String line; for(int i = 0;i<n;i++) { int count = 0; line = br.readLine(); String[] words = line.split(" "); int Googlers = Integer.parseInt(words[0]); int surCount = Integer.parseInt(words[1]); int p = Integer.parseInt(words[2]); for(int j = 0;j<Googlers;j++) { int Score = Integer.parseInt(words[j+3]); if(Score < p) { continue; } if(pass(Score,p)) { count++; } else { if(surCount>0 && surprisePass(Score, p)) { count++; surCount--; } } } System.out.println("Case #" + (i + 1) + ": " + count); } } catch (Exception e) { System.out.print(e.toString()); } } public static boolean pass(int num,int p) { if((num%3 == 0 && num/3 >= p) || ((num-1)%3 == 0 && ((num-1)/3)+1 >= p) || ((num-2)%3 == 0 && ((num-2)/3)+1 >= p)) { return true; } return false; } public static boolean surprisePass(int num,int p) { if(((num-2)%3 == 0 && ((num-2)/3)+2 >= p) || ((num-3)%3 == 0 && ((num-3)/3)+2 >= p) || ((num-4)%3 == 0 && ((num-4)/3)+2 >= p)) { return true; } return false; } }

A11759

A13054

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package _2011.qualification; import java.util.Scanner; public class DancingWithTheGooglers { public static void main(String[] args) { Scanner consola = new Scanner(System.in); int nGooglers, nSurprise, top, total, cont, times = consola.nextInt(); for(int t = 1; t <= times; t++){ nGooglers = consola.nextInt(); nSurprise = consola.nextInt(); top = consola.nextInt(); cont = 0; for(int i = 0; i < nGooglers; i++){ total = consola.nextInt(); if(total < top) continue; if(total >= (top * 3) - 2) cont++; else if(nSurprise > 0 && total >= (top * 3) - 4){ cont++; nSurprise--; } } System.out.println("Case #" + t + ": " + cont); } } }

A11759

A10151

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.Arrays; import java.util.HashSet; import java.util.StringTokenizer; /** * Created by IntelliJ IDEA. * User: 875k * Date: 4/14/12 * Time: 12:08 AM * To change this template use File | Settings | File Templates. */ public class prQB { public static boolean notSurprising(int a, int b, int c) { return Math.abs(a - b) <= 1 && Math.abs(a - c) <= 1 && Math.abs(b - c) <= 1; } public static boolean surprising(int a, int b, int c) { return !notSurprising(a, b, c) && Math.abs(a - b) <= 2 && Math.abs(a - c) <= 2 && Math.abs(b - c) <= 2; } public static int[] points; public static int[] surpriseMax; public static int[] normalMax; public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new FileReader("prQB.in")); PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("prQB.out"))); points = new int[101]; surpriseMax = new int[101]; normalMax = new int[101]; int T = Integer.parseInt(br.readLine()); for(int i = 0; i < T; i++) { Arrays.fill(points, -1); Arrays.fill(surpriseMax, -1); Arrays.fill(normalMax, -1); StringTokenizer st = new StringTokenizer(br.readLine()); int N = Integer.parseInt(st.nextToken()); int S = Integer.parseInt(st.nextToken()); int p = Integer.parseInt(st.nextToken()); for(int j = 0; j < N; j++) { points[j] = Integer.parseInt(st.nextToken()); boolean found = false, founds = false; for(int a = Math.min(10, points[j]); a >= 0 && !(found && founds); a--) { for(int b = Math.max(0, points[j] - a); b >= 0; b--) { int c = points[j] - a - b; if(notSurprising(a, b, c) && a >= normalMax[j]) { found = true; normalMax[j] = a; } if(surprising(a, b, c) && a >= surpriseMax[j]) { founds = true; surpriseMax[j] = a; } } } } //for(int j = 0; j < N; j++) { System.out.print(points[j] + "-" + normalMax[j] + "-" + surpriseMax[j] + ", "); } System.out.println(); HashSet<Integer> hs = new HashSet<Integer>(); for(int j = 0; j < N && S > 0; j++) { if(surpriseMax[j] >= p && normalMax[j] < p) { hs.add(j); S--; } } int c = hs.size(); for(int j = 0; j < N; j++) { if(normalMax[j] >= p && !hs.contains(j)) c++; } out.println("Case #" + (i + 1) + ": " + c); } out.close(); System.exit(0); } }

A11759

A11832

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package com.gdacarv.codejam; import java.io.BufferedReader; import java.io.DataInputStream; import java.io.FileInputStream; import java.io.InputStreamReader; public class ProblemB { public static void main(String [ ] args){ try{ FileInputStream fstream = new FileInputStream("input_problemB.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String input = new String(); String line; while ((line = br.readLine()) != null) input += line + '\n'; System.out.println(input); System.out.println(solveProblemB(input)); }catch (Exception e){//Catch exception if any System.err.println("Error: " + e.getMessage()); } } private static String solveProblemB(String input) { String result = new String(); String[] lines = input.split("\n"), numbers; int len = Integer.parseInt(lines[0]); int N, S, p, qt, num; for(int i = 1; i <= len; i++){ result += "Case #" + i + ": "; numbers = lines[i].split(" "); N = Integer.parseInt(numbers[0]); S = Integer.parseInt(numbers[1]); p = Integer.parseInt(numbers[2]); qt = 0; for(int j = 3; j < 3+N; j++){ num = Integer.parseInt(numbers[j]); if(p == 0){ qt++; }else if(p == 1){ if(num > 0) qt++; }else if(num / p >= 3 || (num-1) / (p-1) >= 3){ qt++; }else if(S > 0 && num - p - 2*(p-2) >= 0){ qt++; S--; } } result += qt + "\n"; } return result; } }

A11759

A10656

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; public class DancingWithTheGooglers { public static void main(String [] args) throws Exception { BufferedReader br = new BufferedReader(new FileReader("BI.txt")); String write = ""; int i = Integer.parseInt(br.readLine()); for(int j = 1; j <= i; j++) { String ra = br.readLine(); int c = 0; Integer [] ir = c(ra.split(" ")); int S = ir[1]; for(int k = 0; k < ir[0]; k++) { boolean flag = false; int score = ir[k + 3]; int [] triplet = new int[3]; for(int l = 0; l < 3; l++) if(score >= 0) { triplet [l] = score / (3 - l); score = score - triplet[l]; if(triplet[l] >= ir[2]) { c = c + 1; flag = true; break; } } if(S > 0) { for(int m = 1; m < 3; m++) { if(!flag && triplet[m-1] > 0) if(triplet[m] == triplet[m - 1]) { triplet[m] = triplet[m] + 1; triplet[m-1] = triplet[m-1] - 1; if(triplet[m] >= ir[2]) { c = c + 1; S = S - 1; } break; } } } } String newLine = "\n"; if(j == i) newLine = ""; write = write + "Case #" + j + ": " + c + newLine; //System.out.println("Case #" + j + ": " + c); } BufferedWriter bw = new BufferedWriter(new FileWriter("BO.txt")); bw.write(write); bw.flush(); bw.close(); System.out.println(write); } static Integer [] c(String [] args) { Integer [] array = new Integer[args.length]; for(int i = 0; i < args.length; i++) { array [i] = Integer.parseInt(args[i]); } return array; } }

A11759

A13110

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; public class better { public static void main(String[] args) throws Exception { int i=0; FileReader fin=new FileReader("B-small-attempt0.in"); BufferedReader br=new BufferedReader(fin); FileWriter fout=new FileWriter("Output12.in"); BufferedWriter bw=new BufferedWriter(fout); int test=Integer.parseInt(br.readLine()); while(i<test) { int count=trial(br.readLine()); bw.write("Case #"+(i+1)+": "+count); bw.newLine(); bw.flush(); i++; } } static int trial(String str) { int count=0; String s[]=str.split(" "); int N=Integer.parseInt(s[0]); int S=Integer.parseInt(s[1]); int P=Integer.parseInt(s[2]); int score[]=new int[N]; int i=0; while(i<N) { score[i]=Integer.parseInt(s[3+i]); i++; } i=0; while(i<N) { if(score[i]>=3*P-2) { count++; } else if(score[i]==(3*P-3)||score[i]==(3*P-4)) { if(S>0 && score[i]!=0) { count++; S--; } } i++; } return count; } }

A11759

A11084

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; public class Dancing { public static void main(String [] args) throws IOException { BufferedReader br = new BufferedReader(new FileReader("B-small-attempt0.in")); BufferedWriter brw = new BufferedWriter(new FileWriter("output")); int t = Integer.parseInt(br.readLine().trim()); int n = 1; while(t-- > 0) { Scanner sc = new Scanner(br.readLine()); int N = sc.nextInt(); int s = sc.nextInt(); int p = sc.nextInt(); int sum1 = p + p-2 + p-2; int sum2 = p + p - 1 + p -1; int ans = 0; while(sc.hasNext()) { int a = sc.nextInt(); if ( s>0 && (sum1>1) && (a ==sum1 || a ==sum1+1)) { s--; ans++; } else if ( a >= sum2) ans++; } brw.write("Case #"+n+": "+ans + "\n"); n++; } brw.close(); } }

A11759

A12510

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package main; import java.io.*; import java.util.Scanner; class Solver { public void createSolution(Scanner input, BufferedWriter outWriter) throws IOException { int numCases = input.nextInt(); for (int i = 0; i < numCases; i++) { int solution = 0; int possibilities = 0; int numDancers = input.nextInt(); int surprises = input.nextInt(); int p = input.nextInt(); for (int k = 0; k < numDancers; k++) { int score = input.nextInt(); if (p == 0 || score > Math.max(0, (3*p - 3))) { solution++; } else if (score > Math.max(0, (3*p - 5))) { possibilities++; } else { // ignore because score < 3*p - 4 } } if (surprises < possibilities) { solution = solution + surprises; } else { solution = solution + possibilities; } outWriter.write("Case #" + String.valueOf(i + 1) + ": " + solution + "\n"); } outWriter.close(); } }

A11759

A12807

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* ID: 14vikra1 LANG: JAVA TASK: dancescore */ import java.io.*; import java.util.*; class dancescore { public static void main (String [] args) throws IOException { BufferedReader br = new BufferedReader(new FileReader("dancescore.in")); PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("dancescore.out"))); int T = Integer.parseInt(br.readLine()); for (int i = 0; i < T; i++) { StringTokenizer st = new StringTokenizer(br.readLine()); int N = Integer.parseInt(st.nextToken()); int S = Integer.parseInt(st.nextToken()); int p = Integer.parseInt(st.nextToken()); int surprise = 0; int work = 0; for (int j = 0; j < N; j++) { int current = Integer.parseInt(st.nextToken()); if (current%3 != 0 && current >= 2) { if (Math.ceil(current/3) + 1 >= p) { work++; } else if (Math.ceil(current/3) + 2 >= p) { surprise++; } } else if (current >= 2) { if (Math.ceil(current/3) >= p) { work++; } else if (Math.ceil(current/3) + 1 >= p) { surprise++; } } else { if (current == 1 && p <= 1) { work++; } else if (current == 1 && p == 2) { surprise++; } else if (current == 0 && p == 0) { work++; } } } int answer = work + Math.min(S, surprise); out.println("Case #" + (i+1) + ": " + answer); } out.close(); System.exit(0); } }

A11759

A11245

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/** * Copyright 2012 Christopher Schmitz. All Rights Reserved. */ package com.isotopeent.codejam.lib.converters; import com.isotopeent.codejam.lib.InputConverter; public class IntLine implements InputConverter<Integer> { private int input; @Override public boolean readLine(String data) { input = Integer.parseInt(data); return false; } @Override public Integer generateObject() { return input; } }

A11759

A10453

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

public class DancingGooglers { private static int sc; private static int result = 0; private static int p; private static void check(int val) { int x = val % 3; int n = val / 3; if (x == 0) { if (n >= p) { result++; } else if (n > 0 && sc > 0 && n + 1 >= p) { result++; sc--; } } else { if (n + 1 >= p) { result++; } else if (x == 2 && n + 2 >= p && sc > 0) { result++; sc--; } } } public static void main(String[] args) throws Exception { String[] in = ProblemUtils.readInput("/home/laf/Downloads/B-small-attempt0.in"); String[] out = new String[in.length]; for (int i = 0; i < in.length; i++) { String[] vals = in[i].split(" "); int n = Integer.parseInt(vals[0]); sc = Integer.parseInt(vals[1]); p = Integer.parseInt(vals[2]); result = 0; for (int j = 3; j < 3 + n; j++) { check(Integer.parseInt(vals[j])); out[i] = "" + result; } } ProblemUtils.writeOutput("/home/laf/Desktop/out.txt", out); } }

A11759

A10264

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package code_jam; import java.io.*; import java.util.Arrays; import java.util.StringTokenizer; public class Code_Jam { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new FileReader("B-small-attempt4.in")); FileWriter out= new FileWriter("B-small-attempt4.out"); //BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); int T,S,P,N,C; T=Integer.parseInt(in.readLine()); StringTokenizer x; for (int i = 1; i <= T; i++) { C=0; x=new StringTokenizer(in.readLine()); N=Integer.parseInt(x.nextToken()); S=Integer.parseInt(x.nextToken()); P=Integer.parseInt(x.nextToken()); int G[]=new int[N]; for (int j = 0; j < N; j++) { G[j]=Integer.parseInt(x.nextToken()); } Arrays.sort(G); for (int j = 0; j < N; j++) { if(G[j]<P)// may be <p only continue; int A,B,D; A=P;G[j]-=P; B=G[j]/2; D=G[j]-B; if(D>=10){ C++; continue; } if(P-B>2) continue; else if(P-B==2&&S>0){ C++; S--; } else if(P-B<=1){ C++; } } //System.out.println(C); out.write("Case #"+i+": "+C+"\n"); } out.close(); } }

A11759

A12257

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedWriter; import java.util.ArrayList; public class Helper { public Helper() { super(); } public String operate(String op) { System.out.println(op); String result =""; int total = 0; String[] split = op.split(" "); int inter = Integer.valueOf(split[1]); int goal = Integer.valueOf(split[2]); System.out.println("Interesting:" + inter + " Goal:" + goal); goal = goal -1; for (int i = 3; i < split.length; i++){ int score = Integer.valueOf(split[i]); int base = score / 3; int next = (score - base) / 2; int third = score - base - next; System.out.println(base + " " + next + " " + third); if (third - base < 2 && third > goal) { total += 1; //Interesting } else if (third - base == 2) { if (inter > 0 && third > goal) { inter -= 1; total += 1; } } else { if (third + 1 > goal && next > 0 && inter > 0) { if (third - base == 1 && next == base){ ; } else { inter -= 1; total += 1; } } } } System.out.println("Result: " + result + total); return result + total; } public void inputStrings(ArrayList<String> anInput) { } public void printResult(BufferedWriter out, String input, int n) { String result = "Case #"+ n +": " + operate(input) + "\n"; //System.out.print(result); try { out.write(result); }catch (Exception e){//Catch exception if any System.err.println("here Error: " + e.getMessage()); } } }

A11759

A10999

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

public class Code2DataStructure { private int noOfGooglers; private int surprisingTrplets; private int p; private int[] marks; private int result; public int getNoOfGooglers() { return noOfGooglers; } public void setNoOfGooglers(int noOfGooglers) { this.noOfGooglers = noOfGooglers; } public int getSurprisingTrplets() { return surprisingTrplets; } public void setSurprisingTrplets(int surprisingTrplets) { this.surprisingTrplets = surprisingTrplets; } public int getP() { return p; } public void setP(int p) { this.p = p; } public int[] getMarks() { return marks; } public void setMarks(int[] marks) { this.marks = marks; } public int getResult() { return result; } public void setResult(int result) { this.result = result; } }

A11759

A10285

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package Problem2; import java.util.ArrayList; public class DancingGooglers { //3 1 5 15 13 11 // tab[0] = numbe of dancers // tab[1] = number of * // tab[2] = threshold p public static int[] Assign_Stars(int allowed_stars, int[] sumratingtab, int threshold){ int a= allowed_stars; int n=sumratingtab.length; int[] maxrates= new int[n]; int i; if (a>0){ for (i=0;i<n;i++){ if ((sumratingtab[i]>0) && (sumratingtab[i] % 3 == 2) && ( ((sumratingtab[i]-2)/3 + 2)<threshold) && ( ((sumratingtab[i]-2)/3 +2) >= threshold)){ // if ((sumratingtab[i]>=0) && (sumratingtab[i] % 3 == 2)){ if (a>0){ maxrates[i]= (sumratingtab[i]-2)/3 + 2; System.out.println("etoile gaspillee pour :" + maxrates[i] + " reste :" +(a-1) ); sumratingtab[i]=-1; a--; } } } } if (a>0){ for (i=0;i<n;i++){ if ((sumratingtab[i]>0) && (sumratingtab[i] % 3 == 0) && (((sumratingtab[i])/3 ) <threshold) && (((sumratingtab[i])/3+1 ) >= threshold) ){ // if ((sumratingtab[i]>=0) && (sumratingtab[i] % 3 == 0) ){ if (a>0){ maxrates[i]= sumratingtab[i]/3 + 1 ; System.out.println("etoile gaspillee pour :" + maxrates[i] + " reste :" +a); sumratingtab[i]=-1; a--; } } } } if (a>0){ for (i=0;i<n;i++){ if ( (sumratingtab[i]>0) && (sumratingtab[i] % 3 == 0) ){ if (a>0){ maxrates[i]= ((sumratingtab[i]/3)) + 1 ; sumratingtab[i]=-1; a--; } } if ( (sumratingtab[i]>0) && (sumratingtab[i] % 3 == 1) ){ if (a>0){ maxrates[i]= (((sumratingtab[i]-1)/3)) + 1 ; sumratingtab[i]=-1; a--; } } if ( (sumratingtab[i]>0) && (sumratingtab[i] % 3 == 2) ){ if (a>0){ maxrates[i]= (((sumratingtab[i]-2)/3)) + 2 ; sumratingtab[i]=-1; a--; } } } } for (i=0;i<n;i++){ if ( (sumratingtab[i]>0) && (sumratingtab[i] % 3 == 0) ){ maxrates[i]= ((sumratingtab[i]/3)) ; sumratingtab[i]=-1; } if ( (sumratingtab[i]>0) && (sumratingtab[i] % 3 == 1) ){ maxrates[i]= (((sumratingtab[i]-1)/3)) + 1 ; sumratingtab[i]=-1; } if ( (sumratingtab[i]>0) && (sumratingtab[i] % 3 == 2) ){ maxrates[i]= (((sumratingtab[i]-2)/3)) + 2 ; sumratingtab[i]=-1; } } return maxrates; } public static int countmorethanp(int[] maxrates ,int p){ int n=maxrates.length; int i; int count=0; for (i=0;i<n;i++){ if (maxrates[i]>=p){ count++; } } return count; } // public static void main(String[] args){ // // int[] tab = {8,0}; // // 2 1 1 8 0 // // 6 8 // int[] tab2 = Assign_Stars(1, tab, 1); // int i=0; // for (i=0;i<tab2.length;i++){ // System.out.println("tab2 : "+tab2[i]); // } // System.out.println(countmorethanp(tab2, 1)); // } public static int result(int allowedstars , int[] tabsum,int threshold ){ int[] tab2 = Assign_Stars(allowedstars, tabsum, threshold); return countmorethanp(tab2, threshold); } public static int StringtoResults(String s1){ String[] arrs = s1.split(" "); int i=1,n=arrs.length; int allowedstars = Integer.parseInt(arrs[1]); int threshold = Integer.parseInt(arrs[2]); int[] arr = new int[n-3]; for (i=3;i<n;i++){ arr[i-3]= Integer.parseInt(arrs[i]); } return result(allowedstars,arr,threshold); } public static int[] Count_List(ArrayList<String> ArS){ int[] Ars_res = new int[ArS.size()]; int i=0; int n =ArS.size(); for(i=0;i<n;i++){ Ars_res[i]=StringtoResults(ArS.get(i)); } return Ars_res; } }

A11759

A10612

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; import java.math.BigInteger; public class B{ public static void main(String []args) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int t, x = 0, n, s, p, ans; t = Integer.parseInt(br.readLine()); while(t>0) {t--; x++; ans = 0; String w = br.readLine(); String arr1[] = w.split("[ ]+"); n = Integer.parseInt(arr1[0]); s = Integer.parseInt(arr1[1]); p = Integer.parseInt(arr1[2]); int a = 0, a1 = 1, r = 2; for(int i = 0; i < n; i++) {r++; a = Integer.parseInt(arr1[r]); int b = (a/3); int c = b*3; int d = (b+1)*3; int e = 0; if(b >= p) { ans++; e = 1;} if(e == 0) { if((c+1) == a && (b+1) >= p) { ans++; e = 1;} else if((c+2) == a && (b+1) >= p){ans++; e = 1;} } if(e == 0 && a1 <= s) { if(c > 0 && (c) == a && (b+1) >= p) { ans++; a1++;} else if((c+1) == a && (b+1) >= p) { ans++; a1++;} else if((c+2) == a && (b+2) >= p) { ans++; a1++;} } } System.out.println("Case #"+x+": "+ans); } } }

A11759

A12233

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package codejam.round1; import java.io.BufferedReader; import java.io.FileReader; import java.io.PrintStream; import java.util.ArrayList; import java.util.List; import java.util.StringTokenizer; public class ProblemB { public static void main(String[] args) throws Exception { BufferedReader reader = new BufferedReader(new FileReader(args[0])); PrintStream out = new PrintStream(args[1]); int testsCount = Integer.parseInt(reader.readLine()); for (int test = 1; test <= testsCount; test++) { String input = reader.readLine(); StringTokenizer tokenizer = new StringTokenizer(input); int N = Integer.parseInt(tokenizer.nextToken()); int S = Integer.parseInt(tokenizer.nextToken()); int p = Integer.parseInt(tokenizer.nextToken()); List<Integer> nonSurprisingExceedingP = new ArrayList<Integer>(); List<Integer> suprisingExceedingP = new ArrayList<Integer>(); for (int i = 0; i < N; i++) { int ti = Integer.parseInt(tokenizer.nextToken()); if (bestNonSuprisingSolution(ti) >= p) { nonSurprisingExceedingP.add(i); }else if(hasSuprisingSolution(ti) && bestSuprisingSolution(ti) >=p) { suprisingExceedingP.add(i); } } int googlersCount = nonSurprisingExceedingP.size() + Math.min(S, suprisingExceedingP.size()); out.println(String.format("Case #%s: %s", test, googlersCount)); } out.close(); reader.close(); } private static int nearestUpperMultipleOfThree(int a) { if (a == 0 || a % 3 == 0) { return a; } return a + (3 - (a % 3)); } private static int nearestMultipleOfThree(int a) { if (a == 0 || a % 3 == 0) { return a; } if (a % 3 == 1) { return a - 1; } return a + 1; } private static int bestNonSuprisingSolution(int total) { return nearestUpperMultipleOfThree(total) / 3; } private static boolean hasSuprisingSolution(int total) { return total > 1; } private static int bestSuprisingSolution(int total) { return (nearestMultipleOfThree(total) / 3) + 1; } }

A11759

A10156

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.util.ArrayList; import java.util.Collection; public class Main { public static void main( String[] args ) { try { BufferedReader reader = new BufferedReader( new FileReader( "C:\\file.in") ); ArrayList<Integer> results = new ArrayList<Integer>(); reader.readLine(); String line = reader.readLine(); int j = 0; while( line != null ) { j++; ArrayList<Collection<Triplet>> tripletCollections = new ArrayList<Collection<Triplet>>(); String[] parameters = line.split( " " ); int nrOfPlayers = Integer.valueOf( parameters[0] ); int nrOfSurprises = Integer.valueOf( parameters[1] ); int treshold = Integer.valueOf( parameters[2] ); System.out.println("Iteration nr." + String.valueOf( j )); System.out.println("Generating triplets for " + String.valueOf( nrOfPlayers )); for( int i = 3; i < parameters.length; i++ ) { tripletCollections.add( generateTriplets( Integer.valueOf( parameters[i]) ) ); } System.out.println("Selecting triplets"); Triplet[] selectedTriplet = new Triplet[nrOfPlayers]; int surprising = 0; for( int i = 0; i < tripletCollections.size(); i++ ) { Collection<Triplet> triplets = tripletCollections.get( i ); if( getAboveNotSurprising( triplets, treshold ) != null ) { selectedTriplet[i] = getAboveNotSurprising( triplets, treshold ); } else if( getAboveAndSurprising( triplets, treshold ) != null ) { selectedTriplet[i] = getAboveAndSurprising( triplets, treshold ); surprising++; } else if( getBelowNotSurprising( triplets, treshold ) != null ) { selectedTriplet[i] = getBelowNotSurprising( triplets, treshold ); } else { selectedTriplet[i] = getBelowAndSurprising( triplets, treshold ); surprising++; } } System.out.println("Improving triplets"); if( nrOfPlayers == 1 ) { System.out.println( "only one player"); } if( surprising != nrOfSurprises ) { if( surprising < nrOfSurprises ) { System.out.println("More surprises than expected"); int i = 0; while( ( i < nrOfPlayers ) && ( surprising != nrOfSurprises ) ) { Collection<Triplet> triplets = tripletCollections.get( i ); if( !selectedTriplet[i].isSurprising() ) { if( getAboveAndSurprising( triplets, treshold ) != null ) { selectedTriplet[i] = getAboveAndSurprising( triplets, treshold ); surprising++; } } i++; } i=0; while( ( i < nrOfPlayers ) && ( surprising != nrOfSurprises ) ) { Collection<Triplet> triplets = tripletCollections.get( i ); if( !selectedTriplet[i].isSurprising() ) { if( getBelowAndSurprising( triplets, treshold ) != null ) { selectedTriplet[i] = getBelowAndSurprising( triplets, treshold ); surprising++; } } i++; } } else { int i=0; while( ( i < nrOfPlayers ) && ( surprising != nrOfSurprises ) ) { Collection<Triplet> triplets = tripletCollections.get( i ); if( selectedTriplet[i].isSurprising() ) { if( getBelowNotSurprising( triplets, treshold ) != null ) { selectedTriplet[i] = getBelowNotSurprising( triplets, treshold ); surprising--; } } i++; } } } int result = 0; for( Triplet triplet : selectedTriplet ) { if( triplet.getBestResult() >= treshold ) { result++; } } results.add(result); line = reader.readLine(); } System.out.println("Writing output"); BufferedWriter writer = new BufferedWriter( new FileWriter( "C:\\output.txt") ); for( int i = 0; i < results.size(); i++ ) { writer.write( "Case #" + String.valueOf( i+1 ) + ": " + String.valueOf( results.get( i ) ) ); writer.newLine(); } writer.close(); } catch( Exception e ) { } } private static Collection<Triplet> generateTriplets( int aSum ) { ArrayList<Triplet> result = new ArrayList<Triplet>(); int temp; if( aSum % 3 == 0 ) { result.add( new Triplet( aSum/3, aSum/3, aSum/3 ) ); } if( (aSum - 1) % 3 == 0 && (aSum - 1) >= 0 ) { temp = ( aSum - 1 ) / 3; if( temp + 1 <= 10 ) { result.add( new Triplet( temp, temp, temp + 1 ) ); } } if( (aSum - 2) % 3 == 0 && (aSum - 2) >= 0) { temp = ( aSum - 2 ) / 3; if( temp + 2 <= 10 ) { result.add( new Triplet( temp, temp, temp + 2 ) ); } if( temp + 1 <= 10 ) { result.add( new Triplet( temp, temp + 1, temp + 1 ) ); } } if( (aSum - 3) % 3 == 0 && (aSum - 3) >= 0) { temp = ( aSum - 3 ) / 3; if( temp + 2 <= 10 ) { result.add( new Triplet( temp, temp + 1, temp + 2 ) ); } } if( (aSum - 4) % 3 == 0 && (aSum - 4) >= 0) { temp = ( aSum - 4 ) / 3; if( temp + 2 <= 10 ) { result.add( new Triplet( temp, temp + 2, temp + 2 ) ); } } return result; } private static Triplet getAboveNotSurprising( Collection<Triplet> aCollection, int aTreshold ) { for (Triplet triplet : aCollection ) { if( ( triplet.getBestResult() >= aTreshold ) && !triplet.isSurprising() ) { return triplet; } } return null; } private static Triplet getBelowNotSurprising( Collection<Triplet> aCollection, int aTreshold ) { for (Triplet triplet : aCollection ) { if( ( triplet.getBestResult() < aTreshold ) && !triplet.isSurprising() ) { return triplet; } } return null; } private static Triplet getAboveAndSurprising( Collection<Triplet> aCollection, int aTreshold ) { for( Triplet triplet : aCollection ) { if( ( triplet.getBestResult() >= aTreshold ) && triplet.isSurprising() ) { return triplet; } } return null; } private static Triplet getBelowAndSurprising( Collection<Triplet> aCollection, int aTreshold ) { for( Triplet triplet : aCollection ) { if( ( triplet.getBestResult() < aTreshold ) && triplet.isSurprising() ) { return triplet; } } return null; } }

A11759

A11433

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.*; import java.io.*; public class Dance { public static void main(String zaga[]) throws FileNotFoundException { Scanner input = new Scanner(System.in); File file = new File("out.txt"); PrintStream writer = new PrintStream(file); int T = input.nextInt(); ArrayList<Integer> ans = new ArrayList<Integer>(); for(int t = 0; t < T; t++) { int N = input.nextInt(); int S = input.nextInt(); int P = input.nextInt(); ArrayList<Integer> scores = new ArrayList<Integer>(); for(int i = 0; i < N; i++) { scores.add(input.nextInt()); } int s = 1; for(int i = 0; i < scores.size(); i++) { int num = scores.get(i); int first = P; if((scores.get(i) - P) >= P * 2 ) { continue; } if(scores.get(i) - P < 0) { scores.remove(i); --i; continue; } if(((scores.get(i) - P) / 2) + 1 == P) { continue; } if(num - P >= 0) { int second = (num - P) / 2; int third = second; if((num - P) % 2 == 1) { ++third; } if(second + 2 >= P && third + 2 >= P) { if(s <= S) { ++s; continue; } else { scores.remove(i); --i; continue; } } else { scores.remove(i); --i; continue; } } else { scores.remove(i); --i; continue; } } ans.add(scores.size()); } for(int i = 0; i < ans.size(); i++) { writer.print("Case #"+(i+1)+": "+ans.get(i)); if(!(i + 1 == ans.size())) { writer.print("\n"); } } } }

A11759

A11547

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.File; import java.io.FileNotFoundException; import java.io.PrintWriter; import java.util.Scanner; public class dancers { public static void main(String[] args) throws FileNotFoundException { File myFile = new File ("E:/GoogleIn.txt"); Scanner inFile = new Scanner (myFile); PrintWriter outputStream = null; outputStream = new PrintWriter("E:/GoogleOut.txt"); String line = inFile.nextLine(); System.out.println("line "+line); int cases = Integer.parseInt(line); System.out.println("cases "+cases); for (int t=0; t < cases; t++){ int numdancing = inFile.nextInt(); System.out.println("numdancing "+numdancing); int outlier = inFile.nextInt(); System.out.println("outlier "+outlier); int p = inFile.nextInt(); System.out.println("p "+p); int p3 = p*3; int cnt =0; int totalScores[] = new int[numdancing]; for (int index = 0; index < numdancing; index++){ totalScores[index] = inFile.nextInt(); } for ( int i = 0; i < numdancing; i++){ if(p ==0){ cnt++; continue; }else if(p ==1){ if (totalScores[i]>0) cnt++; continue; } if (totalScores[i]>= p3-2){ cnt++; } else if(totalScores[i]>= p3-4){ if (outlier>0){ outlier--; cnt++; } } } outputStream.println("Case #"+(t+1)+": "+cnt); } outputStream.flush(); } }

A11759

A10577

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package codejam2012.qualification.b; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter; import java.util.ArrayList; import java.util.List; import java.util.Scanner; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public final class Main { Logger log = LoggerFactory.getLogger(Main.class); private Scanner in; private PrintWriter out; private Memory memory = new Memory(); public Main(InputStream in, OutputStream out) { this.in = new Scanner(in); this.out = new PrintWriter(out); } public void run() throws Exception { memory.init(); int T = in.nextInt(); log.debug("T: " + T); for (int t = 1; t <= T; ++t) { int N = in.nextInt(); int S = in.nextInt(); int P = in.nextInt(); List<Integer> totals = new ArrayList<Integer>(); for (int n = 1; n <= N; ++n) { totals.add(in.nextInt()); } log.debug("N: " + N + " S: " + S + " P: " + P + " totals: " + totals); Round round = new Round(totals, memory); int result = round.run(S, P); log.debug("result: " + result); out.println(String.format("Case #%d: %d", t, result)); } out.flush(); } public static void main(String[] args) throws Exception { String path = "src/main/resources/" + args[0]; try (FileInputStream in = new FileInputStream(path + ".in"); FileOutputStream out = new FileOutputStream(path + ".out")) { Main main = new Main(in, out); main.run(); } } }

A11759

A10442

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.PrintWriter; import java.util.Scanner; public class DWTG { static void log(String fs, Object... args) { System.err.println(String.format(fs, args)); } public static void main(String[] args) throws FileNotFoundException { String filename = "src/data/B-small-attempt0.in"; Scanner sc = new Scanner( new FileInputStream( new File(filename))); PrintWriter pw = new PrintWriter( new FileOutputStream( new File(filename + ".result"))); int[] usually = new int[31]; int[] surprise = new int[31]; for (int a = 0; a <= 10; a++) { for (int b = 0; b <= 10; b++) { for (int c = 0; c <= 10; c++) { int sum = a+b+c; int m = Math.max(c, Math.max(a, b)); if (Math.abs(a-b) <= 1 && Math.abs(b-c) <= 1 && Math.abs(a-c) <= 1) { usually[sum] = Math.max(usually[sum], m); } else if (Math.abs(a-b) <= 2 && Math.abs(b-c) <= 2 && Math.abs(a-c) <= 2) { surprise[sum] = Math.max(surprise[sum], m); } } } } int T = sc.nextInt(); sc.nextLine(); for (int task = 1; task <= T; task++) { int N = sc.nextInt(); int S = sc.nextInt(); int p = sc.nextInt(); int count_usually = 0; int count_surprise = 0; for (int i=0; i<N; i++) { int d = sc.nextInt(); if (usually[d] >= p) count_usually++; else if (surprise[d] >= p) count_surprise++; } int result = count_usually + Math.min(S, count_surprise); pw.println(String.format("Case #%d: %d", task, result)); log("Case #%d: %d", task, result); } pw.close(); } }

A11759

A12562

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; public class B extends CodeJammer { public void process() throws IOException { int[] input = reader.readArray(); int n = input[0]; int s = input[1]; int p = input[2]; int auto =0; //scores that reach p automatically int poss = 0; //scores that can reach p with surprise for (int i=3; i<n+3; i++) { int score = input[i]; int def = (score/3); int mod = (score%3); if (mod != 0) def++;//ceiling, not floor if (def >= p) auto++; else if (def == p-1 && def > 0 && mod != 1) poss++; } if (poss > s) poss = s; //cap number of surprising scores that reach p output(auto+poss); } public static void main(String[] args) { B b = new B(); b.run(args); } }

A11759

A10924

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.PrintStream; import java.util.Arrays; import java.util.Scanner; public class ProblemB { public static void main(String[] args) throws Exception { Scanner in = new Scanner( // System.in new FileInputStream("b-small.in") // new FileInputStream("b-large.in") ); PrintStream out = new PrintStream( // System.out new FileOutputStream("b-small.out") // new FileOutputStream("b-large.out") ); int T = in.nextInt(); in.nextLine(); for (int i = 1; i <= T; i++) { int res = 0; int N = in.nextInt(); int S = in.nextInt(); int p = in.nextInt(); int[] ts = new int[N]; for (int j = 0; j < N; j++) ts[j] = in.nextInt(); in.nextLine(); Arrays.sort(ts); int nscore = Math.max(p * 3 - 2, p); int sscore = Math.max(p * 3 - 4, p); for (int j = N; --j >= 0;) { if (ts[j] >= nscore) res++; else if (ts[j] >= sscore && S-- > 0) res++; else break; } out.println("Case #" + i + ": " + res); } } }

A11759

A11163

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; public class ProblemB { private static final int[] bestSurprise = new int[31]; private static final int[] bestBoring = new int[31]; private static void seed() { Arrays.fill(bestSurprise, -1); Arrays.fill(bestBoring, -1); for (int i = 0; i <= 10; i++) { for (int j = Math.max(0, i - 2); (j <= i + 2) && (j <= 10); j++) { for (int k = Math.max(0, i - 2); (k <= i + 2) && (k <= 10); k++) { if (Math.abs(k - i) > 2 || Math.abs(k - j) > 2 || Math.abs(i - j) > 2) { continue; } int total = i + j + k; int max = Math.max(i, Math.max(j, k)); if (Math.abs(k - i) == 2 || Math.abs(k - j) == 2 || Math.abs(i - j) == 2) { bestSurprise[total] = Math.max(bestSurprise[total], max); } else { bestBoring[total] = Math.max(bestBoring[total], max); } } } } } public static int solve(int[] scores, int S, int P) { int[][] history = new int[scores.length + 1][S + 1]; for (int[] cases : history) { Arrays.fill(cases, -1); } return solve(scores, 0, S, P, history); } private static int solve(int[] scores, int index, int S, int P, int[][] history) { if (index >= scores.length) { if (S > 0) { return -1; } else { return 0; } } else if (S < 0) { return -1; } else if (history[index][S] != -1) { return history[index][S]; } int best = -1; if (S > 0 && bestSurprise[scores[index]] != -1) { int surpriseAttempt = solve(scores, index + 1, S - 1, P, history); if (surpriseAttempt != -1) { best = Math.max(best, surpriseAttempt + (bestSurprise[scores[index]] >= P ? 1 : 0)); } } if (bestBoring[scores[index]] != -1) { int boringAttempt = solve(scores, index + 1, S, P, history); if (boringAttempt != -1) { best = Math.max(best, boringAttempt + (bestBoring[scores[index]] >= P ? 1 : 0)); } } history[index][S] = best; return best; } public static void main(String[] args) throws Exception { seed(); Scanner input = new Scanner(System.in); int T = Integer.parseInt(input.nextLine().trim()); for (int i = 0; i < T; i++) { String[] tokens = input.nextLine().split(" "); int N = Integer.parseInt(tokens[0].trim()); int S = Integer.parseInt(tokens[1].trim()); int P = Integer.parseInt(tokens[2].trim()); int[] scores = new int[N]; for (int j = 0; j < N; j++) { scores[j] = Integer.parseInt(tokens[3 + j].trim()); } System.out.println("Case #" + (i+1) + ": " + solve(scores, S, P)); } } }

A11759

A11418

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.Scanner; public class ProbB1 { public static void main(String arg[]){ Scanner in = new Scanner (System.in); int T= in.nextInt(); for(int i=1;i<=T;i++){ int N = in.nextInt(); int S=in.nextInt(); int p=in.nextInt(); int count = 0; int minN = p*3-4; for(int j=0;j<N;j++){ int n = in.nextInt(); if(minN>=0){ if(n>=minN+2) count++; else if((n>=minN)&&(S>0)){ S--; count++; } } else{ if((n>0)||((n==0)&&(p==0))) count ++ ; } } System.out.println("Case #"+i+": "+count); } } }

A11759

A10471

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.*; import java.io.*; public class Main { public static void main(String[] args) { Scanner scan = new Scanner(System.in); scan.nextLine(); int c = 1; while(scan.hasNextLine()) { Scanner ls = new Scanner(scan.nextLine()); ls.nextInt(); int s = ls.nextInt(); int p = ls.nextInt(); ArrayList<Integer> sc = new ArrayList<Integer>(); while(ls.hasNextInt()) { sc.add(ls.nextInt()); } System.out.println("Case #" + c++ + ": " + process(s, p, sc)); } } public static int process(int surprises, int scoreToBeat, ArrayList<Integer> scores) { int ok = 0; int s = 0; for (int i = 0; i < scores.size(); i++) { int score = scores.get(i); int third = score / 3; int rem = score % 3; if(third >= scoreToBeat || (rem > 0 && (third + 1) >= scoreToBeat)) { ok++; } else { if(s < surprises && rem != 1) { if((rem == 2 && (third + 2) >= scoreToBeat) || (rem == 0 && (third > 0) && (third + 1) >= scoreToBeat)) { s++; ok++; } } } } return ok; } }

A11759

A12196

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package codejam; import java.util.Scanner; public class Qual2012B { private final int[] score; private int[] countWithSurprise; private int[] countWithoutSurprise; public Qual2012B(int[] score, int resultAsked) { this.score = score; this.countWithoutSurprise = new int[31]; this.countWithSurprise = new int[31]; initCountArrays(resultAsked); } protected void initCountArrays(int resultAsked) { for (int a = 0; a <= 10; a++) for (int b = Math.max(0, a - 2); b <= Math.min(10, a + 2); b++) for (int c = Math.max(0, a - 2); c <= Math.min(10, a + 2); c++) { int diff = Math .max(Math.abs(b - c), Math.max(Math.abs(a - c), Math.abs(a - b))); if (diff >= 3) continue; int count = 0; if (a >= resultAsked) count++; if (b >= resultAsked) count++; if (c >= resultAsked) count++; int total = a + b + c; if (diff == 2) { if (count > countWithSurprise[total]) countWithSurprise[total] = 1; } else { if (count > countWithoutSurprise[total]) countWithoutSurprise[total] = 1; } } } public static void main(String[] args) { Scanner scanner = new Scanner( System.in); int nrOfTestCases = scanner.nextInt(); for (int caseNr = 1; caseNr <= nrOfTestCases; caseNr++) { int googCount = scanner.nextInt(); int surprises = scanner.nextInt(); int resultAsked = scanner.nextInt(); int[] score = new int[googCount]; for (int i = 0; i < googCount; i++) score[i] = scanner.nextInt(); Qual2012B solver = new Qual2012B(score, resultAsked); System.out.println("Case #" + caseNr + ": " + solver.solve(0, surprises)); } } private int solve(int index, int surprisesLeft) { if (index >= score.length) return surprisesLeft == 0 ? 0 : Integer.MIN_VALUE; int thisScore = score[index]; int bestWithoutSurprise = countWithoutSurprise[thisScore] + solve(index + 1, surprisesLeft); if (surprisesLeft > 0) { int bestWithSurprise = countWithSurprise[thisScore] + solve(index + 1, surprisesLeft - 1); return Math.max(bestWithSurprise, bestWithoutSurprise); } return bestWithoutSurprise; } }

A11759

A12507

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Round { private int num; private int strange; private int max; private List<Integer> dancers; private int best; public Round(Scanner data){ best = 0; dancers = new ArrayList<Integer>(); num = data.nextInt(); strange = data.nextInt(); max = data.nextInt(); for(int i = 0; i < num; i++){ dancers.add(data.nextInt()); } } public int calculate(){ for(int dancer: dancers){ if(max * 3 <= dancer){ best++; }else if(dancer >= max){ int score1 = max; int temp = dancer - max; int score2 = temp / 2; if(score1 - score2 == 1){ best++; }else if(score1 - score2 == 2 && strange > 0){ best++; strange--; } } } return best; } }

A11759

A11440

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.security.AlgorithmConstraints; import java.util.Scanner; import java.util.StringTokenizer; public class Numbers { static int count =0; static int max; static int surprise; public static void main(String[] args) { // TODO Auto-generated method stub Scanner sc = new Scanner(System.in); int testCases = Integer.parseInt(sc.nextLine().trim()); for(int i=1;i<=testCases;i++){ String line = sc.nextLine(); StringTokenizer st = new StringTokenizer(line); int persons = Integer.parseInt(st.nextToken()); surprise = Integer.parseInt(st.nextToken()); max = Integer.parseInt(st.nextToken()); count =0; if(max == 0){ System.out.println("Case #"+i+": "+persons); }else{ for(int j=0;j<persons;j++){ algorithm(Integer.parseInt(st.nextToken())); } System.out.println("Case #"+i+": "+count); } } } public static void algorithm(int current){ if(current ==0){ return; } int div = current/3; if(current%3==0){ if(div >=max){ count++; }else if(surprise>0 && (div+1) >=max){ count++; surprise--; } }else if(current%3==1){ if((div+1) >=max){ count++; } }else if(current%3==2){ if((div+1) >=max) count++; else if(surprise>0 && (div+2)>=max){ count++; surprise--; } } } }

A11759

A10867

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; public class DanceScore { int score; boolean surprise = false; boolean madeIt = false; public DanceScore(int score) { this.score = score; } private void p(String p) { //System.out.println(p); } public void process(int bestResult) { int goal = bestResult-2; int lastNumber = score-bestResult-bestResult; p("score " + score); p("goal " + bestResult); p("lastNumber " + lastNumber); if (lastNumber <0) { madeIt= false; surprise = false; return; } if (lastNumber >= goal) madeIt = true; int surpriseNumber = bestResult-4; if (lastNumber >= surpriseNumber) surprise = true; p("madeIt " + madeIt); p("surprise " + surprise); } public boolean surprise() { return surprise; } public boolean madeIt() { return madeIt; } public static int maxNumber(int[] scores, int numSurprises, int goal) { int madeItCount = 0; int surpriseCount = 0; for (int score : scores) { DanceScore danceScore = new DanceScore(score); danceScore.process(goal); if (danceScore.madeIt()) madeItCount++; else if (danceScore.surprise()) surpriseCount++; } if (surpriseCount > numSurprises) madeItCount += numSurprises; else madeItCount += surpriseCount; return madeItCount; } public static void main (String [] args) { try { InputStreamReader converter = new InputStreamReader(System.in); BufferedReader in = new BufferedReader(converter); Integer numCases = Integer.valueOf(in.readLine()); for (int i = 0; i < numCases; i ++) { String input = in.readLine(); String[] values = input.split(" "); int numPeople = Integer.valueOf(values[0]); int numSurprises = Integer.valueOf(values[1]); int goal = Integer.valueOf(values[2]); int[] scores = new int[numPeople]; for (int j = 0; j < numPeople ; j++) { scores[j] = Integer.valueOf(values[3+j]); } int maxNumber = maxNumber(scores, numSurprises, goal); System.out.println("Case #" + (i+1) + ": " + maxNumber); } } catch (Exception e) { throw new RuntimeException (e); } } }

A11759

A10368

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package jam2012; import java.io.*; import java.util.*; // Marian G Olteanu public class QB { public static void main(String[] args) throws Exception { BufferedReader inputFile = new BufferedReader(new InputStreamReader(new FileInputStream(args[0]))); int cases = Integer.parseInt(inputFile.readLine()); PrintStream outFile = new PrintStream(new FileOutputStream(args[1])); for (int i = 1; i <= cases; i++) { String lineT[] = tokenize(inputFile.readLine()); int N = Integer.parseInt(lineT[0]); int S = Integer.parseInt(lineT[1]); int p = Integer.parseInt(lineT[2]); int thresholdAlways = 3 * p - 2; int thresholdSurprise = Math.max(1, 3 * p - 4);// if p = 1, score of 0 is not good for surprise int cntAlways = 0; int cntNeedSurprise = 0; for (int j = 3; j < lineT.length; j++) { int value = Integer.parseInt(lineT[j]); if (value >= thresholdAlways) cntAlways++; else if (value >= thresholdSurprise) cntNeedSurprise++; } int out = cntAlways + Math.min(S, cntNeedSurprise); outFile.println("Case #" + i + ": " + out); } outFile.close(); inputFile.close(); } public static String[] tokenize(String input) { StringTokenizer st = new StringTokenizer(input); String[] k = new String[st.countTokens()]; for (int i = 0; i < k.length; i++) k[i] = st.nextToken(); return k; } public static String[] tokenize(String input, String sep) { StringTokenizer st = new StringTokenizer(input , sep); String[] k = new String[st.countTokens()]; for (int i = 0; i < k.length; i++) k[i] = st.nextToken(); return k; } }

A11759

A10171

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; public class DancingWithTheGooglers { public static void main(String[] args) { Scanner sc = null; PrintWriter fout = null; int t = 0; try { sc = new Scanner(new File(args[0])); fout = new PrintWriter(new BufferedWriter(new FileWriter("result.txt"))); t = sc.nextInt(); } catch(Exception e) { System.out.println(e); } for( int i = 0; i < t; i++ ) { int n = sc.nextInt(); int s = sc.nextInt(); int p = sc.nextInt(); int[] total = new int[n]; for( int j = 0; j < n; j++ ) { total[j] = sc.nextInt(); } int ret = 0; for( int j = 0; j < n; j++ ) { if( total[j] >= p * 3 - 2 * Math.min( p, 1 ) ) { ret++; } else if( total[j] >= p * 3 - 2 * Math.min( p, 2 ) && s > 0 ) { ret++; s--; } } //System.out.println("Case #" + (i+1) + ": " + ret); fout.println("Case #" + (i+1) + ": " + ret); } fout.close(); sc.close(); } }

A11759

A12361

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package dancingwiththegooglers; import inout.In; import inout.Out; import java.util.ArrayList; import java.util.Collections; public class Main { public static void main(String[] args) throws Exception { String[] strings = In.read("B-small-attempt3.in", 1); int cont = 1; for (String str : strings) { String[] split = str.split(" "); int number = Integer.parseInt(split[0]); int surprises = Integer.parseInt(split[1]); int atLeast = Integer.parseInt(split[2]); ArrayList<Integer> scores = new ArrayList<Integer>(number); for (int i = 0; i < number; i++) { scores.add(Integer.parseInt(split[i + 3])); } Collections.sort(scores); int maxGooglers = 0; int newSurprises = 0; boolean mores = surprises == 0 ? false : true; for (int i = 0; i < number; i++) { int score = scores.get(i); int result = score / 3; int rest = score % 3; if (rest != 0) { if (result + rest <= 10 && (mores || rest != 2)) { if (result + rest >= atLeast) { maxGooglers++; } if (rest == 2) { newSurprises++; } } else { if (result + 1 >= atLeast) { maxGooglers++; } if (result + 1 == 2) { newSurprises++; } } } else { if (result > 0 && result < 10 && mores) { if (result + 1 >= atLeast) { maxGooglers++; } newSurprises++; } else { if (result >= atLeast) { maxGooglers++; } } } if (newSurprises == surprises) { mores = false; } } Out.write("output.txt", cont++, maxGooglers + ""); } } }

A11759

A10258

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package codejam2012; import java.util.Scanner; /** * * @author Kumudu */ public class Main { /** * @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here String out=""; Scanner in = new Scanner(System.in); String read = in.nextLine(); int N = Integer.valueOf(read); for (int i = 0; i < N; i++) { read = in.nextLine(); String [] str_vals = read.split(" "); int sup = Integer.valueOf(str_vals[1]); int min = Integer.valueOf(str_vals[2]); int min_tot = 3*min - 4; if(min<=1){ min_tot = min; } int both=0; int non_sup=0; for (int j = 3; j < str_vals.length; j++) { if(Integer.valueOf(str_vals[j]) >= min_tot){ both++; } if(Integer.valueOf(str_vals[j]) >= (min_tot+2)){ non_sup++; } } if(min>=2){ System.out.println("Case #"+(i+1)+": "+(non_sup + Math.min(sup, (both-non_sup)))); } if(min<=1){ //System.out.println("ddr"); System.out.println("Case #"+(i+1)+": "+both); } } } }

A11759

A12584

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.IOException; import java.math.BigDecimal; import java.util.Arrays; import java.util.List; public class MinimumScalar extends JamProblem { public static void main(String[] args) throws IOException { MinimumScalar p = new MinimumScalar(); p.go(); } @Override String solveCase(JamCase jamCase) { MSCase c= (MSCase) jamCase; Arrays.sort(c.a); Arrays.sort(c.b); BigDecimal b = new BigDecimal(0); for (int i=0; i< c.lengh; i++) { BigDecimal aaa = new BigDecimal(c.a[i]); BigDecimal bbb = new BigDecimal(c.b[c.lengh - i - 1]); b = b.add(aaa.multiply(bbb)); } return "" + b; } @Override JamCase parseCase(List<String> file, int line) { MSCase c= new MSCase(); c.lineCount=3; int i = line; c.lengh = Integer.parseInt(file.get(i++)); c.a = JamUtil.parseIntList(file.get(i++),c.lengh); c.b = JamUtil.parseIntList(file.get(i++),c.lengh); return c; } } class MSCase extends JamCase { int lengh; int[] a; int[] b; }

A11759

A12552

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; public class B_Qual { static int n, s, score; static int inf = 1 << 25; static int[][] dp = new int[128][128]; static int[] points=new int[128]; public static int go(int index, int surprise) { if(surprise>s)return -inf; if (index == n) { if (surprise == s) return 0; return -inf; } if (dp[index][surprise] != -1) return dp[index][surprise]; int res = 0; for (int i = 0; i <= 10; i++) { for (int j = -1; j <= 1; j++) { for (int k = -1; k <= 1; k++) { int a = i, b = i + j, c = i + k; int max = Math.max(Math.max(a, b), c); if (a+b+c==points[index]&&ValidTriple(a,b,c)&&!surp(a,b,c)) { if (max >= score) res = Math.max(res, 1 + go(index + 1, surprise)); else res = Math.max(res, go(index + 1, surprise)); } } } } for (int i = 0; i <= 10; i++) { for (int j = -2; j <= 2; j ++) { for (int k = -2; k <= 2; k ++) { int a = i, b = i + j, c = i + k; int max = Math.max(Math.max(a, b), c); if (a+b+c==points[index]&&ValidTriple(a,b,c)&&surp(a,b,c)) { if (max >= score) res = Math.max(res, 1 + go(index + 1, surprise + 1)); else res = Math.max(res, go(index + 1, surprise + 1)); } } } } return dp[index][surprise] = res; } private static boolean surp(int a, int b, int c) { int[] x={a,b,c}; for (int i = 0; i < x.length; i++) { for (int j = 0; j < x.length; j++) { if(x[i]-x[j]==2)return true; } } return false; } private static boolean ValidTriple(int a, int b, int c) { int[] x={a,b,c}; Arrays.sort(x); for (int i = 0; i < x.length; i++) { if(!valid(x[i])) return false; } for (int i = 0; i < x.length; i++) { for (int j = i+1; j < x.length; j++) { if(x[j]-x[i]>2) return false; } } return true; } private static boolean valid(int a) { return a >= 0 && a <= 10; } public static void main(String[] args) throws IOException { Scanner in = new Scanner(System.in); int T = in.nextInt(); for (int tt = 1; tt <= T; tt++) { for (int[] x : dp) Arrays.fill(x, -1); n = in.nextInt(); s = in.nextInt(); score = in.nextInt(); for(int i=0;i<n;i++){ points[i]=in.nextInt(); } System.out.printf("Case #%d: %d\n", tt, go(0, 0)); } } }

A11759

A11124

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package GCJ2012QR2012; import java.io.*; import java.util.ArrayList; import java.util.List; import java.util.regex.*; import java.util.HashMap; import java.util.TreeMap; import java.util.Iterator; import java.util.ArrayList; import java.lang.Math; import java.util.LinkedList; import java.util.Map; import java.util.Collections; import java.util.Comparator; import template.Template; public class B { public static void main(String[] args) throws Exception{ Template tpl = new Template('B', false, true, 0); String line = tpl.read(0); int T = Integer.parseInt(line); for(int i=1; i<tpl.getSize(); i++){ String[] str = tpl.read(i).split(" "); int N = Integer.parseInt(str[0]); int S = Integer.parseInt(str[1]); int p = Integer.parseInt(str[2]); int[] t = new int[str.length-3]; for(int j=0; j<N; j++){ t[j] = Integer.parseInt(str[j+3]); } int confirmed = 0; int possible = 0; int never = 0; int cnf_sup = 0; int psb_sup = 0; if(p>=2){ cnf_sup = p+(p-1)+(p-1); psb_sup = p+(p-2)+(p-2); } else if(p>=1){ cnf_sup = p+(p-1)+(p-1); psb_sup = p+(p-1)+(p-1); } else{ cnf_sup = p*3; psb_sup = p*3; } for(int j=0; j<t.length; j++){ if(t[j]>=cnf_sup) confirmed++; else if(t[j]>=psb_sup) possible++; else never++; } int result = confirmed+Math.min(possible, S); String rst = "Case #"+i+": "+ result; tpl.addLine(rst); } tpl.write(); } }

A11759

A11127

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.*; import java.io.*; public class Dance { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int surprise, count, cases, m, n, lines, s, p, y, score1, score2, score3; cases = 0; lines = scan.nextInt(); while((scan.hasNextInt()) && lines > 0 && lines <= 100){ count = surprise = 0; y = 0; m = scan.nextInt(); s = scan.nextInt(); p = scan.nextInt(); score1 = scan.nextInt(); switch(m){ case 1: cases++; if(p == 0 && score1 == 0){ y++; }else if(score1 > 0 && ((p*3 <= score1) || ((p*3 - 1) == score1) || ((p*3 + 1) == score1) || ((p*3 - 2) == score1) || ((p*3 + 2) == score1))){ y++; }else if(score1 > 0 && (surprise != s) && (((p*3 - 3) == score1) || ((p*3 + 3) == score1) || ((p*3 - 4) == score1) || ((p*3 + 4) == score1))){ y++; surprise++; } System.out.println("Case #" + cases + ": " + y); lines--; break; case 2: cases++; score2 = scan.nextInt(); if(p == 0 && score1 == 0){ y++; }else if(score1 > 0 && (p*3 <= score1 || ((p*3 - 1) == score1) || ((p*3 + 1) == score1) || ((p*3 - 2) == score1) || ((p*3 + 2) == score1))){ y++; }else if(score1 > 0 && (surprise != s) && (((p*3 - 3) == score1) || ((p*3 + 3) == score1) || ((p*3 - 4) == score1) || ((p*3 + 4) == score1))){ y++; surprise++; } if(p == 0 && score2 == 0){ y++; }else if(score2 > 0 && (p*3 <= score2 || ((p*3 - 1) == score2) || ((p*3 + 1) == score2) || ((p*3 - 2) == score2) || ((p*3 + 2) == score2))){ y++; }else if(score2 > 0 && (surprise != s) && (((p*3 - 3) == score2) || ((p*3 + 3) == score2) || ((p*3 - 4) == score2) || ((p*3 + 4) == score2))){ y++; surprise++; } System.out.println("Case #" + cases + ": " + y); lines--; break; case 3: cases++; score2 = scan.nextInt(); score3 = scan.nextInt(); if(p == 0 && score1 == 0){ y++; }else if(score1 > 0 && (p*3 <= score1 || ((p*3 - 1) == score1) || ((p*3 + 1) == score1) || ((p*3 - 2) == score1) || ((p*3 + 2) == score1))){ y++; }else if(score1 > 0 && (surprise != s) && (((p*3 - 3) == score1) || ((p*3 + 3) == score1) || ((p*3 - 4) == score1) || ((p*3 + 4) == score1))){ y++; surprise++; } if(p == 0 && score2 == 0){ y++; }else if(score2 > 0 && (p*3 <= score2 || ((p*3 - 1) == score2) || ((p*3 + 1) == score2) || ((p*3 - 2) == score2) || ((p*3 + 2) == score2))){ y++; }else if(score2 > 0 && (surprise != s) && (((p*3 - 3) == score2) || ((p*3 + 3) == score2) || ((p*3 - 4) == score2) || ((p*3 + 4) == score2))){ y++; surprise++; } if(p == 0 && score3 == 0){ y++; }else if(score3 > 0 && ((p*3 <= score3) || ((p*3 - 1) == score3) || ((p*3 + 1) == score3) || ((p*3 - 2) == score3) || ((p*3 + 2) == score3))){ y++; }else if(score3 > 0 && (surprise != s) && (((p*3 - 3) == score3) || ((p*3 + 3) == score3) || ((p*3 - 4) == score3) || ((p*3 + 4) == score3))){ y++; surprise++; } System.out.println("Case #" + cases + ": " + y); lines--; break; } } } }

A11759

A10242

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package com.googlecode.contest.dancing; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.util.ArrayList; import java.util.List; import java.util.StringTokenizer; public class DancingGooglers { public static void main(String[] args) throws Exception { File outputFile = new File("dancing_googlers_output.txt"); FileOutputStream fos = new FileOutputStream(outputFile); BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(fos)); FileInputStream fis = new FileInputStream(args[0]); final String preface = "Case #"; BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fis)); String numberOfTestCasesString = bufferedReader.readLine(); int numberOfTestCases = Integer.parseInt(numberOfTestCasesString); for (int i = 1; i <= numberOfTestCases; i++) { DancingTestCase testCase = parseString(i, bufferedReader.readLine()); solveTestCase(testCase); System.out.println(preface + i + ": " + testCase.getAnswer()); bufferedWriter.write(preface + i + ": " + testCase.getAnswer() ); bufferedWriter.newLine(); bufferedWriter.flush(); } } public static void solveTestCase(DancingTestCase testCase) { int possibleGooglers = 0; int target = testCase.scoreToBeat; int usedSurprises = 0; //short circuit for the easiest case if (target == 0) { testCase.setAnswer(testCase.numberOfDancers); return; } for (String score : testCase.totalScores) { int tripletScore = Integer.parseInt(score); int quotient = tripletScore/3; int modulus = tripletScore%3; if (quotient >= testCase.scoreToBeat) { System.out.println("1 processing score: " + score); possibleGooglers++; } else if (tripletScore == 0 && testCase.scoreToBeat> 0) { //continue; System.out.println("2 processing score: " + score); } else if (quotient + 2 < testCase.scoreToBeat) { //continue; System.out.println("3 processing score: " + score); } else if (quotient + 2 == testCase.scoreToBeat && modulus == 2 && usedSurprises < testCase.surprises) { possibleGooglers++; usedSurprises++; System.out.println("3A processing score: " + score); } else if (quotient + 2 == testCase.scoreToBeat ) { //continue System.out.println("4 processing score: " + score); } else if (modulus > 0) { possibleGooglers++; System.out.println("5 processing score: " + score); } else if (modulus == 0 && usedSurprises < testCase.surprises) { possibleGooglers++; usedSurprises++; System.out.println("6 processing score: " + score); } else if (modulus == 0 && usedSurprises >= testCase.surprises) { //continue System.out.println("7 processing score: " + score); } else { throw new IllegalArgumentException("couldn't handle score: " + score); } } testCase.setAnswer(possibleGooglers); } public static DancingTestCase parseString(final int testCaseNumber, final String s) { StringTokenizer tokenizer = new StringTokenizer(s); String dancerString = tokenizer.nextToken(); int numberOfDancers = Integer.parseInt(dancerString); String surpriseString = tokenizer.nextToken(); int surprises = Integer.parseInt(surpriseString); String scoreString = tokenizer.nextToken(); int scoreToBeat = Integer.parseInt(scoreString); ArrayList<String> scores = new ArrayList<String>(numberOfDancers); while (tokenizer.hasMoreTokens()) { scores.add(tokenizer.nextToken()); } return new DancingTestCase(testCaseNumber, numberOfDancers, surprises, scoreToBeat, scores ); } static class DancingTestCase implements Comparable { final int testCaseNumber; final int numberOfDancers; final int surprises; final int scoreToBeat; final List<String> totalScores; private int answer; public DancingTestCase(int testCaseNumber, int numberOfDancers, int surprises, int scoreToBeat, List<String> totalScores) { this.testCaseNumber = testCaseNumber; this.numberOfDancers = numberOfDancers; this.surprises = surprises; this.scoreToBeat = scoreToBeat; this.totalScores = totalScores; } public int compareTo(Object o) { return 0; } public int getAnswer() { return answer; } public void setAnswer(int answer) { this.answer = answer; } } }

A11759

A12595

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.Scanner; /** * * @author Yasura */ public class B { public static void main(String[] args) { Scanner scanInt= new Scanner(System.in); int noOfCases = scanInt.nextInt(); int N,S,p,t,max; for(int i=0;i<noOfCases;i++){ N=scanInt.nextInt(); S=scanInt.nextInt(); p=scanInt.nextInt(); max=0; for(int j=0;j<N;j++){ t=scanInt.nextInt(); if(t%3==0){ if(t/3>p-1){ max++; } else if((t/3==p-1)&&S!=0&&t>2){ max++; S--; } } else if(t%3==1 && (t+2)/3>p-1){ max++; } else if (t%3==2){ if((t+1)/3>p-1){ max++; } else if ((t+1)/3==p-1&&S!=0){ max++; S--; } } } System.out.println("Case #"+(i+1)+": "+max); } } }

A11759

A12083

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.Scanner; class Dancing{ static Scanner sc = new Scanner(System.in); public static void solve() { int sum,X; int n =sc.nextInt(); int sur =sc.nextInt(); int k =sc.nextInt(); int max=0; for(int i=0;i<n;i++) { sum=sc.nextInt(); X=sum/3; if(X==0) { if(k==0) { max++; } if(k==1 && (sum==1 || sum==2)) { max++; } if(k==2 && sum==2 && sur>0) { sur--; max++; } } else if(k<=X) max++; else if(k==X+1) { if(sum%3!=0) max++; else if(sur>0) { max++; sur--; } } else if(k==X+2 && sum%3==2 && sur>0) { max++; sur--; } } System.out.println(max); } public static void main(String[] args) { int n=sc.nextInt(); sc.nextLine(); for(int i=0;i<n;i++) { System.out.print("Case #"+(i+1)+": "); solve(); } } }

A11759

A13226

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package ru.bobukh.problems; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Map; import java.util.Scanner; /** * * @author anton.bobukh */ public class ProblemB_DancingWithTheGooglers { public static void main(String[] args) throws IOException { Map<Character, Character> mapping = ProblemA_SpeakingInTongues.GetMapping(); try (Scanner input = new Scanner(new BufferedReader(new FileReader("C:\\Users\\maggot\\Desktop\\B-small-attempt0.in")))) { int T = input.nextInt(); input.nextLine(); try(PrintWriter output = new PrintWriter("C:\\Users\\maggot\\Desktop\\output.txt")) { for(int k = 0; k < T; ++k) { output.println(String.format("Case #%d: %d", k + 1, processLine(input.nextLine()))); } } } } public static int processLine(final String line) { int counter = 0; try (Scanner lineReader = new Scanner(line)) { lineReader.useDelimiter(" "); int N = lineReader.nextInt(); int S = lineReader.nextInt(); int P = lineReader.nextInt(); for (int i = 0; i < N; ++i) { int value = lineReader.nextInt(); if(value >= P && value - P >= 2 * (P - 1)) { ++counter; } else if(value >= P && value - P >= 2 * (P - 2) && S > 0) { ++counter; --S; } } } return counter; } }

A11759

A12755

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package googlecodejam; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.StringTokenizer; /** * * @author massimo */ public class ProblemB { //It can be proven that b=min{10,2+floor((totalPoints-2)/3)),totalPoints} if the best possibile result. //The triple must be surprising iff totalPoints<=3*(b-1). public static void main(String[] args) throws FileNotFoundException, IOException { BufferedReader in = new BufferedReader(new FileReader("in.in")); PrintWriter out = new PrintWriter("out.out"); int t = Integer.parseInt(in.readLine()); for (int i = 1; i <= t; i++) { StringTokenizer st = new StringTokenizer(in.readLine(), " "); int n = Integer.parseInt(st.nextToken()); int s = Integer.parseInt(st.nextToken()); int p = Integer.parseInt(st.nextToken()); int res = 0, surprising = 0; for (int j = 0; j < n; j++) { int totalPoints = Integer.parseInt(st.nextToken()); int b = Math.min(Math.min(totalPoints, 10), 2 + (totalPoints - 2) / 3); if (b > p) { res++; } else if (b == p) { if (totalPoints>3*(b-1)) { res++; } else if (surprising<s) { res++; surprising++; } } } out.println("Case #"+i+": "+res); } out.close(); } }

A11759

A10891

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package utils; /** * * @author Fabien Renaud */ public interface JamParser { public JamCase getJamCase(int number); }

A11759

A11432

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class DancingWithGooglers { public static int outputLine(String inputLine){ int count = 0; String[] inputArray = inputLine.split(" "); ArrayList line = new ArrayList(Arrays.asList(inputArray)); int surprises = Integer.parseInt((String) line.get(1)); int key = Integer.parseInt((String) line.get(2)); int minCompare = key + key - 2 + key -2; if (minCompare < 0) minCompare =0; int autoYes = key + key - 1 + key -1; for (int k = 3; k < line.size(); k++) { if (Integer.parseInt((String) line.get(k)) == 0 && key ==0) count++; else if (Integer.parseInt((String) line.get(k)) <= 0) count = count; else if (Integer.parseInt((String) line.get(k)) >= autoYes) { count++; } else if (Integer.parseInt((String) line.get(k)) >= minCompare && surprises > 0) { count ++; surprises --; } } return count; } public static void main (String [] args) { ArrayList answers = new ArrayList(); System.out.println("Insert a number."); int i; Scanner scan = new Scanner(System.in); i = Integer.parseInt(scan.nextLine()); for (int j = 0; j< i; j++) { String inputLine = scan.nextLine(); answers.add(outputLine(inputLine)); } for (int j = 0; j < answers.size(); j++){ System.out.println("Case #" + (j+1) + ": " + (answers.get(j))); } /* String output = ""; int length = inputArray.get(j).length(); for (int k = 0; k < length; k++) { output += convertLetter(inputArray.get(j).substring(k,k+1)); } System.out.println ("Case #" + (j+1) + ": "+ output); */ } }

A11759

A10218

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package qualification; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Component; import java.awt.EventQueue; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.math.BigInteger; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedList; import java.util.Locale; import java.util.Set; import java.util.StringTokenizer; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTable; import javax.swing.table.AbstractTableModel; import javax.swing.table.DefaultTableCellRenderer; public class A { static DecimalFormat DF = new DecimalFormat("0.000000", new DecimalFormatSymbols(Locale.ENGLISH)); private static final int MAX = 1000000; private static final int MIN = 1 - 1; private static final int MOD = 1000000009; public A(int cc) throws IOException { final int N = INT(); int S = INT(); final int p = INT(); int max = 0; for (int i = 0; i < N; i++) { int t = INT(); int b = t / 3; int f = p - b; if( f <= 0 ) { max++; continue; } int k = t % 3; switch (k) { case 0: if (f == 1 && S > 0 && b > 0) { S--; max++; } break; case 1: if (f == 1) { max++; } break; case 2: if (f == 1) { max++; } else if (f == 2 && S > 0) { S--; max++; } break; default: break; } } println("Case #" + cc + ": "+max); //System.out.format("Case #%d: %.09f\n", cc, total); } public static void run() throws Exception { String qprefix = "B"; //init(qprefix+"-large"); init(qprefix + "-small-attempt0"); //init("test"); int cases = INT(); for (int cc = 1; cc <= cases; cc++) { new A(cc); } } static class Ct extends Thread { public void run() { } } static int[][] mapClone(int[][] map) { int[][] cmap = map.clone(); for (int i = 0; i < cmap.length; i++) { cmap[i] = map[i].clone(); } return cmap; } // ************************************************************************************* // *********************************** FRAMEWORK // ************************************************************************************* public static BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in)); public static boolean isStandardInput = false; public static File input; public static FileReader inputreader; public static BufferedReader in; public static File output; public static FileWriter outputwriter; public static BufferedWriter out; public static StringTokenizer st; public static void main(String[] args) throws Exception { doSTDIN(true); setOutput("test.out"); run(); close(); } public static void init(String problemName) throws Exception { doSTDIN(false); setInput(problemName + ".in"); setOutput(problemName + ".out"); } // **************** PRINT METHODS ********************** public static void println() throws IOException { out.write("\n"); System.out.println(); } public static void println(Object obj) throws IOException { out.write(obj.toString()); out.write("\n"); System.out.println(obj.toString()); } public static void print(Object obj) throws IOException { out.write(obj.toString()); System.out.print(obj.toString()); } public static void println(long number) throws IOException { out.write(Long.toString(number)); out.write("\n"); System.out.println(number); } public static void print(long number) throws IOException { out.write(Long.toString(number)); System.out.print(number); } public static void println(char c) throws IOException { out.write(Character.toString(c)); out.write("\n"); System.out.println(c); } public static void print(char c) throws IOException { out.write(Character.toString(c)); System.out.print(c); } public static void println(String line) throws IOException { out.write(line); out.write("\n"); System.out.println(line); } public static void print(String line) throws IOException { out.write(line); System.out.print(line); } // ******************** INPUT DECLARATION ****************** public static void doSTDIN(boolean standard) { isStandardInput = standard; } public static void setInput(String filename) throws IOException { input = new File(filename); inputreader = new FileReader(input); in = new BufferedReader(inputreader); } public static void setOutput(String filename) throws IOException { output = new File(filename); outputwriter = new FileWriter(output); out = new BufferedWriter(outputwriter); } public static void close() throws IOException { if (in != null) in.close(); if (inputreader != null) inputreader.close(); if (out != null) out.flush(); if (out != null) out.close(); if (outputwriter != null) outputwriter.close(); } // ************************** INPUT READING ***************** static String LINE() throws IOException { return isStandardInput ? stdin.readLine() : in.readLine(); } static String TOKEN() throws IOException { while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(LINE()); return st.nextToken(); } static int INT() throws IOException { return Integer.parseInt(TOKEN()); } static long LONG() throws IOException { return Long.parseLong(TOKEN()); } static double DOUBLE() throws IOException { return Double.parseDouble(TOKEN()); } static BigInteger BIGINT() throws IOException { return new BigInteger(TOKEN()); } } class AF { private Object array; private int oa = 0; private int ob = 0; private int as = 10; private int bs = 10; public AF(Object array) { this.array = array; } public AF(Object array, int oa, int ob) { this.array = array; this.oa = oa; this.ob = ob; } public AF(Object array, int oa, int ob, int as, int bs) { this.array = array; this.oa = oa; this.ob = ob; this.as = as; this.bs = bs; } public String toString() { StringBuilder sb = new StringBuilder(); for (int a = 0; a < as; a++) { sb.append(a + oa).append('['); for (int b = 0; b < bs; b++) { sb.append(get(a, b)); if (b != bs - 1) sb.append(','); } sb.append("]\n"); } return sb.toString(); } private String get(int a, int b) { a += oa; b += ob; String s = " "; try { if (array instanceof int[][]) { int[][] na = (int[][]) array; s = Integer.toString(na[a][b]); } else if (array instanceof byte[][]) { byte[][] na = (byte[][]) array; s = Byte.toString(na[a][b]); } else if (array instanceof Object[][]) { Object[][] na = (Object[][]) array; s = na[a][b].toString(); } } catch (Exception e) { } while (s.length() < 2) { s = " " + s; } return s; } } class AF2 extends JFrame implements ActionListener { static Object lock = new Object(); private JTable jt; public AF2(String title, int[][] data) { super(title); setSize(150, 150); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent we) { dispose(); System.exit(0); } }); jt = new JTable(new ITableModel(data)); jt.setDefaultRenderer(Integer.class, new CustomTableCellRenderer()); // jt.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); JScrollPane pane = new JScrollPane(jt, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); getContentPane().add(pane); JButton button = new JButton("Continue"); getContentPane().add(button, BorderLayout.SOUTH); button.addActionListener(this); pack(); setVisible(true); } public void updateData(int[][] data) { ((ITableModel) jt.getModel()).updateData(data); /*synchronized (lock) { try { lock.wait(); } catch (InterruptedException e) { } }*/ return; } public void actionPerformed(ActionEvent arg0) { synchronized (lock) { lock.notify(); } } } class ITableModel extends AbstractTableModel { int[][] data; int[][] old_data; public ITableModel(int[][] data) { if (data != null) this.data = data; else this.data = new int[1][1]; } public void updateData(int[][] p_data) { if( p_data.length == data.length && p_data[0].length == data[0].length ) { old_data = data; } else { old_data = null; } this.data = p_data; EventQueue.invokeLater(new Runnable() { public void run() { fireTableStructureChanged(); } }); } public int getColumnCount() { return data[0].length + 1; } public int getRowCount() { return data.length; } public String getColumnName(int column) { return Integer.toString(column - 1); } public Object getValueAt(int rowIndex, int columnIndex) { if (columnIndex == 0) return rowIndex; if( old_data != null && data[rowIndex][columnIndex - 1] != old_data[rowIndex][columnIndex - 1] ) { return ""+old_data[rowIndex][columnIndex - 1]+" -> "+data[rowIndex][columnIndex - 1]; } return data[rowIndex][columnIndex - 1]; } public Class<?> getColumnClass(int arg0) { return getValueAt(0, arg0).getClass(); } } class CustomTableCellRenderer extends DefaultTableCellRenderer { public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) { Component cell = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column); if (column == 0) { cell.setBackground(Color.gray); } else if (value instanceof Integer) { Integer amount = (Integer) value; if (amount.intValue() <= 0) { cell.setBackground(Color.red); } else { cell.setBackground(Color.white); } } else { cell.setBackground(Color.yellow); } return cell; } }

A11759

A12509

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.File; import java.lang.StringBuilder; import java.util.Scanner; import java.io.FileWriter; import java.util.ArrayList; import java.lang.Math; import java.util.Collections; public class DWTG { public static void main(String[] args) throws Exception{ File input = new File("B-small-attempt2.in"); File output = new File("output.out"); FileWriter fw = new FileWriter(output); Scanner s = new Scanner(input); int numloops = s.nextInt(); StringBuilder sb = new StringBuilder(); for(int n=0; n<numloops; n++){ sb.append("Case #" + (n+1) + ": "); //System.out.println("Case: " + (n+1)); int numGooglers = s.nextInt(); int numSurprises = s.nextInt(); int minscore = s.nextInt(); int maxwithscore = 0; ArrayList<Integer> al = new ArrayList<Integer>(); for(int i=0; i<numGooglers; i++){ int curnum = s.nextInt(); //System.out.println("Curnum: "+curnum+" ceil: "+Math.ceil(((float)curnum)/3)); if(Math.ceil(((float)curnum)/3) >= minscore){ //System.out.println("Added "+Math.ceil(((float)curnum)/3)+" "+minscore); maxwithscore++; continue; } if(curnum == 0) continue; if((int) Math.ceil(((float)curnum)/3) == curnum/3){ al.add( (int) Math.ceil(((float)curnum)/3) +1); //System.out.println((int) Math.ceil(((float)curnum)/3) +1); } else{ al.add( (int) Math.ceil(((float)curnum)/3)); //System.out.println( Math.ceil(((float)curnum)/3)); } } Collections.sort(al); Collections.reverse(al); int i=numSurprises; while(i>0 && !al.isEmpty()){ int curnum = al.get(0); curnum++; //System.out.println(curnum + " " +minscore); if(curnum >= minscore){ maxwithscore++; } al.remove(0); i--; } sb.append(maxwithscore + "\n"); } fw.write(sb.toString()); //System.out.println(sb.toString()); fw.close(); } }

A11759

A13075

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package com.vp.fact; import com.vp.iface.Problem; import com.vp.impl.DancingWithGooglers; import com.vp.impl.SpeakGooglerese; public class SolutionFactory { public static Problem getInstance(int problem) { Problem s = null; switch(problem) { case 1: s= new SpeakGooglerese(); break; case 2: s= new DancingWithGooglers(); break; } return s; } }

A11759

A12430

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class DancingWithGooglers { static String max(String line, int index){ String[] array = line.split(" "); int googlers = new Integer(array[0]); int surprising = new Integer(array[1]); int minimum = new Integer(array[2]); List<Integer> scores = new ArrayList<Integer>(); for (int i=0; i<googlers; i++){ scores.add(new Integer(array[3+i])); } Collections.sort(scores); int count = 0; List<Integer> l = new ArrayList<Integer>(); for (Integer score : scores){ if ((score+2)/3 >= minimum){ count++; } else { l.add(score); } } scores = l; Collections.sort(scores); Collections.reverse(scores); //moderate scores int left = scores.size() > surprising ? surprising : scores.size(); for (int i=0; i<left; i++){ if (scores.get(i) < 2) { } else { scores.set(i, scores.get(i)+ 4); } if (scores.get(i)/3 >= minimum){ count++; } } String prefix = "Case #" + index + ": "; return prefix + count + "\n"; } public static void main(String[] args) throws Exception{ if (args.length < 1) throw new Exception("Expected Filename as first argument."); String filename = args[0]; FileReader input = new FileReader(filename); BufferedReader bufferedinput = new BufferedReader(input); //number of lines int n = new Integer(bufferedinput.readLine()); String line = bufferedinput.readLine(); int index = 1; String outfilename = "b.txt"; FileWriter f = new FileWriter(outfilename); while (line != null){ String result = max(line, index); System.out.println(result); f.write(result); index++; line = bufferedinput.readLine(); } f.close(); } }

A11759

A11928

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package com.my; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { Dancing d = new Dancing(); d.danc(); } } class Dancing { public void danc() { try { String fileLocation = "C://Training//Google//DancingWiththeGooglers//src//com//my//smallInput.txt"; BufferedReader reader = getInputFile(fileLocation); String line = reader.readLine(); int count=1; while ( ( line = reader.readLine()) != null ) { String inputs[] = line.split(" " ); int totalParticipant = Integer.parseInt(inputs[0]); int surprising = Integer.parseInt(inputs[1]); int inResult = Integer.parseInt(inputs[2]); List list = new ArrayList(); for( int i=0;i<totalParticipant;++i) { int score = Integer.parseInt(inputs[3+i]); list.add(triplet(score,inResult)); } int totalCount = 0 ; for( int i=0; i<list.size();++i ) { if( totalCount == surprising) break; List l = (List )list.get(i); if( !((Boolean)l.get(0)) && (Boolean)l.get(1)) { l.set(1, false); l.set(0, false); ++totalCount; } } if( totalCount < surprising) { for( int i=0; i<list.size();++i ) { List l = (List )list.get(i); if( (Boolean)l.get(1)) { l.set(1, false); l.set(0, false); ++totalCount; if( totalCount == surprising) break; } } } for( int i=0; i<list.size();++i ) { List l = (List )list.get(i); if( ((Boolean)l.get(0)) ) { ++totalCount; } } System.out.print("Case #" + count + ": "); ++count; System.out.println(totalCount); } } catch (Exception e) { // TODO: handle exception } } public BufferedReader getInputFile(String fileLocation) throws Exception{ BufferedReader reader = new BufferedReader(new FileReader(new File(fileLocation))); return reader; } public List triplet(int score, int inResult) { List<String> surpriseList = new ArrayList<String>(); java.util.List<String> list = new ArrayList<String>(); try { int mid = score/3; for( int i=0; i<3;++i) { for( int j=0; j<3; ++j) { for( int k=0; k<3; ++k) { int total = (mid+i) + (mid+j) + (mid+k); if( total == score){ if( (mid+i) >= inResult || (mid+j) >= inResult || (mid+k) >= inResult ) { String str = sort((mid+i),(mid+j),(mid+k)); if( isSurprise((mid+i),(mid+j),(mid+k))) { if( !surpriseList.contains(str)) surpriseList.add(str); } else if( !list.contains(str)) list.add(str); } } } } } if( mid >= 1) { mid--; for( int i=0; i<3;++i) { for( int j=0; j<3; ++j) { for( int k=0; k<3; ++k) { int total = (mid+i) + (mid+j) + (mid+k); if( total == score){ if( (mid+i) >= inResult || (mid+j) >= inResult || (mid+k) >= inResult ) { String str = sort((mid+i),(mid+j),(mid+k)); if( isSurprise((mid+i),(mid+j),(mid+k))) { if( !surpriseList.contains(str)) surpriseList.add(str); } else if( !list.contains(str)) list.add(str); } } } } } } } catch (Exception e) { // TODO: handle exception } List returnList = new ArrayList (); if( list.size() > 0) returnList.add(true); else returnList.add(false); if(surpriseList.size() >0 ) returnList.add(true); else returnList.add(false); return returnList; } public String sort(int num1, int num2, int num3) throws Exception{ List<Integer> list = new ArrayList<Integer>(); list.add(num1); list.add(num2); list.add(num3); Collections.sort(list); String s = ""; for( int i =0; i<list.size();++i) { s = s + list.get(i) + " "; } return s; } public boolean isSurprise(int num1, int num2, int num3) { if( num1-num2 == 2 || num1-num3 == 2 || num2-num1 == 2 || num2-num3 == 2 || num3-num1 == 2 || num3-num2 == 2 ) return true; return false; } }

A11759

A10624

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.InputStreamReader; import java.io.PrintWriter; public class problemC { public static void main (String[] argv) throws Exception{ BufferedReader in = new BufferedReader(new InputStreamReader( new FileInputStream("test.in"))); PrintWriter pw = new PrintWriter(new FileOutputStream("result.txt")); int number = Integer.parseInt(in.readLine()); String line = ""; int cases; int base; int score; int l=1; for (int k=0;k<number;k++){ line=(in.readLine()); cases=0; String[] test=line.split(" "); int nbpeople=Integer.parseInt(test[0]); int surprise=Integer.parseInt(test[1]); int min=Integer.parseInt(test[2]); for (int i=3;i<test.length;i++){ score=Integer.parseInt(test[i]); base=score/3; switch (score % 3){ case 0: if (base>=min){ cases++; }else{ if ((surprise > 0)&&(base>0)&& ((base+1)>=min)){ cases++; surprise--; } } break; case 1: if ((base >= min) || ((base+1) >=min)) { cases++; }else{ if ((surprise >0)&&((base+1)>=min)){ cases++; surprise--; } } break; case 2: if (((base+1)>min)|| (base >=min)){ cases++; }else{ if ((surprise >0)&& ((base+2)>= min)){ cases++; surprise--; } } break; } } pw.append("Case #" + l + ": " + cases+ "\n"); l++; //System.out.println (cases); } pw.flush(); } }

A11759

A12908

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; class Main1{ public static void main(String[] ar) throws IOException{ BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\User\\Desktop\\B-small-attempt2.in")); PrintWriter out = new PrintWriter(new FileWriter("C:\\Users\\User\\Desktop\\outputB2.out")); int t = Integer.parseInt(br.readLine()); for (int i=0; i<t; i++){ String[] m = br.readLine().split(" "); int n = Integer.parseInt(m[0]); int s = Integer.parseInt(m[1]); int p = Integer.parseInt(m[2]); int[] r = new int[m.length-3]; int res = 0; for (int j=3; j<m.length; j++){ r[j-3] = Integer.parseInt(m[j]); if (p==0){ res= m.length -3; } else { if (p==1){ if (r[j-3] >=1){ res++; } } else { if (r[j-3] >= 3*p-2){// x >= p+(p-1)+(p-1) pasti masuk res++; } else { if (s>0 && r[j-3]>= 3*p-4){ // x>= p+(p-2)+(p-2) s--; res++; } } } } } out.println("Case #"+(i+1)+": "+res); } out.close(); } }

A11759

A13179

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package dancing.with.the.googlers; import java.io.*; import java.util.ArrayList; import java.util.StringTokenizer; /** * * @author Abhishek */ public class DancingWithTheGooglers { /** * @param args the command line arguments */ static int NoOfGooglers; static int surprisingResults; static int pi; static int count; private static String inputFile = "F:/B-small-attempt0.in"; private static String outputFile = "F:/Output.txt"; public static void main(String[] args) { // TODO code application logic here count = 0; readFile(); } public static void readFile() { int totalLines =0; try { FileInputStream fis = new FileInputStream(inputFile); DataInputStream dis = new DataInputStream(fis); BufferedReader br = new BufferedReader(new InputStreamReader(dis)); ArrayList<Integer> scores = new ArrayList<Integer>(); String str; StringTokenizer st; while( (str = br.readLine()) != null) { NoOfGooglers = -1; surprisingResults = -1; pi = -1; scores.clear(); st = new StringTokenizer(str, " \n"); scores.clear(); while( st.hasMoreTokens()) { if( totalLines == 0 ) { totalLines = Integer.parseInt(str); break; } if( NoOfGooglers == -1) { NoOfGooglers = Integer.parseInt(st.nextToken()); continue; } if(surprisingResults == -1) { surprisingResults = Integer.parseInt(st.nextToken()); continue; } if(pi == -1) { pi = Integer.parseInt(st.nextToken()); continue; } scores.add(Integer.parseInt(st.nextToken())); } if ( pi != -1) { int passPi = findProbabilityPi(NoOfGooglers, surprisingResults, pi, scores); writeFile(passPi); } } } catch(IOException e) { System.out.println("error is " +e.getMessage()); } } public static void writeFile(int passPi) { String line=""; try{ // Create file FileWriter fstream = new FileWriter(outputFile,true); count++; BufferedWriter out = new BufferedWriter(fstream); line = "Case #"+count+": "+passPi; out.write(line); out.newLine(); out.close(); } catch(Exception e) { System.out.println("error is " +e.getMessage()); } } public static int findProbabilityPi(int NoOfGooglers, int surprisingResults,int pi,ArrayList<Integer>scores) { int passPi = 0; NoOfGooglers = 3; for(int sc : scores) { if( sc % NoOfGooglers == 0) { if( (sc/3) == 0 && pi != 0) continue; if( sc/NoOfGooglers >= pi) { passPi++; continue; } if( surprisingResults>0 ) { if( (sc/NoOfGooglers)+1 >= pi) { passPi++; surprisingResults--; continue; } } } else if( (sc+1) % NoOfGooglers == 0) { if( (sc+1)/NoOfGooglers >= pi) { passPi++; continue; } } else if( (sc-1) % NoOfGooglers == 0) { if( (((sc-1)/NoOfGooglers)+1) >= pi) { passPi++; continue; } } if(surprisingResults > 0) { if( (sc+2) % NoOfGooglers == 0) { if( (sc+2)/NoOfGooglers >= pi) { passPi++; surprisingResults--; continue; } } else if( (sc-2) % NoOfGooglers == 0) { if( (((sc-2)/NoOfGooglers)+2) >= pi) { passPi++; surprisingResults--; continue; } } } } return passPi; } }

A11759

A11062

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class Googlers { public static void main(String args[]) throws NumberFormatException, IOException { solve(); } public static void solve() throws NumberFormatException, IOException { ArrayList<String> array=new ArrayList<String>(); FileInputStream in = new FileInputStream("B-small-attempt0.in"); Scanner s = new Scanner(in); String solved=""; int num_cases=s.nextInt(); int N=0,S=0,p=0; int R=0,x=0,y=0,z=0; int count=0; for(int i=0;i<num_cases;i++) { N=s.nextInt(); S=s.nextInt(); p=s.nextInt(); count=0; //System.out.println("N:"+N+" S:"+S+" p:"+p); //System.out.println(""); for(int j=0;j<N;j++){ R=s.nextInt(); for(int d=0;d<5;d++){ x=(R+d)/3; for(int k=0;k<2;k++) { z=(2*x-k-d)/2; y=z+k; if(x+y+z==R && (x>=0 && x<=10) && (y>=0 && y<=10) && (z>=0 && z<=10)){ if((x-y==2 || x-z==2 || y-z==2)) { if(x>=p || y>=p || z>=p){ //System.out.println("x:"+x+" y:"+y+" z:"+z+" = "+R +"(S)"); array.add("S"+i+j); } }else if(!(x-y==2 || x-z==2 || y-z==2)){ if(x>=p || y>=p || z>=p){ //System.out.println("x:"+x+" y:"+y+" z:"+z+" = "+R +"(R)"); array.add("R"+i+j); } } } } } } for(int j=0;j<N;j++){ if(array.contains("R"+i+j)) { count+=(array.remove("R"+i+j) ? 1 : 0); }else if(array.contains("S"+i+j)){ if(count<N && S>0) { count+=(array.remove("S"+i+j) ? 1 : 0); S-=1; }else{ array.remove("S"+i+j); } } } solved+="Case #"+(i+1)+": "+count+"\n"; System.out.println("Case #"+(i+1)+": "+count); } s.close(); in.close(); FileWriter fstream = new FileWriter("sollution.out"); BufferedWriter out = new BufferedWriter(fstream); out.write(solved); out.close(); fstream.close(); } }

A11759

A11562

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.*; import java.util.*; public class Launcher { static int t, n, s, p, tcount, ncount, scount, pcount; static int a, b, num, ans; public static void main(String[] args){ String c; int i,j; try { FileInputStream fin = new FileInputStream ("input.txt"); System.out.println("Input file stream created"); Scanner sc = new Scanner(fin); System.out.println("Scanner created"); FileOutputStream fout = new FileOutputStream ("output.txt"); DataOutputStream dout = new DataOutputStream (fout); t=sc.nextInt(); tcount=0; while (tcount<t){ tcount++; n=sc.nextInt(); s=sc.nextInt(); p=sc.nextInt(); ncount=0; a=(p-1)*3; if (tcount==3){ System.out.println ("a = " +a); } b=a-2; ans=0; scount=0; while (ncount < n){ ncount++; num=sc.nextInt(); if (p==0){ ans = n; } else{ if (p==1){ if (num>0){ ans++; } } else{ if (num>a) { ans++; }else { if (num>b && scount<s) { scount++; ans++; } } } } } //while ncount //Write output file dout.writeBytes("Case #"); dout.writeBytes(Integer.toString(tcount)); dout.writeBytes(": "); dout.writeBytes(Long.toString(ans)); fout.write(13); fout.write(10); } //while tcount } catch (Exception e){ System.out.println(e); } }//main } //class

A11759

A10315

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.StringTokenizer; public class dancing { static BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); static StringTokenizer st = new StringTokenizer(""); public static String next() throws Exception { while (true) { if (st.hasMoreTokens()) return st.nextToken(); String s = br.readLine(); if (s == null) return null; st = new StringTokenizer(s); } } public static int nextInt() throws Exception { return Integer.parseInt(next()); } public static void main(String[] args) throws Exception { int T = nextInt(); for(int t = 1 ; t <= T ; t++){ int N = nextInt(); int S = nextInt(); int p = nextInt(); int count = 0; for(int i = 0 ; i < N ; i ++){ int x = nextInt(); if(x==0){ if(p==0) count++; continue; } if(x==1){ if(p<=1) count++; continue; } if(x % 3 == 0){ if(x/3 >= p){ count++; }else if(S>0&&x/3 + 1 >= p){ count ++; S--; } }else if(x%3 == 1){ if(x/3 +1>= p){ count++; } }else { if(x/3+1 >= p){ count++; }else if(S>0&&x/3 +2 >= p){ count ++; S--; } } } System.out.println("Case #"+t+": "+count); } } }

A11759

A12520

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.FileReader; import java.util.ArrayList; import java.util.List; public class ClientB { public static void main(String args[]) throws Exception { ClientB client = new ClientB(); String[] inputLines = client.getInputLines(args[0]); int lineCount = Integer.valueOf(inputLines[0]); for(int i = 1; i <= lineCount; i++) { String currentLine = inputLines[i]; String[] currentCase = currentLine.split(" "); int numOfGooglers = Integer.valueOf(currentCase[0]); int numOfSuprisingScoreTriplets = Integer.valueOf(currentCase[1]); int numOfBestResultGtEq = Integer.valueOf(currentCase[2]); //System.out.println("Min or better: " + numOfBestResultGtEq); //System.out.println("sup: " + numOfSuprisingScoreTriplets); List<int[]> baseScores = new ArrayList<int[]>(); for(int j = 0; j < numOfGooglers; j++) { baseScores.add(client.fillScores(Integer.valueOf(currentCase[3+j]))); } int[] processedScores = client.categorizeScores(baseScores, numOfBestResultGtEq); int sol = processedScores[0] + Math.min(numOfSuprisingScoreTriplets, processedScores[1]); System.out.println("Case #" + i + ": " + sol); //System.out.println(); } } private int[] categorizeScores(List<int[]> scores, int bar) { int[] cat = {0, 0, 0}; //Good, bad, no potential (of being counted) for(int[] eachScoreSet : scores) { int maxScore = eachScoreSet[1]; //by def of fillScores alg if(maxScore >= bar) { cat[0]++; } else if(maxScore+1 == bar) { int oth = Math.max(eachScoreSet[0], eachScoreSet[2]); if(oth-1 >= 0 && (maxScore+1) - (oth-1) <= 2) { cat[1]++; } else { cat[2]++; } } else { //no hope cat[2]++; } } return cat; } private int[] fillScores(int maxValue) { int[] scores = {0, 0, 0}; int totScore = 0; while(++totScore <= maxValue) { scores[totScore % 3]++; } //System.out.println("maxVal:" + maxValue +" {"+scores[0]+","+scores[1]+","+scores[2]+"}"); return scores; } private String[] getInputLines(String fileName) throws Exception { BufferedReader reader = new BufferedReader(new FileReader(fileName)); List<String> lines = new ArrayList<String>(); String nextLine; while((nextLine = reader.readLine()) != null) { lines.add(nextLine); } return lines.toArray(new String[lines.size()]); } }

A11759

A10960

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

package main; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main { public static void main(String[] args) throws NumberFormatException, IOException { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader reader = new BufferedReader(isr); StringBuilder output = new StringBuilder(); int T = Integer.parseInt(reader.readLine()); for (int i=1; i<=T; i++) { output.append("Case #").append(i).append(": "); String line = reader.readLine(); String[] tokens = line.split(" "); int sol = 0; int N = Integer.parseInt(tokens[0]); int S = Integer.parseInt(tokens[1]); int p = Integer.parseInt(tokens[2]); int max = 3 * p; for (int j=3; j<tokens.length; j++) { int t_i = Integer.parseInt(tokens[j]); if (t_i >= max-2) { sol++; } else if (t_i >= max-4 && max - 4>=0) { if (S > 0) { sol++; } S--; } } output.append(sol).append("\n"); } System.out.println(output.toString()); } }

A11759

A12792

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class Main { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub HashMap<Integer,Integer> nonsurprising=new HashMap<Integer, Integer>(); HashMap<Integer,Integer> surprising=new HashMap<Integer, Integer>(); for(int i=0;i<=10;i++) for(int j=0;j<=10;j++) for(int k=0;k<=10;k++) { if(Math.abs(i-j)>2||(Math.abs(i-k)>2)||(Math.abs(k-j)>2)) { continue; } else if(Math.abs(i-j)<=2||(Math.abs(i-k)<=2)||(Math.abs(k-j)<=2)) { //suprising Integer sum=i+j+k; Integer local_Max=Math.max(i, Math.max(j, k)); if(surprising.containsKey(sum)) { Integer Global_max=surprising.get(sum); if(local_Max>Global_max) { surprising.remove(sum); surprising.put(sum, local_Max); } } else { surprising.put(sum, local_Max); } if(Math.abs(i-j)<=1&&(Math.abs(i-k)<=1)&&(Math.abs(k-j)<=1)) { //nonsurprising if(nonsurprising.containsKey(sum)) { Integer Global_max=nonsurprising.get(sum); if(local_Max>Global_max) { nonsurprising.remove(sum); nonsurprising.put(sum, local_Max); } } else { nonsurprising.put(sum, local_Max); } } } else { } } Scanner input=new Scanner(System.in); int t=input.nextInt(); for(int l=1;l<=t;l++) { int n=input.nextInt(); int s=input.nextInt(); int p=input.nextInt(); int[] totalsum=new int[n+1]; for(int j=1;j<=n;j++) { totalsum[j]=input.nextInt(); } int [][] M=new int [n+1][s+1]; for(int j=0;j<=s;j++) M[0][j]=0; for(int i=1;i<=n;i++) { if(nonsurprising.get(totalsum[i])>=p) M[i][0]=M[i-1][0]+1; else M[i][0]=M[i-1][0]; } for(int i=1;i<=n;i++) for(int j=1;j<=s;j++) { int vertical=M[i-1][j]+(nonsurprising.get(totalsum[i])>=p?1:0); int diag=M[i-1][j-1]+(surprising.get(totalsum[i])>=p?1:0); if(vertical>diag) M[i][j]=vertical; else M[i][j]=diag; } System.out.println("Case #"+l+": "+M[n][s]); } } }

A11759

A12125

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.File; import java.io.PrintWriter; import java.util.Scanner; public class Solution { static int getGroup(int t, int p) { if (t >= 2) { if ((t + 1) / 3 + 1 < p) return 0; if ((t + 2) / 3 < p) return 1; return 2; } else if ((t + 2) / 3 >= p) return 3; return 4; } public static void main(String[] args) throws Exception { Scanner in = new Scanner(new File("B-small-attempt0.in")); PrintWriter out = new PrintWriter(new File("out.txt")); int T = in.nextInt(); for (int tc = 1; tc <= T; tc++) { out.print("Case #" + tc + ": "); int n = in.nextInt(), s = in.nextInt(), p = in.nextInt(); int cnt[] = new int[5]; for (int i = 0; i < n; i++) { int t = in.nextInt(); cnt[getGroup(t, p)]++; } int ans = cnt[3] + cnt[2] + Math.min(cnt[1], s); out.println(ans); } out.close(); } }

A11759

A11316

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

// Dancing With the Googlers import java.io.*; public class DancingWithGooglers { public static void main(String[] args) throws Exception { String inputPath = args[args.length-2]; String outputPath = args[args.length-1]; BufferedReader br = new BufferedReader(new FileReader(inputPath)); int numberOfTestCases = Integer.parseInt(br.readLine()); StringBuilder output = new StringBuilder(); for (int i=1; i<=numberOfTestCases; i++) { String components[] = br.readLine().split(" "); int numberOfDancers = Integer.parseInt(components[0]); int numberOfSurprisingResults = Integer.parseInt(components[1]); int bestScore = Integer.parseInt(components[2]); int numberOfBestScores = 0; for (int totalScoreIndex=3; totalScoreIndex<(3+numberOfDancers); totalScoreIndex++) { int totalScore = Integer.parseInt(components[totalScoreIndex]); int average = totalScore / 3; int overflow = totalScore % 3; if (average >= bestScore) { numberOfBestScores++; } else if ((overflow != 0) && ((average+1) >= bestScore)) { numberOfBestScores++; } else if (numberOfSurprisingResults != 0) { if ((overflow == 2) && ((average+overflow) >= bestScore)) { numberOfBestScores++; numberOfSurprisingResults--; } else if ((overflow == 0) && (average > 0) && ((average+1) >= bestScore)) { numberOfBestScores++; numberOfSurprisingResults--; } } // System.out.println(totalScore + " " + average + " " + overflow + " " + numberOfBestScores); } // System.out.println("Case #" + i + ": " + numberOfBestScores + "\n"); output.append("Case #" + i + ": " + numberOfBestScores + "\n"); } BufferedWriter bw = new BufferedWriter(new FileWriter(outputPath)); String outputString = output.toString(); bw.write(outputString, 0, outputString.length()); bw.close(); } }

A11759

A12530

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.Scanner; public class CodeB{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); int tcase; int numGoogler, surprising, min; int totTriplets, surprisingUsed; int getMinMax; tcase=sc.nextInt(); for(int q=1;q<=tcase;q++){ surprisingUsed=0; getMinMax=0; numGoogler=sc.nextInt(); surprising=sc.nextInt(); min=sc.nextInt(); for(int i=0;i<numGoogler;i++){ totTriplets=sc.nextInt(); //System.out.println((totTriplets%3)+" "+(totTriplets/3)); if(totTriplets%3==0){ if(totTriplets/3>=min){ getMinMax++; } else if((totTriplets/3)!=0 && (totTriplets/3)+1>=min && surprisingUsed<surprising){ getMinMax++; surprisingUsed++; } } else if(totTriplets%3==1 && (totTriplets/3)+1>=min){ getMinMax++; } else if(totTriplets%3==2){ if((totTriplets/3)+1>=min){ getMinMax++; } else if((totTriplets/3)+2>=min && surprisingUsed<surprising){ getMinMax++; surprisingUsed++; } } } System.out.println("Case #"+q+": "+getMinMax); } } }

A11759

A10523

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.Writer; import java.util.Scanner; public class Dancing { public static void main(String[] args) throws IOException { String text = ""; String fileName = "/users/bestja/desktop/abc.txt"; File textFile = new File(fileName); Scanner in = new Scanner(textFile); int testCases = in.nextInt(); in.nextLine(); for (int i = 1; i <= testCases; i++) { int count = in.nextInt(); int surprises = in.nextInt(); int targetScore = in.nextInt(); int[] dancers = new int[count]; int winners = 0; for (int n = 0; n < count; n++) { dancers[n] = in.nextInt(); } for (int n = 0; n < count; n++) { if (dancers[n] > targetScore*3-3 && dancers[n] >= targetScore) winners++; else if (dancers[n] > targetScore*3-5 && surprises > 0 && dancers[n] >= targetScore) { winners++; surprises--; } } text += "Case #" + i + ": " + winners + "\n"; } Writer output = null; File file = new File("/users/bestja/desktop/def.txt"); output = new BufferedWriter(new FileWriter(file)); output.write(text); output.close(); } }

A11759

A12464

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.File; import java.io.FileNotFoundException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /* * To change this template, choose Tools | Templates * and open the template in the editor. */ /** * * @author Chung Lee */ public class DanceGoogler { public static void Main(String[] args) throws FileNotFoundException { Scanner scanner = new Scanner(new File(args[0])); PrintWriter writer = new PrintWriter(args[1]); int noCase = scanner.nextInt(); for (int i = 0; i < noCase; i++) { int noGooglers = scanner.nextInt(); int noSurprice = scanner.nextInt(); int P = scanner.nextInt(); List<Integer> totalScore = new ArrayList<Integer>(); List<Integer> noSurpriceBest = new ArrayList<Integer>(); for (int j = 0; j < noGooglers; j++) { int total = scanner.nextInt(); totalScore.add(total); noSurpriceBest.add((int) Math.ceil(total / 3.)); } int noAtLeastP = 0; for (int j = 0; j < totalScore.size(); j++) { if (noSurpriceBest.get(j) >= P) { noAtLeastP++; } else if ((totalScore.get(j) % 3 == 0 || totalScore.get(j) % 3 == 2) && totalScore.get(j) != 0 && totalScore.get(j) <= 27 && noSurpriceBest.get(j) == P - 1 && noSurprice > 0) { noSurprice--; noAtLeastP++; } } System.out.print(String.format("Case #%d: %d", i + 1, noAtLeastP)); writer.print(String.format("Case #%d: %d", i + 1, noAtLeastP)); if (i != noCase - 1) { System.out.println(); writer.println(); } } writer.close(); } }

A11759

A12747

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class B { public void func(){ Scanner in=null; try { in = new Scanner(new File("C:\\Users\\Suba\\workspace\\Codejam12\\src\\input.txt")); } catch (FileNotFoundException e) { e.printStackTrace(); } int no = in.nextInt(); for(int i=0;i<no;++i){ int ng = in.nextInt(); int sp = in.nextInt(); int min = in.nextInt(); int res = 0; int ss = 0; int k =3; int v = 0; int flag = 0; int[][] intArr = new int[ng][4]; for(int j=0;j<ng;++j){ int score = in.nextInt(); flag = 0; v=0; k=3; while(v<3){ intArr[j][v] = score/k; score -= intArr[j][v]; if((intArr[j][v] >= min) && flag == 0){ res++; intArr[j][3] = 1; ++flag; } --k; ++v; } if(Math.abs((intArr[j][0]-intArr[j][1])) == 2 || Math.abs((intArr[j][1]-intArr[j][2])) == 2 || Math.abs((intArr[j][2]-intArr[j][0])) == 2 ){ ++ss; } } if((res < ng) && (ss < sp)){ for(int j=0;j<ng;++j){ if(intArr[j][3] == 0 && (intArr[j][0]+intArr[j][1]+intArr[j][2] != 0)){ if(Math.abs(intArr[j][0]-intArr[j][1]) < 1){ if(j==ng-1){ intArr[j][0]--; intArr[j][1]++; if(intArr[j][0] >= min || intArr[j][1]>= min) ++res; ++ss; }else{ if(intArr[j][0]-1 >= min || intArr[j][1]+1 >= min){ intArr[j][0]--; intArr[j][1]++; ++res; ++ss; } } ///continue; }else if(Math.abs(intArr[j][1]-intArr[j][2]) < 1){ if(j==ng-1){ intArr[j][1]--; intArr[j][2]++; if(intArr[j][1] >= min || intArr[j][2]>= min) ++res; ++ss; }else{ if(intArr[j][1]-1 >= min || intArr[j][2]+1 >= min){ intArr[j][1]--; intArr[j][2]++; ++res; ++ss; } } }else if(Math.abs(intArr[j][2]-intArr[j][0]) < 1){ if(j==ng-1){ intArr[j][2]--; intArr[j][0]++; if(intArr[j][0] >= min || intArr[j][2]>=min) ++res; ++ss; }else{ if(intArr[j][2]-1 >= min || intArr[j][0]+1 >= min){ intArr[j][2]--; intArr[j][0]++; ++res; ++ss; } } } if(ss>=sp){ break; } } } } System.out.println("Case #"+(i+1)+": "+res); } } public static void main(String[] args) { B b = new B(); b.func(); } }

A11759

A12886

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.util.Scanner; public class BDancingWithGooglers { public static void main(String[] ags) { //System.setIn(new FileInputStream("src/com/afarok/google/codejam2012/qualificationround/B-small-attempt1.in")); //System.setOut(new PrintStream(new File("src/com/afarok/google/codejam2012/qualificationround/B-small-attempt1.out"))); Scanner stdIn = new Scanner(System.in); int t = stdIn.nextInt(); for(int tCase=1;tCase<=t;++tCase) { int n = stdIn.nextInt(); int ns = stdIn.nextInt(); int p = stdIn.nextInt(); int y =0; for(int i=0;i<n;++i) { int nextTotal = stdIn.nextInt(); int d = nextTotal/3; int r = nextTotal%3; if(nextTotal<p) continue; if(d>=p) { ++ y; continue; } if(p-d>2) continue; if(p-d==1) { if(r>0) { ++y; continue; } else { if(ns>0) { ++y; --ns; continue; } } } else { if(ns>0 && r==2) { ++y; --ns; continue; } } } System.out.println("Case #"+tCase+": "+y); } } }

A11759

A11160

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.DataInputStream; import java.io.FileInputStream; import java.io.FileWriter; import java.io.IOException; public class BSmall { private int[] result; public BSmall() throws NumberFormatException, IOException { readFile(); writeOutFile(); } private int[] getNum(int num, int s) { int[] result = new int[4]; int sur = s; int c = 10; result[3] = sur; while (c != 0) { if (num != 0) { int i = num / c; int r = num % c; if (i == 3) { if (r == 0) { result[0] = c; result[1] = c; result[2] = c; result[3] = sur; break; } } if (i == 2) { if (c - r == 1) { result[0] = c; result[1] = c; result[2] = r; result[3] = sur; break; } else if (c - r == 2) { c--; if (c != 0) { i = num / c; r = num % c; if (i == 3) { c++; r = num % c; result[0] = c; result[1] = c; result[2] = r; // result[3] = sur - 1; break; } } } } c--; } else { break; } } return result; } private boolean containsMax(int max, int[] nums) { for (int i = 0; i < nums.length - 1; i++) { if (nums[i] >= max) { return true; } } return false; } private int getIndex(int Max, int[] nums) { int index = -1; for (int i = 0; i < nums.length; i++) { if (Math.abs(nums[i] - Max) == 1) { return i; } } return index; } private boolean check(int[] nums, int num) { boolean flag = true; int result = 0; for (int i = 0; i < nums.length - 1; i++) { result += nums[i]; boolean f = true; int index = -1; for (int j = i; j < nums.length - 1; j++) { if (!(Math.abs(nums[j] - nums[i]) < 3)) { return false; } else { if ((Math.abs(nums[j] - nums[i]) == 2)) { if (!f) { if (index != 0) { if (nums[index] != nums[j]) { return false; } } } else { f = false; index = j; } } } } } if (result != num) { return false; } return flag; } private int getResult(int S, int Max, int[] numbers) { int result = 0; int s = S; for (int i = 0; i < numbers.length; i++) { int[] nums = getNum(numbers[i], s); s = nums[3]; boolean contain = containsMax(Max, nums); if (!contain) { int index = getIndex(Max, nums); if (index != -1 && s != 0) { int num = nums[index]; for (int j = 0; j < nums.length; j++) { if (index != j) { if (num == nums[j]) { nums[index] = num + 1; nums[j] = nums[j] - 1; if (nums[j] >= 0) { boolean flag = check(nums, numbers[i]); if (flag) { s--; result++; break; } } } } } } } else { result++; } } return result; } private void readFile() throws NumberFormatException, IOException { FileInputStream fis = new FileInputStream("Input.txt"); DataInputStream dis = new DataInputStream(fis); result = new int[Integer.parseInt(dis.readLine())]; int c = 0; while (dis.available() > 0) { String line = dis.readLine(); String[] numbers = line.split(" "); int[] nums = new int[Integer.parseInt(numbers[0])]; int s = Integer.parseInt(numbers[1]); int Max = Integer.parseInt(numbers[2]); for (int i = 3; i < numbers.length; i++) { nums[i - 3] = Integer.parseInt(numbers[i]); } result[c] = getResult(s, Max, nums); c++; } } private void writeOutFile() throws IOException { FileWriter fw = new FileWriter("Output.txt"); for (int i = 0; i < result.length; i++) { if (i < result.length - 1) { fw.write("Case #" + (i + 1) + ": " + result[i] + "\n"); } else { fw.write("Case #" + (i + 1) + ": " + result[i]); } } fw.close(); } public static void main(String[] args) throws NumberFormatException, IOException { BSmall bs = new BSmall(); } }

A11759

A11010

import java.io.*; import java.util.*; public class Problem2 { static ArrayList<Integer> scores; public static void main(String args[]) { try { FileInputStream fstream = new FileInputStream("B-small-attempt0.in"); DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String line; int total; int i = 0, cases; Scanner sc; int number, surprising, minpoints; while ((line = br.readLine()) != null) { if(i == 0) { total = Integer.parseInt(line); i = 1; continue; } sc = new Scanner(line); scores = new ArrayList<Integer>(); number = sc.nextInt(); surprising = sc.nextInt(); minpoints = sc.nextInt(); cases = 0; for(int j = 0; j < number; j++) { scores.add(sc.nextInt()); } for(int score : scores) { int base = (int)(score/3); switch(score%3) { case 0: { if(base>=minpoints) { cases++; } else if(surprising > 0 && base > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 1: { if(base>=minpoints | base + 1 >= minpoints) { cases++; } else if(surprising > 0 && base + 1 >= minpoints) { cases++; surprising--; } break; } case 2: { if(base + 1>= minpoints | base>=minpoints) { cases++; } else if(surprising > 0 && base + 2 >= minpoints) { cases++; surprising--; } break; } } } System.out.println("Case #"+i+": "+cases); write("Case #"+i+": "+cases); i++; } in.close(); }catch (Exception e){ System.err.println("Error: " + e.getMessage()); } } public static void write(String text) { try { BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true)); bw.write(text); bw.newLine(); bw.close(); }catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } }

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.StringTokenizer; public class CodeJam3 { public static void main(String [] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int testcases = Integer.parseInt(br.readLine()); for(int ii=1;ii<=testcases;++ii) { StringTokenizer st = new StringTokenizer(br.readLine()); int num = Integer.parseInt(st.nextToken()); int s = Integer.parseInt(st.nextToken()); int p = Integer.parseInt(st.nextToken()); int cnt=0; int p34 = 3*p-4; int p33 = 3*p-3; if(p34 < 0 ) p34 = 0; for(int i=0; i<num ; ++i) { int curr = Integer.parseInt(st.nextToken()); if(curr > p33) cnt++; else if(curr >= p34 && s > 0 && curr >= p) { --s; cnt++; } } System.out.println("Case #"+ii+": "+cnt); } } }