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 | A10746 | 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.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
public class Googlers {
static int T = 0;
public static void main(String[] args) {
Googlers c = new Googlers();
c.parseInput();
}
private void parseInput()
{
try{
FileInputStream fstream = new FileInputStream("B-small-attempt1.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
FileWriter fwstream = new FileWriter("B-small-attempt1.out");
BufferedWriter out = new BufferedWriter(fwstream);
if((strLine = br.readLine()) != null)
T = Integer.parseInt(strLine);
for( int ctr = 1; ctr <= T; ctr++ )
{
if(ctr > 1 )
out.newLine();
int N = 0;
int S = 0;
int p = 0;
String strLine2;
if((strLine2 = br.readLine()) != null)
{
// System.out.println(strLine2);
}
String [] numberStrings = strLine2.split(" ");
N = Integer.parseInt(numberStrings[0]);
S = Integer.parseInt(numberStrings[1]);
p = Integer.parseInt(numberStrings[2]);
int answer = 0;
// run for each player
for( int i = 0; i < N; i++ )
{
int score = Integer.parseInt(numberStrings[3+i]);
int triple = p*3;
if(triple == 0) {
answer++;
}else if(score == 0) {
continue;
} else if(score >= triple-2) {
answer++;
} else if((S > 0) && (score >= triple-4)) {
S--;
answer++;
}
}
// System.out.println(answer);
out.write("Case #" + ctr +": " + answer);
}
in.close();
out.close();
}catch (Exception e)
{
System.err.println("Error: " + e.getMessage());
}
}
}
| 0 | 1,189,100 |
A11759 | A12256 | 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.DataInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.FileWriter;
import java.io.BufferedWriter;
//import java.util.ArrayList;
public class Min_Scale_Prod {
public static void main(String[] args){
try{
String inputFileName = "B-small-attempt3.in";
String outputFileName = "B-small.out";
FileInputStream fstream = new FileInputStream(inputFileName);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
FileWriter foutstream = new FileWriter(outputFileName);
BufferedWriter out = new BufferedWriter(foutstream);
String strLine;
Helper help = new Helper();
int counter = 0;
while ((strLine = br.readLine()) != null) {
//Print the content to file
if (counter == 0) {
;
} else {
help.printResult(out, strLine, counter);
}
counter +=1;
}
//Close the output stream
out.close();
}catch (Exception e){//Catch exception if any
System.err.println(e);
}
}
}
| 0 | 1,189,101 |
A11759 | A10613 | 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 static void main(String[] args) throws FileNotFoundException
{
Scanner sc = new Scanner(new File("B.txt"));
int testCase = Integer.parseInt(sc.nextLine());
for(int Case=1; Case<=testCase; Case++)
{
int n = sc.nextInt();
int sup = sc.nextInt();
int p = sc.nextInt();
p=3*p;
int[] X=new int[n];
int ans=0;
for(int i=0; i<n;i++)
{X[i]=sc.nextInt();
if(X[i]>=(p-2)){ans++;}
else
{if(X[i]>0 && X[i]>=(p-4) && sup>0){ans++;sup--;}}
}
System.out.println("Case #"+Case+": "+ans);
}
}
} | 0 | 1,189,102 |
A11759 | A12757 | 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.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
public class SolutionB_2 {
public static void main(String[] args) throws IOException {
String curDir = "DancingWithGooglers/";
Scanner sc = new Scanner(new FileReader(curDir + "B-small-attempt11.in"));
PrintWriter pw = new PrintWriter(new FileWriter(curDir + "B-small-attempt0.out"));
int totalTestCase = Integer.parseInt(sc.nextLine());
for (int testCase = 1; testCase <= totalTestCase; testCase++) {
Integer nGoogler = sc.nextInt();
Integer nSurprising = sc.nextInt();
Integer bestNum = sc.nextInt();
Integer maxNum = 0;
Integer nCheck = 0;
List<Integer> g = new ArrayList<Integer>();
List<Integer> g1 = new ArrayList<Integer>();
for (int i = 0; i < nGoogler; i++) {
Integer a = sc.nextInt();
g.add(a);
g1.add(a);
}
if (nSurprising == 0) {
for (Integer t : g) {
int y = t / 3;
int z = t % 3;
if (t == 0 || t == 1) {
if (t >= bestNum) {
maxNum++;
}
} else if (z == 0) {
if (y >= bestNum) {
maxNum++;
}
} else if (z == 1) {
if (y + 1 >= bestNum) {
maxNum++;
}
} else if (z == 2) {
if (y + 1 >= bestNum) {
maxNum++;
}
}
}
} else {
java.util.Collections.sort(g, new Comparator<Integer>() {
public int compare(Integer a, Integer b) {
if (a > b) {
return 1;
} else if (a < b) {
return -1;
} else {
return 0;
}
}
});
for (Iterator<Integer> it = g.iterator(); it.hasNext();) {
Integer t = it.next();
int y = t / 3;
int z = t % 3;
if (t == 0 || t == 1) {
continue;
} else if (z == 0) {
if (y + 1 >= bestNum && nCheck < nSurprising) {
maxNum++;
nCheck++;
it.remove();
}
} else if (z == 1) {
if (y + 1 >= bestNum && nCheck < nSurprising) {
maxNum++;
nCheck++;
it.remove();
}
} else if (z == 2) {
if (y + 2 >= bestNum && nCheck < nSurprising) {
maxNum++;
nCheck++;
it.remove();
} else if (y + 1 >= bestNum && nCheck < nSurprising) {
maxNum++;
nCheck++;
it.remove();
}
}
}
if (nCheck >= nSurprising) {
for (Integer t : g) {
int y = t / 3;
int z = t % 3;
if (t == 0 || t == 1) {
if (t >= bestNum) {
maxNum++;
}
} else if (z == 0) {
if (y >= bestNum) {
maxNum++;
}
} else if (z == 1) {
if (y + 1 >= bestNum) {
maxNum++;
}
} else if (z == 2) {
if (y + 1 >= bestNum) {
maxNum++;
}
}
}
}
}
pw.println(String.format("Case #%d: %d", testCase, maxNum));
System.out.println(String.format("Case #%d: %d, %d, %s => %d", testCase, nSurprising, bestNum, g1.toString(), maxNum));
}
pw.flush();
pw.close();
sc.close();
}
}
| 0 | 1,189,103 |
A11759 | A11680 | 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 googlejam;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class DancingWithGooglers {
private static int N;
private static int S;
private static int p;
private static int[] ts;
private static int[][] memo;
private static int[] maxSupr;
private static int[] maxNotSupr;
public static void main(String[] args) throws FileNotFoundException {
Scanner sc = new Scanner(new File("inputB.txt"));
PrintWriter pw = new PrintWriter("outputB.txt");
int T = sc.nextInt();
maxSupr = new int[31];
Arrays.fill(maxSupr, -1);
maxNotSupr = new int[31];
Arrays.fill(maxNotSupr, -1);
for (int a = 0; a <= 10; a++) {
for (int b = 0; b <= 10; b++) {
for (int c = 0; c <= 10; c++) {
int s = a + b + c;
if (Math.abs(a - b) <= 2 && Math.abs(b - c) <= 2 && Math.abs(c - a) <= 2) {
int max = Math.max(a, Math.max(b, c));
if (Math.abs(a - b) == 2 || Math.abs(b - c) == 2 || Math.abs(c - a) == 2) {
maxSupr[s] = Math.max(maxSupr[s], max);
} else {
maxNotSupr[s] = Math.max(maxNotSupr[s], max);
}
}
}
}
}
for (int t = 1; t <= T; t++) {
N = sc.nextInt();
S = sc.nextInt();
p = sc.nextInt();
ts = new int[N];
for (int i = 0; i < ts.length; i++) {
ts[i] = sc.nextInt();
}
memo = new int[N + 1][S + 1];
for (int[] m : memo) {
Arrays.fill(m, -1);
}
int max = getMax(0, S);
pw.println("Case #" + t + ": " + max);
}
pw.flush();
pw.close();
}
public static int getMax(int index, int surpr) {
int res = memo[index][surpr];
if (res == -1) {
if (index == N) {
if (surpr == 0) {
res = 0;
} else {
res = -1000;
}
} else {
// not suprised
res = (maxNotSupr[ts[index]] >= p ? 1 : 0) + getMax(index + 1, surpr);
if (surpr > 0 && maxSupr[ts[index]] != -1) {
// suprised
res = Math.max(res, (maxSupr[ts[index]] >= p ? 1 : 0) + getMax(index + 1, surpr - 1));
}
}
memo[index][surpr] = res;
}
return res;
}
}
| 0 | 1,189,104 |
A11759 | A13022 | 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.googlers;
/**
* Class to hold the result of given test case.
* @author Sushant Deshpande
*/
public class TestResult {
/**
* variable to represent testOutput.
*/
private int testOutput;
/**
* Constructor to create TestResult with testOutput.
* @param testOutput String
*/
public TestResult(final int testOutput) {
this.testOutput = testOutput;
}
/**
* Getter method for test output.
* @return String
*/
public final int getTestOutput() {
return testOutput;
}
} | 0 | 1,189,105 |
A11759 | A10556 | 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.codejam;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class CodeJam1 {
char map[];
public static void main(String[] args) {
Scanner fileIn = null;
FileWriter fileOut = null;
try {
fileIn = new Scanner(new File("input.txt"));
fileOut = new FileWriter(new File("output.in"));
int noOfTestCases = Integer.parseInt(fileIn.nextLine());
int testCase = 0;
while (fileIn.hasNextLine()) {
testCase++;
//fileIn.nextLine();
int noOfPpl = fileIn.nextInt();
int s = fileIn.nextInt();
int p = fileIn.nextInt();
int input[] = new int[noOfPpl];
int noOfSurprise=0,count=0;
for(int i=0;i<noOfPpl;i++){
input[i] = fileIn.nextInt();
}
fileIn.nextLine();
for(int i=0;i<noOfPpl;i++){
if(p>input[i]){
continue;
}
int remainingSum = input[i]-p;
int q = remainingSum/2;
if(q>=p){
count++;
continue;
}
if((p-q)<2){
count++;
}
else if((p-q)==2 && noOfSurprise<s){
noOfSurprise++;
count++;
continue;
}
}
fileOut.write("Case #" + testCase + ": " + count
+ "\n");
}
fileIn.close();
fileOut.close();
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}
| 0 | 1,189,106 |
A11759 | A11240 | 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 q2Alt{
public static void main (String[] args) throws IOException
{
BufferedReader input = new BufferedReader (new FileReader ("B-small-attempt0.txt"));
PrintWriter output = new PrintWriter (new FileWriter("test2DoneAlt.out"));
StringTokenizer st;
int numOfLine = Integer.parseInt(input.readLine());
for(int i = 0; i < numOfLine; i++){
st = new StringTokenizer(input.readLine());
int N = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int P = Integer.parseInt(st.nextToken());
int better = 0;
int[] scores = new int [N];
for(int j = 0; j < N; j++){
scores[j] = Integer.parseInt(st.nextToken());
}
for(int j = 0; j < N; j++){
int reduction = scores[j] - P;
if(reduction < 0){}
else if(reduction >= 2*(P - 1)){
better ++;
}
else if(reduction >= 2*(P-2) && S > 0){
better ++;
S --;
}
}
output.println("Case #" + (i+1) + ": " + better);
}
output.close();
}
}
| 0 | 1,189,107 |
A11759 | A12329 | 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 cases = in.nextInt();
for(int z=1;z<=cases;++z) {
System.out.print("Case #" + z + ": ");
int googlers = in.nextInt();
int surprizes = in.nextInt();
int goodScore = in.nextInt();
int[] scores = new int[googlers];
for(int i=0;i<googlers;++i) {
scores[i] = in.nextInt();
}
Arrays.sort(scores);
int answer = 0;
int magicNumber = 3*goodScore-2;
int minNumber = 3*goodScore-4;
for(int i=googlers-1;i>=0;--i) {
if (scores[i] >= magicNumber) {
++answer;
}
else if (scores[i] >= minNumber && surprizes != 0) {
if (scores[i] <= 28 && scores[i] >= 2) {
++answer;
--surprizes;
}
}
}
System.out.println(answer);
}
}
} | 0 | 1,189,108 |
A11759 | A12221 | 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.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class ProblemB_DancingWithTheGooglers {
public static void main(String[] args) throws IOException
{
Scanner scan = new Scanner(new File("c:/B-small-attempt0.in"));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("Googlers.out")));
int N = Integer.valueOf(scan.nextLine());
int id =1;
while(scan.hasNextLine())
{
String letters = scan.nextLine();
String[] letter = letters.split(" ");
int peopleNum = Integer.valueOf(letter[0]);
int superiNum = Integer.valueOf(letter[1]);
int score = Integer.valueOf(letter[2]);
int[] scores = new int[peopleNum];
for(int i=0;i<peopleNum;i++)
{
scores[i] = Integer.valueOf(letter[i+3]);
}
int reslut = algorithm(peopleNum, superiNum, score, scores);
out.println("Case #" + id + ": " + reslut);
out.println();
id++;
}
out.close();
}
public static int algorithm(int peopleNum, int superiNum, int score,int[] scores)
{
int num = 0;
int highScores = score * 3 - 2;
int lowScores = score * 3 - 4;
//the case score=1
if(lowScores <= 0) lowScores = 1;
for(int item : scores)
{
if(item >= highScores)
num ++;
else
{
if(superiNum > 0)
{
if(item >= lowScores)
{
num++;
superiNum --;
}
}
}
}
return num;
}
}
| 0 | 1,189,109 |
A11759 | A10161 | 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 {
public static void main(String args[]) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("B-small-attempt0.in"));
PrintWriter out = new PrintWriter(new FileWriter("B-small.out"));
int T = Integer.parseInt(in.readLine());
for(int i=0; i<T; i++) {
String s = in.readLine();
String[] ss = s.split(" ");
int N = Integer.parseInt(ss[0]);
int S = Integer.parseInt(ss[1]);
int P = Integer.parseInt(ss[2]);
int[] ar = new int[50];
for(int j=0; j<N; j++) {
int x = Integer.parseInt(ss[3+j]);
ar[x]++;
}
int ans = 0;
if(P==0) ans=N; else {
int a = 0;
int b = 0;
for(int k=40; k>=0; k--) {
int n = ar[k];
if(k>(P-1)*3) {
a+=n;
} else if(P>1&& (k==(P-1)*3||k==(P-1)*3-1)) {
b+=n;
}
}
ans = a+Math.min(b,S);
}
out.println("Case #"+(i+1)+": "+ans);
}
out.close();
}
}
| 0 | 1,189,110 |
A11759 | A11284 | 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 P2
{
public static void main(String[] args) throws Exception
{
Scanner sc = new Scanner(new FileReader("B-small-attempt0.in"));
PrintWriter pw = new PrintWriter(new FileWriter("output.txt"));
int cases = Integer.parseInt(sc.nextLine());
int c = 0, temp = 0, us = 0;
for (int i = 0; i < cases; i++)
{
int n = sc.nextInt(); // no. of googlers
int s = sc.nextInt(); // no. of surprising
int p = sc.nextInt(); // criterion
us = 0; // used suprises
c = 0; // googlers that pass the test
for(int j = 0; j<n; j++)
{
temp = sc.nextInt();
double q = (temp+0.0)/(3.0);
// total = 4 (1 1 2) 1.33
int t1 = ((int)Math.floor(q+(2.0/3.0)));
int t2 = ((int)Math.floor(q+(4.0/3.0)));
if(temp < p)
{
continue;
}
else if(q >= p || t1 >= p)
{
c++;
continue;
}
// total = 5 (1 1 3) 1.66
else if(us != s && t2 >= p)
{
c++;
us++;
continue;
}
}
pw.println("Case #" + (i + 1) + ": " + c);
}
pw.close();
sc.close();
}
}
// ((temp+1)/n)+ 1 >= p
// ((temp+1)/n) >= p
// q+1 >= p | 0 | 1,189,111 |
A11759 | A10715 | 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 javaapplication2;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
/**
*
* @author Mash
*/
public class B {
public static void main(String[] args) throws IOException{
Scanner in = new Scanner(new FileReader("C:\\ima\\ans.txt"));
PrintWriter out=new PrintWriter(new FileWriter("C:\\ima\\input.txt"));
int T,S,p,N,G[];
T=in.nextInt();
for(int i=1;i<=T;i++){
N=in.nextInt();
G=new int[N];
S=in.nextInt();
p=in.nextInt();
for(int j=0;j<N;j++)G[j]=in.nextInt();
Arrays.sort(G);
if(p>1){
int q=p*3-2;
int s=p*3-4;
int cnt=0;
int pt=N-1;
for(int j=N-1;j>=0;j--){
if(G[j]>=q){cnt++;pt--;}
}
while(pt>=0&&G[pt]>=s&&S>0){
cnt++;pt--;S--;
}
System.out.println("Case #"+i+": " +cnt);
}else if(p==1){
int m=0;
for(m=0;m<N;m++){
if(G[m]>0)break;
}
System.out.println("Case #"+i+": " +(N-m));
}else if(p==0)System.out.println("Case #"+i+": "+N);
}
}
}
| 0 | 1,189,112 |
A11759 | A12487 | 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.blah;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
class Triplet {
int numbers[] = new int[3];
public Triplet(int number) {
numbers[0] = numbers[1] = numbers[2] = number;
// TODO Auto-generated constructor stub
}
boolean hasBestResultOrMore(int p){
return numbers[0]>=p || numbers[1]>=p || numbers[2]>=p;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "[" + numbers[0] +"," + numbers[1] +"," + numbers[2] +"]";
}
}
class ComponentNumber {
@Override
public String toString() {
// TODO Auto-generated method stub
return "Number "+total+" : "+primary+","+secondary+" (*)" ;
}
int total;
boolean marked = false;
Triplet primary,secondary = null;//secondary is a surprising result always
boolean hasBestResultOrMore(int p){
return primary.hasBestResultOrMore(p);
}
boolean hasSurprisingBestResultOrMore(int p){
return secondary!=null && secondary.hasBestResultOrMore(p);
}
public ComponentNumber(int totalPoints) {
total = totalPoints;
int base = totalPoints/3;
primary = new Triplet(base);
if(totalPoints==0){
//do nothing, 0 = 0 + 0 + 0
}
else if(totalPoints==1){
primary.numbers[2] = 1;
//1 = 0 + 0 + 1 or any other permutation
}
else {
switch(totalPoints%3){
case 2:
primary.numbers[1] = primary.numbers[2] = base + 1;
secondary = new Triplet(base);
secondary.numbers[2] = base + 2;
break;
case 1:
primary.numbers[2] = base + 1;
secondary = new Triplet(base);
secondary.numbers[0] = base - 1;
secondary.numbers[1] = secondary.numbers[2] = base + 1;
break;
case 0:
secondary = new Triplet(base);
secondary.numbers[0] = base - 1;
secondary.numbers[2] = base + 1;
break;
}
}
}
}
class Case {
int googlers;
int surprising;
int bestResult;
ArrayList<Integer> results;
int components[][] = new int[3][2];
Case(String g,String s,String p){
googlers = Integer.parseInt(g);
surprising = Integer.parseInt(s);
bestResult = Integer.parseInt(p);
results = new ArrayList<Integer>();
}
void addResult(String result){
results.add(Integer.parseInt(result));
}
}
public class MainProblem3 {
public static void main(String[] args) {
ArrayList<Case> cases = new ArrayList<Case>();
try {
System.setOut(new PrintStream("data.out"));
BufferedReader br = new BufferedReader(new FileReader("data.in"));
int numCases = Integer.parseInt(br.readLine());
StringTokenizer st;
Case aCase;
for (int i = 0; i < numCases; i++) {
st = new StringTokenizer(br.readLine());
aCase = new Case(st.nextToken(), st.nextToken(), st.nextToken());
for (int j = 0; j < aCase.googlers; j++) {
aCase.addResult(st.nextToken());
}
cases.add(aCase);
}
resolver(cases);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void resolver(ArrayList<Case> cases) {
Case aCase;
for (int j = 0; j < cases.size(); j++) {
aCase = cases.get(j);
int p = aCase.bestResult;
int s = aCase.surprising;
ArrayList<ComponentNumber> theBest = new ArrayList<ComponentNumber>();
ArrayList<ComponentNumber> theSurprises = new ArrayList<ComponentNumber>();
ComponentNumber aCandidate;
for (int k = 0; k < aCase.googlers; k++) {
aCandidate = new ComponentNumber(aCase.results.get(k));
//System.out.println(aCandidate);
if(aCandidate.hasBestResultOrMore(p)){
theBest.add(aCandidate);
}
else if(aCandidate.hasSurprisingBestResultOrMore(p)){
theSurprises.add(aCandidate);
}
}
int totalBest = theBest.size() + Math.min(theSurprises.size(), s);
System.out.println("Case #"+(j+1)+": "+totalBest);
}
}
} | 0 | 1,189,113 |
A11759 | A10662 | 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.world2012.qualification.b;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class B {
private static class Triplet {
public boolean surprising = false;
public boolean unsurprising = false;
public Triplet() {}
public Triplet(boolean surprising, boolean unsurprising) {
this.surprising = surprising;
this.unsurprising = unsurprising;
}
@Override
public String toString() {
return "[ " + (surprising?"surprising":"") + " " + (unsurprising?"unsurprising":"") + " ]";
}
}
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("src/codejam/world2012/qualification/b/small.in"));
BufferedWriter out = new BufferedWriter(new FileWriter("src/codejam/world2012/qualification/b/small.out"));
HashMap<Integer, HashMap<Integer, Triplet>> matrix = new HashMap<Integer, HashMap<Integer, Triplet>>();
for (int q = 0; q<=10; q++) {
HashMap<Integer, Triplet> row = new HashMap<Integer, Triplet>();
for (int r=0; r<31; r++) row.put(r, new Triplet(false, false));
matrix.put(q, row);
}
for (int i = 10; i>= 0; i--) {
for (int j=i; j >= i-2; j--) {
if (j < 0) continue;
for (int k = i; k >= i-2; k--) {
if (k < 0) continue;
int ti = i+j+k;
Triplet triplet = matrix.get(i).get(ti);
if (triplet == null) triplet = new Triplet();
if ((i-j == 2) || (i-k == 2) || (j-k == 2)) {
// surprising
triplet.surprising = true;
} else {
// unsurprising
triplet.unsurprising = true;
}
matrix.get(i).put(ti, triplet);
}
}
}
for (int ti=0; ti<31; ti++) {
Triplet triplet = new Triplet(false, false);
for (int p = 10; p>= 0; p--) {
if (matrix.get(p).get(ti).surprising) triplet.surprising = true;
if (matrix.get(p).get(ti).unsurprising) triplet.unsurprising = true;
matrix.get(p).put(ti, new Triplet(triplet.surprising, triplet.unsurprising));
}
}
int T = 0;
T = Integer.parseInt(in.readLine());
for (int t = 0; t < T; t++) {
String[] line = in.readLine().split(" ");
Long N = Long.parseLong(line[0]);
Long S = Long.parseLong(line[1]);
Integer p = Integer.parseInt(line[2]);
List<Integer> scoresList = new ArrayList<Integer>();
Long answer = 0L;
for (int i = 3; i< line.length; i++) {
scoresList.add(Integer.parseInt(line[i]));
}
for (Integer ti : scoresList) {
Triplet triplet = matrix.get(p).get(ti);
if (triplet.surprising && !triplet.unsurprising) {
if (S > 0) {
answer++;
S--;
}
} else if (triplet.unsurprising) {
answer++;
}
}
out.write("Case #"+String.valueOf(t+1) +": "+answer.toString());
if (t < T-1) out.write(System.getProperty("line.separator"));
/*
for (Long totalScore : scoresList) {
Long diff = totalScore - p;
Long first = Math.round((double) diff/2);
if (p - first > 2) {
// impossible
continue;
}
Long second = diff - first;
if (p - second > 2) {
// impossible
continue;
}
}
for (Long totalScore : scoresList) {
// ceiling
Long ceil = Math.round(Math.ceil(totalScore/3));
Long floor = Math.round(Math.floor(totalScore/3));
if (ceil == floor) {
// nice
} else {
if (ceil*3 - totalScore < 3) {
}
if (totalScore - floor*3 < 3) {
}
}
//System.err.println("total: " + totalScore + ", average: " + average);
Long diff = average*3 - totalScore; // diff > 0
Long max = 0L;
if (diff > 0) max = average + diff;
else max = average;
if (max >= p) answer++;
if ((Math.abs(diff) > 1) && (S > 0)) S--;
}
if (S == 0) {
System.err.println("Case #"+String.valueOf(t+1) +": "+answer.toString());
continue;
}
// S > 0
for (Long totalScore : scoresList) {
Long average = Math.round((double) totalScore/3);
Long diff = totalScore - average*3;
Long max = 0L;
if (diff > 0) max = average + diff;
else max = average;
if (Math.abs(diff) > 0) continue;
if (max >= p) continue;
if (S == 0) break;
max = average + 1;
S--;
if (max >= p) answer++;
}
System.err.println("Case #"+String.valueOf(t+1) +": "+answer.toString());
*/
}
out.close();
}
}
| 0 | 1,189,114 |
A11759 | A11597 | 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 gcj2012.qual;
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Character.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.math.BigInteger.*;
public class B {
static final char PROB = B.class.getSimpleName().charAt(0);
static final boolean PRAC = false;
static final double EPS = 1e-12;
static final int INF = 1 << 20;
static final int[] di = { -1, 0, 0, 1 };
static final int[] dj = { 0, -1, 1, 0 };
static Scanner sc = new Scanner(System.in);
final int N, S, p, t[];
public B() {
N = sc.nextInt();
S = sc.nextInt();
p = sc.nextInt();
t = new int[N];
for (int i = 0; i < N; i++)
t[i] = sc.nextInt();
}
public String solve() {
int s = 0;
int n = 0;
for (final int tt : t)
if (tt + 2 >= p * 3)
n++;
else if (tt > 0 && tt + 4 >= p * 3)
s++;
return "" + (n + min(s, S));
}
public static void main(String... args) {
small();
int T = Integer.parseInt(sc.nextLine());
for (int t = 1; t <= T; t++) {
System.err.printf("Case #%s%n", t);
System.out.printf("Case #%s: %s%n", t, new B().solve());
}
System.err.println("done.");
}
public static void small() {
String in = PROB + "-small" + (PRAC ? "-practice" : "-attempt" + 0) + ".in";
String out = PROB + "-small.out";
if (!PRAC)
for (int i = 1; new File(PROB + "-small" + "-attempt" + i + ".in").exists(); i++)
in = PROB + "-small" + "-attempt" + i + ".in";
try {
System.setIn(new BufferedInputStream(new FileInputStream(in)));
System.setOut(new PrintStream(out));
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
sc = new Scanner(System.in);
}
public static void large() {
String in = PROB + "-large" + (PRAC ? "-practice" : "") + ".in";
String out = PROB + "-large.out";
try {
System.setIn(new BufferedInputStream(new FileInputStream(in)));
System.setOut(new PrintStream(out));
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
sc = new Scanner(System.in);
}
private static void debug(Object... os) {
System.err.println(deepToString(os));
}
} | 0 | 1,189,115 |
A11759 | A13184 | 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 Main {
public static void main(String[] args) throws Exception {
BufferedReader bf = new BufferedReader(new FileReader(new File("B-small-attempt0.in")));
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("B-small-attempt0.out")));
int T = Integer.parseInt(bf.readLine());
for (int c = 0; c < T; c++) {
String tokens[] = bf.readLine().split(" ");
int N = Integer.parseInt(tokens[0]), S = Integer.parseInt(tokens[1]), p = Integer.parseInt(tokens[2]), t[] = new int[N], ans =0;
for (int i = 0; i < N; i++) {
t[i] = Integer.parseInt(tokens[i + 3]);
int base = t[i] / 3, mod = t[i] % 3;
if (base >= p || (mod > 0 && base + 1 >= p))
ans++;
else if(S>0 && base >0 && base + Math.max(1, mod) >= p) {
ans++;
S--;
}
}
bw.write(String.format("Case #%d: %d\n", c+1, ans));
}
bw.close();
}
}
| 0 | 1,189,116 |
A11759 | A12972 | 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 mgg.problems;
import java.util.ArrayList;
import java.util.List;
import mgg.utils.CombinatoryUtils;
import mgg.utils.FileUtil;
import mgg.utils.StringUtils;
import mgg.utils.Triplet;
/**
* @author manolo
* @date 14/04/12
*/
public class ProblemB {
public final static String EXAMPLE_IN = "B-example.in";
public final static String EXAMPLE_OUT = "B-example.out";
public final static String B_SMALL_IN = "B-small-attempt0.in";
public final static String B_SMALL_OUT = "B-small-attempt0.out";
public final static String B_LARGE_IN = "B-largein";
public final static String B_LARGE_OUT = "B-large.out";
public final static String delim = " ";
public static String solve(FileUtil util) {
String line = util.getLine();
List<Integer> listOfArgs = StringUtils.stringWithIntegersToList(line, delim);
//System.out.println("\tArgs = " + listOfArgs);
int googlers = listOfArgs.get(0);
System.out.println("\tGooglers = " + googlers);
int surprisingScores = listOfArgs.get(1);
System.out.println("\tSurprising scores = " + surprisingScores);
int leastScore = listOfArgs.get(2);
System.out.println("\tMinimum = " + leastScore);
List<Integer> listOfScores = listOfArgs.subList(3, listOfArgs.size());
System.out.println("\tScores = " + listOfScores);
List<Triplet> listOfTriplets, newListOfTriplets = new ArrayList<Triplet>();
int surprisingScoresLeft = surprisingScores;
// int [] withTriplets = new int[3];
// withTriplets[0] = 0;
// withTriplets[1] = 0;
// withTriplets[2] = 0;
int greatGooglers = 0;
for(int score : listOfScores){
listOfTriplets = CombinatoryUtils.possibleTriplets(score);
//System.out.println("\tPossible triplets: " + listOfTriplets);
newListOfTriplets = new ArrayList<Triplet>();
for(Triplet t : listOfTriplets){
if (t.max() >= leastScore){
newListOfTriplets.add(t);
}
}
System.out.println("\tNew possible triplets: " + newListOfTriplets);
// withTriplets[newListOfTriplets.size()]++;
if(newListOfTriplets.size() == 2){
greatGooglers++;
}
if(newListOfTriplets.size() == 1){
if(newListOfTriplets.get(0).isSurprising() && surprisingScoresLeft > 0){
greatGooglers++;
surprisingScoresLeft--;
}
if(!newListOfTriplets.get(0).isSurprising()){
greatGooglers++;
}
}
}
return "" + greatGooglers;
// System.out.println("\t" + withTriplets[0] + " with 0 triples");
// System.out.println("\t" + withTriplets[1] + " with 1 triples");
// System.out.println("\t" + withTriplets[2] + " with 2 triples");
//
// if((surprisingScores == 0) && (withTriplets[1] > 0)){
// return "0";
// }
// if(surprisingScores > withTriplets[1]){
// return "0";
// }
// else {
// return "" + (withTriplets[1] + withTriplets[2]);
// }
}
private static Triplet takeMax(List<Triplet> listOfTriplets) {
Triplet max_t = new Triplet(-1, -1, -1);
for(Triplet t : listOfTriplets){
if(!max_t.isSurprising()){
if(t.isSurprising()){
max_t = t;
}
else if(t.max() > max_t.max()){
max_t = t;
}
}
}
return max_t;
}
}
| 0 | 1,189,117 |
A11759 | A11126 | 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.*;
import java.util.Arrays;
import java.util.Scanner;
/**
* @author Roman Elizarov
*/
public class B {
public static void main(String[] args) throws IOException {
new B().go();
}
Scanner in;
PrintWriter out;
int[] maxS = new int[31];
int[] maxNS = new int[31];
private void go() throws IOException {
buildMax();
in = new Scanner(new File("src\\qualification\\b.in"));
out = new PrintWriter(new File("src\\qualification\\b.out"));
int t = in.nextInt();
for (int tn = 1; tn <= t; tn++) {
out.println("Case #" + tn + ": " + solveCase());
}
in.close();
out.close();
}
private void buildMax() {
Arrays.fill(maxS, -1);
Arrays.fill(maxNS, -1);
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, Math.max(a - 2, b - 2)); c <= Math.min(10, Math.min(a + 2, b + 2)); c++) {
int t = a + b + c;
int max = Math.max(a, Math.max(b, c));
if (Math.abs(a - b) == 2 || Math.abs(a - c) == 2 || Math.abs(b - c) == 2)
maxS[t] = Math.max(maxS[t], max);
else
maxNS[t] = Math.max(maxNS[t], max);
}
}
private int solveCase() {
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();
int[][] r = new int[n + 1][s + 1];
Arrays.fill(r[0], -1);
r[0][0] = 0;
for (int i = 0; i < n; i++) {
Arrays.fill(r[i + 1], -1);
for (int j = 0; j <= s; j++) {
if (r[i][j] >= 0 && maxNS[t[i]] >= 0)
r[i + 1][j] = r[i][j] + (maxNS[t[i]] >= p ? 1 : 0);
if (j > 0 && r[i][j - 1] >= 0 && maxS[t[i]] >= 0)
r[i + 1][j] = Math.max(r[i + 1][j], r[i][j - 1] + (maxS[t[i]] >= p ? 1 : 0));
}
}
return r[n][s];
}
}
| 0 | 1,189,118 |
A11759 | A10413 | 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 codjam;
import java.util.*;
public class DancingWithTheGooglers {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int k = 1; k <= T; k++) {
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int c = 0;
int To = 0;
for (int i = 0; i < N; i++) {
To = in.nextInt();
int a = To/3; // Integer division
int n = To%3;
if (To == 0) {
if (p == 0) c++;
} else {
int tmax = (n == 0) ? a : a+1;
if (tmax >= p) {
c++;
continue;
} else if (S > 0 && tmax == p-1 && (n == 0 || n == 2)) {
S--;
c++;
continue;
}
}
}
System.out.println("Case #" + k + ": " + c);
}
}
}
| 0 | 1,189,119 |
A11759 | A11134 | 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 _2012.QualificationRound.B;
import java.util.ArrayList;
import Utils.InputFile;
import Utils.OutputFile;
public class B {
private static void solve(InputFile inputFile, OutputFile outputFile){
int nbCases = Integer.parseInt(inputFile.getNextLine());
for(int caseNumber = 0; caseNumber < nbCases; caseNumber++){
String[] line = inputFile.getNextLine().split(" ");
int nbGooglers = Integer.parseInt(line[0]);
int nbSurprising = Integer.parseInt(line[1]);
int noteSeuil = Integer.parseInt(line[2]);
int result = 0;
for(int i = 3; i < 3+nbGooglers; i++){
int totalNote = Integer.parseInt(line[i]);
int maxWithoutSurprise = -1;
int maxWithSurprise = -1;
if(totalNote == 0){
maxWithoutSurprise = 0;
maxWithSurprise = -1;
}
else if(totalNote == 1){
maxWithoutSurprise = 1;
maxWithSurprise = -1;
}
else if(totalNote == 2){
maxWithoutSurprise = 1;
maxWithSurprise = 2;
}
else if(totalNote == 3){
maxWithoutSurprise = 1;
maxWithSurprise = 2;
}
else if(totalNote == 4){
maxWithoutSurprise = 2;
maxWithSurprise = 2;
}
else if(totalNote == 5){
maxWithoutSurprise = 2;
maxWithSurprise = 3;
}
else if(totalNote == 6){
maxWithoutSurprise = 2;
maxWithSurprise = 3;
}
else if(totalNote == 7){
maxWithoutSurprise = 3;
maxWithSurprise = 3;
}
else if(totalNote == 8){
maxWithoutSurprise = 3;
maxWithSurprise = 4;
}
else if(totalNote == 9){
maxWithoutSurprise = 3;
maxWithSurprise = 4;
}
else if(totalNote == 10){
maxWithoutSurprise = 4;
maxWithSurprise = 4;
}
else if(totalNote == 11){
maxWithoutSurprise = 4;
maxWithSurprise = 5;
}
else if(totalNote == 12){
maxWithoutSurprise = 4;
maxWithSurprise = 5;
}
else if(totalNote == 13){
maxWithoutSurprise = 5;
maxWithSurprise = 5;
}
else if(totalNote == 14){
maxWithoutSurprise = 5;
maxWithSurprise = 6;
}
else if(totalNote == 15){
maxWithoutSurprise = 5;
maxWithSurprise = 6;
}
else if(totalNote == 16){
maxWithoutSurprise = 6;
maxWithSurprise = 6;
}
else if(totalNote == 17){
maxWithoutSurprise = 6;
maxWithSurprise = 7;
}
else if(totalNote == 18){
maxWithoutSurprise = 6;
maxWithSurprise = 7;
}
else if(totalNote == 19){
maxWithoutSurprise = 7;
maxWithSurprise = 7;
}
else if(totalNote == 20){
maxWithoutSurprise = 7;
maxWithSurprise = 8;
}
else if(totalNote == 21){
maxWithoutSurprise = 7;
maxWithSurprise = 8;
}
else if(totalNote == 22){
maxWithoutSurprise = 8;
maxWithSurprise = 8;
}
else if(totalNote == 23){
maxWithoutSurprise = 8;
maxWithSurprise = 9;
}
else if(totalNote == 24){
maxWithoutSurprise = 8;
maxWithSurprise = 9;
}
else if(totalNote == 25){
maxWithoutSurprise = 9;
maxWithSurprise = 9;
}
else if(totalNote == 26){
maxWithoutSurprise = 9;
maxWithSurprise = 10;
}
else if(totalNote == 27){
maxWithoutSurprise = 9;
maxWithSurprise = 10;
}
else if(totalNote == 28){
maxWithoutSurprise = 10;
maxWithSurprise = 10;
}
else if(totalNote == 29){
maxWithoutSurprise = 10;
maxWithSurprise = -1;
}
else if(totalNote == 30){
maxWithoutSurprise = 10;
maxWithSurprise = -1;
}
if(maxWithoutSurprise >= noteSeuil){
result++;
} else if(maxWithSurprise >= noteSeuil && nbSurprising > 0){
result++;
nbSurprising--;
}
}
String resultString = "" + result;
outputFile.writeResult(resultString);
}
}
public static void main(String[] args) {
InputFile inputFile = new InputFile("B", "small-attempt1");
OutputFile outputFile = new OutputFile(inputFile);
solve(inputFile, outputFile);
outputFile.endFile();
}
}
| 0 | 1,189,120 |
A11759 | A10072 | 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());
}
}
} | /**
* @(#)Text1.java
*
*
* @author
* @version 1.00 2012/4/14
*/
import java.util.*;
import java.io.*;
public class B {
public static int diff(int a, int b, int c) {
int max = 0;
if(Math.abs(a-b) > max) max = Math.abs(a-b);
if(Math.abs(b-c) > max) max = Math.abs(b-c);
if(Math.abs(c-a) > max) max = Math.abs(c-a);
return max;
}
public static int max(int a, int b, int c) {
return Math.max(Math.max(a, b), c);
}
public static int combo(int score, int best) {
double avg = score/3.0;
int min = 3;
for(int i = 0; i <= 11; i++) {
for(int j = 0; j <= 11; j++) {
for(int k = 0; k <= 11; k++) {
if(i + j + k == score && max(i, j, k) >= best) {
int s = diff(i, j, k);
//System.out.println(" S: " + score + " B: " + best + " ("+i+", "+j+", "+k+")" + " " + s);
if(s < min) min = s;
if(min == 0 || min == 1) return min;
}
}
}
}
//System.out.println(" MIN: " + min);
return min;
}
public static void main(String [] argz) throws IOException {
Scanner reader = new Scanner(new File("B-small-attempt1.in"));
int numCases = reader.nextInt();
reader.nextLine();
FileWriter fstream = new FileWriter("out.txt");
BufferedWriter out = new BufferedWriter(fstream);
for(int i = 0; i < numCases; i++) {
ArrayList<Integer> scores = new ArrayList<Integer>();
Scanner lineReader = new Scanner(reader.nextLine());
while(lineReader.hasNext()) scores.add(lineReader.nextInt());
int googlers = scores.remove(0);
int surprising = scores.remove(0);
int best = scores.remove(0);
int amount = 0;
//System.out.println("\n\n\nCase #" + (i+1) + " best: " + best);
for(int j = 0; j < scores.size(); j++) {
int current = combo(scores.get(j), best);
if(current == 2 && surprising > 0) {
amount++;
surprising--;
}
if(current == 1 || current == 0) amount++;
//System.out.println("AMT: " + amount + " SUR: " + surprising);
}
//System.out.println();
out.write("Case #" + (i+1) + ": " + amount + "\n");
}
out.close();
}
} | 0 | 1,189,121 |
A11759 | A12788 | 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.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class DancingGooglers {
static BufferedWriter out;
private static int countMaxScores = 0;
public static void main(String[] args) {
System.out.print("Start\n");
// Prepare the writer
try {
FileWriter fstream;
fstream = new FileWriter("resultfinal.txt");
out = new BufferedWriter(fstream);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Prepare the reader
try {
BufferedReader reader = new BufferedReader(new FileReader("B-small-attempt4.in"));
// Read the count of testcases
int testcases = Integer.parseInt(reader.readLine());
for (int i = 0; i < testcases; i++) {
countMaxScores = 0;
int countwinners = doYourThing(reader.readLine());
out.write("Case #" + (i + 1) + ": " + countwinners + "\n");
}
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Close the output stream
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static Integer doYourThing(String readLine) {
// System.out.print(readLine +"\n");
String parts[] = readLine.split(" ");
int countgooglers = Integer.parseInt(parts[0]);
int suprising = Integer.parseInt(parts[1]);
int maxscore = Integer.parseInt(parts[2]);
ArrayList<Integer> surprisings = new ArrayList<Integer>();
surprisings.clear();
// First get all the obvious winners
for (int i = 0; i < countgooglers; i++) {
int j = i + 3;
int score = Integer.parseInt(parts[j]);
if (score >= maxscore) {
if (score >= ((maxscore * 3) - 2)) {
countMaxScores++;
} else if (score <= ((maxscore * 3) - 5)) {
// Finding the obvious loser
System.out.print("Loser " + score + "\n");
} else {
surprisings.add(score);
}
}
}
if (surprisings.size() >= suprising) {
return countMaxScores + suprising;
} else {
return countMaxScores + surprisings.size();
}
}
}
| 0 | 1,189,122 |
A11759 | A10304 | 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.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Dancing {
public static void main(String[] s){
doIt();
}
private static void doIt() {
Scanner s=null;
try {s = new Scanner(new File("B-small-attempt0.in"));}
catch (FileNotFoundException e) {e.printStackTrace();}
PrintWriter out=null;
try {out = new PrintWriter(new FileWriter("a.out"));}
catch (IOException e) {e.printStackTrace();}
int cases=s.nextInt();
for(int idx=0;idx<cases;idx++){
int number=s.nextInt();
int surprising=s.nextInt();
int targetScore=s.nextInt();
int valid=0;
for(int idy=0;idy<number;idy++){
int current=s.nextInt();
if(current%3==0 && current/3>=targetScore) valid++;
else if(current%3!=0 && current/3+1>=targetScore) valid++;
else if(surprising>0 && current/3+1==targetScore && current>1){
surprising--;
valid++;
}
else if(surprising>0 && current%3==2 && current/3+2==targetScore){
surprising--;
valid++;
}
}
int index=idx+1;
out.println
("Case #"+index+": "+valid);
}
out.close();
}
}
| 0 | 1,189,123 |
A11759 | A12944 | 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 hu.hke.gcj;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
/**
* @author katalma
*
*/
public class DancingWithTheGooglers {
static DancingWithTheGooglers dwtg = new DancingWithTheGooglers() ;
/**
* @param args
*/
public static void main(String[] args) {
readAndCalculate(args[0], args[1]);
}
private static void readAndCalculate(String inputF, String outputF) {
BufferedReader input = null;
BufferedWriter output = null;
try {
String line = null;
input = new BufferedReader(new FileReader(inputF));
output = new BufferedWriter(new FileWriter(outputF));
boolean first = true;
int expectedRows = 0;
int actualRows = -1;
while ((( line = input.readLine()) != null) && (actualRows < expectedRows)) {
System.out.print(actualRows+1);
System.out.println("----------------------------------------------------");
if (first) {
first = false;
expectedRows = Integer.parseInt(line);
} else {
output.write("Case #" +(actualRows+1)+": "+ dwtg.maximumBestResults(line));
if (actualRows +1 < expectedRows) {
output.write("\n");
}
}
actualRows++;
}
input.close();
output.close();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
}
}
private String maximumBestResults(String line) {
// TODO Auto-generated method stub
System.out.println(line);
B actLine = new B(line);
return actLine.pGooglers();
}
class B {
int googlerN;
int suprs;
int p;
Googler[] googlers;
int pGooglers;
private B() {};
B(String line) {
String[] tmp = line.split(" ");
googlerN = Integer.parseInt(tmp[0]);
suprs = Integer.parseInt(tmp[1]);
p = Integer.parseInt(tmp[2]);
googlers = new Googler[googlerN<= tmp.length-3? googlerN : tmp.length-3];
for (int i = 0; i < googlers.length; i++) {
googlers[i] = new Googler(Integer.parseInt(tmp[i+3]));
}
pGooglers = 0;
}
public String pGooglers() {
// TODO Auto-generated method stub
System.out.println("Limit: "+p+" Suprise: "+suprs);
pGooglers = 0;
int actSuprs = 0;
for (int i = 0; i < googlers.length; i++) {
if (googlers[i].possibleP(p)) {
System.out.println("Possible: " +googlers[i]);
pGooglers++;
} else if (actSuprs< suprs) {
System.out.println("with suprise?");
if (googlers[i].possiblePS(p)) {
System.out.println("Possible with suprise: " +googlers[i]);
pGooglers++;
actSuprs++;
}
}
}
return Integer.toString(pGooglers);
}
}
class Googler {
int totalCounts;
int div;
int mod;
Googler(int i) {
totalCounts = i;
div = i/3;
mod = i%3;
}
public boolean possibleP(int p) {
if (div>=p) {
return true;
}
if ((mod<2 ) &&(div+mod>=p)) {
return true;
}
if ((mod==2 ) && (div+1>=p)&& (totalCounts>1)) {
return true;
}
return false;
}
public boolean possiblePS(int p) {
if (div>=p) {
return true;
}
if (div+mod>=p) {
return true;
}
if ((mod==0 ) && (div+1>=p) && (totalCounts>1)) {
return true;
}
return false;
}
public String toString() {
return "googgler: "+totalCounts+"::"+div+"::"+mod;
}
}
}
| 0 | 1,189,124 |
A11759 | A12417 | 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 test2
{
public static void main(String[] args) throws Exception
{
new test2().run();
}
PrintWriter out = null;
boolean isOK(int n, int p, boolean s)
{
int a = n / 3;
if (n % 3 != 0)
a++;
if (a >= p)
return true;
if (s)
{
return 3 * p - 4 <= n;
}
return false;
}
void run() throws Exception
{
Scanner in = new Scanner(System.in);
out = new PrintWriter(new FileWriter("codejam.txt"));
int T = in.nextInt();
for (int i = 0; i < T; i++)
{
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int[] scores = new int[N];
for (int j = 0; j < N; j++)
scores[j] = in.nextInt();
Arrays.sort(scores);
int total = 0;
for (int j = N - 1; j >= 0; j--)
{
if (isOK(scores[j], p, false))
total++;
else
{
if (S > 0 && p >= 2)
{
if (isOK(scores[j], p, true))
{
total++;
S--;
}
else
break;
}
else
break;
}
}
out.printf("Case #%d: %d\n", i + 1, total);
}
out.close();
}
}
| 0 | 1,189,125 |
A11759 | A10518 | 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 c = 1; c <= T; c++){
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int high = 0;
int low = 0;
int ans;
if(p < 2){
int count = 0;
for(int i = 0; i < n; i++){
int t = in.nextInt();
if(t > 0) count++;
}
if(p == 0)
ans = n;
else
ans = count;
}
else{
for(int i = 0; i < n; i++){
int t = in.nextInt();
if(t >= 3*p - 2)
high++;
else if(t >= 3*p - 4)
low++;
}
ans = ans = high + ((s < low)? s : low);
}
System.out.println("Case #" + c + ": " + ans);
}
}
} | 0 | 1,189,126 |
A11759 | A13240 | 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 codejam;
import java.io.*;
import java.util.Arrays;
import java.util.HashMap;
/**
*
* @author Ostap
*/
public class CodeJam {
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws FileNotFoundException, IOException {
BufferedReader bf = new BufferedReader(new FileReader("B-small-attempt0.in"));
int n = Integer.parseInt(bf.readLine());
PrintWriter pw = new PrintWriter(new FileWriter("output.txt"));
for (int i = 0;i < n;i++){
int count = 0;
int uses = 0;
String[] s = bf.readLine().split(" ");
int N = Integer.parseInt(s[0]);
int S = Integer.parseInt(s[1]);
int p = Integer.parseInt(s[2]);
for (int j = 0; j < N; j++) {
int v = Integer.parseInt(s[j+3]);
int a[] = new int[3];
for (int k = 0; k < 2; k++) {
a[k] = v/(3-k);
v-=a[k];
}
a[2] = v;
Arrays.sort(a);
if (a[2] >= p){
count++;
continue;
}
if (uses < S){
if (a[2] == a[1] && a[1] !=0)
if (a[2]+1 >= p){
count++;
uses++;
}
}
}
pw.println("Case #"+(i+1)+": "+count);
}
pw.flush();;
pw.close();
}
}
| 0 | 1,189,127 |
A11759 | A10788 | 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;
/**
*
* @author Optee
*/
public class ScoreCounter {
int numberOfGooglers;
int surpriseCount;
int minScore;
int[] scores;
public ScoreCounter(String line) {
String[] numbers = line.split(" ");
this.numberOfGooglers = Integer.valueOf(numbers[0]);
this.surpriseCount = Integer.valueOf(numbers[1]);
this.minScore = Integer.valueOf(numbers[2]);
this.scores = new int[numbers.length-3];
int j = 0;
for (int i = 3; i < numbers.length; i++) {
scores[j++] = Integer.valueOf(numbers[i]);
}
}
int Count2() {
int winners = 0;
Integer surprise = surpriseCount;
for (int i = 0; i < numberOfGooglers; i++) {
int score = this.scores[i];
int minCount = minScore * 3;
if(score == 0 && minScore > 0) continue;
if (score + 2 >= minCount) {
winners++;
}
else if (score + 4 >= minCount && surprise > 0) {
surprise--;
winners++;
}
}
return winners;
}
int Count() throws Exception {
int winners = 0;
Integer surprise = surpriseCount;
Integer possibleSurprises = 0;
for (int i = 0; i < numberOfGooglers; i++) {
int score = this.scores[i];
int tail = score - minScore;
if (tail <= 0) continue;
int divTileOne = tail/2;
int divTileTwo = tail - divTileOne;
if (Math.max(divTileOne, divTileTwo) >= minScore){
if (Math.max(divTileOne, divTileTwo) - minScore >=2)
possibleSurprises++;
winners++;
}
else if (minScore - Math.min(divTileOne, divTileTwo) < 2) {
winners++;
}
else if (minScore - Math.min(divTileOne, divTileTwo) == 2) {
if (surprise > 0) {
surprise--;
winners++;
}
}
}
return winners;
}
}
| 0 | 1,189,128 |
A11759 | A13040 | 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 static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class B {
int[][] allno=new int[31][2];
Scanner sc;
void solve(int caseID) {
int res=0;
int n=sc.nextInt();
int s=sc.nextInt();
int p=sc.nextInt();
int[] nos=new int[n];
for(int i=0;i<n;i++)
nos[i] = sc.nextInt();
for(int i=0;i<n;i++)
{
if(allno[nos[i]][0]>=p)
res++;
else if(s>0 && allno[nos[i]][1]>=p)
{
res++;
s--;
}
}
System.out.println(""+res);
}
void run() {
long time = System.currentTimeMillis();
update();
sc = new Scanner(System.in);
int caseN = sc.nextInt();
for (int caseID = 1; caseID <= caseN; caseID++) {
//double t = (System.currentTimeMillis() - time) * 1e-3;
//if (!SAMPLE) System.err.printf("%03d/%03d %.3f/%.3f%n", caseID, caseN, t, t / (caseID - 1) * caseN);
System.out.printf("Case #%d: ", caseID);
solve(caseID);
System.out.flush();
}
}
void update()
{
int rem;
int no;
for(int i=1;i<=30;i++)
{
rem=i%3;
no=i/3;
switch(rem)
{
case 0:
allno[i][0]=no;
allno[i][1]=no+1;
break;
case 1:
allno[i][0]=no+1;
allno[i][1]=no+1;
break;
case 2:
allno[i][0]=no+1;
allno[i][1]=no+2;
break;
}
}
}
void debug(Object...os) {
System.err.println(deepToString(os));
}
public static void main(String[] args) {
try {
System.setIn(new FileInputStream("B.in"));
System.setOut(new PrintStream(new FileOutputStream("B.out")));
} catch (IOException e) {
}
new B().run();
}
} | 0 | 1,189,129 |
A11759 | A10709 | 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.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
public class DancingWithGooglers {
private static String[] linhas;
private static String[] linhasRespostas;
private static String stringDoArquivo = "";
private static Integer numeroDeTestes = null;
/**
* @param args
*/
public static void main(String[] args) {
try {
FileInputStream fs = new FileInputStream("/home/gustavo/Downloads/B-small-attempt1.in");
DataInputStream di = new DataInputStream(fs);
BufferedReader br = new BufferedReader(new InputStreamReader(di));
linhas = new String[101];
int i = 0;
String linha;
while((linha = br.readLine()) != null && (i <= 100)){
if(i== 0 && numeroDeTestes == null){
numeroDeTestes = Integer.valueOf(linha);
if(numeroDeTestes > 100 || numeroDeTestes < 1){
System.out.println("Erro: Número de casos de teste fora dos padrões!");
}
}else{
linhas[i] = linha;
i++;
}
}
di.close();
if(i == 0 || i > 100 || i > numeroDeTestes){
System.out.println("Número de linhas fora dos padrões.");
System.exit(0);
}
linhasRespostas = new String[i];
for(int j = 0; j < i; j++){
linhasRespostas[j] = "Case #" + (j + 1) + ": " + Converterlinha(linhas[j]);
}
for (int k = 0; k < linhasRespostas.length; k++) {
if (k + 1 == linhasRespostas.length) {
stringDoArquivo = stringDoArquivo + linhasRespostas[k];
break;
}
stringDoArquivo = stringDoArquivo + linhasRespostas[k] + "\n";
}
escreverNoArquivo(stringDoArquivo);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (NumberFormatException e){
System.out.println("Numero de casos de teste errado!");
}
}
private static String Converterlinha(String string) {
String[] stringComNumero = string.split(" ");
Integer numeroVariaveis = stringComNumero.length;
Integer googlers;
Integer surpresa = 0;
Integer pontoMinimo = 0;
Integer jogadores = 0;
if(numeroVariaveis > 0){
googlers = Integer.valueOf(stringComNumero[0]);
if(numeroVariaveis > 1){
surpresa = Integer.valueOf(stringComNumero[1]);
}
if(numeroVariaveis > 2){
pontoMinimo = Integer.valueOf(stringComNumero[2]);
}
try{
for(int i = 3; i < 3 + googlers; i++){
Integer base = Integer.valueOf(Integer.valueOf(stringComNumero[i])/3);
switch(Integer.valueOf(stringComNumero[i]) % 3){
case 0:
if (base >= pontoMinimo){
jogadores++;
}else{
if(surpresa > 0 && base > 0 && base + 1 >= pontoMinimo){
surpresa--;
jogadores++;
}
}
break;
case 1:
if(base >= pontoMinimo || base + 1 >= pontoMinimo){
jogadores++;
}else{
if(surpresa > 0 && base > 0 && base + 1 >= pontoMinimo){
jogadores++;
surpresa--;
}
}
break;
case 2:
if(base >= pontoMinimo || base + 1 >= pontoMinimo){
jogadores++;
}else{
if(surpresa > 0 && base > 0 && base + 2 >= pontoMinimo){
jogadores++;
surpresa--;
}
}
break;
}
}
} catch(ArrayIndexOutOfBoundsException e){
System.out.println("Erro! Número de jogadores errado.");
System.exit(0);
}
}else{
System.out.println("Erro: Número argumentos inválido.");
}
return String.valueOf(jogadores);
}
public static char criarMapa(char x) {
switch (x) {
case 'a':
return 'y';
case 'b':
return 'h';
case 'c':
return 'e';
case 'd':
return 's';
case 'e':
return 'o';
case 'f':
return 'c';
case 'g':
return 'v';
case 'h':
return 'x';
case 'i':
return 'd';
case 'j':
return 'u';
case 'k':
return 'i';
case 'l':
return 'g';
case 'm':
return 'l';
case 'n':
return 'b';
case 'o':
return 'k';
case 'p':
return 'r';
case 'q':
return 'z';
case 'r':
return 't';
case 's':
return 'n';
case 't':
return 'w';
case 'u':
return 'j';
case 'v':
return 'p';
case 'w':
return 'f';
case 'x':
return 'm';
case 'y':
return 'a';
case 'z':
return 'q';
}
return x;
}
public static void escreverNoArquivo(String texto) {
try {
String file_name = "A-small.out";
FileWriter fstream = new FileWriter(file_name);
BufferedWriter out = new BufferedWriter(fstream);
out.write(texto);
out.close();
System.out.println("SaÃda criada!");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
| 0 | 1,189,130 |
A11759 | A12781 | 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.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Scanner;
public class B {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = null;
if (args != null && args.length > 0) {
try {
sc = new Scanner(new File(args[0]));
if (args.length > 1) {
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(new File(args[1])), 128)));
}
} catch (FileNotFoundException e) {
// e.printStackTrace();
sc = new Scanner(System.in);
}
} else {
sc = new Scanner(System.in);
}
int T = Integer.valueOf(sc.nextLine());
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int S = sc.nextInt();
int p = sc.nextInt();
int[] t = new int[N];
for (int j = 0; j < N; j++) {
t[j] = sc.nextInt();
}
int answer = solve(S, p, t);
System.out.printf("Case #%d: %d\n", i + 1, answer);
}
System.out.close();
}
public static int solve(int S, int p, int[] t) {
int suprisingSuccess = 0;
int answer = 0;
for (int i = 0; i < t.length; i++) {
if (t[i] >= 3 * p - 2) {
answer++;
} else if (p < 3 && t[i] >= p) {
suprisingSuccess++;
} else if ( p >= 3 && t[i] >= 3 * p - 4 ) {
suprisingSuccess++;
}
}
answer += (S >= suprisingSuccess) ? suprisingSuccess : S;
return answer;
}
}
| 0 | 1,189,131 |
A11759 | A12629 | 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 triplet {
int judgea;
int judgeb;
int judgec;
String status;
//0 invalid
//1 not surprising
//2 surprising
public triplet(int a, int b, int c){
int minab, maxab;
minab = Math.min(a, b);
maxab = Math.max(a, b);
//Reorganize judgea to have min
judgea = Math.min(minab, c);
judgeb = Math.min(maxab, c);
judgec = Math.max(maxab, c);
if(judgea < 0 || judgec > 10){
status = "invalid";
}
else{
if(judgec - judgea==2){
status = "surprising";
}
else if((judgec - judgea)==1 || (judgec - judgea)==0){
status = "not surprising";
}
else{
status = "invalid";
}
}
}
public int score(){
return Math.max(Math.max(judgea,judgeb),judgec);
}
public String toString(){
if(status.matches("invalid")){
return "invalid";
}
return "(" + judgea+ "," + judgeb + "," + judgec +")";
}
}
| 0 | 1,189,132 |
A11759 | A10203 | 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.whitecrow.codejam2012.qualification;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.StringTokenizer;
public class B {
/**
* @param args
*/
public static void main(String[] args) {
String filename = "B-small-attempt0";
FileReader input;
FileWriter output;
try {
input = new FileReader(filename + ".in");
output = new FileWriter(filename + ".out");
BufferedReader reader = new BufferedReader(input);
BufferedWriter writer = new BufferedWriter(output);
// String in = "";
String out = "";
int T = Integer.parseInt(reader.readLine());
int N;
int S;
int p;
for (int i = 0; i < T; i++) {
StringTokenizer token = new StringTokenizer(reader.readLine(), " ");
int result = 0;
int suprising = 0;
N = Integer.parseInt(token.nextToken());
S = Integer.parseInt(token.nextToken());
p = Integer.parseInt(token.nextToken());
/*
* for (int j = 0; j < token.countTokens(); j++) { }
*/
int t = 0;
int m;
int e;
for (int j = 0; j < N; j++) {
t = Integer.parseInt(token.nextToken());
m = t / 3;
e = t % 3;
if (m >= p || (m >= p - 1 && e >= 1)) { // Qualified
result++;
} else if ((m + e != 0) && ((m == p - 1 && e == 0) || (m == p - 2 && e == 2))) { // Surprising
suprising++;
if (S >= suprising) {
result++;
}
}
}
out = "Case #" + (i + 1) + ": " + result;
System.out.println(out + "\tSuprising : " + suprising);
writer.write(out+"\n");
}
reader.close();
writer.close();
} catch (IOException e) {
e.printStackTrace();
System.exit(0);
}
}
}
| 0 | 1,189,133 |
A11759 | A11559 | 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 Dancing_With_the_Googlers {
/**
* @param args
* @throws IOException
* @throws NumberFormatException
*/
public static void main(String[] args) throws NumberFormatException,
IOException {
FileInputStream inFile = new FileInputStream(
new File("C:\\Users\\ruzbeh\\Downloads\\in.in"));
DataInputStream br = new DataInputStream(inFile);
FileOutputStream outFile = new FileOutputStream(new File("out.in"));
DataOutputStream out = new DataOutputStream(outFile);
int T = Integer.parseInt(br.readLine());
for (int i = 0; i < T; i++) {
int res = 0;
String[] str = br.readLine().split(" ");
int count = Integer.parseInt(str[1]);
int focus_score = Integer.parseInt(str[2]);
int min_score = focus_score - 2;
if (min_score < 0)
min_score = 0;
int min_value = focus_score + (min_score) * 2;
int surprise_value = focus_score * 3 - 3;
for (int j = 0; j < Integer.parseInt(str[0]); j++) {
if (Integer.parseInt(str[3 + j]) < min_value) {
continue;
} else if (Integer.parseInt(str[3 + j]) <= surprise_value) {
if (count > 0) {
count -= 1;
res += 1;
} else
continue;
} else {
res += 1;
}
}
out.writeBytes("Case #" + (i + 1) + ": " + res);
out.writeBytes("\n");
}
}
}
| 0 | 1,189,134 |
A11759 | A10815 | 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.*;
/**
*
* @author ankush
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args)throws IOException {
//System.out.println(Math.floor(Math.log10(11)));
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
int ans[]=new int[t];
for(int i=0;i<t;i++)
{
String x=br.readLine();
String r[]=new String[250];
r=x.split(" ");
int n=Integer.parseInt(r[0]);
int s=Integer.parseInt(r[1]);
int p=Integer.parseInt(r[2]);
int count=0;
int arr[]=new int[n];
for(int j=0;j<n;j++)
{
arr[j]=Integer.parseInt(r[j+3]);
}
int pos[]=new int[n];
for(int j=0;j<n;j++)
{
int max=0,a=0,b=0,c=0;
for(a=p;a<11;a++)
{
for(b=0;b<11;b++)
{
c=(arr[j]-a-b);
if(c>=0 && Math.abs(a-b)<2 && Math.abs(a-c)<2 && Math.abs(c-b)<2)
{
max=Math.max(a, b);
max=Math.max(max,c);
if(max >= p && pos[j]!=1)
{
count++;
pos[j]=1;
// System.out.println(arr[j]+" "+a+" "+b+" "+c);
a=100;b=100;
break;
}
}
}
}
if(a==11)
{
for(a=p;a<11;a++)
{
for(b=0;b<11;b++)
{
c=(arr[j]-a-b);
if(c>=0 && Math.abs(a-b)<3 && Math.abs(a-c)<3 && Math.abs(c-b)<3)
{
max=Math.max(a, b);
max=Math.max(max,c);
if(max >= p && s>0 && pos[j]!=1)
{
s--;
count++;
pos[j]=1;
// System.out.println(arr[j]+" "+a+" "+b+" "+c+" "+s);
a=11;b=11;
break;
}
}
}
}
}
}/*
if(s>0)
{
for(int j=0;j<n;j++)
{
if(pos[j]==1)
{
int max=0,a=0,b=0,c=0;
for(a=0;a<11;a++)
{
for(b=0;b<11;b++)
{
c=(arr[j]-a-b);
if(c>=0 && Math.abs(a-b)==2 || Math.abs(a-c)==2 || Math.abs(c-b)==2)
{
max=Math.max(a, b);
max=Math.max(max,c);
if(max >= p && pos[j]==1)
{
s--;
// System.out.println(arr[j]+" "+a+" "+b+" "+c);
a=100;b=100;
break;
}
}
}
}
}
}
}*/
ans[i]=count;
//System.out.println(x+" "+ans[i]+" "+s);
}
for(int i=0;i<t;i++)
{
System.out.println("Case #"+(i+1)+": "+ans[i]);
}
}
} | 0 | 1,189,135 |
A11759 | A11393 | 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 Dance
{
public static void main(String args[]) throws Exception
{
int N,S,T,p,ti;
Scanner in = new Scanner( System.in );
T = in.nextInt();
int pos = 1;
while( pos <= T )
{
N = in.nextInt(); // Number of idiots
S = in.nextInt(); // Number of times a judge was biased
p = in.nextInt(); // The best result we are looking for
int count = 0;
int test_1 = Math.max(p * 3 - 2 , p );
int test_2 = Math.max( test_1 - 2 , p);
for( int i = 0 ; i < N ;i++)
{
ti = in.nextInt();
if( ti >= test_1 )
{
count++;
}else if( S > 0 && ti >= test_2 )
{
S--;
count++;
}
}
System.out.println("Case #" + pos + ": " + count);
pos++;
}
}
} | 0 | 1,189,136 |
A11759 | A10727 | 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 code;
/**
*
* @author Yogendra
*/
import java.io.*;
import java.util.Scanner;
public class second {
static int x,y,z;
public static void main(String[] args) throws IOException {
File f = new File("input2.txt");
Scanner s = new Scanner(f);
int num = s.nextInt();
for (int i=0;i<num;i++)
{
int gglr=s.nextInt(); // number of googlers
int surp=s.nextInt(); //number of surprising triplet
int p=s.nextInt(); // least best score
int result=0;
int n,m=0;
for(int j=0;j<gglr;j++)
{
n=s.nextInt();
if(n%3==0)
{
x=y=z=n/3;
if(x>=p)
{
result++;
}
else
{
if(m<surp)
{
if(x!=0)
{
x--;
y++;
if(y>=p)
{
result++;
m++;
}
}
}
}
}
else
{
x=y=z=n/3;
if((n-(x+y+z))==1)
{
y++;
}
else
{
if((n-(x+y+z))==2)
{
y++;
z++;
}
}
if(y>=p)
{
result++;
}
else
{
if(m<surp)
{
if(x==z)
{
if(x!=0)
{
x--;
z++;
if(y >= p || z>=p)
{
result++;
m++;
}
}
}
else
{
z--;
y++;
if(y >= p|z>=p)
{
result++;
m++;
}
}
}
}
}
//System.out.println("X "+x +" y "+y+" z " +z+" #");
}
System.out.println("Case #"+(i+1)+": "+result);
}}}
| 0 | 1,189,137 |
A11759 | A11592 | 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) throws Exception {
BufferedReader in = new BufferedReader(new FileReader(args[0]));
in.readLine();
String[] segments;
int[] scores;
int numCase = 0;
while (in.ready()) {
segments = in.readLine().split(" ");
scores = new int[segments.length - 3];
for (int i = 0; i < scores.length; ++i) {
scores[i] = Integer.parseInt(segments[i + 3]);
}
solve(++numCase, Integer.parseInt(segments[1]), Integer.parseInt(segments[2]), scores);
}
}
private static void solve(int caseNum, int s, int p, int[] scores) {
int max = 0;
if (p == 0) {
max = scores.length;
} else if (p == 1) {
for (int i = 0; i < scores.length; ++i) {
if (scores[i] >= 1) {
++max;
}
}
} else {
int limit1 = (p - 2) * 3 + 2;
int limit2 = limit1 + 1;
int needS = 0;
int score;
for (int i = 0; i < scores.length; ++i) {
score = scores[i];
if (score < limit1) {
continue;
}
if (score <= limit2) {
++ needS;
continue;
}
++max;
}
max += Math.min(needS, s);
}
System.out.printf("Case #%d: %d\n", caseNum, max);
}
} | 0 | 1,189,138 |
A11759 | A10278 | 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 gcj;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
public class Gcj {
private static final String path = "/home/me/dev/gcj/";
private BufferedReader br = null;
private String[] tokens;
private int itoken,ntokens;
static public void err(String e) {
System.out.println("\n**\n"+e+" :-)\n");
System.exit(1);
}
public Gcj(String filename) {
try {
br = new BufferedReader(new FileReader(path + filename));
}
catch (Exception e) {
e.printStackTrace();
}
}
public String rawLine() {
String line = null;
try {
line = br.readLine();
}
catch (Exception e) {
e.printStackTrace();
}
return line;
}
public String[] readLine() {
String line = rawLine();
if (line == null) {
tokens = null;
ntokens = 0;
}
else {
tokens = line.trim().split("\\s+");
ntokens = tokens.length;
}
itoken = 0;
return tokens;
}
private String nextToken() {
String err = null;
if (ntokens < 1) err = "There is no token";
else if (itoken >= ntokens) err = "No more token";
else {
return tokens[itoken++];
}
Gcj.err(err);
return null;
}
public String sToken() {
return nextToken();
}
public String[] sBunch() {
String[] l = new String[ntokens-itoken];
int i=0;
while (itoken < ntokens) l[i++] = tokens[itoken++];
return l;
}
public char cToken() {
return nextToken().charAt(0);
}
public char[] cBunch() {
char[] l = new char[ntokens-itoken];
int i = 0;
while (itoken < ntokens) l[i++] = tokens[itoken++].charAt(0);
return l;
}
public int iToken() {
return Integer.parseInt(nextToken());
}
public int[] iBunch() {
int[] l = new int[ntokens-itoken];
int i = 0;
while (itoken < ntokens) l[i++] = Integer.parseInt(tokens[itoken++]);
return l;
}
public long lToken() {
return Long.parseLong(nextToken());
}
public long[] lBunch() {
long[] l = new long[ntokens-itoken];
int i = 0;
while (itoken < ntokens) l[i++] = Long.parseLong(tokens[itoken++]);
return l;
}
public double dToken() {
return Double.parseDouble(nextToken());
}
public double[] dBunch() {
double[] l = new double[ntokens-itoken];
int i = 0;
while (itoken < ntokens) l[i++] = Double.parseDouble(tokens[itoken++]);
return l;
}
// --
public void terminate() {
try {
if (br != null) br.close();
}
catch (Exception e) {
e.printStackTrace();
}
System.out.println("");
}
// --- OUTPUT ---
public static void outcase(int n, boolean rc) {
System.out.print("Case #" + n + ": ");
if (rc) System.out.print("\n");
}
}
| 0 | 1,189,139 |
A11759 | A12941 | 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 dance
{
public static void main(String[] args) throws Exception
{
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File("dance.in"))));
PrintStream out = new PrintStream(new File("dance.out"));
int cases = Integer.parseInt(in.readLine());
StringTokenizer s1;
int quant, surp, score, specnum1, specnum2, total, surpcount, with, without;
int[] scores;
for(int x = 0; x < cases; x++){
s1 = new StringTokenizer(in.readLine(), " ");
quant = Integer.parseInt(s1.nextToken());
surp = Integer.parseInt(s1.nextToken());
score = Integer.parseInt(s1.nextToken());
scores = new int[quant];
total = 0;
surpcount = 0;
for(int y = 0; y < quant; y++){
scores[y] = Integer.parseInt(s1.nextToken());
with = maxWith(scores[y]);
without = maxWithout(scores[y]);
if(without >= score)
total++;
else if(surpcount < surp){
if(with >= score){
total++;
surpcount++;
}
}
}
out.println("Case #" + (x+1) + ": " + total);
}
}
public static int maxWith(int num)
{
int base = num/3;
int rem = num%3;
if(num == 0)
return 0;
else if(rem == 0)
return (base+1);
else if(rem == 1)
return (base+1);
else
return (base+2);
}
public static int maxWithout(int num)
{
int base = num/3;
int rem = num%3;
if(rem == 0)
return base;
else
return (base+1);
}
} | 0 | 1,189,140 |
A11759 | A11556 | 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 cj2012;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
public class b {
static PrintWriter pw;
static int testOut = 1;
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(new FileReader(
"C://CODEJAM//2012//B-small-0.in"));
pw = new PrintWriter(new FileWriter("C://CODEJAM//2012//B-small-0.out"));
int ntest = sc.nextInt();
for (int test = 1; test <= ntest; ++test) {
int N = sc.nextInt();
int S = sc.nextInt();
int p = sc.nextInt();
// System.out.print(N+"."+S+"."+p+".");
int y = 0;
for (int i = 1; i <= N; i++) {
int t = sc.nextInt();
// System.out.print(t+",");
if (t >= p) {
if (t >= ((3 * p) - 2)) {
y++;
} else if ((t >= ((3 * p) - 4)) && (S > 0)) {
y++;
S--;
}
}
}
// System.out.println();
wc("" + y);
}
pw.close();
sc.close();
System.out.println("finished");
}
private static void wc(String text) {
String tt = "Case #" + testOut++ + ": " + text;
pw.print(tt);
pw.println();
System.out.println(tt);
}
}
| 0 | 1,189,141 |
A11759 | A12721 | 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.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class B {
private static void solve(String[] inp) {
int n = Integer.parseInt(inp[0]);
int s = Integer.parseInt(inp[1]);
int p = Integer.parseInt(inp[2]);
int[] mas = new int[n];
int countSure = 0;
int countUnsure = 0;
for(int i = 0; i<n; i++) {
mas[i] = Integer.parseInt(inp[i+3]);
boolean isSure = false;
boolean isUnsure = false;
m:for(int i1 = 0; i1<=10; i1++) {
for(int i2 = i1; i2<=10; i2++) {
int i3 = mas[i] - i1 - i2;
if(i3 < i2)continue;
if(i3 - i1 > 2)continue;
if(i3 >= p) {
if(i3 - i1 == 2) {
isUnsure = true;
} else {
isUnsure = isSure = true;
break m;
}
}
}
}
if(isSure)countSure++;
if(isUnsure)countUnsure++;
}
out.println(Math.min(countSure + s, countUnsure));
}
public static void main(String[] args) throws Exception {
int t = Integer.parseInt(inB.readLine());
for(int _ = 0; _<t; _++) {
out.print("Case #" + (_+1) + ": ");
solve(inB.readLine().split(" "));
}
out.flush();
}
// ///////////////////////////////////////////////////////////////
// IO
// ///////////////////////////////////////////////////////////////
private static StreamTokenizer in;
private static PrintWriter out;
private static BufferedReader inB;
private static boolean FILE = true;
private static int nextInt() throws Exception {
in.nextToken();
return (int) in.nval;
}
private static String nextString() throws Exception {
in.nextToken();
return in.sval;
}
static {
try {
out = new PrintWriter(FILE ? (new FileOutputStream("output.txt"))
: System.out);
inB = new BufferedReader(new InputStreamReader(
FILE ? new FileInputStream("B-small-attempt0.in") : System.in));
} catch (Exception e) {
e.printStackTrace();
}
in = new StreamTokenizer(inB);
}
// ///////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////
// pre - written
// ///////////////////////////////////////////////////////////////
private static void println(Object o) throws Exception {
out.println(o);
out.flush();
}
private static void exit(Object o) throws Exception {
println(o);
exit();
}
private static void exit() {
System.exit(0);
}
private static final int INF = Integer.MAX_VALUE;
private static final int MINF = Integer.MIN_VALUE;
// ////////////////////////////////////////////////////////////////
}
| 0 | 1,189,142 |
A11759 | A10361 | 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.*;
import java.awt.geom.*;
import static java.lang.Math.*;
public class Solution implements Runnable {
int sum1 []; // diff < 2
int sum2 []; // diff == 2
public void solve () throws Exception {
int tt = nextInt();
sum1 = new int [31];
sum2 = new int [31];
for (int num1 = 0; num1 <= 10; num1++)
for (int num2 = num1; num2 <= 10; num2++)
for (int num3 = num2; num3 <= 10; num3++) {
int sum = num1 + num2 + num3;
int diff = num3 - num1;
if (diff < 2) {
sum1 [sum] = max (sum1 [sum], num3);
} else if (diff == 2) {
sum2 [sum] = max (sum2 [sum], num3);
}
}
for (int test = 1; test <= tt; test++) {
int n = nextInt();
int s = nextInt();
int p = nextInt();
int d [][] = new int [n + 1][s + 1];
boolean can [][] = new boolean [n + 1][s + 1];
can [0][0] = true;
for (int i = 0; i < n; i++) {
int sum = nextInt();
int add1 = 0, add2 = 0;
int p1 = sum1[sum]; if (p1 >= p) add1 = 1;
int p2 = sum2[sum]; if (p2 >= p) add2 = 1;
for (int j = 0; j <= s; j++) {
if (can[i][j]) {
d[i + 1][j] = max (d[i + 1][j], d[i][j] + add1);
can[i + 1][j] = true;
if (j < s) {
d[i + 1][j + 1] = max (d[i + 1][j + 1], d[i][j] + add2);
can [i + 1][j + 1] = true;
}
}
}
}
out.println("Case #"+test+": "+d[n][s]);
}
}
final String fname = "";
long stime = 0;
BufferedReader in;
PrintWriter out;
StringTokenizer st;
private String nextToken () throws Exception {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(in.readLine());
}
return st.nextToken();
}
private int nextInt () throws Exception {
return Integer.parseInt(nextToken());
}
private long nextLong () throws Exception {
return Long.parseLong(nextToken());
}
private double nextDouble () throws Exception {
return Double.parseDouble(nextToken());
}
@Override
public void run() {
try {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter(new FileWriter("output.txt"));
solve ();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
out.close();
}
}
public static void main(String[] args) {
new Thread(null, new Solution(), "", 1<<26).start();
}
} | 0 | 1,189,143 |
A11759 | A12647 | 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 net.mauhiz.contest.codejam.qual2012;
import java.io.IOException;
import net.mauhiz.contest.codejam.CodejamLineChunkSolver;
public class DancingGoogler extends CodejamLineChunkSolver {
public static void main(String... args) throws IOException {
new DancingGoogler().run(args);
}
@Override
protected String doJamProblem(String[] chunks) {
int n = Integer.parseInt(chunks[0]);
int s = Integer.parseInt(chunks[1]);
int p = Integer.parseInt(chunks[2]);
int[] t = new int[n];
for (int i = 0; i < n; i++) {
t[i] = Integer.parseInt(chunks[3 + i]);
}
int y = solve(s, p, t);
return Integer.toString(y);
}
protected int solve(int s, int p, int[] t) {
log.fine("s " + s);
log.fine("p " + p);
int r = s; // remaining surprises
int y0 = 0, y1 = 0, y2 = 0;
int t0 = 0, t1 = 0, t2 = 0;
for (int i = 0; i < t.length; i++) {
int mod = t[i] % 3;
switch (mod) {
case 0:
t0++;
int m0 = t[i] / 3;
if (m0 >= p) {
y0++;
} else if (r > 0 && m0 + 1 == p && t[i] >= 3) {
// consume a surprise
r--;
y0++;
}
break;
case 1:
t1++;
int m1 = (t[i] + 2) / 3;
if (m1 >= p) {
y1++;
}
break;
case 2:
t2++;
int m2 = (t[i] + 1) / 3;
if (m2 >= p) {
y2++;
} else if (r > 0 && m2 + 1 == p) {
// consume a surprise
r--;
y2++;
}
break;
}
}
log.fine("r " + r);
log.fine("t0 " + t0);
log.fine("t1 " + t1);
log.fine("t2 " + t2);
log.fine("y0 " + y0);
log.fine("y1 " + y1);
log.fine("y2 " + y2);
return y0 + y1 + y2;
}
@Override
public String getName() {
return "DancingGoogler";
}
}
| 0 | 1,189,144 |
A11759 | A10027 | 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 WQ;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Problem_B {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
String filename = "B-small-attempt0 (1).in";
Scanner s = new Scanner(new FileReader(filename));
PrintWriter out = new PrintWriter("out.txt");
int num = s.nextInt();
for (int CASE = 1; CASE <= num; CASE++) {
int n = s.nextInt();
int sr = s.nextInt();
int p = s.nextInt();
int[] compet = new int[n];
for (int i = 0; i < n; i++) {
compet[i] = s.nextInt();
}
int count = 0;
for (int i = 0; i < compet.length; i++) {
int divide = compet[i] / 3;
int rem = compet[i] % 3;
if (divide >= p)
count++;
else {
if (rem == 0 && sr > 0 && divide > 0 && divide + 1 >= p) {
count++;
sr--;
} else if (rem == 1 && divide + 1 >= p) {
count++;
} else if (rem == 2) {
if (divide + 1 >= p)
count++;
else if (sr > 0 && divide + 2 >= p) {
count++;
sr--;
}
}
}
}
out.println("Case #" + CASE + ": " + count);
}
out.close();
}
}
| 0 | 1,189,145 |
A11759 | A12446 | 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 Palabras{
static int T;
static BufferedReader input;
static int [][] matrix;
static int [] valores;
static StringTokenizer token;
static String leerLinea() throws IOException
{
String linea = input.readLine();
if(linea!=null)
{
token = new StringTokenizer(linea," ");
}
return linea;
}
static String siguiente()
{
return token.nextToken();
}
static void escribirArchivo(String data) throws IOException
{
PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(data)));
for(int i=0; i<T; i++)
{
output.println("Case #"+(i+1)+": "+valores[i]);
}
output.close();
}
static int siguienteInt()
{
return Integer.parseInt(siguiente());
}
static int procesarDatos()
{
int val = 0;
int tmp=0;
int P =0;
int S =0;
int values[];
valores = new int [T];
for(int i=0; i<T; i++)
{
val=0;
tmp=0;
S = matrix[i][1];
P = matrix[i][2];
int m[][] = new int [(int)Math.pow(2, matrix[i][0])][matrix[i][0]];
for(int k=0; k<m.length; k++)
{
for(int l=0; l<m[k].length; l++)
{
if(k==0)
{
m[k][l] = 1;
}
else
{
m[k][l] = m[k-1][l];
}
}
m[k][m[k].length-1]++;
int v=m[k].length-1;
while(m[k][v]>2 && v>0)
{
m[k][v]=1;
v--;
m[k][v]++;
}
}
//Ya tengo la tabla de todos los posibles valores
int combinaciones=0;
combinaciones = (int)factorial(matrix[i][0]);
combinaciones /= (int)factorial(matrix[i][1]);
combinaciones /= (int)factorial(matrix[i][0]-matrix[i][1]);
int matrix2[][] = new int [combinaciones][matrix[i][0]];
int c=combinaciones;
//tengo el numero de combinaciones
//ahora sacare dichas combinacinoes
int pos=0;
while(c>0 && pos<(int)Math.pow(2,matrix[i][0]))
{
int suma=0;
for(int u=0; u<matrix[i][0]; u++)
{
suma= suma + m[pos][u];
}
suma = suma - matrix[i][0];
///System.out.println("Suma ="+suma );
if(suma == matrix[i][1])
{
for(int u=0; u<matrix[i][0]; u++)
{
matrix2[c-1][u] = m[pos][u];
//System.out.println("M : ("+c+","+u+")="+matrix2[c-1][u] );
}
c--;
///System.out.println("C ="+c );
}
pos++;
///System.out.println("pos ="+pos );
}
//ya tengo los valores combinados que son
int sumaTotal=0;
//ahora calculo los valores optimos
for(int p=0; p<matrix2.length; p++)
{
for(int q=0; q<matrix2[p].length; q++)
{
System.out.print(" "+matrix2[p][q] );
}
System.out.println();
}
///System.out.println("Combi="+ combinaciones);
for(int y=0; y<combinaciones; y++)
{
sumaTotal=0;
values = new int[ matrix[i][0] ];
for(int j=0; j<matrix[i][0]; j++)
{
if(matrix[i][j+3]%3==0 && (matrix2[y][j]==1 || matrix2[y][j]==0) )
{
values[j] = matrix[i][j+3]/3;
}
else if(matrix[i][j+3]%3==0 && matrix2[y][j]==2)
{
values[j] = 1 + (matrix[i][j+3]/3);
if(matrix[i][j+3]==0)
{ values[j]=0 ; }
}
else if(matrix[i][j+3]%3==1)
{
values[j] = (matrix[i][j+3]/3) + 1;
}
else if(matrix[i][j+3]%3==2 && (matrix2[y][j]==1 || matrix2[y][j]==0) )
{
values[j] = (matrix[i][j+3]/3) + 1;
}
else if(matrix[i][j+3]%3==2 && matrix2[y][j]==2)
{
values[j] = (matrix[i][j+3]/3) + 2;
}
}
System.out.print(" !_ ");
for(int p=0; p<values.length; p++)
{
System.out.print(" "+values[p]+ " ");
}
System.out.print(" _? ");
for(int t=0; t<matrix[i][0]; t++)
{
if(values[t]>= matrix[i][2])
{sumaTotal++;}
}
if( val < sumaTotal)
{val = sumaTotal;}
}
valores[i] = val;
val=0;
}
return val;
}
static double factorial(int x)
{
double multiplicador=1;
for(int i=x; i>1; i--){
multiplicador = multiplicador * i;}
return multiplicador;
}
public static void main(String[] args) throws IOException {
input = new BufferedReader(new FileReader(new File("prueba.in")));
//System.out.println("jd");
T = Integer.parseInt(leerLinea());
if(T<1 || T>100)
{
System.out.println("ERROR T");
}
valores = new int[T];
matrix = new int[T][];
for(int i=0; i<T; i++)
{
leerLinea();
int N=0;
N = siguienteInt();
matrix[i] = new int[N+3];
matrix[i][0]=N;
for(int j=1; j<N+3; j++)
{
matrix[i][j] = siguienteInt();
}
}
procesarDatos();
escribirArchivo("prueba.out");
}
}
| 0 | 1,189,146 |
A11759 | A10139 | 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 taskB {
PrintWriter out;
BufferedReader br;
StringTokenizer st;
String nextToken() throws IOException {
while ((st == null) || (!st.hasMoreTokens()))
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
public void solve() throws IOException {
int n = nextInt();
int s = nextInt();
int p = nextInt();
int ans = 0;
for (int i = 0; i < n; i++) {
int a = nextInt();
if (p > a)
continue;
if (p * 3 - 2 <= a) {
ans++;
continue;
}
if (s == 0)
continue;
if (p * 3 - 4 <= a) {
s--;
ans++;
}
}
out.println(ans);
}
public void run() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
br = new BufferedReader(new FileReader("taskB.in"));
out = new PrintWriter("taskB.out");
int n = nextInt();
for (int i = 0; i < n; i++) {
out.print("Case #" + (i + 1) + ": ");
solve();
}
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new taskB().run();
}
}
| 0 | 1,189,147 |
A11759 | A11614 | 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 ProbB
{
public static void main (String[] args) throws Exception
{
MyInputReader in = new MyInputReader(new FileInputStream("B-small-attempt2.in"));
PrintWriter pw = new PrintWriter("output.txt");
int T = in.nextInt();
for(int q=0; q<T; q++)
{
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int result = 0;
int count = 0;
for(int i=0; i<n; i++)
{
int temp = in.nextInt();
if(temp==0 && p>0)
continue;
if(3*p<=temp || 3*p-2==temp || 3*p-1==temp)
result++;
else if(count<s && ((3*p-3)==temp || (3*p-4)==temp || (3*p+4)==temp || (3*p+3)==temp))
{
result++;
count++;
}
}
pw.println("Case #"+(q+1)+": "+result);
pw.flush();
}
}
static class MyInputReader
{
final private int BUFFER_SIZE = 1 << 17;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public MyInputReader(InputStream in)
{
din = new DataInputStream(in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String nextString() throws Exception
{
StringBuffer sb=new StringBuffer("");
byte c = read();
while(c <= '\n')
c = read();
do
{
sb.append((char)c);
c=read();
}
while(c>'\n');
return sb.toString();
}
public String nextWord() throws Exception
{
StringBuffer sb=new StringBuffer("");
byte c = read();
while(c <= ' ')
c = read();
do
{
sb.append((char)c);
c=read();
}
while(c>' ');
return sb.toString();
}
public char nextChar() throws Exception
{
byte c=read();
while(c<=' ')
c= read();
return (char)c;
}
public int nextInt() throws Exception
{
int ret = 0;
byte c = read();
while(c <= ' ')
c = read();
boolean neg = c == '-';
if(neg)
c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
}
while (c > ' ');
if(neg)
return -ret;
return ret;
}
public long nextLong() throws Exception
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = c == '-';
if(neg)
c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
}
while (c > ' ');
if(neg)
return -ret;
return ret;
}
private void fillBuffer() throws Exception
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if(bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws Exception
{
if(bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
}
} | 0 | 1,189,148 |
A11759 | A11023 | 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.concurrent.Callable;
import java.util.concurrent.Future;
import fixjava.ParallelWorkQueue.CallableFactory;
public class ArrayStats {
public final double[][] data;
public final int n, k;
private double[][] centered;
private double[] mean;
private double[][] cov;
private double[] stddev = null;
private double[][] corr = null;
/** Calculate covariance matrix */
public ArrayStats(double[][] data) {
if (data == null || data.length < 2 || data[0].length < 2)
throw new IllegalArgumentException("Invalid data");
this.data = data;
this.n = data.length;
this.k = data[0].length;
}
/** Compute mean for each dimension */
public double[] mean() {
if (mean == null) {
mean = new double[k];
for (int dim = 0; dim < k; dim++) {
double tot = 0;
for (int pt = 0; pt < n; pt++)
tot += data[pt][dim];
mean[dim] = tot / n;
}
}
return mean;
}
/** Compute stddev for each dimension */
public double[] stddev() {
if (stddev == null) {
// Make sure means are computed
mean();
stddev = new double[k];
for (int dim = 0; dim < k; dim++) {
for (int pt = 0; pt < n; pt++) {
double diff = data[pt][dim] - mean[dim];
stddev[dim] += diff * diff;
}
stddev[dim] = Math.sqrt(stddev[dim] / n);
}
}
return stddev;
}
/** Re-center data by subtracting mean from each dimension */
public double[][] centered() {
if (centered == null) {
// Make sure means are computed
mean();
centered = new double[n][k];
for (int pt = 0; pt < n; pt++)
for (int dim = 0; dim < k; dim++)
centered[pt][dim] = data[pt][dim] - mean[dim];
}
return centered;
}
/** Compute covariance matrix */
public double[][] cov() {
if (cov == null) {
// Make sure centered version of data is computed
centered();
// Work on transposed array for cache coherence
final double[][] centeredT = ArrayUtils.transpose(centered);
cov = new double[k][k];
try {
//final DecimalFormat formatPercent1dp = new DecimalFormat("0.0%");
for (Future<Void> res : new ParallelWorkQueue<Integer, Void>(/* numThreads = */25,
ParallelWorkQueue.makeIntRangeIterable(k), new CallableFactory<Integer, Void>() {
//IntegerMutable counter = new IntegerMutable();
@Override
public Callable<Void> newInstance(final Integer ii) {
return new Callable<Void>() {
int dim1 = ii.intValue();
double[][] centeredTLocal = centeredT;
double[][] covLocal = cov;
@Override
public Void call() {
for (int dim2 = dim1; dim2 < k; dim2++) {
double numer = 0.0;
for (int pt = 0; pt < n; pt++)
numer += centeredTLocal[dim1][pt] * centeredTLocal[dim2][pt];
int denom = n - 1;
covLocal[dim1][dim2] = covLocal[dim2][dim1] = denom == 0 ? 0 : numer / denom;
}
// int count = counter.increment();
// if (count % 10 == 0)
// System.out.println(formatPercent1dp.format((count / (float) (k - 1))));
return null;
}
};
}
}))
// Barricade
res.get();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
return cov;
}
/** Compute correlation matrix */
public double[][] corr() {
if (corr == null) {
// Make sure per-dim stddevs and covariance matrix are computed
stddev();
cov();
corr = new double[k][k];
for (int dim1 = 0; dim1 < k; dim1++) {
for (int dim2 = dim1; dim2 < k; dim2++) {
double prod = stddev[dim1] * stddev[dim2];
corr[dim1][dim2] = corr[dim2][dim1] = prod == 0.0 ? 0.0 : cov[dim1][dim2] / prod;
}
}
}
return corr;
}
}
| 0 | 1,189,149 |
A11759 | A10769 | 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.util.regex.*;
import static java.lang.Math.*;
public class B {
public class Tripple {
Integer t1, t2, t3;
public Tripple() {
}
@Override
public String toString() {
return "(" + t1 + ", " + t2 + ", " + t3 + ")";
}
}
public static void main(String[] args) throws Exception {
B b = new B();
b.run(args);
}
public void run(String[] args) throws Exception {
Scanner in = (args.length > 0) ? new Scanner(new File(args[0])) : new Scanner(System.in);
int T = in.nextInt();
for(int zz = 1; zz <= T;zz++){
System.err.format("#%d\n", zz);
System.out.format("Case #%d: ", zz);
int N = in.nextInt();
int S = in.nextInt();
int s = S;
int p = in.nextInt();
int tps[] = new int[N];
int count = 0;
for (int n = 0; n < N; n++) {
tps[n] = in.nextInt();
Tripple tripple = new Tripple();
int tp = tps[n];
s = tripple(tp, p, s, tripple);
if (s >= 0 && tripple.t1 != null && tripple.t1 >= p) {
count++;
}
System.err.println(tp + "_" + p + " : " + tripple + " ... " + s + " c: " + count);
}
System.out.format("%d\n", count);
}
}
private int tripple(int tp, int p0, int s, Tripple t) {
if (s < 0 || tp < p0) {
t.t1 = null;
return s;
}
int p = p0;
boolean possible1 = false;
while(!possible1) {
possible1 = true;
int r = tp;
t.t1 = p;
r -= p;
int p2 = p;
boolean possible = false;
int run = 0;
while(!possible) {
run++;
t.t2 = p2;
int r2 = r - p2;
t.t3 = r2;
if (t.t2 + 1 >= p && t.t3 + 1 >= p) {
possible = true;
} else if (t.t2 + 2 >= p && t.t3 + 2 >= p && run > 1) {
if (s <= 0) {
p--;
possible1 = false;
} else {
s--;
}
possible = true;
} else if (p2 < 1) {
t.t1 = null;
return s;
} else {
p2--;
}
}
if (t.t3 > p) {
p++;
possible1 = false;
}
}
return s;
}
}
| 0 | 1,189,150 |
A11759 | A12165 | 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 client;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.math.*;
public class DancingGoogler {
public DancingGoogler() {
super();
}
public static void main(String[] args) throws FileNotFoundException,
IOException {
DancingGoogler dancingGoogler = new DancingGoogler();
FileReader fr = new FileReader("B-small-attempt3.in");
//FileReader fr = new FileReader("A-small-practice.in");
BufferedReader br = new BufferedReader(fr);
String noofT = br.readLine();
int noOfTestCases = Integer.parseInt(noofT);
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
for (int i=0; i < noOfTestCases; i++ ){
StringTokenizer st = new StringTokenizer(br.readLine()," ");
String nofG = st.nextToken();
int noOfGooglers = Integer.parseInt(nofG);
String nofS = st.nextToken();
int noOfSurprises = Integer.parseInt(nofS);
String p = st.nextToken();
int P = Integer.parseInt(p);
int cnt = 0;
int cntS =0;
int[] cntr = new int[noOfGooglers];
forloop: for (int j=0 ; j < noOfGooglers; j++){
String jG = st.nextToken();
int totjG = Integer.parseInt(jG);
int q = totjG/3;
int r = totjG%3;
int[][] ar = new int[100][3];
boolean flagr = false;
if (r == 0){
ar[0][0] = q;
ar[0][1] = q;
ar[0][2] = q;
for(int k=0;k<3;k++){
if (ar[0][k] >= P)
cntr[j] = cntr[j] + 1;
}
}
if (q+1 <= 10){
if (Math.abs(totjG - q - q - 1 - q) <= 1 && Math.abs(totjG - q - q - 1 - q -1) <=1 ){
ar[0][0] = q;
ar[0][1] = q+1;
ar[0][2] = totjG - q - q - 1;
for(int k=0;k<3;k++){
if (ar[0][k] >= P)
cntr[j] = cntr[j] + 1;
}
}
}
for (int k=0;k<j;k++){
if (cntr[k] >= 2)
flagr= true;
// System.out.println("cntr =" + cntr[k]);
}
if (noOfSurprises > 0 && ((cntS < noOfSurprises) || (flagr == true))){
if (q + 1 <= 10 && q-1>=0){
if (( Math.abs(totjG - 2*q - q + 1) <= 2) && (Math.abs(totjG-2*q - q -1) <= 2)){
ar[1][0] = q + 1;
ar[1][1] = q-1;
ar[1][2] = totjG - 2*q;
for(int k=0;k<3;k++){
if (ar[1][k] >= P){
cntr[j] = cntr[j] + 1;
cntS++;
break;
}
}
}
}
if (q+2 <= 10){
if ((Math.abs(totjG - q- q -2 - q) <= 2) && (Math.abs(totjG - q- q -2 - q -2) <=2)){
ar[1][0] = q;
ar[1][1] = q+2;
ar[1][2] = totjG- q - q -2;
for(int k=0;k<3;k++){
if (ar[1][k] >= P){
cntr[j] = cntr[j] + 1;
cntS++;
break;
}
}
}
}
}
for (int m=0;m < 2; m++){
for(int n = 0; n < 3;n++){
System.out.print(ar[m][n]);
}
System.out.println("");
}
int val=0;
for (int m=0;m <2; m++){
for(int n = 0; n < 3;n++){
val = ar[m][n];
if (ar[m][n] >= P){
cnt++;
break;
}
}
if (val >= P)
break;
}
}
String out = "Case #" + (i+1) + ": " + cnt;
bw.write(out);
bw.newLine();
System.out.println("Case #" + (i+1) + ": " + cnt);
}
bw.close();
}
}
| 0 | 1,189,151 |
A11759 | A10084 | 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.FileReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
public class googler {
private static File f = new File("C:/Users/Cybermask/Desktop/myfile.txt");
private static File outfile = new File("C:/Users/Cybermask/Desktop/out.txt");
private static BufferedReader reader;
private static int getMaximum(int element,int surprisingindex){
if(element==0)return 0;
boolean surprising;
if(surprisingindex==0)surprising=false;
else surprising=true;
if(!surprising){
if(element%3 ==0)return element/3;
if(element%3 ==1)return ((element-1)/3)+1;
else return ((element-2)/3)+1;
}else{
if(element%3 ==0 )return (element/3)+2;
else if(element%3 == 1 ) return ((element-1)/3)+2;
else return ((element-2)/3)+2;
}
}
private static String read() throws Exception{
return reader.readLine();
}
private static int toint(String s){
return Integer.parseInt(s);
}
private static ArrayList<Object> reverse(ArrayList<Object>list){
ArrayList<Object> result = new ArrayList<Object>();
for(int i=0;i<list.size();i++)
result.add(list.get(list.size()-i-1));
return result;
}
/* private static int count(int element){
int count=0;
while(true){
count+=element%2;
element=(int)(element/2.0);
if(element==0)return count;
}
}*/
private static int[] count = new int[100];
public static void main(String args[])throws Exception{
//System.out.println(getMaximum(23,1)+":"+getMaximum(23,0));
reader = new BufferedReader(new FileReader(f));
BufferedReader countreader = new BufferedReader(new FileReader("C:/Users/Cybermask/Desktop/count.txt"));
for(int i=0;i<100;i++)count[i]=toint(countreader.readLine());
PrintWriter pw = new PrintWriter(outfile);
int n = toint(read());
for(int i=0;i<n;i++){
Scanner scanner = new Scanner(read());
scanner.useDelimiter(" ");
int googlerscount = scanner.nextInt();
int surprising = scanner.nextInt();
int max = scanner.nextInt();
int googlers [] =new int[googlerscount];
for(int k=0;k<googlerscount;k++)googlers[k]=scanner.nextInt();
int totalmax=0;
//if(googlerscount>3)googlerscount=3;
int total = (int)Math.pow(2,googlerscount);
for(int j=0;j<total;j++){
if(count[j]!=surprising)continue;
int max1=0;
int jc = j;
int z = 0;
int o = ((int)(j/2.0))%2;
int t = ((int)(j/4.0))%2;
/* if(getMaximum(googlers[0],z)>=max)max1=1;
if(googlerscount>1)if(getMaximum(googlers[1],o)>=max)max2=1;
if(googlerscount>2)if(getMaximum(googlers[2],t)>=max)max3=1;*/
for(int k=0;k<googlerscount;k++){
z = jc%2;
if(getMaximum(googlers[k],z)>=max)max1++;
jc = (int)(jc/2.0);
}
if(max1>totalmax)totalmax=max1;
}
pw.println("Case #"+(i+1)+": "+totalmax);
}
pw.flush();
}
}
| 0 | 1,189,152 |
A11759 | A10550 | 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.PrintWriter;
import java.util.StringTokenizer;
public class DancingWithTheGooglers {
static int N,S,p;
static int t[];
static int solve() {
int i,j,k;
int a,b,c;
int opt[][] = new int[N+1][S+1];
boolean canMakeOne, goodScoreCaseOneBigger, goodScoreCaseOneSmaller;
boolean canMakeTwo, goodScoreCaseTwoBigger, goodScoreCaseTwoSmaller;
for (i=1;i<=N;i++) {
// we need to get t[i]
canMakeOne = false;
goodScoreCaseOneBigger = false;
goodScoreCaseOneSmaller = false;
canMakeTwo = false;
goodScoreCaseTwoBigger = false;
goodScoreCaseTwoSmaller = false;
for (a=0;a<=10;a++) {
for (b=a;(b<=a+2)&&(b<=10);b++) {
for (c=b;(c<=a+2)&&(c<=10);c++) {
if ((a+b+c) == t[i]) {
if ((c-a) <= 1) {
canMakeOne = true;
if (c >= p)
goodScoreCaseOneBigger = true;
else
goodScoreCaseOneSmaller = true;
} else {
canMakeTwo = true;
if (c >= p)
goodScoreCaseTwoBigger = true;
else
goodScoreCaseTwoSmaller = true;
}
}
}
}
}
if (canMakeOne == true) {
if (goodScoreCaseOneBigger == true) {
for (j=0;j<=S;j++) {
opt[i][j] = Math.max(opt[i][j], opt[i-1][j]+1);
}
}
if (goodScoreCaseOneSmaller == true) {
for (j=0;j<=S;j++) {
opt[i][j] = Math.max(opt[i][j], opt[i-1][j]);
}
}
}
if (canMakeTwo == true) {
if (goodScoreCaseTwoBigger == true) {
for (j=1;j<=S;j++) {
opt[i][j] = Math.max(opt[i][j], opt[i-1][j-1]+1);
}
}
if (goodScoreCaseTwoSmaller == true) {
for (j=1;j<=S;j++) {
opt[i][j] = Math.max(opt[i][j], opt[i-1][j-1]);
}
}
}
}
return opt[N][S];
}
public static void main(String[] args) throws Exception {
int i,j,k;
BufferedReader br = new BufferedReader(new FileReader("B-small.in"));
PrintWriter out = new PrintWriter("B-small.out");
StringTokenizer st;
int T = Integer.parseInt(br.readLine());
for (k=1;k<=T;k++) {
st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
S = Integer.parseInt(st.nextToken());
p = Integer.parseInt(st.nextToken());
t = new int[N+1];
for (i=1;i<=N;i++)
t[i] = Integer.parseInt(st.nextToken());
out.println("Case #"+k+": "+solve());
}
out.close();
}
}
| 0 | 1,189,153 |
A11759 | A10093 | 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.codejam2012;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileUtils {
public static String readFile(String fileName){
FileReader reader = null;
String temp = null;
try {
reader = new FileReader(fileName);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
StringBuffer strContent = new StringBuffer("");
try
{
BufferedReader bufferedReader = new BufferedReader(reader);
temp =bufferedReader.readLine();
while (temp != null)
{
strContent.append(temp + "\n");
temp =bufferedReader.readLine();
}
}
catch (Exception e)
{
System.out.println(e);
}
return strContent.toString();
}
public static void appendToFile(String outputFileName, String dataToPrint) {
File file =new File(outputFileName);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
FileWriter fileWritter;
try {
fileWritter = new FileWriter(outputFileName,true);
BufferedWriter bufferWritter = new BufferedWriter(fileWritter);
bufferWritter.write(dataToPrint);
bufferWritter.close();
fileWritter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deleteFile(String outputFileName) {
File file =new File(outputFileName);
if(file.exists()){
file.delete();
}
}
}
| 0 | 1,189,154 |
A11759 | A11006 | 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.awt.image.BufferStrategy;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Scanner;
public class DancingGooglers {
public static void main(String[] args) {
File file = new File("C:\\Users\\aadi\\Desktop\\DancingGooglers\\B-small-attempt0.in");
try{
FileWriter fstream = new FileWriter("C:\\Users\\aadi\\Desktop\\DancingGooglers\\out.txt");
BufferedWriter out = new BufferedWriter(fstream);
Scanner scanner = new Scanner(file);
int numOfCases = Integer.parseInt(scanner.nextLine());
for(int i =0 ;i< numOfCases ; i++){
int sCount= 0;
int non_sCount = 0;
String line = scanner.nextLine();
Scanner scanner2 = new Scanner(line);
scanner2.useDelimiter(" ");
int n = scanner2.nextInt();
int s = scanner2.nextInt();
int p = scanner2.nextInt();
while(scanner2.hasNext()){
int tot = scanner2.nextInt();
if(tot>=Math.max((p*3-2), 0)){
non_sCount++;
}else if(tot>=(p + Math.max((p-2),0) + Math.max((p-2),0)) ){
sCount++;
}
}
out.write("Case #"+(i+1)+": ");
if(sCount<s){
//System.out.println(non_sCount+sCount);
out.write(""+(non_sCount+sCount));
}else{
//System.out.println(non_sCount+s);
out.write(""+(non_sCount+s));
}
//System.out.println("");
out.write(System.getProperty("line.separator"));
}
out.close();
}catch(FileNotFoundException f){
f.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
}
}
| 0 | 1,189,155 |
A11759 | A11984 | 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 static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.util.Arrays.fill;
import java.io.*;
import java.math.BigInteger;
import java.util.StringTokenizer;
public class B {
static BufferedReader in;
static PrintWriter out;
static StringTokenizer tok;
static void solveTest() throws Exception {
int N = nextInt();
int S = nextInt();
int p = nextInt();
int res = 0;
for(int i = 0;i< N;i++){
int t = nextInt();
int sho = t / 3;
int rem = t % 3;
if(t == 30 || t == 0){
if(sho >= p) res++;
continue;
}
else if( t == 29){
if(sho + 1 >= p) res++;
continue;
}
if( rem == 1){
if(sho + 1 >= p) res++;
}
else
{
int border;
if(rem == 0) border = sho;
else border = sho + 1;
if(border >= p) res++;
else if( border + 1 == p){
if(S > 0){
S--;
res++;
}
}
}
}
out.printf("%d\n", res);
}
static void solve() throws Exception {
int tests = nextInt();
for (int test = 1; test <= tests; test++) {
out.print("Case #" + test + ": ");
solveTest();
}
}
public static void main(String[] args) throws Exception {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
solve();
in.close();
out.close();
}
static String next() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine()," \r\n\t\f");
}
return tok.nextToken();
}
static char nextChar() throws IOException {
String token = next();
if (token.length() != 1) {
throw new IllegalArgumentException("String \"" + token + "\" is not a single character");
}
return token.charAt(0);
}
static int nextInt() throws IOException {
return parseInt(next());
}
static long nextLong() throws IOException {
return parseLong(next());
}
static BigInteger nextBigInt() throws IOException {
return new BigInteger(next());
}
} | 0 | 1,189,156 |
A11759 | A10332 | 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 QR_2012;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import Utils.IOStreams;
public class B_Dancing_With_The_Googlers {
public static void main(String[] args) throws IOException {
IOStreams streams = new IOStreams(args[0]);
System.setIn(new FileInputStream(args[0]));
Scanner sc = new Scanner(System.in);
sc.nextLine(); // Skip number of cases
int caseNumber = 1;
while (sc.hasNextInt()) {
int numberOfGooglers = sc.nextInt();
int surprisingTriplets = sc.nextInt();
int minimumScore = sc.nextInt();
List<Integer> totalPoints = new ArrayList<Integer>();
for(int i=0 ; i<numberOfGooglers ; i++){
totalPoints.add(sc.nextInt());
}
streams.printLine("Case #" + (caseNumber++) + ": " + solveIt(numberOfGooglers, surprisingTriplets, minimumScore, totalPoints) + "\n");
}
streams.closeStreams();
}
private static int solveIt(int numberOfGooglers, int surprisingTriplets, int minimumScore, List<Integer> totalPoints) {
int solution = 0;
for (Integer integer : totalPoints) {
if(integer==0){
if(minimumScore==0) solution++;
continue;
}
if(integer%3!=0){
if((integer/3+1)>=minimumScore)
solution++;
else if(integer/3+1<minimumScore && (integer/3)+(integer%3)>=minimumScore && surprisingTriplets>0){
solution++;
surprisingTriplets--;
}
}
else if (integer%3==0){
if(integer/3>=minimumScore)
solution++;
else if(integer/3<minimumScore && integer/3+1>=minimumScore && surprisingTriplets>0){
solution++;
surprisingTriplets--;
}
}
}
return solution;
}
}
| 0 | 1,189,157 |
A11759 | A11849 | 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 DancingWithTheGooglers extends ProgrammingProblem
{
static int min[] = { 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10 };
static int max[] = { 0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 10 };
int N, S, p, t[];
@Override
protected void print()
{
}
@Override
protected void readInput()
{
N = sc.nextInt();
S = sc.nextInt();
p = sc.nextInt();
t = new int[N];
for (int i = 0; i < N; i++)
{
t[i] = sc.nextInt();
}
}
@Override
protected String execute()
{
int c = 0;
for (int i = 0; i < N; i++)
{
if (min[t[i]] >= p || (max[t[i]] >=p && S-- > 0 ))
{
c++;
}
}
return c + "";
}
public static void main(String[] args) throws Exception
{
DEBUG = false;
main(DancingWithTheGooglers.class);
}
}
| 0 | 1,189,158 |
A11759 | A12753 | 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 Dancing
{
public static void main(String[] args) throws FileNotFoundException
{
Scanner sc = new Scanner(new File("inputs/dancing.in"));
int cases = sc.nextInt();
for (int i = 1; i <= cases; i++)
{
int googs = sc.nextInt();
int surprises = sc.nextInt();
int min = sc.nextInt();
int num = 0;
for (int j = 0; j < googs; j++)
{
int curr = sc.nextInt();
int remain = curr - min;
if (remain < 0)
{
continue;
}
else if (remain / 2 >= (min - 1))
{
num++;
}
else if (surprises > 0 && (remain / 2 == (min - 2)))
{
num++;
surprises--;
}
}
System.out.printf("Case #%s: %s\n", i, num);
}
}
}
| 0 | 1,189,159 |
A11759 | A10712 | 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;
public class DancingTest {
public static void main(String[] args) {
int numCase = 0;
int caseIndex = 0;
int[] numGooglers = null;
int[] numSurprises = null;
int[] bestResult = null;
int[][] scores = null;
int maxNumScores = 30;
try {
FileReader reader = new FileReader("C:\\Users\\CheeMeng\\Downloads\\B-small-attempt1.in");
BufferedReader br = new BufferedReader(reader);
String s = br.readLine();
numCase = new Integer(s).intValue();
numGooglers = new int[numCase];
numSurprises = new int[numCase];
bestResult = new int[numCase];
scores = new int[numCase][maxNumScores];
while((s = br.readLine()) != null) {
String s1[] = s.split(" ");
numGooglers[caseIndex] = new Integer(s1[0]).intValue();
numSurprises[caseIndex] = new Integer(s1[1]).intValue();
bestResult[caseIndex] = new Integer(s1[2]).intValue();
for (int i = 3; i < s1.length; i++) {
scores[caseIndex][i - 3] = new Integer(s1[i]).intValue();
}
caseIndex++;
}
reader.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for (int i = 1; i <= numCase; i++) {
System.out.println("Case #" + i + ": " + dancingTest(numGooglers[i - 1], numSurprises[i - 1], bestResult[i - 1], scores[i - 1]));
}
}
public static int dancingTest(int numGooglers, int numSurprises, int bestResult, int[] scores) {
int count = 0;
int nearMisses = 0;
for (int i = 0; i < numGooglers; i++) {
int best = 0;
if ((scores[i] % 3) == 0) {
// Assume scores are (x, x, x), so best score will be the average
best = scores[i] / 3;
// Specially consider the case where scores are (x - 1, x, x + 1)
if ((best == bestResult - 1) && (best >= 1) && (best <= 9)) {
nearMisses++;
}
}
else if ((scores[i] % 3) == 2) {
// Assume scores are (x - 1, x, x), so best score will be the average
best = (scores[i] + 1) / 3;
// Specially consider the case where scores are (x - 1, x - 1, x + 1)
if ((best == bestResult - 1) && (best >= 1) && (best <= 9)) {
nearMisses++;
}
}
else if ((scores[i] % 3) == 1) {
// Scores will be either (x - 1, x - 1, x) or (x - 2, x, x)
// doesn't matter if any of them is marked surprising
best = (scores[i] + 2) / 3;
}
if (best >= bestResult) {
count++;
}
}
count = count + Math.min(nearMisses, numSurprises);
return count;
}
}
| 0 | 1,189,160 |
A11759 | A10174 | 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.io.PrintWriter;
import java.util.StringTokenizer;
public class GCJ2012QB {
static int[] a = new int[100];
public static void main(String[] args) throws Exception {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st;
int t = Integer.parseInt(r.readLine());
int n, s, p, a, result, best;
for (int i = 1; i <= t; i++) {
st = new StringTokenizer(r.readLine());
n = Integer.parseInt(st.nextToken());
s = Integer.parseInt(st.nextToken());
p = Integer.parseInt(st.nextToken());
result = 0;
for (int j = 0; j < n; j++) {
a = Integer.parseInt(st.nextToken());
best = maxBest(a);
if (best >= p) {
result++;
} else {
if (s > 0) {
best = maxBestWithSurprise(a);
if (best >= p) {
result++;
s--;
}
}
}
}
pw.println("Case #" + i + ": " + result);
}
pw.flush();
}
private static int maxBestWithSurprise(int a) {
if (a == 0) {
return 0;
} else {
return (a + 4) / 3;
}
}
private static int maxBest(int a) {
return (a + 2) / 3;
}
}
| 0 | 1,189,161 |
A11759 | A10970 | 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.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
public class googlers {
private static String[] casos;
private static String[] respuestas;
private static int cantidadPuntajesSorprendentes;
private static boolean pudoObtenerPuntaje(int puntaje, int total)
{
if(total == 0)
return puntaje == 0;
int umbralNormal = (puntaje-1) * 3 + 1;
int umbralSorprendente = (puntaje-1) * 3 - 1;
if(total >= umbralNormal)
return true;
if(cantidadPuntajesSorprendentes > 0 && total >= umbralSorprendente)
{
cantidadPuntajesSorprendentes --;
return true;
}
return false;
}
private static int maximaCantidadConMinimoPuntaje(int minimoPuntaje, int[] puntajes) {
int respuesta = 0;
for(int i=0; i<puntajes.length; i++) {
if(pudoObtenerPuntaje(minimoPuntaje, puntajes[i]))
respuesta ++;
}
return respuesta;
}
private static String resolver(String caso) {
String[] datos = caso.split(" ");
int cantidad = Integer.parseInt(datos[0]);
cantidadPuntajesSorprendentes = Integer.parseInt(datos[1]);
int minimoPuntaje = Integer.parseInt(datos[2]);
int[] totales = new int[cantidad];
for(int i=0; i<cantidad; i++) {
totales[i] = Integer.parseInt(datos[3+i]);
}
int resultado = maximaCantidadConMinimoPuntaje(minimoPuntaje, totales);
return String.valueOf(resultado);
}
/**
* @param args
*/
public static void main(String[] args) {
leerArchivo();
respuestas = new String[casos.length];
for(int i = 0; i<casos.length; i++) {
String respuesta = resolver(casos[i]);
respuestas[i] = respuesta;
}
escribirRespuesta();
}
private static void leerArchivo() {
try {
FileInputStream fstream;
fstream = new FileInputStream("input.txt");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
int numeroCasos = Integer.parseInt(br.readLine());
casos = new String[numeroCasos];
for(int i = 0; i < numeroCasos; i++) {
casos[i] = br.readLine();
}
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static void escribirRespuesta() {
try {
FileWriter fstream = new FileWriter("output.txt");
BufferedWriter out = new BufferedWriter(fstream);
for(int i=0; i<respuestas.length; i++) {
out.write("Case #" + (i + 1) + ": " + respuestas[i] + "\n");
}
out.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,162 |
A11759 | A10888 | 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 Dancing{
public static void main(String[] args) throws IOException{
Scanner in = new Scanner(new File("d.in"));
int a = Integer.parseInt(in.nextLine());
for(int i = 1; i <= a; i++){
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int q = 0;
for(int j = 0; j < n; j++){
int c = in.nextInt();
if(p*3-2 <= c){
q++;
}
else if((s > 0) && (p*3-4 > 0) && p*3-4 <= c){
q++;
s--;
}
}
in.nextLine();
System.out.printf("Case #%d: %d\n",i,q);
}
}
}
| 0 | 1,189,163 |
A11759 | A11247 | 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;
import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
public class Utils {
private static final String FILE_IN_EXTENSION = ".in";
private static final String FILE_OUT_EXTENSION = ".out";
private static final String OUT_DATE_FORMAT = "_yyyy-MM-dd_HH-mm-ss";
public static <T> void solve(String filePath, String fileName, InputConverter<T> inputConverter, SolverBase<T> solver) {
File folder = new File(filePath);
File fin = getInputFile(folder, fileName);
File fout = getOutputFile(folder, fileName);
if (!fout.exists()) {
try {
fout.createNewFile();
} catch (IOException e) {
System.err.println("Error creating file " + fout.getAbsolutePath());
e.printStackTrace();
}
}
InputReader<T> reader = null;
SolutionWriter writer = null;
try {
reader = new InputReader<T>(fin, inputConverter);
solver.init(reader);
writer = new SolutionWriter(fout);
int caseNum = 1;
String solution;
long startTime = System.currentTimeMillis();
while ((solution = solver.solveNext()) != null) {
writer.writeSolution(caseNum++, solution);
writer.flush();
}
int time = (int)(System.currentTimeMillis() - startTime);
System.out.println("Done in " + (time / 1000) + " seconds (" + (time / (caseNum - 1)) + "ms average)");
} catch (Exception e) {
System.err.println("Error solving");
e.printStackTrace();
}
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
// do nothing
}
}
if (writer != null) {
writer.flush();
writer.close();
}
}
public static File getInputFile(File folder, String fileName) {
return new File(folder, fileName + FILE_IN_EXTENSION);
}
public static File getOutputFile(File folder, String fileName) {
DateFormat dateFormat = new SimpleDateFormat(OUT_DATE_FORMAT);
String date = dateFormat.format(Calendar.getInstance().getTime());
return new File(folder, fileName + date + FILE_OUT_EXTENSION);
}
public static String[] convertToStringArray(String line) {
return line.split(" ");
}
public static int[] convertToIntArray(String line, int count) {
int[] items = new int[count];
int wordStart = 0;
for (int i = 0; i < count; i++) {
int wordEnd = line.indexOf(' ', wordStart);
if (wordEnd < 0) {
wordEnd = line.length();
}
int param = Integer.parseInt(line.substring(wordStart, wordEnd));
items[i] = param;
wordStart = wordEnd + 1;
}
return items;
}
public static int convertToIntArray(String line, int[] itemsOut) {
int count = 0;
int wordStart = 0;
int length = line.length();
while (wordStart < length) {
int wordEnd = line.indexOf(' ', wordStart);
if (wordEnd < 0) {
wordEnd = line.length();
}
int param = Integer.parseInt(line.substring(wordStart, wordEnd));
itemsOut[count++] = param;
wordStart = wordEnd + 1;
}
return count;
}
}
| 0 | 1,189,164 |
A11759 | A10070 | 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 {
static void solve() throws IOException {
int T = nextInt();
for(int c = 1; c <= T; c++) {
int N = nextInt();
int S = nextInt();
int P = nextInt();
int[] sc = new int[N];
for(int i = 0; i < sc.length; i++)
sc[i] = nextInt();
Arrays.sort(sc);
int res = 0;
for(int i = sc.length - 1, used = S; i >= 0; i--) {
if(3*P - 2 <= sc[i])
res++;
else {
if(used > 0 && sc[i] >= 2 && (3*P - 4 == sc[i] || 3*P - 3 == sc[i])) {
res++;
used--;
}
}
}
out.println("Case #" + c + ": " + res);
}
}
public static void main(String[] args) {
try {
br = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
solve();
out.close();
} catch (Throwable e) {
e.printStackTrace();
System.exit(239);
}
}
static BufferedReader br;
static StringTokenizer st;
static PrintWriter out;
static String nextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String line = br.readLine();
if (line == null) {
return null;
}
st = new StringTokenizer(line);
}
return st.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
static long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
static double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
| 0 | 1,189,165 |
A11759 | A11148 | 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.HashSet;
import java.util.Scanner;
/**
* User: Sasha
* Date: 09.04.12
* Time: 19:13
*/
public class Main {
private Scanner sc;
private PrintWriter wr;
private HashSet<String> set;
private void prepare() throws Exception {
sc = new Scanner(new File("C:\\Projects\\B-small-attempt2.in"));
File file = new File("C:\\Projects\\out.txt");
wr = new PrintWriter(file);
// wr = new PrintWriter(System.out);
}
private void solve() {
int T = sc.nextInt();
for (int i = 0; i < T; ++i) {
set = new HashSet<String>();
wr.print(String.format("Case #%d: ", (i + 1)));
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int r[] = new int[n];
for (int j = 0; j < r.length; ++j)
r[j] = sc.nextInt();
int res = 0;
for (int j = 0; j < n; ++j) {
int e = r[j] / 3;
int k = r[j] - e * 3;
if (e >= p) {
++res;
} else if (k >= 1 && e + 1 >= p) {
++res;
} else if (k == 0 && e + 1 >= p && s > 0 && e > 0) {
++res;
--s;
}
else if (k == 2 && e + 2 >= p && s > 0) {
++res;
--s;
}
}
wr.println(res);
}
wr.flush();
}
public static void main(String args[]) throws Exception {
Main main = new Main();
main.prepare();
main.solve();
}
}
| 0 | 1,189,166 |
A11759 | A11020 | 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.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* A work queue that allows the work queue to continue to increase in size if it is discovered that subdivision of work is
* necessary. Call hasIdleWorkers() to see if there are idle workers, and have the worker subdivide their work further by calling
* enqueueWork().
*/
public class ParallelWorkQueueDynamic {
private int numThreads;
private ExecutorService threadPool;
private CompletionService<Void> completionService;
private int numWorkUnitsEnqueued = 0;
private Object lock = new Object();
public ParallelWorkQueueDynamic(int numThreads) {
this.numThreads = numThreads;
threadPool = Executors.newFixedThreadPool(numThreads);
completionService = new ExecutorCompletionService<Void>(threadPool);
}
/**
* Enqueue work. Called by the main thread to start processing, and can also be called by workers to subdivide their work.
*/
public void enqueueWork(Callable<Void> workUnit) {
synchronized (lock) {
numWorkUnitsEnqueued++;
}
completionService.submit(workUnit);
}
/**
* Test if there are any idle workers. Should only be called from within a worker so that the total number of workers is greater
* than zero (to avoid a race).
*/
public boolean hasIdleWorkers() {
return numWorkUnitsEnqueued < numThreads;
}
/**
* Wait for all work submitted by workers to be completed. Throws IllegalArgumentException if any of the worker threads throw an
* exception (this causes an ExecutionException).
*/
public void waitForAllWorkersToQuit() {
try {
while (numWorkUnitsEnqueued > 0) {
// .take() waits for completion of next task and returns a Future for it
completionService.take().get();
synchronized (lock) {
numWorkUnitsEnqueued--;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
throw new IllegalArgumentException("waitForAllWorkersToQuit() failed with " + e.getMessage(), e);
} catch (ExecutionException e) {
e.printStackTrace();
throw new IllegalArgumentException("waitForAllWorkersToQuit() failed with " + e.getMessage(), e);
}
}
public void shutdown() {
threadPool.shutdown();
}
}
| 0 | 1,189,167 |
A11759 | A12499 | 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.List;
public class CodeJam {
// public static final String INPUT_FILE_PATH = "D://CodeJamInput.txt";
public static final String INPUT_FILE_PATH = "D://B-small-attempt0.in";
public static final String OUTPUT_FILE_PATH = "D://CodeJamOutput.txt";
public static List<String> readInput() {
List<String> list = new ArrayList<String>();
try {
BufferedReader input = new BufferedReader(new FileReader(
INPUT_FILE_PATH));
try {
String line = null;
while ((line = input.readLine()) != null) {
list.add(line);
}
} finally {
input.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
return list;
}
public static void writeOutput(List<String> output) {
PrintWriter writer = null;
try {
writer = new PrintWriter(new FileWriter(OUTPUT_FILE_PATH));
for (String line : output) {
writer.println(line);
}
writer.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (writer != null)
writer.close();
}
}
public static void main(String[] args) {
List<DanceFloor> danceFloors = DanceFloor.parseFromFile(CodeJam.readInput());
List<String> output = new ArrayList<String>();
for(int i = 0; i < danceFloors.size(); i++) {
System.out.println(danceFloors.get(i));
String line = "";
line += "Case #" + (i + 1) + ": " + danceFloors.get(i).calculate();
output.add(line);
}
CodeJam.writeOutput(output);
}
}
class DanceFloor {
private List<Integer> tripletsTotalCounts;
private int surpriseCount;
private int targetScore;
private int dancersCount;
public DanceFloor(List<Integer> tripletsTotalCounts, int surpriseCount,
int targetScore, int dancersCount) {
this.tripletsTotalCounts = tripletsTotalCounts;
this.surpriseCount = surpriseCount;
this.targetScore = targetScore;
this.dancersCount = dancersCount;
}
public int calculate() {
int result = 0;
if (targetScore == 0) return dancersCount;
for (int i = 0; i < tripletsTotalCounts.size(); i++) {
int total = tripletsTotalCounts.get(i);
if (total < (targetScore * 3 - 4)) {
tripletsTotalCounts.remove(i--);
} else if (total == 0) {
tripletsTotalCounts.remove(i--);
}
}
for (int i = 0; i < tripletsTotalCounts.size(); i++) {
int total = tripletsTotalCounts.get(i);
if ((surpriseCount > 0) && (total == targetScore * 3 - 4)) {
result++;
surpriseCount--;
tripletsTotalCounts.remove(i--);
} else if ((surpriseCount == 0) && (total == targetScore * 3 - 4)) {
tripletsTotalCounts.remove(i--);
}
}
for (int i = 0; i < tripletsTotalCounts.size(); i++) {
int total = tripletsTotalCounts.get(i);
if ((surpriseCount > 0) && (total == targetScore * 3 - 3)) {
result++;
surpriseCount--;
tripletsTotalCounts.remove(i--);
} else if ((surpriseCount == 0) && (total == targetScore * 3 - 3)) {
tripletsTotalCounts.remove(i--);
}
}
result += tripletsTotalCounts.size();
return result;
}
public static List<DanceFloor> parseFromFile(List<String> readInput) {
List<DanceFloor> result = new ArrayList<DanceFloor>();
int testCaseCount = Integer.parseInt(readInput.get(0));
for (int i = 0; i < testCaseCount; i++) {
String line[] = readInput.get(i + 1).split(" ");
List<Integer> totalCounts = new ArrayList<Integer>();
for (int j = 0; j < Integer.parseInt(line[0]); j++) {
totalCounts.add(Integer.parseInt(line[3 + j]));
}
result.add(new DanceFloor(totalCounts, Integer.parseInt(line[1]),
Integer.parseInt(line[2]), Integer.parseInt(line[0])));
}
return result;
}
@Override
public String toString() {
return "dancersCount = " + dancersCount + "; surpriseCount = " + surpriseCount
+ "; targetScore = " + targetScore + "; tripletsTotalCounts"
+ tripletsTotalCounts.toString();
}
}
| 0 | 1,189,168 |
A11759 | A11746 | 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 googlers;
/**
*
* @author amr
*/
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception
{
FileWriter foutstream = new FileWriter("result.out");
FileReader finstream = new FileReader("B-small-attempt5.in");
PrintWriter out = new PrintWriter(foutstream);
BufferedReader br = new BufferedReader(finstream);
int i=0,count=1,result=0;
int N,S,P,min_val_1,min_val_2;
while(br.ready())
{
i++;
String str = br.readLine();
if(i != 1)
{
result = 0;
String str_arr[] = str.split(" ");
int arr[] = new int[str_arr.length];
for(int j=0 ; j<arr.length ; j++)
{
arr[j] = Integer.parseInt(str_arr[j]);
}
N = arr[0];
S = arr[1];
P = arr[2];
min_val_1 = P+P-2+P-2;
min_val_2 = P+P-2+P-1;
int min_val_1_count = 0;
int min_val_2_count = 0;
for(int j=3 ; j<arr.length ; j++)
{
if(P > 1)
{
if(arr[j] > min_val_1 && arr[j] > min_val_2)
result++;
if(arr[j] == min_val_1)
min_val_1_count++;
if(arr[j] == min_val_2)
min_val_2_count++;
}
else
{
if(arr[j] >= P)
result++;
}
}
if(S == 0 || P <= 1)
{
out.print("Case #"+count+": ");
out.println(result);
}
else if(S > 0)
{
int d = 0;
int x = min_val_1_count + min_val_2_count ;
if(x >= S)
d = S;
else
d = x;
out.print("Case #"+count+": ");
out.println(result+d);
}
count++;
}
}
out.close();
}
}
| 0 | 1,189,169 |
A11759 | A11578 | 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.qualrnd.dncingglers;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class DancingGooglersInputReader {
public DancingGooglersInput read() {
Scanner scanner = new Scanner(System.in);
String firstLine = scanner.nextLine();
int noOfLines = Integer.parseInt(firstLine);
GooglersScoreboard[] allScoreboards = new GooglersScoreboard[noOfLines];
for (int lineNum = 0; lineNum < noOfLines; lineNum++) {
String inputValues[] = scanner.nextLine().split(" ");
GooglersScoreboard scoreboard = new GooglersScoreboard();
int noOfGooglers = Integer.parseInt(inputValues[0]);
scoreboard.setNoOfGooglers(noOfGooglers);
scoreboard.setNoOfSurprisingScores(Integer.parseInt(inputValues[1]));
scoreboard.setBestScore(Integer.parseInt(inputValues[2]));
List<Integer> scores = new ArrayList<Integer>(noOfGooglers);
for (int scoreIndex = 0; scoreIndex < noOfGooglers; scoreIndex++) {
scores.add(Integer.parseInt(inputValues[scoreIndex+3]));
}
scoreboard.setScores(scores);
allScoreboards[lineNum] = scoreboard;
}
return new DancingGooglersInput(noOfLines, allScoreboards);
}
}
| 0 | 1,189,170 |
A11759 | A12698 | 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.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class CJ_2012_Q_B {
public static void main(String[] args) throws IOException {
Scanner in = new Scanner(new File("cj_files/in"));
FileWriter w = new FileWriter(new File("cj_files/out"));
int cases = in.nextInt();
int numDancers, numSurprises, p, cSurprises, cRegular, score;
for(int i = 1; i <= cases; i++) {
numDancers = in.nextInt();
numSurprises = in.nextInt();
p = in.nextInt();
cRegular = 0;
cSurprises = 0;
for(int j = 0; j < numDancers; j++) {
score = in.nextInt();
score -= p;
if(score < 0) {
continue;
}
score /= 2;
if(p - score <= 1) {
cRegular++;
} else if (p - score == 2) {
cSurprises++;
}
}
w.append(String.format("Case #%d: %d\n", i, (cRegular + Math.min(cSurprises, numSurprises))));
}
w.close();
}
}
| 0 | 1,189,171 |
A11759 | A10207 | 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;
public class Dance {
/**
* @param args
*/
static int test(int n, int p, int surp, int [] ds){
int res=0;
int mean,mod;
if (p==0) return n;
for(int i=0; i<n; i++){
if (ds[i] == 0) continue;
mean = ds[i]/3;
mod = ds[i]%3;
if (mean >= p
|| (mean + 1 >= p && mod >= 1)) {res ++; continue;}
if (((mod==2 && mean +2 >= p) || (mean+1>=p))&& surp > 0) {res ++; surp --; continue;}
}
return res;
}
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int nbtests;
try {
nbtests = new Integer(br.readLine());
for (int i=0; i<nbtests; i++){
String s = br.readLine();
String []tmp = s.split(" ",4);
int n = new Integer(tmp[0]);
int surp = new Integer(tmp[1]);
int p = new Integer(tmp[2]);
String[] dss = tmp[3].split(" ",n);
int []ds = new int[n];
for (int j=0; j<n; j++) ds[j]=new Integer(dss[j]);
System.out.println("Case #"+(i+1)+": " + test(n,p,surp,ds));
}
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,172 |
A11759 | A10997 | 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.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
public class Dancing {
static int[][] bestScores = {
{0, 0},
{1, 1},
{1, 2},
{1, 2},
{2, 2},
{2, 3},
{2, 3},
{3, 3},
{3, 4},
{3, 4},
{4, 4},
{4, 5},
{4, 5},
{5, 5},
{5, 6},
{5, 6},
{6, 6},
{6, 7},
{6, 7},
{7, 7},
{7, 8},
{7, 8},
{8, 8},
{8, 9},
{8, 9},
{9, 9},
{9, 10},
{9, 10},
{10, 10},
{10, 10},
{10, 10}
};
public static void main(String[] args) throws IOException {
//createMatrix();
String inFileName = "B-small-attempt0.in";
Scanner in = new Scanner(new File(inFileName));
String outFileName = inFileName.substring(0, inFileName.lastIndexOf('.')) + ".out";
PrintWriter out = new PrintWriter(outFileName);
int numSets = in.nextInt();
in.nextLine();
for(int probSet = 1; probSet <= numSets; probSet++) {
int numDancers = in.nextInt();
int surp = in.nextInt();
int minScore = in.nextInt();
ArrayList<Integer> scores = new ArrayList<Integer>();
for(int i = 0; i < numDancers; i++) {
int score = in.nextInt();
if(bestScores[score][1] < minScore) continue;
scores.add(score);
}
int answer = recurse(scores, 0, 0, minScore, surp);
out.println("Case #" + probSet + ": " + answer);
}
in.close();
out.close();
}
public static int recurse(ArrayList<Integer> scores, int index, int soFar,
int minScore, int surp) {
if(index == scores.size()) return soFar;
int isSurp = 0;
if(surp > 0) isSurp = recurse(scores, index + 1, soFar + 1, minScore, surp - 1);
int notSurp = 0;
if(scores.size() > surp) {
int score = scores.get(index);
int bestScore = bestScores[score][0]; //highest possible number in unsurprising score
int newSoFar = bestScore >= minScore ? soFar + 1 : soFar;
notSurp = recurse(scores, index + 1, newSoFar, minScore, surp);
}
return Math.max(isSurp, notSurp);
}
public static void createMatrix() {
int[][] grid = new int[31][2];
for(int i = 0; i <= 30; i++) {
grid[i][0] = (i + 2) / 3;
for(int j = 10; j >= 0; j--) {
int temp = i - j;
if(j - 2 > 0) temp -= 2 * (j - 2);
if(temp >= 0) {
grid[i][1] = j;
break;
}
}
}
//print out grid to hard code
System.out.println("int[][] bestScores = {");
for(int i = 0; i < grid.length; i++) {
System.out.print(" {" + grid[i][0] + ", " + grid[i][1] + "}");
if(i != grid.length - 1) System.out.print(",");
System.out.println();
}
System.out.println("};");
}
}
| 0 | 1,189,173 |
A11759 | A11946 | 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.FileReader;
import java.io.FileWriter;
import java.io.Writer;
import java.util.Scanner;
public class DancingWithTheGooglers {
private String mInputFileName;
private String mOutputFileName;
private int N;
private int S;
private int P;
private int[] mScores;
public DancingWithTheGooglers(String inputFileName, String outputFileName) {
mInputFileName = inputFileName;
mOutputFileName = outputFileName;
}
public void solve() {
long start = System.currentTimeMillis();
Scanner scanner = null;
try {
scanner = new Scanner(new FileReader(mInputFileName));
Writer output = new BufferedWriter(new FileWriter(mOutputFileName));
int cases = scanner.nextInt();
for (int i = 1; i <= cases; i++) {
N = scanner.nextInt();
S = scanner.nextInt();
P = scanner.nextInt();
mScores = new int[N];
for (int j = 0; j < N; j++) {
mScores[j] = scanner.nextInt();
}
System.out.println("CASE: " + i + " / " + cases);
if (i > 1) output.write("\n");
output.write("Case #" + i + ": ");
output.write(getAnswer());
}
output.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (scanner != null) scanner.close();
}
System.out.println("TIME: " + (System.currentTimeMillis() - start));
}
private String getAnswer() {
int res = 0;
for (int j = 0; j < N; j++) {
int score = mScores[j];
int q = score / 3;
int r = score % 3;
int noSup = q;
int sup = q;
if (score > 0) {
switch (r) {
case 0:
sup++;
break;
case 1:
noSup++;
sup++;
break;
case 2:
noSup++;
sup += 2;
break;
}
}
if (noSup >= P) {
res++;
} else if (S > 0 && sup >= P) {
res++;
S--;
}
}
//System.out.println(res);
return "" + res;
}
public static void main(String[] args) {
String fileName = "test";
String extension = ".txt";
String outputSuffix = "_output";
new DancingWithTheGooglers(fileName + extension,
fileName + outputSuffix + extension).solve();
}
}
| 0 | 1,189,174 |
A11759 | A12378 | 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.*;
/**
*
* @author Hilos
*/
public class ProblemB {
public static BufferedWriter bw;
public static BufferedReader br;
public static void main(String[] args) {
try {
String filename = "B-small-attempt0";
br = new BufferedReader(new FileReader("E:\\Downloads\\" + filename + ".in"));
bw = new BufferedWriter(new FileWriter("E:\\Downloads\\" + filename + ".out"));
int caseCount = Integer.parseInt(br.readLine());
for (int c = 0; c < caseCount; c++) {
String[] lineParts = br.readLine().split(" ");
int N = Integer.parseInt(lineParts[0]);
int S = Integer.parseInt(lineParts[1]);
int p = Integer.parseInt(lineParts[2]);
int[] scores = new int[N];
for (int s = 0; s < N; s++) {
scores[s] = Integer.parseInt(lineParts[3 + s]);
}
SolveCase(c + 1, N, S, p, scores);
}
} catch (Exception exc) {
System.out.println(exc.toString());
}
}
public static void SolveCase(int caseNumber, int N, int S, int p, int[] scores) throws Exception {
int aboveOrEqual = 0;
int surprisingLeft = S;
int scoreCount = scores.length;
for (int s = 0; s < scoreCount; s++) {
int score = scores[s];
if(score == 0){
if(p == 0){
aboveOrEqual++;
}
}else if (score % 3 == 1) {
if ((score + 2) / 3 >= p) {
aboveOrEqual++;
}
} else if (score % 3 == 0) {
if ((score / 3) >= p) {
aboveOrEqual++;
} else if (surprisingLeft > 0 && (score / 3) + 1 >= p) {
aboveOrEqual++;
surprisingLeft--;
}
} else if (score % 3 == 2) {
if (((score + 1) / 3) >= p) {
aboveOrEqual++;
} else if (surprisingLeft > 0 && ((score + 1) / 3) + 1 >= p) {
aboveOrEqual++;
surprisingLeft--;
}
}
}
bw.write("Case #" + caseNumber + ": " + aboveOrEqual + "\n");
bw.flush();
}
}
| 0 | 1,189,175 |
A11759 | A12780 | 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;
/**
*
* @author James
*/
public class ScoreAnalyzer {
private int targetBestResultScore;
private int surprisingScores;
private int[] totalScores;
public ScoreAnalyzer(int[] data) {
surprisingScores = data[1];
targetBestResultScore = data[2];
totalScores = new int[data[0]];
for (int i = 0; i < data[0]; i++) {
totalScores[i] = data[i+3];
}
}
public int getMaxNumOfHighScoringDancers() {
int result = 0;
int avgTotal = targetBestResultScore * 3;
if (avgTotal == 0) {
return totalScores.length; // all competitors got at least 0.
}
for (int i = 0; i < totalScores.length; i++) {
if (totalScores[i] != 0) {
if (totalScores[i] >= (avgTotal-2)) {
// score set is at least
// target-1 target-1 target
result++;
} else if ((totalScores[i] >= (avgTotal-4)) && (surprisingScores > 0)) {
// score is at least
// target-2 target-2 target
// and this result may be a surprising score
result++;
surprisingScores--; // remove a surprising score
} // else it cannot possibly have a sufficiently high max score
}
}
return result;
}
}
| 0 | 1,189,176 |
A11759 | A11539 | 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 pl.helman.codejam.dancing;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Dancing {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("d:\\dancing.in");
BufferedReader br = new BufferedReader(fr);
String line = br.readLine();
FileWriter f0 = new FileWriter("d:\\dancing.out");
// number of cases
int t = Integer.parseInt(line.trim());
for (int c = 1; c <= t; c++) {
System.out.println();
line = br.readLine();
String[] elems = line.split(" ");
// number of dancers
int n = Integer.parseInt(elems[0]);
// number od surprises
int s = Integer.parseInt(elems[1]);
// points
int p = Integer.parseInt(elems[2]);
System.out.println(" n:"+n+" p:"+p+" s:"+s);
int ret = 0;
for (int i = 0; i < n; i++) {
int w = Integer.parseInt(elems[3 + i]);
// max not surprising note
int m = (w + 2) / 3;
System.out.print(" w:"+w+" m:"+m+" m%3:"+m%3+" s:"+s);
if (m >= p) {
ret++;
System.out.print(" +1");
} else if (w>0 && (m == p - 1) && ((w % 3) != 1) && (s > 0)) {
s--;
ret++;
System.out.print(" +2");
}
System.out.println();
}
System.out.println("Case #" + c + ": " + ret);
f0.write("Case #" + c + ": " + ret + "\r\n");
}
fr.close();
f0.close();
}
}
| 0 | 1,189,177 |
A11759 | A12819 | 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.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
public class Main
{
public static HashMap<Character,Character> mapp = new HashMap<Character,Character>();
public static void main(String[] args) throws Exception
{
PrintWriter writer = new PrintWriter(new FileWriter("output.txt"));
BufferedReader input = new BufferedReader(new FileReader("B-small-attempt0.in"));
int size=Integer.parseInt(input.readLine());
for(int i=0; i<size; i++)
{
String testCase = input.readLine();
String tokens[] = testCase.split(" ");
int N = Integer.parseInt(tokens[0]);
int S = Integer.parseInt(tokens[1]);
int p = Integer.parseInt(tokens[2]);
int count=0;
//ArrayList<Integer> google = new ArrayList<Integer>();
for(int j=3; j<N+3; j++)
{
int testNum = Integer.parseInt(tokens[j]);
if((testNum - p) >= 2*(p-1) && (testNum-p)>=0)
{
count++;
}
else if((testNum - p) < 2*(p-1) && (testNum-p)>=0)
{
if(S!=0 && (testNum - p) >= 2*(p-2) )
{
count++;
S--;
}
}
}
writer.println("Case #"+(i+1)+": "+count);
}
writer.close();
input.close();
}
}
| 0 | 1,189,178 |
A11759 | A12817 | 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;
/**
* Google code jam.
* Qualification Round 2012.
* Problem B. Dancing With the Googlers
*
* Usage: <app> <input >output
*
* @author sombrabr@gmail.com
*
*/
public class QualB {
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int cases = new Integer(in.readLine());
run(in, cases);
}
static void run(BufferedReader in, int cases) throws IOException {
for(int i=0; i<cases; ++i) {
String line = in.readLine();
System.out.print("Case #" + (i+1) + ": ");
String[] parts = line.split(" ");
int j=0;
int N = Integer.parseInt(parts[j++]); // Number of Googlers
int S = Integer.parseInt(parts[j++]); // Surprising triplets
int p = Integer.parseInt(parts[j++]); // Best result base
int tripletScore = p+2*(Math.max(0, p-2)); // Triplet score
int minimumScore = p+2*(Math.max(0, p-1)); // Minimum score not a triplet
int surprisings = 0; // Total surprisings already found
int googlers = 0; // Count of Googlers with p
for(int k=0; k<N; ++k) {
int t = Integer.parseInt(parts[j++]); // Total score
if(t>=minimumScore) {
googlers++;
} else if(t>=tripletScore && surprisings<S) {
surprisings++;
googlers++;
}
}
System.out.println(googlers);
}
}
}
| 0 | 1,189,179 |
A11759 | A12837 | 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.Arrays;
import java.util.Formatter;
import java.util.Locale;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author edemairy
*/
public class Main {
private final static Logger logger = Logger.getLogger(Main.class.getName());
private static int nbTC;
private static StringBuilder result = new StringBuilder();
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
logger.setLevel(Level.OFF);
// Scanner scanner = new Scanner(System.in);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
nbTC = readInt(reader);
// scanner.nextLine();
for (int tc = 1; tc <= nbTC; ++tc) {
result.append("Case #" + tc + ": ");
result.append(oneTestCase(reader));
result.append('\n');
}
System.out.print(result);
}
private static int N;
private static int S;
private static int P;
private static int T[] = new int[101];
private static StringBuilder oneTestCase(BufferedReader reader) throws IOException {
N = readInt(reader);
S = readInt(reader);
P = readInt(reader);
for (int i = 0; i < N; ++i) {
T[i] = readInt(reader);
}
Formatter formatter = new Formatter();
StringBuilder result = new StringBuilder();
for (int i = 0; i < 102; ++i) {
Arrays.fill(v[i], -2);
}
result.append(val(S, 0));
// for (int i = 0; i < 5; ++i) {
// formatter.format("%3d", n[i]);
// }
// result.append(formatter.out());
return result;
}
public static int[][] v = new int[102][102];
public static int val(int s, int pos) {
if (v[s][pos] != -2) {
return v[s][pos];
}
int result;
if (pos >= N) {
if (s == 0) {
result = 0;
} else {
result = -1;
}
} else {
int surprising = -1;
if (s > 0) {
surprising = valSurprising(T[pos], P);
int rem = val(s - 1, pos + 1);
if ((surprising == -1) || (rem == -1)) {
surprising = -1;
} else {
surprising += rem;
}
}
int remNotSurprising = val(s, pos + 1);
int notSurprising = valNotSurprising(T[pos], P);
if ((notSurprising == -1) || (remNotSurprising == -1)) {
notSurprising = -1;
} else {
notSurprising += remNotSurprising;
}
if ((surprising == -1) && (notSurprising == -1)) {
result = -1;
} else if (surprising == -1) {
result = notSurprising;
} else if (notSurprising == -1) {
result = surprising;
} else {
result = Math.max(surprising, notSurprising);
}
}
v[s][pos] = result;
return result;
}
private static int readInt(BufferedReader reader) throws IOException {
int result = 0;
boolean positive = true;
char currentChar = (char) reader.read();
while ((currentChar == ' ') || (currentChar == '\n')) {
currentChar = (char) reader.read();
}
if (currentChar == (char) -1) {
throw new IOException("end of stream");
}
if (currentChar == '-') {
positive = false;
currentChar = (char) reader.read();
}
while ((currentChar >= '0') && (currentChar <= '9')) {
result = result * 10 + currentChar - '0';
currentChar = (char) reader.read();
}
if (positive) {
return result;
} else {
return -result;
}
}
private static char readChar(BufferedReader reader) throws IOException {
return (char) reader.read();
}
public static int valNotSurprising(int t, int p) {
if ((t < 0) || (t > 30)) {
return -1;
}
int m = t / 3;
// searching a and b such as t = a*m+ b*(m+1)
int b = t - (3*m);
int a = 3 - b;
int result = 0;
if (m >= p) {
result = 1;
}
if ((b!=0) && (m + 1 >= p)) {
result = 1;
}
return result;
}
public static int valSurprising(int t, int p) {
if ((t < 2) || (t > 28)) {
return -1;
}
int result = 0;
foralpha:
for (int alpha = 0; alpha < 3; ++alpha) {
int remn = (t - 2 - alpha) % 3;
if (remn != 0) {
continue foralpha;
}
int n = (t - 2 - alpha) / 3;
int resultLoop = 0;
if (n >= p) {
resultLoop = 1;
}
if ((n + 2) >= p) {
resultLoop = 1;
}
if ((n + alpha) >= p) {
resultLoop = 1;
}
result = Math.max(result, resultLoop);
}
return result;
}
}
| 0 | 1,189,180 |
A11759 | A12841 | 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.FileReader;
import java.io.IOException;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Wilmer
*/
public class main {
int numeroCasos;
public void leerArchivo(File archivo) throws FileNotFoundException, IOException{
FileReader fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
String linea = br.readLine();
numeroCasos = Integer.parseInt(linea.trim());
String[] datos = null;
int resultado = 0;
int googlers=0;
int numeroDeSorpresas = 0;
int objetivo = 0;
int puntajeActual=0;
int validos = 0;
int validoSorpresa = 0;
int noValidoSorpresa = 0;
int sorpresasPorEncontrar=0;
for(int i=1; i<=numeroCasos; i++){
linea = br.readLine();
datos = linea.split(" ");
googlers = Integer.parseInt(datos[0]);
numeroDeSorpresas = Integer.parseInt(datos[1]);
objetivo = Integer.parseInt(datos[2]);
puntajeActual=0;
validos = 0;
validoSorpresa = 0;
noValidoSorpresa = 0;
sorpresasPorEncontrar=0;
for(int j = 3; j<googlers+3; j++){
puntajeActual = Integer.parseInt(datos[j]);
if( puntajeActual >= ((objetivo*3)-2) ){
validos++;
}else{
if( puntajeActual < ((objetivo*3)-2) && puntajeActual >= ((objetivo*3)-4) && puntajeActual>1){
validoSorpresa++;
}else{
if(puntajeActual>1){
noValidoSorpresa++;
}
}
}
}
//System.out.println(validos+"*"+validoSorpresa+"*"+noValidoSorpresa+"*-*"+numeroDeSorpresas);
//sorpresasPorEncontrar = sorpresasPorEncontrar - noValidoSorpresa;
if(validoSorpresa > numeroDeSorpresas && numeroDeSorpresas>=0){
validoSorpresa = numeroDeSorpresas;
}
resultado = validos + validoSorpresa;
System.out.println("Case #"+i+": "+resultado);
}
}
public static void main(String[] args) throws FileNotFoundException, IOException{
File archivo = new File("B-small-attempt0.in");
main m = new main();
m.leerArchivo(archivo);
}
}
| 0 | 1,189,181 |
A11759 | A11519 | 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.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class B {
int INF = 1 << 28;
void run() {
Scanner sc;
FileOutputStream fw;
try {
sc = new Scanner(new File("B.in"));
fw = new FileOutputStream(new File("B.out"));
PrintWriter pw = new PrintWriter(fw);
// sc.useDelimiter("\\n");
int n = sc.nextInt();
for(int i=1;i<=n;i++) {
int t = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int[] total = new int[t];
for(int j=0;j<t;j++) {
total[j] = sc.nextInt();
}
sort(total);
int[][] score = new int[t][3];
for(int j=0;j<t;j++) {
int ave = total[j]/3;
if(total[j]%3 == 0) {
score[j][0] = score[j][1] = score[j][2] = ave;
}
else if(total[j]%3 == 1) {
score[j][0] = score[j][1] = ave;
score[j][2] = ave+1;
}
else {
score[j][0] = ave;
score[j][1] = score[j][2] = ave+1;
}
}
int cnt = 0;
for(int j=0;j<t;j++) {
// debug(score[j]);
if( score[j][2] >= p ) cnt++;
else if( s > 0 ){
if( score[j][2] == score[j][1] && score[j][2] + 1 >= p &&
total[j] != 0 && score[j][2] != 10) {
s--;
cnt++;
}
}
}
pw.println("Case #" + i + ": " + cnt);
}
pw.close();
fw.close();
} catch (FileNotFoundException e) {
// TODO èªåçæããã catch ãããã¯
e.printStackTrace();
} catch (IOException e) {
// TODO èªåçæããã catch ãããã¯
e.printStackTrace();
}
}
public static void main(String[] args) {
new B().run();
}
void debug(Object... os) {
System.err.println(Arrays.deepToString(os));
}
}
| 0 | 1,189,182 |
A11759 | A11241 | 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;
import com.isotopeent.codejam.lib.SolverBase;
import com.isotopeent.codejam.lib.Utils;
import com.isotopeent.codejam.lib.converters.IntArrayLine;
public class Solver extends SolverBase<int[]> {
private static final String FILE_PATH = "C:\\codejam\\";
private static final String FILE_NAME = "B-small-attempt0";
private static final int INIT_PARAM_COUNT = 1;
private static final int PARAM_COUNT = 3;
private static final int MAX_ARRAY_SIZE = PARAM_COUNT + 100; // 3 params + N=100
private static final int SCORE_COUNT = 3;
public static void main(String [] args) {
Utils.solve(FILE_PATH, FILE_NAME, new IntArrayLine(new int[MAX_ARRAY_SIZE]), new Solver());
}
public Solver() {
super(INIT_PARAM_COUNT);
}
@Override
protected String solve(int[] input) {
int surprisingScores = input[1];
int scoreThreashold = input[2];
int minUnsurprisingScore = scoreThreashold * SCORE_COUNT - SCORE_COUNT + 1;
int minSurprisingScore = Math.max(minUnsurprisingScore - SCORE_COUNT + 1, scoreThreashold);
int count = 0;
int length = input.length;
for (int i = PARAM_COUNT; i < length; i++) {
int score = input[i];
if (score >= minUnsurprisingScore) {
count++;
} else if (score >= minSurprisingScore && surprisingScores > 0) {
count++;
surprisingScores--;
}
}
return Integer.toString(count);
}
}
| 0 | 1,189,183 |
A11759 | A13204 | 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 Googlers {
public static void main(String[] args) {
// 3p-4 n 3p-3 are critical..
Scanner c = new Scanner(System.in);
int t = c.nextInt();
for (int i = 1; i <= t; ++i) {
System.out.print("Case #" + i + ": ");
int n = c.nextInt();
int s = c.nextInt();
int p = c.nextInt();
int count = 0, num;
if (p == 0) {
int m=n;
while(n-- >0)
c.nextInt();
System.out.println(m);
} else if (p == 1) {
while(n-- >0)
if(c.nextInt() > 0)
count++;
System.out.println(count);
} else {
while (n-- > 0)
if ((num = c.nextInt()) < 3 * p - 4)
continue;
else if (num < 3 * p - 2 && s-- > 0)
count++;
else if (num >= 3 * p - 2)
count++;
System.out.println(count);
}
}
}
}
| 0 | 1,189,184 |
A11759 | A10589 | 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 triplets {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int numCases = scan.nextInt();
for(int i = 0; i < numCases; i++) {
int size = scan.nextInt();
int s = scan.nextInt();
int p = scan.nextInt();
int[] scores = new int[size];
for(int j = 0; j < size; j++) {
scores[j] = scan.nextInt();
}
System.out.println("Case #" + (i+1) + ": " + number(scores,s,p));
}
}
public static int number(int[] scores, int s, int p) {
int minScore = Math.max(p*3 - 2, p);
int minS = Math.max(p*3 - 4, p);
int count = 0;
for(int i = 0; i < scores.length; i++) {
if(scores[i]>=minScore) count++;
else if(scores[i] >= minS) {
if(s>0) {
s--;
count++;
}
}
}
return count;
}
}
| 0 | 1,189,185 |
A11759 | A10887 | 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.qualification;
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class Dancing {
/**
* @param args
*/
public static void main(String[] args) throws IOException {
String file = "input2small";
Scanner in = new Scanner(new File(file));
int tot = Integer.parseInt(in.nextLine());
// System.out.println(tot);
for(int i=0;i<tot;i++) {
String line = in.nextLine();
String[] data = line.split(" ");
int N = Integer.parseInt(data[0]);
int S = Integer.parseInt(data[1]);
int p = Integer.parseInt(data[2]);
int output = 0;
switch(p) {
case 0:
output = N;
break;
case 1:
for(int j=0; j<N; j++) {
int t = Integer.parseInt(data[3+j]);
if(t > 0) output++;
}
break;
default:
int temp = 0;
for(int j=0; j<N; j++) {
int t = Integer.parseInt(data[3+j]);
if(t >= 3*p-2)
output++;
else
if(t >= 3*p-4)
temp++;
}
if(temp <= S)
output += temp;
else
output += S;
}
System.out.println("Case #"+(i+1)+": "+output);
}
}
}
| 0 | 1,189,186 |
A11759 | A10388 | 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 DancingWithTheGooglers
{
public static void main(String []args)
{
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for(int i = 1; i <= T; i++)
{
System.out.print("Case #" + i + ": ");
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int count = 0;
for(int j = 0; j < N; j++)
{
int t = in.nextInt();
if(t >= 2 * Math.max(p - 1, 0) + p) count++;
else if(t >= 2 * Math.max(p - 2, 0) + p && S > 0) { count++; S--; }
}
System.out.print(count);
if(i < T) System.out.println();
}
}
} | 0 | 1,189,187 |
A11759 | A13217 | 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 B {
public static void main(String[] args) throws FileNotFoundException {
Scanner scanner = new Scanner(new File("B-small-attempt0.in"));
PrintWriter printer = new PrintWriter(new File("a.out"));
int t = scanner.nextInt();
for (int i = 0; i < t; i++) {
int n = scanner.nextInt();
int s = scanner.nextInt();
int p = scanner.nextInt();
int ans = 0;
for (int j = 0; j < n; j++) {
int tmp = scanner.nextInt();
if (tmp >= p + 2 * Math.max(p - 1, 0)) {
ans++;
} else if (s > 0 && tmp >= p + 2 * Math.max(p - 2, 0)) {
ans++;
s--;
}
}
printer.println("Case #" + (i + 1) + ": " + ans);
}
printer.flush();
printer.close();
}
}
| 0 | 1,189,188 |
A11759 | A10975 | 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 codejam.B2012;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class B2012 {
public static void main(String[] args) throws FileNotFoundException {
Scanner scanner = new Scanner(new File("C:/docs/codejam/2012/B-small-attempt7.in"));
PrintWriter output = new PrintWriter(new File("C:/docs/codejam/2012/___B_small_out_7.txt"));
int T = scanner.nextInt();
for (int i = 1; i < T + 1; i++) {
int N = scanner.nextInt();
int S = scanner.nextInt();
int p = scanner.nextInt();
System.out.println("N = " + N + " | S = " + S + " | p = " + p);
int c = 0;
int mp = 3 * p - 2;
int smp = 3 * p - 4;
for (int j = 0; j < N; j++) {
int tp = scanner.nextInt();
System.out.print(tp + " ");
if (tp >= mp) {
c++;
} else if (tp >= smp && S > 0 && smp >= 0) {
c++;
S--;
}
}
System.out.println();
System.out.println("c = " + c);
System.out.println("--------------");
output.println("Case #" + i + ": " + c);
}
scanner.close();
output.close();
}
}
| 0 | 1,189,189 |
A11759 | A11481 | 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 qualificationround;
import java.io.*;
import java.util.Scanner;
public class ProblemB {
/**
* @param args
*/
public static void main(String[] args) throws IOException{
Scanner sc = new Scanner(new FileReader("B.in"));
PrintWriter out = new PrintWriter(new FileWriter("B.out"));
int t = sc.nextInt();
for (int caseNum = 1; caseNum <= t; caseNum++)
{
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int count = 0;
for (int i = 0; i<n; i++)
{
int pscore = sc.nextInt();
int score = getScore(pscore);
if (score>=p)
count++;
else if (p-score == 1 && s>0 && pscore >=2)
{
s--;
count++;
}
}
out.println("Case #"+caseNum+": "+count);
}
out.close();
}
public static int getScore(int num)
{
if (num % 3 == 0)
return num/3;
else
return num/3+1;
}
}
| 0 | 1,189,190 |
A11759 | A13114 | 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.Arrays;
public class Dance {
public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
for (int i = 0; i < t; i++) {
String[] str = br.readLine().split(" ");
int n = Integer.parseInt(str[0]);
int s = Integer.parseInt(str[1]);
int p = Integer.parseInt(str[2]);
int[] tis = new int[n];
for (int j = 0; j < tis.length; j++) {
tis[j] = Integer.parseInt(str[3+j]);
}
System.out.println("Case #" + (i + 1) + ": " + find(n,s,p,tis));
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static int find(int n, int s, int p, int[] tis) {
Arrays.sort(tis);
int normalScore = Math.max(3*p-2, 0);
int surpriseScore = 3*p-4;
if (surpriseScore < 0) surpriseScore = normalScore;
int ind = tis.length-1;
for (; ind >= 0 && tis[ind] >= normalScore; ind--);
for (int i=0; ind >= 0 && i < s && tis[ind] >= surpriseScore; ind--, i++);
return n-ind-1;
}
}
| 0 | 1,189,191 |
A11759 | A12921 | 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 google.solver;
public interface ChallengeConstants {
public static final String DELIMITER = "\\";
public static final String CHALLENGE_DEFINITION = "challengeDefinition";
public static final String BASE_DIR= "D:\\Development\\Workspaces\\test1\\googleChallanges\\src\\google\\contest";
public static final String CHALLENGE_NAME="A";
public static final String TEST_IN="test.in";
}
| 0 | 1,189,192 |
A11759 | A11410 | 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 Goggledance {
private boolean isSurprising=false;
private boolean isCandidate=false;
int total,p;
public Goggledance(int total,int p){
this.total=total;
this.p=p;
determinesurprising();
}
private void determinesurprising() {
// TODO Auto-generated method stub
if(total/3>=p){
isSurprising=false;
isCandidate=true;
return;
}
int left=total-p;
if(left<0){
isSurprising=false;
isCandidate=false;
return;
}
int left1=left/2;
int left2=left-left1;
if(p-left1<=1 && p-left2<=1){
isSurprising=false;
isCandidate=true;
return;
}
if(p-left1<=2 && p-left2<=2){
isSurprising=true;
isCandidate=true;
return;
}
isSurprising=false;
isCandidate=false;
}
public boolean isSurprising() {
return isSurprising;
}
public boolean isCandidate() {
return isCandidate;
}
}
| 0 | 1,189,193 |
A11759 | A10594 | 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 ProblemSolvers;
import CaseSolvers.GooglereseCase;
import CaseSolvers.WiresCase;
public class Googlerese extends ProblemSolver {
public Googlerese(String filePath) {
super(filePath);
}
@Override
public void process() {
cases = io.readInt();
for (int i = 1; i <= cases; i++) {
new GooglereseCase(i, 1, io).process().printSolution();
}
}
}
| 0 | 1,189,194 |
A11759 | A10031 | 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 DancingWithGooglers {
Scanner s = new Scanner(System.in);
public static void main(String args[]) {
DancingWithGooglers p = new DancingWithGooglers();
p.run();
}
void run() {
prepare();
int nCases = s.nextInt();
for (int i=0; i<nCases; i++) {
System.out.println("Case #"+(i+1)+": "+runOneCase());
}
}
int[][] mTable = new int[31][2];
void prepare() {
for (int i=1; i<=28; i++) {
mTable[i][0] = (i+2) / 3;
mTable[i][1] = (i+4) / 3;
}
mTable[29][0] = 10;
mTable[29][1] = 10;
mTable[30][0] = 10;
mTable[30][1] = 10;
}
int runOneCase() {
int N = s.nextInt();
int S = s.nextInt();
int P = s.nextInt();
int count = 0;
for (int i=0; i<N; i++) {
int score = s.nextInt();
if (mTable[score][0] >= P) {
count++;
} else if (S>0 && mTable[score][1]>=P) {
count++;
S--;
}
}
return count;
}
} | 0 | 1,189,195 |
A11759 | A10007 | 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.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Scanner;
public class QB {
public static int cal(Scanner sc){
int result = 0;
int N = sc.nextInt();
int S = sc.nextInt();
int p = sc.nextInt();
if(p > 1){
for(int i=0; i<N; i++){
int t = sc.nextInt();
if(t >= p*3-2){
result++;
} else if(t >= p*3-4 && S > 0){
S--;
result++;
}
}
} else if(p == 1){
for(int i=0; i<N; i++){
int t = sc.nextInt();
if(t != 0){
result++;
}
}
} else if(p == 0){
for(int i=0; i<N; i++){
int t = sc.nextInt();
result++;
}
}
return result;
}
public static void main ( String [] args ) throws IOException
{
Scanner sc = new Scanner(new File("B-small-attempt0.in"));
Path file = FileSystems.getDefault().getPath(".", "B-small-practice.out");
BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.US_ASCII, StandardOpenOption.CREATE);
int t = sc.nextInt();
for(int i=0; i<t; i++){
String output = String.format("Case #%d: %d\n", i+1, cal(sc));
writer.write(output);
}
sc.close();
writer.flush();
writer.close();
}
} | 0 | 1,189,196 |
A11759 | A12419 | 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 {
public static void main(String[] args) throws IOException {
//variable initialization
String inFile = args[0];
String outFile = inFile.split("\\.")[0] + ".out";
//file reading...
BufferedReader reader = new BufferedReader(new FileReader(inFile));
PrintWriter writer = new PrintWriter(new FileWriter(outFile));
//get input data
int T = Integer.valueOf(reader.readLine());
for (int i = 0; i < T; i++) {
String[] str_nums = reader.readLine().split(" ");
int[] nums = new int[str_nums.length];
int n = 0;
for (String str : str_nums) {
nums[n++] = Integer.valueOf(str);
}
int N = nums[0];
int S = nums[1];
int p = nums[2];
int res = 0;
for (n = 0; n < N; n++) {
int total = nums[n+3];
int k = total / 3;
int k2 = total % 3;
if (k >= p) res++;
else if (p-k == 1 && k2 > 0) res++;
else if (S > 0)
if (k2 >= p-k || (k2 == 0 && k != 0 && p-k == 1)) {
S--;
res++;
// System.out.println("Surpraise: (" + k + "," + k + "," + (k+k2) + ") p=" + p);
}
}
String result = "Case #" + (i+1) + ": " + res;
writer.println(result);
// char[] line = readerReal.readLine().toCharArray();
// for (char c : line) {
// if (dict.containsKey(c)) {
// writer.write(dict.get(c));
// } else {
// writer.write(c);
// }
// }
// writer.write('\n');
// System.out.println(Arrays.toString(nums));
// System.out.println(result);
}
reader.close();
writer.close();
}
}
| 0 | 1,189,197 |
A11759 | A11454 | 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.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Problem2 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("B-small.txt"));
PrintWriter out = new PrintWriter(new File("B-out.txt"));
int testCases = Integer.parseInt(in.readLine().trim());
for (int i = 0; i < testCases; i++) {
String line = in.readLine();
StringTokenizer tokenizer = new StringTokenizer(line);
int numDancers = Integer.parseInt(tokenizer.nextToken());
int S = Integer.parseInt(tokenizer.nextToken());
int p = Integer.parseInt(tokenizer.nextToken());
int result = 0;
for (int j = 0; j < numDancers; j++) {
int score = Integer.parseInt(tokenizer.nextToken());
int subScore1 = -1;
int subScore2 = -1;
boolean isValid2 = true;
if (score % 3 == 0) {
subScore1 = score / 3;
if (score - 3 < 0) {
isValid2 = false;
}
subScore2 = ((score - 3) / 3) + 2;
}
if (score % 3 == 1) {
if (score - 4 < 0) {
isValid2 = false;
}
subScore1 = ((score - 1) / 3) + 1;
subScore2 = ((score - 4) / 3) + 2;
}
if (score % 3 == 2) {
if (score - 2 < 0) {
isValid2 = false;
}
subScore1 = ((score - 2) / 3) + 1;
subScore2 = ((score - 2) / 3) + 2;
}
if(subScore2 > 10){
isValid2 = false;
}
if (subScore1 >= p) {
result++;
} else if (isValid2) {
if (subScore2 < p) {
continue;
} else {
if (S != 0) {
result++;
S--;
}
}
}
}
out.println("Case #" + (i + 1) + ": " + result);
}
out.close();
}
}
| 0 | 1,189,198 |
A11759 | A10130 | 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.PrintWriter;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
class Pair {
int a;
int b;
Pair(int a, int b) {
this.a = a;
this.b = b;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + getOuterType().hashCode();
result = prime * result + a;
result = prime * result + b;
return result;
}
@Override
public boolean equals(Object o) {
Pair second = (Pair) o;
if (second == null) {
return false;
}
return this.a == second.a && this.b == second.b || this.a == second.b && this.b == second.b;
}
private Main getOuterType() {
return Main.this;
}
}
Scanner in;
PrintWriter out;
void asserT(boolean e) {
if (!e) {
throw new Error();
}
}
int maxDigitAtSurprise[] = new int[31];
int maxDigitAtNotSurprise[] = new int[31];
void solve() {
for (int sum = 0; sum <= 30; sum++) {
for (int c = 0; c <= 10; c++) {
for (int p = 0; p <= 10; p++) {
if (2 * c + p + 1 == sum && c + 1 <= 10 && Math.abs(c - p) <= 1 && Math.abs(c + 1 - p) <= 1) {
maxDigitAtNotSurprise[sum] =Math.max(maxDigitAtNotSurprise[sum],Math.max(c + 1, p));
}
if (3*c==sum){
maxDigitAtNotSurprise[sum] =Math.max(maxDigitAtNotSurprise[sum],c);
}
}
}
for (int c = 0; c <= 10; c++) {
for (int p = 0; p <= 10; p++) {
if (2 * c + p + 2 == sum && c + 2 <= 10 && Math.abs(c - p) <= 2 && Math.abs(c + 2 - p) <= 2) {
maxDigitAtSurprise[sum] =Math.max( maxDigitAtSurprise[sum], Math.max(c + 2, p));
}
}
}
}
int nTests = in.nextInt();
for (int i = 1; i <= nTests; i++) {
out.println("Case #" + i + ": " + solveOne());
}
}
long solveOne() {
int n = in.nextInt();
int nSurp = in.nextInt();
int minMax = in.nextInt();
Set<Integer> surpIds = new TreeSet<Integer>();
Set<Integer> notSuriIds = new TreeSet<Integer>();
Set<Integer> bad = new TreeSet<Integer>();
int cnt = 0;
int nums[] = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = in.nextInt();
int sum = nums[i];
if (maxDigitAtNotSurprise[sum] >= minMax && maxDigitAtSurprise[sum] >= minMax) {
cnt++;
}else if (maxDigitAtSurprise[sum]>=minMax){
surpIds.add(i);
}else if (maxDigitAtNotSurprise[sum]>=minMax){
notSuriIds.add(i);
}else{
bad.add(i);
}
}
cnt+=Math.min(surpIds.size(),nSurp )+notSuriIds.size();
return cnt;
}
void run() {
try {
in = new Scanner(new FileReader("B-small-attempt1.in"));
// in = new Scanner(System.in);
out = new PrintWriter("output.txt");
} catch (Exception e) {
// TODO: handle exception
}
try {
solve();
} finally {
out.close();
}
}
public static void main(String[] args) {
new Main().run();
}
} | 0 | 1,189,199 |