f1
stringlengths 6
6
| f2
stringlengths 6
6
| content_f1
stringlengths 66
8.69k
| content_f2
stringlengths 48
42.7k
| flag
int64 0
1
| __index_level_0__
int64 0
1.19M
|
|---|---|---|---|---|---|
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);
}
}
} | 0 | 1,189,900 |
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]);
}
} | 0 | 1,189,901 |
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();
}
}
| 0 | 1,189,902 |
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"));
}
}
| 0 | 1,189,903 |
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();
}
}
}
| 0 | 1,189,904 |
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();
}
}
| 0 | 1,189,905 |
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;
}
} | 0 | 1,189,906 |
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"));
// }
}
| 0 | 1,189,907 |
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();
}
}
}
| 0 | 1,189,908 |
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;
} | 0 | 1,189,909 |
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
*/
| 0 | 1,189,910 |
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");
}
}
}
| 0 | 1,189,911 |
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++;
}
} | 0 | 1,189,912 |
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();
}
}
| 0 | 1,189,913 |
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);
}
}
} | 0 | 1,189,914 |
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());
}
}
}
| 0 | 1,189,915 |
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);
}
}
}
}
| 0 | 1,189,916 |
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);
}
}
}
| 0 | 1,189,917 |
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);
}
}
}
| 0 | 1,189,918 |
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();
}
}
| 0 | 1,189,919 |
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);
}
}
| 0 | 1,189,920 |
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);
}
}
| 0 | 1,189,921 |
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);
}
}
| 0 | 1,189,922 |
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);
}
}
| 0 | 1,189,923 |
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++];
}
}
| 0 | 1,189,924 |
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();
}
}
| 0 | 1,189,925 |
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;
}
}
| 0 | 1,189,926 |
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();
}
}
| 0 | 1,189,927 |
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;
}
}
| 0 | 1,189,928 |
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();
}
}
| 0 | 1,189,929 |
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;
}
}
| 0 | 1,189,930 |
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;
}
}
| 0 | 1,189,931 |
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);
}
}
} | 0 | 1,189,932 |
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);
}
}
| 0 | 1,189,933 |
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;
}
}
| 0 | 1,189,934 |
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;
}
} | 0 | 1,189,935 |
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;
}
}
| 0 | 1,189,936 |
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();
}
}
| 0 | 1,189,937 |
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();
}
}
| 0 | 1,189,938 |
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);
}
}
| 0 | 1,189,939 |
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;
}
}
| 0 | 1,189,940 |
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);
}
}
| 0 | 1,189,941 |
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();
}
}
| 0 | 1,189,942 |
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());
}
}
}
| 0 | 1,189,943 |
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;
}
}
| 0 | 1,189,944 |
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;
}
}
| 0 | 1,189,945 |
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);
}
}
}
| 0 | 1,189,946 |
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;
}
}
| 0 | 1,189,947 |
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;
}
}
| 0 | 1,189,948 |
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");
}
}
}
} | 0 | 1,189,949 |
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();
}
}
| 0 | 1,189,950 |
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();
}
}
}
| 0 | 1,189,951 |
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();
}
}
| 0 | 1,189,952 |
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);
}
}
| 0 | 1,189,953 |
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);
}
}
}
| 0 | 1,189,954 |
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));
}
}
} | 0 | 1,189,955 |
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);
}
}
}
| 0 | 1,189,956 |
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;
}
}
| 0 | 1,189,957 |
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;
}
}
| 0 | 1,189,958 |
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;
}
}
| 0 | 1,189,959 |
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--;
}
}
}
}
| 0 | 1,189,960 |
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);
}
}
} | 0 | 1,189,961 |
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;
}
}
| 0 | 1,189,962 |
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();
}
}
| 0 | 1,189,963 |
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 + "");
}
}
}
| 0 | 1,189,964 |
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);
}
}
}
}
| 0 | 1,189,965 |
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;
}
| 0 | 1,189,966 |
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));
}
}
} | 0 | 1,189,967 |
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();
}
}
| 0 | 1,189,968 |
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;
}
}
}
}
| 0 | 1,189,969 |
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;
}
}
}
| 0 | 1,189,970 |
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);
}
}
}
| 0 | 1,189,971 |
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();
}
}
} | 0 | 1,189,972 |
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;
}
}
| 0 | 1,189,973 |
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();
}
}
| 0 | 1,189,974 |
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);
} | 0 | 1,189,975 |
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);
*/
}
} | 0 | 1,189,976 |
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;
}
}
| 0 | 1,189,977 |
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();
}
}
| 0 | 1,189,978 |
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;
}
}
| 0 | 1,189,979 |
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();
}
}
| 0 | 1,189,980 |
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;
}
}
| 0 | 1,189,981 |
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();
}
} | 0 | 1,189,982 |
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();
}
} | 0 | 1,189,983 |
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;
}
}
| 0 | 1,189,984 |
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();
}
}
| 0 | 1,189,985 |
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 | 0 | 1,189,986 |
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);
}
}
}
| 0 | 1,189,987 |
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()]);
}
}
| 0 | 1,189,988 |
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());
}
}
| 0 | 1,189,989 |
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]);
}
}
}
| 0 | 1,189,990 |
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();
}
}
| 0 | 1,189,991 |
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();
}
}
| 0 | 1,189,992 |
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);
}
}
} | 0 | 1,189,993 |
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();
}
}
| 0 | 1,189,994 |
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();
}
}
| 0 | 1,189,995 |
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();
}
}
| 0 | 1,189,996 |
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);
}
}
}
| 0 | 1,189,997 |
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();
}
}
| 0 | 1,189,998 |
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);
}
}
}
| 0 | 1,189,999 |