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 | A10165 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.PrintStream;
import java.util.ArrayList;
import java.util.Scanner;
/**
* @author Paul LaMotte
*
*/
public class GooglerDance {
public static void main(String[] args) {
Scanner in;
try {
System.setOut(new PrintStream(new File("qualB.out")));
in = new Scanner(new File("B-small-attempt2.in"));
int lines = Integer.parseInt(in.nextLine());
for (int i = 0; i < lines; i++) {
int googlers = in.nextInt();
int trips = in.nextInt();
int best = in.nextInt();
int count = 0;
ArrayList<Integer> scores = new ArrayList<Integer>();
for (int j = 0; j < googlers; j++) {
int score = in.nextInt();
int rem = score - best;
int tmp = (int)Math.floor(rem / 2);
if (score < best) {
continue;
}
if (best - tmp <= 1) {
count++;
} else if (best - tmp <= 2 && trips > 0) {
trips -= 1;
count++;
}
}
System.out.printf("Case #%d: %d\n", i + 1, count);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}
| 0 | 1,189,400 |
A11759 | A11989 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | class CodeJam2012 {
public static void main(String[] args) {
String[] input = "100 3 1 5 15 13 11 3 0 8 23 22 21 2 0 4 9 8 2 0 4 16 4 2 0 8 20 5 1 0 6 7 1 0 4 17 3 1 4 25 9 8 3 1 5 12 12 11 3 0 6 6 12 8 2 0 10 26 26 3 0 8 21 21 1 1 0 3 6 3 0 10 2 28 10 2 1 3 5 6 3 3 4 18 8 3 1 0 9 23 1 0 4 9 3 3 0 4 24 21 3 3 10 27 7 20 1 0 4 8 1 0 10 26 3 0 1 17 13 21 3 0 10 7 1 1 2 2 6 22 12 1 0 9 24 2 0 8 7 7 3 0 1 25 13 0 2 0 5 27 12 2 0 9 5 1 2 1 9 26 18 2 1 0 5 10 3 0 10 26 14 11 2 2 5 15 2 1 0 6 15 1 0 6 14 2 2 9 14 4 2 0 4 8 8 3 2 2 6 6 8 3 1 10 27 30 27 1 0 0 16 3 0 10 17 12 15 2 0 4 23 7 3 0 10 30 30 30 1 0 3 6 1 0 9 12 1 0 4 20 1 1 2 3 2 1 1 22 0 2 1 5 26 10 1 0 5 12 2 2 1 2 25 2 1 4 8 17 1 1 4 14 1 1 8 15 2 2 8 15 2 2 0 6 5 6 2 2 9 5 10 2 0 9 16 11 3 3 7 26 21 28 2 0 0 30 30 1 0 8 0 1 1 2 27 1 0 4 9 3 2 5 11 12 12 1 0 8 20 1 1 4 25 1 0 6 14 1 0 8 26 3 2 0 9 9 10 1 0 6 15 2 0 4 1 8 1 1 3 5 3 0 2 22 3 1 2 2 2 24 18 1 0 0 0 3 0 1 7 25 14 1 0 10 17 1 0 9 24 3 0 8 22 18 20 1 1 5 11 3 1 9 24 23 28 2 2 1 22 6 3 1 5 11 12 16 3 1 1 6 3 17 2 0 6 14 14 2 2 2 22 6 2 2 5 21 21 2 1 7 6 9 3 0 1 0 0 0 3 0 9 9 13 27 3 0 7 17 18 17 1 0 10 27 3 1 3 6 5 14 1 0 2 14 2 0 6 14 26 3 1 8 15 15 4 1 1 9 24 3 0 0 27 3 23 3 1 5 20 11 12 ".split(" ");
QuestionA(input);
}
static void QuestionA(String[] input){
int inputCounter = 0, T, N, S, p, nonSupprising, supprising, googlers, thresholdSmall, thresholdLarge;
T=Integer.valueOf(input[inputCounter]);
inputCounter++;
for (int i=0; i<T; i++){
N=Integer.valueOf(input[inputCounter]);
inputCounter++;
S=Integer.valueOf(input[inputCounter]);
inputCounter++;
p=Integer.valueOf(input[inputCounter]);
inputCounter++;
nonSupprising=0;
supprising=0;
thresholdSmall= Math.max(p,p*3-4);
thresholdLarge= Math.max(p,p*3-2);
for(int j=0; j<N;j++){
googlers=Integer.valueOf(input[inputCounter]);
inputCounter++;
if(googlers>=thresholdLarge){
nonSupprising++;
}
else if(googlers>=thresholdSmall){
supprising++;
}
}
System.out.print("Case #"+(i+1)+": "+(nonSupprising+Math.min(supprising, S))+"\n");
}
}
} | 0 | 1,189,401 |
A11759 | A10859 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
public class Googlers {
public static void main(String[] args) throws Exception {
String srcFile = "C:" + File.separator + "Documents and Settings"
+ File.separator + "rohit" + File.separator + "My Documents"
+ File.separator + "Downloads" + File.separator
+ "A-small-attempt0.in";
String destFile = "C:" + File.separator + "Documents and Settings"
+ File.separator + "rohit" + File.separator + "My Documents"
+ File.separator + "Downloads" + File.separator
+ "A-small-attempt0.out";
File file = new File(srcFile);
List<String> readData = new ArrayList<String>();
FileReader fileInputStream = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileInputStream);
StringBuilder stringBuilder = new StringBuilder();
String line = null;
while ((line = bufferedReader.readLine()) != null) {
readData.add(line);
}
stringBuilder.append(generateOutput(readData));
File writeFile = new File(destFile);
if (!writeFile.exists()) {
writeFile.createNewFile();
}
FileWriter fileWriter = new FileWriter(writeFile);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write(stringBuilder.toString());
bufferedWriter.close();
System.out.println("output" + stringBuilder);
}
/**
* @param number
* @return
*/
private static String generateOutput(List<String> number) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < number.size(); i++) {
if (i == 0) {
continue;
} else {
String tempString = number.get(i);
stringBuilder.append("Case #" + i + ": ");
stringBuilder.append(testMethod(tempString));
stringBuilder.append("\n");
}
}
if (stringBuilder.length() > 0) {
stringBuilder.deleteCharAt(stringBuilder.length() - 1);
}
return stringBuilder.toString();
}
private static List<Integer> probability(int total) {
List<Integer> val = new ArrayList<Integer>();
int n1, n2, n3, n;
n = total / 3;
n1 = n2 = n3 = n;
if (n1 + n2 + n3 == total) {
n1 = n2 = n3 = n;
}
if (n1 + n2 + n3 + 1 == total) {
n1 = n1 + 1;
}
if (n1 + n2 + n3 + 2 == total) {
n1 = n1 + 1;
n2 = n2 + 1;
}
val.add(n1);
val.add(n2);
val.add(n3);
return val;
}
private static List<Integer> probabilityWithSurp(int total) {
List<Integer> val = new ArrayList<Integer>();
int n1, n2, n3, n;
n = total / 3;
n1 = n2 = n3 = n;
if (total % 3 == 0) {
n1 = n1 - 1;
n3 = n3 + 1;
} else if (total % 3 == 1) {
n1 = n1 + 1;
n2 = n2 + 1;
n3 = n3 - 1;
} else if (total % 3 == 2) {
n3 = n3 + 2;
}
val.add(n1);
val.add(n2);
val.add(n3);
return val;
}
private static String testMethod(String test) {
String[] testArr = test.split(" ");
int noOfG = Integer.valueOf(testArr[0]);
int supR = Integer.valueOf(testArr[1]);
int freQ = Integer.valueOf(testArr[2]);
List<Integer> val = new ArrayList<Integer>();
int count = 0;
for (int i = 3; i < noOfG + 3; i++) {
int no = Integer.valueOf(testArr[i]);
val = probability(no);
System.out.println(i + " " + val.toString());
boolean isFreqPresent = testIsPresent(val, freQ);
if (isFreqPresent) {
count++;
} else {
if (supR > 0 && no >= 2 && no <= 28) {
val = probabilityWithSurp(no);
System.out.println(i + " " + val.toString());
if (testIsPresent(val, freQ)) {
count++;
supR--;
}
}
}
}
return String.valueOf(count);
}
private static boolean testIsPresent(List<Integer> valInsideList, int freQ) {
boolean isFreq = false;
for (Integer valInside : valInsideList) {
if (valInside >= freQ) {
isFreq = true;
break;
}
}
return isFreq;
}
} | 0 | 1,189,402 |
A11759 | A11145 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class DancingWithTheGooglers {
public static void readInput(String pFileName, List<String> pInputCases) {
File tFile = new File(pFileName);
try {
BufferedReader tBufferedReader = new BufferedReader(
new InputStreamReader(new FileInputStream(tFile)), 4096);
String tLineRead = tBufferedReader.readLine().trim();
int tCaseSize = Integer.valueOf(tLineRead);
int tLineIndex = 0;
while(tLineIndex < tCaseSize) {
tLineRead = tBufferedReader.readLine().trim();
pInputCases.add(tLineRead);
tLineIndex++;
}
} catch(FileNotFoundException pException) {
pException.printStackTrace();
} catch(IOException pException) {
pException.printStackTrace();
}
}
public static void main(String[] pArgs) throws Exception {
if(pArgs.length == 0) {
throw new Exception("no input");
}
List<String> tInputCases = new ArrayList<String>();
readInput(pArgs[0], tInputCases);
for(int tCaseIndex = 0; tCaseIndex < tInputCases.size(); tCaseIndex++) {
String[] tInputs = tInputCases.get(tCaseIndex).split("[ ]+");
int tNumberOfGooglers = Integer.valueOf(tInputs[0]);
int tSurprise = Integer.valueOf(tInputs[1]);
int tPoint = Integer.valueOf(tInputs[2]);
//System.out.print(tNumberOfGooglers);
//System.out.print(" ");
//System.out.print(tSurprise);
//System.out.print(" ");
//System.out.print(tPoint);
//System.out.println();
int tNumber = 0;
for(int i = 3; i < tNumberOfGooglers + 3; ++i) {
int tTotal = Integer.valueOf(tInputs[i]);
//System.out.print(tInputs[i]);
//System.out.print(" ");
int tDifference = tTotal % 3;
int tScore = tTotal / 3;
//System.out.print(tDifference);
//System.out.print(",");
//System.out.print(tScore);
//System.out.print(" ");
switch(tDifference) {
case 0:
if(tScore >= tPoint) {
++tNumber;
} else if((tScore + 1 >= tPoint) && (tScore > 0)) {
if(tSurprise > 0) {
++tNumber;
--tSurprise;
}
}
break;
case 1:
if(tScore + 1 >= tPoint) {
++tNumber;
}
break;
case 2:
if(tScore + 1 >= tPoint) {
++tNumber;
} else if(tScore + 2 >= tPoint) {
if(tSurprise > 0) {
++tNumber;
--tSurprise;
}
}
break;
}
//System.out.println("Case #" + tCaseIndex + ": " + tNumber);
}
System.out.println("Case #" + (tCaseIndex + 1) + ": " + tNumber);
}
}
}
| 0 | 1,189,403 |
A11759 | A10808 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 problemB;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;
public class DancingwithTheGooglers {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("B-small-attempt0.in"));
FileWriter fw = new FileWriter("B-small-attempt0.out");
/*BufferedReader in = new BufferedReader(new FileReader("A-large-practice.in"));
FileWriter fw = new FileWriter("A-large-practice.out");*/
int T = new Integer(in.readLine());
for (int cases = 1; cases <= T; cases++){
StringTokenizer st=new StringTokenizer(in.readLine());
int numG = new Integer(st.nextToken());
int numTriplets = new Integer(st.nextToken());
int leastP = new Integer(st.nextToken());
Integer[] A = new Integer[numG];
for (int i = 0; i < A.length; i++){
A[i] = new Integer(st.nextToken());
}
Arrays.sort(A, Collections.reverseOrder());
int result = 0;
for (int i = 0; i < A.length; i++){
if (A[i] >= 2){
if (A[i] > (leastP * 3 - 3)){
result++;
}
else{
if ((A[i] > (leastP *3 - 5)) && numTriplets > 0){
result++;
numTriplets--;
}
}
}
else{
if (A[i] >= leastP){
result++;
}
}
}
if (cases != T) {fw.write("Case #" + cases + ": "+ result + "\n"); }
else{fw.write("Case #" + cases + ": "+ result);}
}
fw.flush();
fw.close();
}
}
| 0 | 1,189,404 |
A11759 | A10222 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.code;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
/**
* @author Wellington Tadeu dos Santos [wellsantos@wellsantos.com]
*/
public class ProblemB {
boolean endOfLine;
Reader reader;
Appendable writer;
public ProblemB(Reader in, Appendable out) throws Exception {
this.reader = in;
this.writer = out;
}
public static void main(String[] args) throws Exception {
long time = System.nanoTime();
String in = "./src/com/google/code/B-small-attempt5.in";
String out = in.substring(0, in.length() - 3) + ".out";
FileReader reader = new FileReader(in);
FileWriter writer = new FileWriter(out);
new ProblemB(reader, writer).run();
writer.flush();
writer.close();
reader.close();
System.out.println((System.nanoTime() - time) / 1000000.0);
}
private int readInt() throws Exception {
int val = 0;
int chr;
while ((chr = this.reader.read()) >= '0' && chr <= '9') {
val = val * 10 + (chr - '0');
}
switch (chr) {
case '\r':
chr = this.reader.read();
case '\n':
case -1:
this.endOfLine = true;
break;
default:
this.endOfLine = false;
}
return val;
}
private void run() throws Exception {
int testCases = this.readInt();
for (int caseIndex = 1; caseIndex <= testCases; caseIndex++) {
int n = this.readInt();
int s = this.readInt();
int p = this.readInt();
int scored = 0;
int surprisingPossibility = 0;
for (int i = 0, c = n; i < c; i++) {
int ti = this.readInt();
int dif = (ti % 3);
int low = ti / 3;
switch (dif) {
case 0:
if (low >= p){
scored++;
} else if (low + 1 >=p && low > 0){
surprisingPossibility++;
}
break;
case 1:
if (low + 1>= p){
scored++;
}
break;
case 2:
if (low + 1>= p){
scored++;
} else if (low + 2 >=p){
surprisingPossibility++;
}
break;
}
}
if (surprisingPossibility > s) {
surprisingPossibility = s;
}
scored += surprisingPossibility;
this.writer.append("Case #" + caseIndex + ": " + scored + "\n");
}
}
} | 0 | 1,189,405 |
A11759 | A12242 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 cats;
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public Main() throws Exception{
FileReader fr = new FileReader(new File("input.txt"));
BufferedReader in = new BufferedReader(fr);
File outFile = new File("output.txt");
outFile.createNewFile();
FileWriter fw = new FileWriter(outFile);
BufferedWriter out = new BufferedWriter(fw);
int numTests = Integer.parseInt(in.readLine());
for(int x = 0; x<numTests; x++){
System.out.println("Working on case " + x + " of " + numTests);
String[] split = in.readLine().split(" ");
int numPeople, surprises, scoreToBeat;
numPeople = Integer.parseInt(split[0]);
surprises = Integer.parseInt(split[1]);
scoreToBeat = Integer.parseInt(split[2]);
ArrayList<Integer> totals = new ArrayList<Integer>(numPeople);
for(int p = 0; p<numPeople; p++){
totals.add(Integer.parseInt(split[3+p]));
}
Collections.sort(totals);
Collections.reverse(totals);
int count = 0;
int surprisesLeft = surprises;
for(int t: totals){
if(t == 0){
if(scoreToBeat == 0) count++;
else break;
}else if(t >= scoreToBeat+(scoreToBeat-1)*2){
count++;
}else if(t >= scoreToBeat+(scoreToBeat-2)*2 && surprisesLeft > 0){
surprisesLeft--;
count++;
}else break;
}
out.write("Case #" + (x+1) + ": " + count + "\n");
}
in.close();
out.close();
}
public static void main(String[] args) throws Exception{
new Main();
}
}
| 0 | 1,189,406 |
A11759 | A12099 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
class Main
{
public static int dance(int ll,int spp,int maxx,int g[])
{
int c=0;
int l=ll;
long result[][]=new long[l][4];
int max=maxx;
//int g[]={15,13,11};
int s=0;
int i=0;
int sum=0;
int flag=0;
int t=2;
int presp=spp;
int special=0;
int sp=0;
int sol=0;int maxsol=0;int row=0;
int sum2=0;
boolean yes=true;
for(int loop=0;loop<l;loop++)
{
i=0;
while(i<=10 && flag==0)
{
for(int j=i;j<=i+t && flag==0;j++)
{
for(int k=i;k<=i+t && flag==0;k++)
{
sum=i+j+k;
if(sum==g[loop])
{
sum2=sum;
sol++;
if(j==i+2 || k==i+2)
{
sp++;
special++;
}
//System.out.println(sum+" ... "+g[loop]);
if(i>=max || j>=max ||k>=max)
{
maxsol++;
//System.out.println(i+ " "+j+" "+k);
c++;
flag=0;
}
}
}
}
i++;
/*if(special==presp)
{
t=1;
special=0;
}*/
}
result[row][0]=sum2;
result[row][1]=sol;
result[row][3]=sp;
result[row][2]=maxsol;
row++;
flag=0;
sol=0;
maxsol=0;
sp=0;
}
//System.out.println("ans :"+c);
//System.out.println("special :"+special);
int ans=0;
sort(result,l);
for(int rr=0;rr<l;rr++)
{
if(result[rr][2]>0)
{
presp=rr+presp;
break;
}
}
//System.out.println("presp ="+presp);
for(int rr=0;rr<l;rr++)
{
if(result[rr][2]>0 )
{
if(rr>(presp-1))
{
if(result[rr][3]>=result[rr][2])
{
yes=false;
}
}
if(yes)
ans++;
yes=true;
}
/*
for(int cc=0;cc<4;cc++)
{
//System.out.print(result[rr][cc]+" | ");
}
System.out.println();*/
}
//System.out.println("ans right:"+ans);
return ans;
}
public static void sort(long a[][],int l)
{
long cell1=0,cell2=0,cell3=0,cell4=0;
for(int i=0;i<l;i++)
{
for(int j=i+1;j<l;j++)
{
if(a[i][2]>a[j][2])
{
cell1=a[i][0];
cell2=a[i][1];
cell3=a[i][2];
cell4=a[i][3];
a[i][0]=a[j][0];
a[i][1]=a[j][1];
a[i][2]=a[j][2];
a[i][3]=a[j][3];
a[j][0]=cell1;
a[j][1]=cell2;
a[j][2]=cell3;
a[j][3]=cell4;
}
}
}
}
public static void main(String ar[]) throws IOException
{
FileReader in=new FileReader("hello.txt");
FileWriter ot=new FileWriter("check.txt",true);
BufferedReader ds=new BufferedReader(in);
BufferedWriter out=new BufferedWriter(ot);
//System.out.println("check332wefsd");
int loop=Integer.parseInt(ds.readLine());
String i[]=new String[loop];
int ll,maxx,sp;
int rs[];
int ans;
for(int ii=1;ii<=loop;ii++)
{
i=ds.readLine().split(" ");
ll=Integer.parseInt(i[0]);
sp=Integer.parseInt(i[1]);
maxx=Integer.parseInt(i[2]);
rs=new int[ll];
for(int j=3;j<ll+3;j++)
{
rs[j-3]=Integer.parseInt(i[j]);
}
ans=dance(ll,sp,maxx,rs);
out.write("Case #"+String.valueOf(ii)+": "+String.valueOf(ans));
out.newLine();
}
in.close();
out.close();
}
} | 0 | 1,189,407 |
A11759 | A11102 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
public class ProblemB {
/*
* Takes an input file and output file as inputs.
*/
public static void main(String file[]) throws IOException{
BufferedReader in;
BufferedWriter out;
int numCases, numGooglers, numSurp, p, score;
Integer result;
// Open the file and create a reader
in = new BufferedReader(new FileReader(file[0]));
// Create an output file and a writer
out = new BufferedWriter(new FileWriter(file[1]));
numCases = Integer.parseInt(in.readLine());
// for each case
for (int i = 0; i < numCases; i++) {
out.write("Case #" + (i+1) + ": ");
// prepare variables
String line = in.readLine();
String[] numbers = line.split(" ");
numGooglers = Integer.parseInt(numbers[0]);
numSurp = Integer.parseInt(numbers[1]);
p = Integer.parseInt(numbers[2]);
result = 0;
for (int j = 0; j < numGooglers; j++) {
score = Integer.parseInt(numbers[j+3]);
// first check if it could give p without being surprising
if (score >= 3*p-2) {
result++;
if (score < p)
result--;
}
// otherwise see if it could give p being a surprise and
// also if we even have any suprises left
else if (numSurp > 0 && score >= 3*p-4) {
result++;
numSurp--;
if (score < p) {
result--;
numSurp++;
}
}
}
System.out.println(result);
out.write(result.toString());
out.newLine();
}
in.close();
out.close();
}
}
| 0 | 1,189,408 |
A11759 | A10475 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.PrintWriter;
import java.util.Scanner;
public class dancers {
public static void main(String[] args) {
try {
Scanner input = new Scanner(new File("c:\\files\\B-small-attempt0.in"));
FileWriter fw = new FileWriter("c:\\files\\douts.txt");
PrintWriter output = new PrintWriter(fw);
int n = input.nextInt();
for(int i=0;i<n;i++)
{
int noD = input.nextInt();
int surprise = input.nextInt();
int points = input.nextInt();
int total[] = new int[noD];
int count = 0;
for(int j=0;j<noD;j++)
total[j]=input.nextInt();
for(int j=0;j<noD-1;j++)
for(int k=j+1;k<noD;k++)
if(total[j]<total[k])
{
int temp=total[j];
total[j]=total[k];
total[k]=temp;
}
for(int dIndex=0;dIndex<noD;dIndex++)
{
if(total[dIndex]>=3*points-2)
count++;
else if(surprise>0 && (total[dIndex]==3*points-3 || total[dIndex]==3*points-4) && total[dIndex]>0)
{
surprise--;
count++;
}
else
break;
}
output.println("Case #"+(i+1)+": "+count);
}
output.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,409 |
A11759 | A10440 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileNotFoundException;
import java.io.PrintWriter;
import java.util.*;
public class Dance {
private static int raw_num;
private static int pot_num;
public static void main(String[] args) throws FileNotFoundException{
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter("dance_out.txt");
int t = in.nextInt();
for (int i = 0; i < t; i++){
raw_num = pot_num = 0;
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
for (int j = 0; j < n; j++){
process(in.nextInt(), p);
}
if (pot_num < s)
raw_num += pot_num;
else
raw_num += s;
out.printf("Case #%d: %d%n", i+1, raw_num);
}
out.close();
}
private static void process(int score, int p){
switch (score % 3) {
case 0:
if (score / 3 >= p)
raw_num++;
else {
if (score / 3 + 1 >= p && score / 3 - 1 > 0)
pot_num++;
}
break;
case 1:
if (score / 3 + 1 >= p)
raw_num++;
break;
case 2:
if (score / 3 + 1 >= p)
raw_num++;
else {
if (score / 3 + 2 >= p)
pot_num++;
}
default:
break;
}
}
}
| 0 | 1,189,410 |
A11759 | A12978 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.io.RandomAccessFile;
import java.util.Scanner;
public class Dancing {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
File f = new File("D://1.txt");
Scanner sc;
try {
sc = new Scanner(f);
int n = sc.nextInt();
//System.out.println(n);
for (int i = 0;i<n;i++){
int nn = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int num = 0;
int snum = 0;
for (int j = 0;j<nn;j++){
int val = sc.nextInt();
if (val/3 >=p)
num++;
else if (val/3 == p-1 && val/3 >= 0){
if (val % 3 ==0){
if (val/3-1 >= 0)
snum++;
}
else
num++;
}
else if (val/3 == p-2 && val/3 >= 0){
if (val % 3 ==2)
snum++;
}
}
num = num + (snum>s?s:snum);
System.out.println("Case #"+(i+1)+": "+num);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
| 0 | 1,189,411 |
A11759 | A12988 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 question2;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
/**
*
* @author karim
*/
public class Question2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
BufferedWriter out = new BufferedWriter(new FileWriter("output.out"));
BufferedReader in = new BufferedReader(new FileReader("B-small-attempt0.in"));
int numOfcases = Integer.parseInt(in.readLine());
for (int caseNum = 1; caseNum <= numOfcases; caseNum++) {
String input = in.readLine();
Scanner s = new Scanner(input);
int googlers = s.nextInt();
int surp = s.nextInt();
int p = s.nextInt();
int minCountedTriplet = 3*p -2;
int minCountedTripletWithSur = 3*p -4;
int output =0;
while(s.hasNextInt()){
int temp = s.nextInt();
if(temp >= minCountedTriplet)
output++;
else{
if(surp>0 && temp >= minCountedTripletWithSur && minCountedTripletWithSur>=0){
output++;
surp--;
}
}
}
out.write("Case #" + caseNum + ": " + output);
out.newLine();
}
out.flush();
out.close();
in.close();
// TODO code application logic here
}
}
| 0 | 1,189,412 |
A11759 | A10040 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class Dance {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(new File("B-small-attempt1.in"));
FileWriter fw = new FileWriter("dance.txt");
int k=0;
int n = Integer.parseInt(sc.nextLine());
for(int j = 0; j<n; j++){
k++;
String ln = sc.nextLine();
fw.write("Case #"+k+": ");
String arr[] = ln.split(" ");
//int num = Integer.parseInt(arr[0]);
int s = Integer.parseInt(arr[1]);
int p = Integer.parseInt(arr[2]);
int count = 0;
for(int i=3; i<arr.length; i++){
int t = Integer.parseInt(arr[i]);
if(t>=p){
if(Math.max(0, 3*p-2) <= t)
count++;
else if (Math.max(0, 3*p-4) <= t && s>0){
count++;
s--;
}
}
}
fw.write(count+"\n");
}
sc.close();
fw.close();
}
}
| 0 | 1,189,413 |
A11759 | A12853 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class Googlers {
static public int min(int a, int b){
return a < b ? a : b;
}
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
File f = new File( "B-small-attempt2.in" );
FileWriter out=new FileWriter("output.txt");
Scanner in = new Scanner(new FileReader(f));
if(f.exists()){
int T;
int N, S, p;
int[] t = new int[100];
T = in.nextInt();
for(int i = 1; i <= T; i++){
N = in.nextInt();
S = in.nextInt();
p = in.nextInt();
int sup = 0;
int litige = 0;
for(int j = 0; j < N ; j++)
t[j] = in.nextInt();
for(int j = 0; j < N ; j++){
if(t[j] >= 3*p-2)
sup++;
else
if(t[j] >= 3*p-4 && 3*p-4 >= 0)
litige++;
}
out.write("Case #" + i +": " + (sup+ min(S, litige))+ "\n");
}
}
in.close();
out.close();
}
}
| 0 | 1,189,414 |
A11759 | A12374 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.FileInputStream;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Nova
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream;
try {
inputStream = new FileInputStream("B.input.txt");
} catch (IOException e) {
throw new RuntimeException(e);
}
OutputStream outputStream;
try {
outputStream = new FileOutputStream("B.output.txt");
} catch (IOException e) {
throw new RuntimeException(e);
}
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int numberOfTests = in.nextInt();
for (int testNum = 1; testNum <= numberOfTests; testNum++) {
out.print("Case #" + testNum + ": ");
int res = 0;
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = in.nextInt();
for (int i = 0; i < n; i++) {
int cc = a[i] / 3;
if (a[i] % 3 != 0) cc++;
if (cc >= p) res++;
else if (s > 0) {
cc = a[i] / 3;
if (a[i] % 3 == 0 && cc > 0) cc++;
if (a[i] % 3 == 1) cc++;
if (a[i] % 3 == 2) cc += 2;
if (cc >= p) {
res++;
s--;
}
}
}
out.println(res);
}
}
}
class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(outputStream);
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
writer.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
| 0 | 1,189,415 |
A11759 | A11648 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class LaDanceGoogler {
public static void main(String[] args) throws IOException {
Path input = Paths.get("/Users/mdymczyk/google-codejam/Tongues/src/input.in");
List<String> lines = Files.readAllLines(input, Charset.forName("UTF-8"));
lines.remove(0);
int i = 1;
for(String line : lines) {
StringBuilder sb = new StringBuilder();
sb.append("Case #"+i+": ");
String[] numbers = line.split(" ");
int specials = Integer.parseInt(numbers[1]);
int searchedValue = Integer.parseInt(numbers[2]);
int results = 0;
for(int j = 3 ; j < numbers.length ; j++) {
int score = Integer.parseInt(numbers[j]);
for(int s = searchedValue ; s <= 10 ; s++){
int rest = score-s;
if(rest-2*s == 0 ||
(rest-2*s+1 == 0 && score-1 >= 0) ||
(rest-2*s+2 == 0 && score-1 >= 0)) {
results++;
break;
} else if(specials > 0 && ((rest-2*s+3 == 0 && score-1 >= 0) ||
(rest-2*s+4 == 0 && score-2 >= 0))) {
results++;
specials--;
break;
}
}
}
sb.append(results);
System.out.println(sb);
i++;
}
}
}
| 0 | 1,189,416 |
A11759 | A10874 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Test1;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Test1 {
static String[] orig = {"ejp mysljylc kd kxveddknmc re jsicpdrysi", "rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd","de kr kd eoya kw aej tysr re ujdr lkgc jv"};
static String[] target = {"our language is impossible to understand","there are twenty six factorial possibilities","so it is okay if you want to just give up"};
static int[] map = new int[26];
static int[] hash = new int[26];
public static void main(String[] args) {
int n,s,p,T;
int[] t = new int[31];
BufferedReader in = new BufferedReader(new InputStreamReader(System.in)) ;
try {
String str = in.readLine();
int result,vaildp,tempmax;
n = Integer.parseInt(str.trim());
for (int i = 1; i <= n; i++) {
str = in.readLine();
String[] temp = str.split(" ");
T = Integer.parseInt(temp[0]);
s = Integer.parseInt(temp[1]);
p = Integer.parseInt(temp[2]);
result = 0;
vaildp = 0;
for (int j=3; j<temp.length;j++){
int numtemp = Integer.parseInt(temp[j]);
int max = numtemp / 3;
if (numtemp % 3 != 0) max++;
if (max >= p) result++;
else {
tempmax = numtemp / 3;
if (numtemp % 3 == 1) tempmax = tempmax +1;
else if (numtemp % 3 == 2) tempmax = tempmax +2;
else if (tempmax > 0) tempmax = tempmax + 1;
if (tempmax >= p) vaildp++;
}
//System.out.println("num="+numtemp+";max="+max+";vild="+vaildp);
}
if (vaildp > s) vaildp = s;
result = result + vaildp;
if (result > T) result = T;
System.out.println("Case #"+i+": "+result);
//System.out.println("");
}
} catch (Exception e) {
}
}
}
| 0 | 1,189,417 |
A11759 | A12743 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Solve {
public static void main ( String[] args ) throws FileNotFoundException, IOException {
BufferedReader in = new BufferedReader( new FileReader ( args[0] ) );
BufferedWriter out = new BufferedWriter( new FileWriter ( "outfile.txt" ) );
int cases = Integer.parseInt( in.readLine() );
String[] tmp;
int number, surprising, minimum, count, allMax, result;
int[] scores;
for ( int i = 1; i <= cases; i++ ) {
tmp = in.readLine().split( " " );
result = 0;
number = Integer.parseInt( tmp[0] );
surprising = Integer.parseInt( tmp[1] );
minimum = Integer.parseInt( tmp[2] );
scores = new int[ number ];
allMax = minimum * 3;
for ( int j = 0; j < number; j++ ) {
scores[j] = Integer.parseInt( tmp[ j + 3 ] );
}
for ( int j = number - 1; j >= 0; j-- ) {
if ( scores[j] > allMax - 3 ) {
result ++;
}
else {
if ( scores[j] >= allMax - 4 && minimum -2 >= 0) {
if ( surprising > 0 ) {
result++;
surprising--;
}
}
}
}
out.write( "Case #" + i + ": " + result );
out.newLine();
out.flush();
}
in.close();
out.close();
}
public static String replace( String first, String second, char target, char replacement ) {
String ret = "";
for ( int i = 0; i < first.length(); i++ ) {
if ( first.charAt( i ) == target ) {
ret = ret + replacement;
}
else {
ret = ret + second.charAt( i );
}
}
return ret;
}
}
| 0 | 1,189,418 |
A11759 | A12433 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.dancingwiththegooglers;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import codejam.common.AbstractProblemSolver;
public class DancingScoresProblemSolver extends
AbstractProblemSolver<DancingScores, Integer> {
@Override
public DancingScores readProblem(BufferedReader reader) throws IOException {
return new DancingScores(reader.readLine());
}
@Override
public Integer solveProblem(DancingScores problem) {
return problem.maxNumberScoresAboveThreshold();
}
@Override
public void writeSolution(int solutionNumber, Integer solution,
BufferedWriter writer) throws IOException {
writer.append("Case #" + solutionNumber + ": ");
writer.append(solution.toString());
writer.newLine();
}
public static void main(String[] args) {
new DancingScoresProblemSolver().solve(new File(
"D:/code/codejam/resources/dancing-input.txt"), new File(
"D:/code/codejam/resources/dancing-output.txt"));
}
}
| 0 | 1,189,419 |
A11759 | A10673 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.LineNumberReader;
import java.io.PrintWriter;
import java.util.Scanner;
public class go2 {
public static final String IN_FILE = "B-small-attempt0.in";
public static final String OUT_FILE = "out.txt";
public static void main(String[] args) throws Throwable {
try (LineNumberReader reader = new LineNumberReader(new FileReader(IN_FILE))) {
try (PrintWriter writer = new PrintWriter(OUT_FILE)) {
int T = Integer.parseInt(reader.readLine());
//Tests
for (int t = 1; t <= T; t++) {
Scanner scanner = new Scanner(reader.readLine());
int N = scanner.nextInt();
int S = scanner.nextInt();
int P = scanner.nextInt();
int result = 0;
int bothSurprisingAndNotSurprising = 0;
for (int i = 0; i < N; i++) {
int currentScore = scanner.nextInt();
if (currentScore == 0) {
if (P == 0) {
result++;
}
} else if (currentScore == 1) {
if (P == 0 || P == 1) {
result++;
}
} else if (currentScore == 30) {
result++;
} else if (currentScore == 29) {
result++;
}
// 2 <= currentScore <= 28
else {
int bestSurprising;
int bestNotSurprising;
if ((currentScore % 3 == 0)) {
bestSurprising = (currentScore / 3) + 1;
bestNotSurprising = (currentScore / 3);
}
else if ((currentScore % 3 == 1)) {
bestNotSurprising = bestSurprising = (currentScore / 3) + 1;
}
else {
bestSurprising = (currentScore / 3) + 2;
bestNotSurprising = (currentScore / 3) + 1;
}
if(bestNotSurprising < P && bestSurprising == P){
if(S > 0) {
S--;
result++;
}
}
else if(bestNotSurprising >= P){
bothSurprisingAndNotSurprising++;
}
}
}
result += bothSurprisingAndNotSurprising;
writer.printf("Case #%d: %d\n", t, result);
}
}
}
}
}
| 0 | 1,189,420 |
A11759 | A10229 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package codejam2;
public interface CodejamCase {
public void compute();
public String getOutput();
}
| 0 | 1,189,421 |
A11759 | A11057 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.PrintStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
/**
* @author Mark Devine
*
*/
public class B {
static final boolean DEBUG = false;
static Scanner in;
static PrintStream out;
public static void main(String[] args) throws FileNotFoundException {
if (DEBUG) {
in = new Scanner(new File("t"));
out = System.out;
} else {
in = new Scanner(new File(B.class.getName() + ".in"));
out = new PrintStream(B.class.getName() + ".out");
}
int T = i();
for (int i = 0; i < T; i++) {
pl(f("Case #%d: %s", i + 1, solve()));
}
out.close();
in.close();
System.out.println("Done");
}
static String solve() {
int Number = i();
int Surprising = i();
int minResult = i();
int supMin = 3 * minResult - 4;
int regMin = 3 * minResult - 2;
if (supMin == -1) {
supMin = 1;
}
if (supMin <= 0) {
supMin = 0;
}
if (regMin < 0) {
regMin = 0;
}
Integer[] results = new Integer[Number];
for (int i = 0; i < Number; i++) {
results[i] = i();
}
Arrays.sort(results, Collections.reverseOrder());
// pl(f("Suprising min: %d, %d", minResult, supMin));
// pl(Arrays.toString(results));
for (int i = 0; i < Number; i++) {
if (results[i] >= regMin) {
continue;
} else if (results[i] >= supMin && Surprising > 0) {
Surprising--;
continue;
} else {
return i + "";
}
}
return Number + "";
}
static void p(String x) {
out.print(x);
}
static void pl(String x) {
out.println(x);
}
static String f(String format, Object... args) {
return String.format(format, args);
}
static int i() {
return in.nextInt();
}
static long l() {
return in.nextLong();
}
static String s(String pattern) {
return in.next(pattern);
}
static String li() {
return in.nextLine();
}
} | 0 | 1,189,422 |
A11759 | A11882 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 dance;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
/**
*
* @author ALEX
*/
public class Dance {
public ArrayList<Scores> al;
public Dance()
{
al=new ArrayList<Scores>();
}
/**
* @param args the command line arguments
*/
public void readFile()
{
try {
FileReader fin=new FileReader("B-small-attempt0.in");
BufferedReader in = new BufferedReader(fin);
FileWriter fout=new FileWriter("result.txt");
BufferedWriter out=new BufferedWriter(fout);
int nrt;
nrt=Integer.valueOf(in.readLine());
String [] med;
for(int i=1;i<=nrt;i++)
{
String str=in.readLine();
med=str.split(" ");
int nrs = Integer.valueOf(med[0]);
int su = Integer.valueOf(med[1]);
int pe = Integer.valueOf(med[2]);
for(int j=1;j<=nrs;j++){
Scores ob=new Scores(Integer.valueOf(med[j+2]));
al.add(ob);
}
out.write("Case #"+i+": "+workFun(su,pe));
out.newLine();
al.clear();
}
in.close();
fin.close();
out.close();
fout.close();
}
catch(Exception e){}
}
public int workFun(int sup,int pes)
{
int nr=0;
int sp=0;
for(int i=0;i<al.size();i++){
if(al.get(i).getMaxS()>=pes && sp<sup && al.get(i).getMaxUnS()<pes){
nr++;
sp++;
}
else{
if(al.get(i).getMaxUnS()>=pes){
nr++;
}
}
}
return nr;
}
public static void main(String[] args) {
// TODO code application logic here
Dance d=new Dance();
d.readFile();
/*System.out.println(d.isSurprize(23,8,0));
System.out.println(d.isSurprize(22,8,0));
System.out.println(d.isSurprize(21,8,0));
System.out.println(d.nr);
System.out.println(d.b);*/
}
}
| 0 | 1,189,423 |
A11759 | A10574 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.DataInputStream;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
public class CodeJam {
public static void main(String[] args) throws IOException {
String outputFile = System.getenv("USERPROFILE") +
"\\Documents\\B-small.out";
String inputFile = System.getenv("USERPROFILE") +
"\\Documents\\B-small.in";
BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile));
DataInputStream reader = new DataInputStream(new FileInputStream(
inputFile));
int T = Integer.valueOf(reader.readLine());
for (int k = 1; k <= T; k++) {
String line = reader.readLine();
int nbreDancers = Integer.valueOf(line.substring(0,
line.indexOf(" ")));
line = line.substring(line.indexOf(" ") + 1);
int s = Integer.valueOf(line.substring(0, line.indexOf(" ")));
line = line.substring(line.indexOf(" ") + 1);
int p = Integer.valueOf(line.substring(0, line.indexOf(" ")));
line = line.substring(line.indexOf(" ") + 1);
line += " ";
int q = 0;
int n = 0;
if (3 * p - 4 < 0)
s = 0;
for (int j = 0; j < nbreDancers; j++) {
int sum = Integer.valueOf(line.substring(0, line.indexOf(" ")));
line = line.substring(line.indexOf(" ") + 1);
if (sum >= 3 * p - 4) {
if (((sum == 3 * p - 4) || (sum == 3 * p - 3))) {
q++;
if (q <= s) {
n++;
}
} else {
n++;
}
}
}
writer.write("Case #" + k + ": " + n);
writer.newLine();
}
writer.close();
}
} | 0 | 1,189,424 |
A11759 | A12597 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Dancing {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
String number = bReader.readLine();
int num = Integer.parseInt(number);
for (int i = 0; i < num; i++) {
String s = bReader.readLine();
String[] strs = s.split(" ");
int N = Integer.parseInt(strs[0]);
int S = Integer.parseInt(strs[1]);
int P = Integer.parseInt(strs[2]);
int s1 = P + 2*Math.max(0, P-1);
int s2 = P + 2*Math.max(0, P-2);
int result = 0;
for (int j = 0; j < N; j++) {
int tmp = Integer.parseInt(strs[3+j]);
if(tmp>=s1)
{
++result;
}else if(tmp>=s2 && S>0)
{
--S;
++result;
}
}
System.out.println("Case #"+(i+1)+": "+result);
}
}
}
| 0 | 1,189,425 |
A11759 | A11797 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 googlecodejam;
import java.io.*;
/**
*
* @author $Ruslan
*/
public class Dancing {
private static FileInputStream fileInputStream;
private static int testCaseNumber = -1;
public static void main(String[] args)
{
String filepath = "D:\\Programming\\NetBeansProjects\\" + ""
+ "GoogleCodeJam\\src\\googlecodejam\\B-small-attempt0.in";
try{
if (args[0] != "")
{
filepath = args[0];
}
} catch (Exception e) {
}
try{
fileInputStream = new FileInputStream(filepath);
readInput();
} catch (Exception e) {
System.err.println("Exception: " + e.getMessage());
}
}
private static void readInput()
{
try {
String str;
DataInputStream in = new DataInputStream(fileInputStream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
str = br.readLine();
testCaseNumber = Integer.parseInt(str);
System.out.println(testCaseNumber);
for (int i = 0; i < testCaseNumber; i++)
{
System.out.print("Case #"+(i+1)+":");
str = br.readLine();
calculate(str);
}
in.close();
} catch (IOException | NumberFormatException e) {
System.err.println("Exception: " + e.getMessage());
}
}
private static void calculate(String str)
{
String[] splitedStr = str.split(" ");
int amountOfGooglers = Integer.parseInt(splitedStr[0]);
int amountOfSurpTrp = Integer.parseInt(splitedStr[1]);
int maxValue = Integer.parseInt(splitedStr[2]);
int value = -1;
int answer = 0;
int minSet = 0;
for (int i = 0; i < amountOfGooglers; i++)
{
minSet = -1;
value = Integer.parseInt(splitedStr[i+3]);
minSet = maxValue*3-2;
if (value >= minSet)
{
answer++;
} else {
minSet -= 2;
if (minSet < 1)
{
minSet = 1;
}
if ((value >= minSet) && (amountOfSurpTrp > 0))
{
answer++;
amountOfSurpTrp--;
}
}
}
System.out.println(" " + answer);
}
}
| 0 | 1,189,426 |
A11759 | A12553 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.util.Arrays.deepToString;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
public class Solution {
private static void debug(final Object...objs) {
System.out.println(deepToString(objs));
}
private String solveCase() throws IOException {
final int N = nextInt();
int S = nextInt();
final int p = nextInt();
int res = 0;
for (int i = 0; i < N; i++) {
final int t = nextInt();
final int avg = t / 3;
if (avg >= p) {
res++;
continue;
}
if (avg + 2 < p) {
continue;
}
final int mod = t % 3;
if (mod == 0) {
if (S > 0 && avg > 0 && avg + 1 == p) {
res++;
S--;
}
}
else if (mod == 1) {
if (avg + 1 == p) res++;
}
else {
if (avg + 1 == p) res++;
else if (S > 0 && avg + 2 == p) {
res++;
S--;
}
}
}
return String.valueOf(res);
}
private void solve() throws IOException {
final int T = nextInt();
for (int test = 0; test < T; test++) {
final String result = "Case #" + (test + 1) + ": " + solveCase();
pw.println(result);
System.out.println(result);
}
}
private BufferedReader br;
private PrintWriter pw;
private StringTokenizer st;
int nextInt() throws IOException {
return Integer.parseInt(next());
}
String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
public static void main(final String[] args) throws IOException {
new Solution().run();
}
private void run() throws IOException {
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter("output.txt");
solve();
br.close();
pw.flush();
pw.close();
}
} | 0 | 1,189,427 |
A11759 | A10558 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.PrintStream;
import java.util.Scanner;
public class B {
public static void main(String[] args) throws FileNotFoundException {
Scanner scan = new Scanner(new File("B-small-attempt1.in"));
System.setOut(new PrintStream("B-small-attempt1.out"));
int t = scan.nextInt();
for (int c = 0; c < t; c++) {
int n = scan.nextInt(); // num
int s = scan.nextInt(); // surprising
int p = scan.nextInt(); // best result cutoff
int[] totalPoints = new int[n];
for (int i = 0; i < n; i++)
totalPoints[i] = scan.nextInt();
int sUsed = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int pts = totalPoints[i];
// can it be done normal?
if (pts >= p + (p - 1) * 2)
ans++;
// can it be done surp?
else if (pts >= p + Math.max(p - 2, 0) * 2)
if (sUsed < s) {
ans++;
sUsed++;
}
}
System.out.printf("Case #%d: %d%n", c + 1, ans);
}
}
} | 0 | 1,189,428 |
A11759 | A12424 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.util.Arrays.deepToString;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class DancingWithTheGooglers {
final static String FILENAME = "B-small-attempt0";
//final static String FILENAME = "sample";
final static String FILENAME_IN = FILENAME + ".in";
final static String FILENAME_OUT = FILENAME + ".out";
final static int THREADS = 1; // use 1 to solve them sequentially
// VM arguments: -ea -Xms4096M -Xmx4096M
static class Solver implements Callable<String> {
// PROBLEM SOLUTION STARTS HERE -----------------------------------------------------------
// ----------------------------------------------------------------------------------------
Solver(Scanner in, int testId) {
this.testId = testId;
// TODO: Read input
N = in.nextInt();
S = in.nextInt();
p = in.nextInt();
numbers = new int[N];
for (int i=0; i<N; i++) {
numbers[i] = in.nextInt();
}
}
// TODO: Define input variables
final int N, S, p;
int [] numbers;
@Override
public String call() throws Exception {
long now = System.nanoTime();
// TODO: Solve problem here and return result as a string
int normal = 3 * p - 2;
int surprising = 3 * p - 4;
if (p==0) {
normal = surprising = 0;
}
if (p==1) {
surprising = 1;
}
int countSurprise = 0;
int count = 0;
for (int number : numbers) {
if (number >= normal) {
count++;
} else if (number >= surprising && countSurprise < S) {
count++; countSurprise++;
}
}
String res = Integer.toString(count);
System.err.println(String.format("%4d ms %s" , (System.nanoTime() - now) / 1000000, res));
return res;
}
// PROBLEM SOLUTION ENDS HERE -------------------------------------------------------------
// ----------------------------------------------------------------------------------------
final int testId;
}
static void debug(Object...os) {
System.err.println(deepToString(os));
}
;
public static void main(String[] args) throws FileNotFoundException, InterruptedException {
long now = System.nanoTime();
System.setIn(new FileInputStream(FILENAME_IN));
System.setOut(new PrintStream(new FileOutputStream(FILENAME_OUT)));
Scanner in = new Scanner(System.in);
int numTests = in.nextInt(); in.nextLine();
System.err.println(String.format("TESTS: %d" , numTests));
List<Solver> solvers = new ArrayList<Solver>();
for (int i=0; i<numTests; i++) {
solvers.add(new Solver(in, i+1));
}
ExecutorService executor = Executors.newFixedThreadPool(THREADS);
List<Future<String>> solutions = executor.invokeAll(solvers);
for (int i = 0; i < numTests; i++) {
try {
System.out.println(String.format("Case #%d: %s", solvers.get(i).testId, solutions.get(i).get()));
} catch (Exception e) {
System.out.println(String.format("Case #%d: EXCEPTION !!!!!", solvers.get(i).testId));
System.err.println(String.format("Case #%d: EXCEPTION !!!!!", solvers.get(i).testId));
e.printStackTrace(System.err);
}
}
executor.shutdown();
System.err.println(String.format("TOTAL: %d ms" , (System.nanoTime() - now) / 1000000));
}
} | 0 | 1,189,429 |
A11759 | A11398 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class DancingWithTheGooglers {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader(args[0]));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(args[0]+".out")));
String l = in.readLine();
int N = Integer.parseInt(l);
int i=1;
while((l=in.readLine())!= null)
{
int cnt = 0;
out.print("Case #"+i+++": ");
String ll[] = l.split(" ");
int S = Integer.parseInt(ll[1]);
int p = Integer.parseInt(ll[2]);
//da ll[3]; a ll[ll.length-1]; somme
ArrayList<Integer> amb = new ArrayList<Integer>();
int cntA=0;
for(int z=3;z<ll.length;z++)
{
int sum = Integer.parseInt(ll[z]);
if(p==0)
{
cnt++;
continue;
}
if(p==1)
{
if(sum>0) cnt++;
continue;
}
int foo = p+(p-1)+(p-1);
int bar = p+(p-2)+(p-2);
if(sum>=foo) cnt++;
else if(sum>=bar) cntA++;
}
cnt+= Math.min(cntA,S);
out.print(cnt);
if(i<=N) out.println("");
}
in.close();
out.close();
}
}
| 0 | 1,189,430 |
A11759 | A10792 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.elbr.codejam2012.qualification.B;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
public class Dancing {
private static boolean debug = false;
private static String findP;
private static int p = 0;
private static int s = 0;
private static boolean checkDiff(String prefix, boolean checkNoSurprise) {
prefix = prefix.trim();
if (prefix.length() == 0) {
return true;
}
String[] params = prefix.split("\\s");
int max = -1;
int min = -1;
for (String s : params) {
int i = Integer.parseInt(s);
if (min == -1) {
min = i;
}
if (max == -1) {
max = i;
}
max = Math.max(max, i);
min = Math.min(min, i);
}
if ((max > 10) || (min > 10)) {
return false;
}
if (((max - min) > 2) || (max < p)) {
return false;
}
if ((max - min) < 2) {
return true;
}
if (checkNoSurprise) {
return false;
}
if (s == 0) {
return false;
}
s--;
return true;
}
public static int count(String input, String countString) {
return input.trim().split("\\Q" + countString + "\\E", -1).length - 1;
}
public static void main(String[] in) throws IOException {
// String fileName = "sample2.in";
String fileName = "B-small-attempt3.in";
URL file = Dancing.class.getResource(fileName);
String path = file.getFile();
BufferedReader reader = new BufferedReader(new FileReader(path));
File fileOut = new File(fileName + ".out");
fileOut.createNewFile();
BufferedWriter writer = new BufferedWriter(new FileWriter(fileOut));
int numOfCases = Integer.parseInt(reader.readLine());
for (int t = 0; t < numOfCases; t++) {
String line = reader.readLine();
String outputLine = "Case #" + (t + 1) + ": " + result(line);
if (true || debug) {
System.out.println(outputLine);
}
writer.write(outputLine + System.getProperty("line.separator"));
}
reader.close();
writer.close();
}
public static void partition(int n, boolean checkNoSurprise) {
findP = null;
partition(n, n, "", checkNoSurprise);
}
public static void partition(int n, int max, String prefix,
boolean checkNoSurprise) {
if (findP != null) {
return;
}
if (n == 0) {
if ((count(prefix, " ") == 2)) {
if (debug) {
System.out.println("Check votes: " + prefix);
}
if (checkDiff(prefix, checkNoSurprise)) {
findP = prefix;
}
}
return;
}
for (int i = Math.min(max, n); i >= 1; i--) {
String np = prefix + " " + i;
if (count(prefix, " ") <= 2) {
partition(n - i, i, np, checkNoSurprise);
}
}
}
private static int result(String line) {
String[] params = line.split("\\s");
int n = Integer.parseInt(params[0]);
s = Integer.parseInt(params[1]);
p = Integer.parseInt(params[2]);
System.out.println(line + ": " + s + ", " + p);
int[] m = new int[n];
int a = 0;
for (int i = 0; i < n; i++) {
m[i] = Integer.parseInt(params[3 + i]);
if (debug) {
System.out.println(m[i] + " => ");
}
if ((m[i] == 0) && (p == 0)) {
findP = "0 0 0";
if (debug) {
System.out.println("not surprise => " + findP);
}
a++;
} else {
partition(m[i], true);
if (findP != null) {
a++;
if (debug) {
System.out.println("not surprise => " + findP);
}
} else {
if (debug) {
System.out.println("---");
}
partition(m[i], false);
if (findP != null) {
a++;
if (debug) {
System.out.println("surprise => " + findP);
}
}
}
}
}
return a;
}
}
| 0 | 1,189,431 |
A11759 | A10459 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 {
static Vector<Set<Integer>> num = new Vector<Set<Integer>>();
static void fill() {
for(int i = 0; i < 33; ++i) {
num.add(new TreeSet<Integer>());
}
for(int i = 0; i <= 10; ++i) {
for(int j = i; j <= i+2; ++j) {
for(int k = j; k <= i+2; ++k) {
if(k <= 10) {
int sum = i+j+k;
int diff1 = k-i, diff2 = j-i;
// if(sum == 13) {
// System.out.println(i + " " + j + " " + k);
// }
if(diff1 == 2) {
if(diff2 < 2) {
num.get(3*k+2).add(sum);
// if(sum == 13) {
// System.out.println("Strict");
// }
}
else {
num.get(3*k+1).add(sum);
// if(sum == 13) {
// System.out.println("Non");
// }
}
}
else {
num.get(3*k).add(sum);
// if(sum == 13) {
// System.out.println("Binhthuong");
// }
}
}
}
}
}
}
static int[] check(int score, int p) {
int r[] = new int[3];
int size = num.size();
for(int i = 0; i < size; ++i) {
Set<Integer> temp = num.get(i);
if(temp.contains(score)) {
if(i/3 >= p) {
r[0] = 1;
if(i%3 == 2 && r[2] >= 0) {
r[2] = 1;
}
else {
r[2] = -1;
}
}
if(i%3 != 0) {
r[1] = 1;
}
}
}
if(r[2] < 0) {
r[2] = 0;
}
// System.out.println("check " + score + " " + Arrays.toString(r));
return r;
}
public static void main(String args[]) {
fill();
Scanner input = new Scanner(System.in);
int test = input.nextInt();
for(int i = 1; i <= test; ++i) {
int N = input.nextInt(), S = input.nextInt(), p = input.nextInt();
int t[] = new int[N];
for(int j = 0; j < N; ++j) {
t[j] = input.nextInt();
}
int result = 0;
//int high[] = new int[N], strict[] = new int[N], nons[] = new int[N];
int high = 0, strict = 0, nons = 0;
for(int j = 0; j < N; ++j) {
int temp[] = check(t[j], p);
high += temp[0];
nons += temp[1];
strict += temp[2];
}
// System.out.println(N + " " + S + " " + p);
// System.out.println(high + " " + nons + " " + strict);
if(nons < S) {
result = 0;
}
else {
if(strict > S) {
result = high + S -strict;
}
else {
result = high;
}
}
System.out.println("Case #" + i + ": " + result);
}
}
}
| 0 | 1,189,432 |
A11759 | A11885 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.*;
class GooglersDance {
public static void main(String[] args)
throws Exception {
new GooglersDance().start();
}
void start()
throws Exception {
InputStreamReader is =
new InputStreamReader(
new FileInputStream("Input"));
BufferedReader br = new BufferedReader(is);
OutputStreamWriter os =
new OutputStreamWriter(
new FileOutputStream("Output"));
BufferedWriter bw = new BufferedWriter(os);
String line;
int[] inputs;
int test = 1;
line = br.readLine();
while ((line = br.readLine()) != null) {
String[] inp = line.split(" ");
inputs = new int[inp.length];
int i = 0;
for (String s : inp) {
inputs[i++] = Integer.parseInt(s);
}
int surp = inputs[1];
int t = inputs[2];
Arrays.sort(inputs, 3, inputs.length);
System.out.print("Case #" + test + ": ");
String toWrite = "Case #" + test++ + ": ";
bw.write(toWrite, 0, toWrite.length());
for (i = 3; i < inputs.length; i++) {
//System.out.print(inputs[i] + " ");
}
int result = 0;
for (i = inputs.length - 1; i > 2; i--) {
int tot = inputs[i];
if (tot >= (t * 3)) {
result++;
continue;
}
if (tot <= t) {
break;
}
tot -= t;
int val = t - (tot / 2);
//System.out.print(" val = " + val + " ");
if (val == 1) {
result++;
continue;
}
else if (val == 2) {
if (--surp >= 0) {
result ++;
continue;
}
else {
break;
}
}
else {
break;
}
}
System.out.println(result);
String res = Integer.toString(result);
bw.write(res, 0, res.length());
bw.newLine();
}
br.close();
bw.close();
}
} | 0 | 1,189,433 |
A11759 | A10462 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 B {
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
int cases;
cases = in.nextInt();
in.nextLine();
for(int i = 0; i < cases; i ++ ) {
int n = in.nextInt();
int surprises = in.nextInt();
int threshold = in.nextInt();
int passed = 0;
for( int j = 0; j < n; j ++ ) {
int score = in.nextInt();
if( score/3.0 >= threshold) {
passed++;
continue;
}
score -= threshold;
if( score < 0 ) {
continue;
}
int test1 = score - ( threshold - 1 );
if( test1 >= 0 ) {
if( test1 >= ( threshold - 1 ) && test1 <= ( threshold + 1 ) ) {
passed++;
continue;
}
}
test1++;
if( test1 < 0 ) {
continue;
}
if( test1 >= ( threshold - 2 ) && test1 <= ( threshold + 2 ) ) {
if( surprises > 0 ) {
passed++;
surprises--;
continue;
}
}
}
System.out.println("Case #" + (i+1) + ": " + passed);
}
}
}
| 0 | 1,189,434 |
A11759 | A11469 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 DancingWithGooglers {
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
//Read in the T int -- Test Cases
int T = Integer.parseInt(sc.nextLine());
for (int t = 1; t <= T; t++) {
int num = 0;
//START OF CODE
int N = sc.nextInt(); //Num of googlers
int S = sc.nextInt(); //Surprising Triplets
int p = sc.nextInt();
int ti [] = new int[N];
for (int n = 0; n < N; n++) {
ti[n] = sc.nextInt();
}
for (int i = 0; i < ti.length; i++) {
//Do not care if scores are above p
//Only lower than p and if need be adjusted
if(ti[i] == 0 && p == 0){
num++;
} else if(ti[i] == 0){
} else if(ti[i] / 3 >= p || (ti[i] / 3 == p-1 && ti[i] % 3 != 0)){
num++;
} else if(S !=0 && ((ti[i] / 3 == p-2 && ti[i] % 3 == 2 ) || (ti[i] / 3 == p-1))){
num++;
S--;
}
}
//END OF CODE
//OUTPUT
System.out.format("Case #%d: %d\n", t, num);
}
}
}
| 0 | 1,189,435 |
A11759 | A10758 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 static java.lang.System.out;
import static java.lang.Math.*;
public class BaiB implements Runnable {
public void run() {
int[][] C = new int[33][2];
for (int[] a1 : C) Arrays.fill(a1, -1);
for (int i = 0; i <= 10; ++i) {
for (int j = 0; j <= 10; ++j) {
for (int k = 0; k <= 10; ++k) if (abs(i - j) <= 2 && abs(j - k) <= 2 && abs(k - i) <= 2) {
int sur = 0;
if (abs(i - j) == 2 || abs(j - k) == 2 || abs(k - i) == 2) {
sur = 1;
}
C[i + j + k][sur] = max(C[i + j + k][sur], max(i, max(j, k)));
}
}
}
int ntest = nextInt();
for (int test = 1; test <= ntest; ++test) {
int n = nextInt();
int s = nextInt();
int p = nextInt();
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = nextInt();
}
int[][] F = new int[n + 1][n + 1];
for (int[] a1 : F) Arrays.fill(a1, -1);
F[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= i; ++j)
if (F[i][j] >= 0) {
for (int k = 0; k < 2; ++k) if (C[a[i]][k] >= 0) {
F[i + 1][j + k] = max(F[i + 1][j + k], F[i][j] + (C[a[i]][k] >= p ? 1 : 0));
}
}
out.println("Case #" + test + ": " + F[n][s]);
}
}
int[] ar(int st, int en) { int[] res = new int[Math.max(en - st, 0)]; for (int i = st; i < en; ++i) res[i - st] = i; return res; }
int[] ar(int n) { return ar(0, n); }
void viet(Object...os) { System.err.println(Arrays.deepToString(os)); }
BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer strtok = null;
String nextStr() {
try {
while(strtok == null || !strtok.hasMoreTokens())
strtok = new StringTokenizer(keyboard.readLine());
return strtok.nextToken();
}
catch(Exception ex) {
System.out.println(ex.getMessage());
ex.printStackTrace();
return null;
}
}
int nextInt() {
return Integer.parseInt(nextStr());
}
long nextLong() {
return Long.parseLong(nextStr());
}
double nextDouble() {
return Double.parseDouble(nextStr());
}
public static void main(String[] args) {
new BaiB().run();
}
} | 0 | 1,189,436 |
A11759 | A12022 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | /**
*
*/
package code.google.codejam;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
/**
* @author sunilkumarp
*
*/
public abstract class Template {
int testcases = 0;
int casePoniter = 0;
PrintWriter writer = null;
BufferedReader reader = null;
String line = null;
int linePointer = -1;
int linePerTestCase = 1;
char lastChar = '!';
/**
* @param args
*/
public static void main(String[] args) {
try {
Template template = (Template) Class.forName(args[1]).newInstance();
template.start(args);
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace(System.out);
}
}
/**
* @param args
*/
protected void start(String[] args) {
InputStream io = null;
OutputStream os = null;
try {
io = Template.class.getResourceAsStream(args[0]);
reader = new BufferedReader(new InputStreamReader (io));
os = new FileOutputStream(new File(args[0].substring(0, args[0].length() -2 )+ "out"));
writer = new PrintWriter(os);
testcases = Integer.valueOf(reader.readLine());
solveProblem();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace(System.out);
} finally {
try {
writer.flush();
writer.close();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace(System.out);
}
try {
reader.close();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace(System.out);
}
try {
io.close();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace(System.out);
}
try {
os.flush();
os.close();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace(System.out);
}
}
}
public void solveProblem() throws Exception {
long sTime = System.nanoTime();
for (;++casePoniter <= testcases;) {
long sTimeCase = System.nanoTime();
writeOutput(casePoniter, solveProblemForATestCase());
System.out.println("Time taken for test case" + "[" + casePoniter + "]:" + (System.nanoTime() - sTimeCase));
}
System.out.println("Total time for all test cases:" + (System.nanoTime() - sTime));
}
protected Object solveProblemForATestCase() throws Exception {
initializeTestCase();
printInput();
return doSolveProblem();
}
protected abstract Object doSolveProblem() throws Exception;
protected abstract void printInput() throws Exception;
protected abstract void initializeTestCase() throws Exception;
protected void writeOutput (int caseNo, Object result) {
String str = "Case #" + caseNo + ": " + result;
System.out.println("==========" + str + "=============");
writer.println(str);
}
public char readChar() throws IOException {
return lastChar = (char)reader.read();
}
public char readCharFromLine() throws IOException {
int length = line.length();
if (linePointer >= length - 1) {
throw new IllegalStateException("Line has already ended.");
}
return line.charAt(++linePointer);
}
public String readLine() throws IOException {
line = reader.readLine();
linePointer = -1;
return line;
}
public int readNextInteger() {
int val = 0;
int length = line.length();
if (linePointer >= length) {
throw new IllegalStateException("Line has already ended.");
}
while(++linePointer < length) {
if (Character.isDigit(lastChar = line.charAt(linePointer))) {
val = val * 10 + Character.digit(lastChar, 10);
} else {
break;
}
}
return val;
}
}
| 0 | 1,189,437 |
A11759 | A12002 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.*;
import java.io.*;
public class Dance {
public static void main(String args[]) throws Exception
{
BufferedReader in = new BufferedReader(new FileReader(new File("dance.in")));
FileWriter out = new FileWriter(new File("dance.out"));
int n = Integer.parseInt(in.readLine());
for (int i = 1; i <= n; i++) {
String s = in.readLine();
StringTokenizer st = new StringTokenizer(s);
int N = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
int max = 0;
for (int j = 0; j < N; j++)
{
int g = Integer.parseInt(st.nextToken());
if (g < 2) {
if (g >= p) max++;
}
else if ((g + 2) / 3 >= p) max++;
else if ((g+4) / 3 >= p && S > 0) {
S--;
max++;
}
}
out.write("Case #" + i + ": " + max + "\n");
}
in.close();
out.close();
}
}
| 0 | 1,189,438 |
A11759 | A10407 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package codejam2012;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
/**
*
* @author devashish
*/
public class ProblemB {
public static void main(String[] args) {
StringTokenizer st = null;
BufferedReader in;
PrintWriter out = null;
try {
in = new BufferedReader(new FileReader(new File("E:/b.in")));
out = new PrintWriter(new FileWriter(new File("E:/b.out")));
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(in.readLine());
}
int t = Integer.parseInt(st.nextToken());
for (int i = 1; i <= t; i++) {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(in.readLine());
}
int N = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
int[] T = new int[N];
for (int j = 0; j < N; j++) {
T[j] = Integer.parseInt(st.nextToken());
}
int outputLine = maxGooglers(N, S, p, T);
out.print("Case #" + i + ": " + outputLine + "\n");
}
} catch (IOException e) {
}
out.flush();
}
private static int maxGooglers(int N, int S, int p, int[] T) {
int output = 0;
int surprisingMinScore = Math.max(3 * p - 4, 0) ;
int nonSurprisingMinScore = Math.max(3 * p - 2, 0);
int countSurprise = 0;
// System.out.println(surprisingMinScore);
// System.out.println(nonSurprisingMinScore);
for (int i = 0; i < T.length; i++) {
// System.out.println(T[i]);
// System.out.println("T[i]: " + T[i]);
if (T[i] < surprisingMinScore) {
continue;
} else if (T[i] >= surprisingMinScore && T[i] < nonSurprisingMinScore) {
//either surprising or low scores
//countSurprise += findPossibleSurprisingScoresWithBestResult(T[i], p);
if (S > 0 && T[i] >= 2) {
countSurprise += findPossibleSurprisingScoresWithBestResult(T[i], p);
// System.out.println("#countSurprise: " + countSurprise);
//output += findPossibleSurprisingScoresWithBestResult(T[i], p);
}
} else if (T[i] >= nonSurprisingMinScore) {
//Non surprising score
//System.out.println("non surprising score.");
output++;
}
}
//System.out.println("#output: " + output);
//System.out.println((countSurprise < S ? countSurprise : S));
return output + (countSurprise < S ? countSurprise : S);
}
private static int findPossibleSurprisingScoresWithBestResult(int t, int p) {
int count = 0;
int a = t/3;
int b = ((t + 4)/3);
if (p >= a && p <=b) {
count++;
}
//System.out.println("#count:" + count);
return count;
}
}
| 0 | 1,189,439 |
A11759 | A12909 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 {
Scanner sc = new Scanner(System.in);
int N, S, p;
int[] ts;
void read() {
N = sc.nextInt();
S = sc.nextInt();
p = sc.nextInt();
ts = new int[N];
for (int i = 0; i < N; i++) ts[i] = sc.nextInt();
}
void solve() {
int res = 0;
for (int i = 0; i < N; i++) {
if (p * 3 - 2 <= ts[i]) res++;
else if (p <= ts[i] && p * 3 - 4 <= ts[i] && S-- > 0) res++;
}
System.out.println(res);
}
void run() {
int caseN = sc.nextInt();
for (int caseID = 1; caseID <= caseN; caseID++) {
read();
System.out.printf("Case #%d: ", caseID);
solve();
System.out.flush();
}
}
void debug(Object...os) {
System.err.println(deepToString(os));
}
public static void main(String[] args) {
try {
System.setIn(new BufferedInputStream(new FileInputStream(args.length > 0 ? args[0] : (B.class.getName() + ".in"))));
} catch (Exception e) {
}
new B().run();
}
}
| 0 | 1,189,440 |
A11759 | A11610 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.jp.common;
import com.codejam.two12.tongue.Googlerese;
public class ExecutorApp {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// String inputFileName = "/Users/joekumar/Documents/workspace/CodeJam/src/com/jp/data/sample_input.txt";
// String outputFileName = "/Users/joekumar/Documents/workspace/CodeJam/src/com/jp/data/sample_output.txt";
String inputFileName = "/Users/joekumar/Downloads/B-small-attempt1.in";
String outputFileName = "/Users/joekumar/Desktop/output/sample_output.txt";
InputOutputProcessor inputOutputProcessor = new InputOutputProcessor();
inputOutputProcessor.initializeInput(inputFileName);
int numberOfCases = inputOutputProcessor.getNumberOfCases();
String[] resultArray = new String[numberOfCases];
inputOutputProcessor.setDoesInputHaveDataSetLines(false);
inputOutputProcessor.setNumberOfDataSetLines(1);
// Googlerese.init();
for (int i = 1; i <= numberOfCases; i++) {
try {
String[] dataSet = inputOutputProcessor.getDataSet();
/* BotTrust botTrust = new BotTrust();
int result = botTrust.findRequiredSeconds(dataSet);
String resultCase = "Case #"+ i + ": "+ result;
resultArray[i-1] = resultCase;
System.out.println(resultCase);*/
Puzzle puzzle = PuzzleFactory.getPuzzleSolution("GooglerDance");
String[] result = puzzle.solve(dataSet);
String resultCase = "Case #"+ i + ": "+ result[0] ;
System.out.println(resultCase);
resultArray[i-1] = resultCase;
}
catch (Exception exp) {
exp.printStackTrace();
inputOutputProcessor.closeScanner();
}
}
inputOutputProcessor.closeScanner();
inputOutputProcessor.writeOutput(outputFileName, resultArray);
}
}
| 0 | 1,189,441 |
A11759 | A11974 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.text.*;
public class DancingWithTheGooglers {
static final int INF = 1 << 28, MAX = 1000;
static final double EPS = 1E-9;
static void solve() {
Scanner scan = new Scanner(in);
int T = scan.nextInt();
for (int t = 1; t <= T; t++) {
out.print("Case #" + t + ": ");
int N = scan.nextInt();
int S = scan.nextInt();
int P = scan.nextInt();
int[] points = new int[N];
for (int i = 0; i < N; i++)
points[i] = scan.nextInt();
int max = 0;
for (int mask = 0; mask < 1<<N; mask++) {
if (Integer.bitCount(mask) != S)
continue;
int k = 0;
for (int i = 0; i < N; i++) {
int a = points[i] / 3;
int r = points[i] % 3;
if ((mask & (1 << i)) == 0) {
if (r > 0)
a++;
} else {
if (r == 0 && a > 0)
a++;
else
a += r;
}
if (a >= P)
k++;
}
max = Math.max(max, k);
}
out.println(max);
}
}
static String read() {
try { return in.readLine(); } catch (IOException e) { return null; }
}
public static void main(String[] args) throws IOException {
// in = new BufferedReader(new InputStreamReader(System.in));
// out = new PrintWriter(new BufferedOutputStream(System.out));
String file = "B-small";
in = new BufferedReader( new FileReader(file + ".in") );
out = new PrintWriter( new FileOutputStream(file + "_" + System.currentTimeMillis() + ".out") );
solve(); out.flush();
}
static BufferedReader in; static PrintWriter out;
}
| 0 | 1,189,442 |
A11759 | A10041 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | 100
3 1 5 15 13 11
3 0 8 23 22 21
1 0 6 26
2 1 6 23 26
3 1 5 19 18 11
2 0 4 15 8
3 0 9 24 15 8
3 0 4 8 9 9
1 0 4 14
1 1 0 28
2 1 0 5 22
2 2 2 9 25
2 0 3 12 0
2 1 5 12 12
3 1 9 23 24 23
3 0 3 29 12 10
3 1 8 20 20 13
1 1 5 7
1 0 4 9
2 2 8 20 27
1 0 2 2
3 2 2 5 19 8
2 0 3 12 14
1 0 6 11
2 0 5 19 12
3 3 1 20 5 24
1 0 7 2
2 1 2 2 2
2 1 10 27 27
3 1 0 5 8 18
3 0 4 2 12 15
1 0 6 9
3 3 9 3 26 14
2 0 0 7 26
1 1 3 6
3 0 8 23 2 21
3 0 5 6 16 30
1 0 1 11
1 0 0 28
1 1 8 18
2 1 4 9 8
3 1 0 20 22 1
2 0 1 0 0
1 0 9 25
1 0 3 29
3 1 10 26 15 21
2 2 6 16 26
1 1 8 11
2 2 8 22 23
1 0 4 8
3 3 3 18 27 5
1 0 6 14
1 1 4 4
3 0 4 29 9 29
1 1 2 6
2 2 10 16 5
2 0 2 23 9
3 3 5 24 21 24
2 2 1 25 17
1 0 4 15
2 0 10 30 30
1 1 1 19
2 0 7 18 30
1 0 6 15
3 3 9 12 4 26
1 1 8 28
2 1 1 0 4
3 3 3 26 27 24
3 3 10 9 24 12
2 0 8 20 0
3 0 9 23 0 26
3 3 10 4 3 19
2 1 9 20 19
2 0 0 0 0
1 0 6 3
1 0 4 1
3 3 3 8 3 21
2 1 3 18 13
3 3 1 20 7 14
2 0 5 11 25
1 0 3 6
2 0 0 30 30
2 1 10 27 26
1 1 8 7
2 2 5 9 13
2 0 2 6 13
3 0 5 18 16 8
2 1 6 24 2
1 1 7 12
3 0 7 17 22 5
2 0 0 0 8
1 1 3 12
1 0 5 28
2 2 9 9 7
1 0 9 24
1 0 0 27
2 2 9 10 4
1 0 8 11
2 0 7 1 22
3 3 9 9 24 7
| 0 | 1,189,443 |
A11759 | A11132 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
public class GoogleDancing {
public static void solution(String fileName) throws IOException {
FileReader fileReader = new FileReader(new File(fileName));
BufferedReader bufferedReader = new BufferedReader(fileReader);
String textLine = bufferedReader.readLine();
int lines = Integer.parseInt(textLine);
int[] ret = new int[lines];
for (int i = 0; i < lines; i++) {
textLine = bufferedReader.readLine();
String[] t = textLine.split(" ");
int N = Integer.parseInt(t[0]);
int S = Integer.parseInt(t[1]);
int p = Integer.parseInt(t[2]);
int c = 0;
int c1 = 0;
int min = p * 3 - 2;
min = min > 0 ? min : 0;
int min1 = min - 2;
min1 = min1 > 0 ? min1 : 0;
for (int j = 3; j < t.length; j++) {
int tt = Integer.parseInt(t[j]);
if (tt == 0) {
if (p == 0) {
c++;
}
continue;
}
if (tt < p)
continue;
if (tt >= min) {
c++;
} else if (tt >= min1 && c1 < S) {
c++;
c1++;
}
}
ret[i] = c;
}
for (int i = 0; i < ret.length; i++) {
System.out.println("Case #" + (i + 1) + ": " + ret[i]);
}
}
public static void main(String[] args) throws Exception {
solution("c:\\sql\\B-small-attempt1(1).in");
}
}
| 0 | 1,189,444 |
A11759 | A12480 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Scanner;
public class Dancing_With_the_Googlers {
/**
* The first line of the input gives the number of test cases, T.
* T test cases follow.
* Each test case consists of a single line containing integers separated by single spaces.
* The first integer will be N, the number of Googlers, and the second integer will be S, the number of surprising triplets of scores.
* The third integer will be p, as described above. Next will be N integers ti: the total points of the Googlers.
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
// Reading the input file
Scanner in = new Scanner(new File("B-small-attempt1.in"));
// writting the input file
FileOutputStream fos = new FileOutputStream("B-small-attempt1.out");
PrintStream out = new PrintStream(fos);
//Close the output stream
int testCase=Integer.parseInt(in.nextLine());
for(int i=0;i<testCase;i++) {
out.print("Case #" + (i + 1) + ":\t");
int NoOfGooglers= in.nextInt();
int NoOfSurprisingResults = in.nextInt();
int atLeastP=in.nextInt();
ArrayList<Integer> scores= new ArrayList<Integer>();
int BestResults=0;
int Surprising=0;
for(int j=0;j<NoOfGooglers;j++)
{
scores.add(in.nextInt());
//System.out.print(scores.get(j));
int modulus=scores.get(j)%3;
int temp = scores.get(j);
switch (modulus) {
case 0:
if (((temp / 3) >= atLeastP)) {
BestResults++;
} else {
if (((((temp / 3) + 1) >= atLeastP) && ((temp / 3) >= 1))
&& (Surprising < NoOfSurprisingResults)) {
BestResults++;
Surprising++;
}
System.out.println("Case 0"+"itr:"+i+" surprising:"+temp);
}
break;
case 1:
if ((temp / 3) + 1 >= atLeastP) {
BestResults++;
continue;
}
break;
case 2:
if ((temp / 3) + 1 >= atLeastP) {
BestResults++;
} else {
if (((temp / 3) + 2 >= atLeastP)
&& (Surprising < NoOfSurprisingResults)) {
BestResults++;
Surprising++;
}
System.out.println("Case 2"+"itr:"+i+" surprising:"+temp);
}
break;
default:
System.out.println("Error");
}
}// Internal for
out.println(BestResults);
// System.out.println(BestResults);
System.out.println(Surprising);
BestResults = 0;
}// for
in.close();
out.close();
fos.close();
}
}
| 0 | 1,189,445 |
A11759 | A10951 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
public class Reader {
private String fileName;
private BufferedReader reader;
public Reader(String fileName){
this.fileName= fileName;
}
public void open() throws Exception{
reader = new BufferedReader(new FileReader(new File(fileName)));
reader.readLine();
}
public void close() throws Exception{
reader.close();
}
public String getNext() throws Exception{
String line = reader.readLine();
return line;
}
}
| 0 | 1,189,446 |
A11759 | A11848 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 abstract class ProgrammingProblem
{
protected static final Scanner sc = new Scanner(System.in);
protected static boolean DEBUG = false;
protected abstract void print();
protected abstract void readInput();
protected abstract String execute();
protected static void main(@SuppressWarnings("rawtypes") Class myclass) throws InstantiationException, IllegalAccessException
{
int T = sc.nextInt();
for (int i = 0; i < T; i++)
{
ProgrammingProblem m = (ProgrammingProblem) myclass.newInstance();
m.readInput();
if (DEBUG)
{
m.print();
}
System.out.println("Case #" + (i+1) + ": " + m.execute());
}
}
protected static ProgrammingProblem getTestCase()
{
return null;
}
public ProgrammingProblem()
{
super();
}
} | 0 | 1,189,447 |
A11759 | A11036 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package fixjava;
import java.util.ArrayList;
import java.util.HashMap;
/**
* Get the index of the given key if this key has been assigned an index before, and if not, allocate a new index for it by
* incrementing a counter that starts at zero, and return the new index.
*/
public class UniqueIndexAllocator<T> {
private HashMap<T, Integer> map = new HashMap<T, Integer>();
private ArrayList<T> orderedKeys = new ArrayList<T>();
public UniqueIndexAllocator() {
}
/** Allocate unique indices for each item in the given collection. Read back the indices using the other methods. */
public UniqueIndexAllocator(Iterable<T> collection) {
for (T it : collection)
getOrAllocateIndex(it);
}
/** Get the assigned index for a key, or assign it a new unique index if this key has not previously been assigned an index */
public int getOrAllocateIndex(T key) {
Integer currIdx = map.get(key);
if (currIdx == null) {
map.put(key, currIdx = orderedKeys.size());
orderedKeys.add(key);
}
return currIdx;
}
/** Get all the keys as a list in their index order */
public ArrayList<T> getOrderedKeys() {
return orderedKeys;
}
/** Get all the keys as an array in their index order */
@SuppressWarnings("unchecked")
public T[] getOrderedKeysAsArray() {
return (T[]) orderedKeys.toArray();
}
/** Get the mapping from key to index */
public HashMap<T, Integer> getKeyToIndexMap() {
return map;
}
/** Return the number of allocated indices, i.e. the number of unique keys */
public int numIndices() {
return orderedKeys.size();
}
}
| 0 | 1,189,448 |
A11759 | A11748 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
public class Problem extends Template {
public static void main(String[] args) throws Exception {
_iFILE = "sample";
_oFILE = "output";
// Base ProblemA = new Base(new int[] {0, 1}) {
// String lhs = " abcdefghijklmnopqrstuvwxyz";
// String rhs = " yhesocvxduiglbkrztnwjpfmaq";
//
// @Override
// protected String implementation(String[][] params) {
// String trans = "";
// String input = ArrayUtil.join(params[0], " ");
// for (int i = 0; i < input.length(); i++) {
// trans += rhs.charAt(lhs.indexOf(input.charAt(i)));
// }
//
// return trans;
// }
// };
Base ProblemB = new Base(new int[] {0, 1}) {
@Override
protected String implementation(String[][] params) {
int count = 0;
int n = new Integer(params[0][0]).intValue();
int s = new Integer(params[0][1]).intValue();
int p = new Integer(params[0][2]).intValue();
boolean[][] match = new boolean[n][2];
int[] t = new int[n];
for (int i = 0; i < n; i++) {
t[i] = new Integer(params[0][3 + i]).intValue();
//Assuming x <= y <= z
boolean s_match = false;
boolean n_match = false;
for (int x = 0; x <= 10; x++) {
{
int z = x + 2;
int y = t[i] - x - z;
if(x <= y && y <= z && z >= p) {
//System.out.println("\t(" + x + "," + y + "," + z + ") " + p);
s_match = true;
}
}
{
int z = x + 1;
int y = t[i] - x - z;
if(x <= y && y <= z && z >= p) {
//System.out.println("\t(" + x + "," + y + "," + z + ") " + p);
n_match = true;
}
}
{
int z = x;
int y = t[i] - x - z;
if(x <= y && y <= z && z >= p) {
//System.out.println("\t(" + x + "," + y + "," + z + ") " + p);
n_match = true;
}
}
}
match[i][0] = s_match;
match[i][1] = n_match;
/*System.out.print(t[i]);
if(s_match) System.out.print(" *");
if(n_match) System.out.print(" +");
System.out.println();*/
if(n_match)
count++;
else if(s > 0 && s_match) {
s--;
count++;
}
}
return Integer.toString(count);
}
};
// Base ProblemC = new Base(new int[] {0, 1}) {
// @Override
// protected String implementation(String[][] params) {
// int count = 0;
// try {
// int len = params[0][0].length();
// Integer[] p = ArrayUtil.convert(params[0], Integer.class);
// for (int n = p[0]; n <= p[1]; n++) {
// int m = n;
// while(true) {
// m = (int) ((m%10)*Math.pow(10, len - 1)) + m/10;
// if(n < m && m <= p[1]) count++;
//
// if(n == m) break;
// }
// }
// }catch (Exception e) {
// e.printStackTrace();
// System.exit(0);
// }
//
// return Integer.toString(count);
// }
// };
// Base ProblemD = new Base(new int[] {1, 0}) {
// @Override
// protected String implementation(String[][] params) {
// int r = new Integer(params[0][0]).intValue();
// int c = new Integer(params[0][1]).intValue();
// int d = new Integer(params[0][2]).intValue();
//
//
//
//
// return "";
// }
// };
ProblemB.run();
}
}
class Template {
public static String _oFILE;
public static String _iFILE;
public static abstract class Base {
static { System.out.println("--- GOOGLE CODE JAM 2012 ---------------------------------------"); }
private int[] inputType;
private String columnSeperator = " ";
private Template.Base.iCollection input;
abstract protected String implementation(String[][] params) throws Exception;
public Base(int[] inputType) throws Exception {
this.inputType = inputType;
if (new File(_iFILE).exists()) {
input = new Template.Base.iCollection();
String strLine;
BufferedReader buffReader = new BufferedReader(new FileReader(_iFILE));
while ((strLine = buffReader.readLine()) != null)
input.add(strLine.split(columnSeperator));
buffReader.close();
input.index();
}else { throw new Exception("Input File Missing"); }
}
public void run() throws Exception {
int inputSize = new Integer(input.get(0)[0]).intValue();
BufferedWriter buffWriter = new BufferedWriter(new FileWriter(new File(_oFILE)));
for (int i = 1; i <= inputSize; i++) {
String result = implementation(Template.ArrayUtil.convert(input.item(i)));
printResult(input.item(i), result);
buffWriter.write("Case #" + i + ": " + result + "\n");
buffWriter.flush();
}
buffWriter.close();
System.out.println("----------------------------------------- GOOGLE INPUT TYPES ---");
System.out.println("{0,n} : EACH CASE WITH n (n > 0) ROWS");
System.out.println("{1,0} : EACH CASE WITH DYNAMIC (DEFINED @ FIRST ROW) SET OF ROWS");
System.out.println("--------------------------------------------- Subodh Gairola ---");
}
private void printResult(ArrayList<String[]> params, String result) {
for (int i = 0; i < params.size(); i++) {
for (int j = 0; j < params.get(i).length; j++) {
System.out.print(params.get(i)[j] + " ");
}
System.out.println();
}
System.out.println("\t\t|" + result + "|");
}
class iCollection extends ArrayList<String[]> {
private static final long serialVersionUID = 1L;
int[][] _index;
public void index() {
_index = new int[new Integer(this.get(0)[0]).intValue() + 1][2];
_index[0][0] = inputType[0];
_index[0][1] = inputType[1];
for (int i = 1; i < _index.length; i++) {
if (_index[0][0] == 0) {
int len = inputType[1];
_index[i][0] = 1 + (i - 1) * len;
_index[i][1] = len;
} else if (_index[0][0] == 1) {
int lastPos = _index[i - 1][0];
int lastLen = _index[i - 1][1];
_index[i][0] = lastPos + lastLen;
_index[i][1] = new Integer(this.get(_index[i][0])[0]).intValue() + 1;
}
}
}
public Template.Base.iCollection item(int index) {
int pos = _index[index][0];
int len = _index[index][1];
Template.Base.iCollection params = new Template.Base.iCollection();
for (int i = pos; i < pos + len; i++) {
params.add(this.get(i));
}
return params;
}
}
}
public static class Generator {
public int[] a;
public BigInteger numLeft;
public BigInteger total;
public void reset() {
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
numLeft = new BigInteger(total.toString());
}
public BigInteger getNumLeft() {
return numLeft;
}
public BigInteger getTotal() {
return total;
}
public boolean hasMore() {
return numLeft.compareTo(BigInteger.ZERO) == 1;
}
public static BigInteger getFactorial(int n) {
BigInteger fact = BigInteger.ONE;
for (int i = n; i > 1; i--) {
fact = fact.multiply(new BigInteger(Integer.toString(i)));
}
return fact;
}
public static class Permutation extends Template.Generator {
public Permutation(int n) {
if (n < 1) {
throw new IllegalArgumentException("Minimum 1");
}
a = new int[n];
total = Template.Generator.getFactorial(n);
reset();
}
public int[] getNext() {
if (numLeft.equals(total)) {
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
int temp;
int j = a.length - 2;
while (a[j] > a[j + 1]) {
j--;
}
int k = a.length - 1;
while (a[j] > a[k]) {
k--;
}
temp = a[k];
a[k] = a[j];
a[j] = temp;
int r = a.length - 1;
int s = j + 1;
while (r > s) {
temp = a[s];
a[s] = a[r];
a[r] = temp;
r--;
s++;
}
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
}
public static class Combination extends Template.Generator {
private int n;
private int r;
public Combination(int n, int r) {
if (r > n) {
throw new IllegalArgumentException();
}
if (n < 1) {
throw new IllegalArgumentException();
}
this.n = n;
this.r = r;
a = new int[r];
BigInteger nFact = Template.Generator.getFactorial(n);
BigInteger rFact = Template.Generator.getFactorial(r);
BigInteger nminusrFact = Template.Generator.getFactorial(n - r);
total = nFact.divide(rFact.multiply(nminusrFact));
reset();
}
public int[] getNext() {
if (numLeft.equals(total)) {
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
int i = r - 1;
while (a[i] == n - r + i) {
i--;
}
a[i] = a[i] + 1;
for (int j = i + 1; j < r; j++) {
a[j] = a[i] + j - i;
}
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
}
}
public static class ArrayUtil {
@SuppressWarnings("unchecked")
public static <T> T[][] permutations(T[] array) {
Template.Generator.Permutation x = new Template.Generator.Permutation(array.length);
ArrayList<T[]> permutations = new ArrayList<T[]>();
while (x.hasMore()) {
int[] indices = x.getNext();
T[] permutation = (T[]) Array.newInstance(array[0].getClass(), indices.length);
for (int i = 0; i < indices.length; i++) {
permutation[i] = array[indices[i]];
}
permutations.add(permutation);
}
return convert(permutations);
}
@SuppressWarnings("unchecked")
public static <T> T[][] combinations(T[] array, int n) {
Template.Generator.Combination x = new Template.Generator.Combination(array.length, n);
ArrayList<T[]> combinations = new ArrayList<T[]>();
while (x.hasMore()) {
int[] indices = x.getNext();
T[] combination = (T[]) Array.newInstance(array[0].getClass(), indices.length);
for (int i = 0; i < indices.length; i++) {
combination[i] = array[indices[i]];
}
combinations.add(combination);
}
return convert(combinations);
}
@SuppressWarnings("unchecked")
public static <T> T[] convert(String[] array, Class<T> cl) throws Exception {
T[] n = (T[]) Array.newInstance(cl, array.length);
for (int i = 0; i < array.length; i++) {
n[i] = cl.getConstructor(String.class).newInstance(array[i]);
};
return n;
}
public static <T> String[] convert(T[] array) throws Exception {
String[] n = new String[array.length];
for (int i = 0; i < array.length; i++) {
n[i] = array[i].toString();
}
return n;
}
@SuppressWarnings("unchecked")
public static <T> T[] convert(ArrayList<T> arrayList) {
if (arrayList.size() == 0) {
return null;
}
T[] array = (T[]) Array.newInstance(arrayList.get(0).getClass(), arrayList.size());
for (int i = 0; i < array.length; i++) {
array[i] = arrayList.get(i);
}
return array;
}
public static <T> String join(T[] array, String seperator) {
String string = "";
for (int i = 0; i < array.length; i++) {
string += array[i].toString();
if (i < array.length - 1) {
string += seperator;
}
}
return string;
}
public static <T> T[] remove(T[] array, int index) {
ArrayList<T> arrayList = new ArrayList<T>();
for (int i = 0; i < array.length; i++) {
if (i != index) {
arrayList.add(array[i]);
}
}
return convert(arrayList);
}
public static <T> T[] unique(T[] array) {
ArrayList<T> arrayList = new ArrayList<T>();
for (int i = 0; i < array.length; i++) {
if (!arrayList.contains(array[i])) {
arrayList.add(array[i]);
}
}
return convert(arrayList);
}
}
}
| 0 | 1,189,449 |
A11759 | A12428 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.*;
public class jam02 {
/**
* @param args
*/
public static void main1(){
// scalar product problem
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int number_test;
Scanner sc = new Scanner(System.in);
number_test = sc.nextInt();
for(int j=1;j<=number_test;j++) {
int numOfGooglers = sc.nextInt();
int numOfSurprises = sc.nextInt();
int surPrisingNum = sc.nextInt();
int[] googlers = new int[numOfGooglers];
for(int i=0;i<numOfGooglers;i++)
{
googlers[i] = sc.nextInt();
}
System.out.print("Case #" + j + ": ");
action(surPrisingNum,numOfSurprises,googlers);
// System.out.println(sum);
}
}
private static void action(int surPrisingNum, int numOfSurprises,
int[] googlers) {
// TODO Auto-generated method stub
// Iterating over the elements in the set
int finalGuys = 0;
for(int i=0;i<googlers.length;i++)
{
if(googlers[i] >= (surPrisingNum*3)-2)
{
finalGuys++;
}
else if(numOfSurprises !=0 && googlers[i] !=0 && googlers[i] >= (surPrisingNum*3)-4)
{
finalGuys++;
numOfSurprises--;
}
}
System.out.println(finalGuys);
}
}
| 0 | 1,189,450 |
A11759 | A12845 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam2012.qr;
import codejam.common.CodeHelper;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
*
* @author Chen Ling
*/
public class ProblemB {
private static String SMALL_IN_FILE_NAME = "/codejam2012/qr/B-small.in";
private static String LARGE_IN_FILE_NAME = "/codejam2012/qr/B-large.in";
private static String SMALL_OUT_FILE_NAME = "/codejam2012/qr/B-small.out";
private static String LARGE_OUT_FILE_NAME = "/codejam2012/qr/B-large.out";
public static void main(String[] args) {
List<String> smallLines = CodeHelper.loadInputLines(SMALL_IN_FILE_NAME);
List<String> smallOutputs = new ArrayList<String>();
for (int i = 1; i < smallLines.size(); i++) {
String line = smallLines.get(i);
List<String> numbers = new ArrayList<String>();
String[] numberArray = line.split(" ");
for (String number : numberArray) {
numbers.add(number);
}
smallOutputs.add("Case #" + i + ": " + solve(numbers));
}
CodeHelper.writeOutputs(SMALL_OUT_FILE_NAME, smallOutputs);
//
// List<String> largeLines = CodeHelper.loadInputLines(LARGE_IN_FILE_NAME);
// List<String> largeOutputs = new ArrayList<String>();
// for (int i = 1; i < largeLines.size(); i++) {
// String line = largeLines.get(i);
// List<String> numbers = new ArrayList<String>();
// String[] numberArray = line.split(" ");
// for (String number : numberArray) {
// numbers.add(number);
// }
// largeOutputs.add("Case #" + i + ": " + solve(numbers));
// }
// CodeHelper.writeOutputs(LARGE_OUT_FILE_NAME, largeOutputs);
}
public static int solve(List<String> numbers) {
int result = 0;
int s = Integer.parseInt(numbers.get(1));
int p = Integer.parseInt(numbers.get(2));
List<Triplet> triplets = new ArrayList<Triplet>();
for (int i = 3; i < numbers.size(); i++) {
int t = Integer.parseInt(numbers.get(i));
int n = t / 3;
int a = t % 3;
Triplet triplet = null;
if (a == 0) {
triplet = new Triplet(n, n, n);
} else if (a == 1) {
triplet = new Triplet(n, n, n + 1);
} else {
triplet = new Triplet(n, n + 1, n + 1);
}
triplets.add(triplet);
}
Collections.sort(triplets);
int index = 0;
for (Triplet triplet : triplets) {
if (index == s) {
break;
}
if (triplet.getThird() >= p) {
continue;
}
if ((triplet.getThird() - triplet.getFirst()) == 0) {
if (triplet.getFirst() == 0) {
continue;
}
triplet.setFirst(triplet.getFirst() - 1);
triplet.setThird(triplet.getThird() + 1);
index++;
} else if ((triplet.getThird() - triplet.getSecond()) == 1) {
if (triplet.getSecond() == 0) {
continue;
}
triplet.setFirst(triplet.getFirst() - 1);
triplet.setSecond(triplet.getSecond() + 1);
index++;
} else if ((triplet.getThird() - triplet.getFirst()) == 1) {
triplet.setSecond(triplet.getSecond() - 1);
triplet.setThird(triplet.getThird() + 1);
index++;
}
}
Collections.sort(triplets);
for (Triplet triplet : triplets) {
if (triplet.getThird() >= p) {
result++;
} else {
break;
}
}
return result;
}
private static class Triplet implements Comparable<Triplet> {
private int first;
private int second;
private int third;
public Triplet(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
public int getFirst() {
return first;
}
public void setFirst(int first) {
this.first = first;
}
public int getSecond() {
return second;
}
public void setSecond(int second) {
this.second = second;
}
public int getThird() {
return third;
}
public void setThird(int third) {
this.third = third;
}
@Override
public int compareTo(Triplet o) {
return o.getThird() - this.getThird();
}
}
}
| 0 | 1,189,451 |
A11759 | A11043 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.Collection;
import java.util.Comparator;
/**
* Typed 3-tuple
*/
public class Tuple3<A, B, C> {
private final A field0;
private final B field1;
private final C field2;
public A getField0() {
return field0;
}
public B getField1() {
return field1;
}
public C getField2() {
return field2;
}
public Tuple3(final A field0, final B field1, final C field2) {
this.field0 = field0;
this.field1 = field1;
this.field2 = field2;
}
/** Convenience method so type params of pair don't have to be specified: just do Tuple3.make(a, b, c) */
public static <A, B, C> Tuple3<A, B, C> make(A field0, B field1, C field2) {
return new Tuple3<A, B, C>(field0, field1, field2);
}
// ---------------------------------------------------------------------------------------------------
private static final boolean objEquals(Object p1, Object p2) {
if (p1 == null)
return p2 == null;
return p1.equals(p2);
}
@Override
public final boolean equals(Object o) {
if (!(o instanceof Tuple3<?, ?, ?>)) {
return false;
} else {
final Tuple3<?, ?, ?> other = (Tuple3<?, ?, ?>) o;
return objEquals(getField0(), other.getField0()) && objEquals(getField1(), other.getField1())
&& objEquals(getField2(), other.getField2());
}
}
@Override
public int hashCode() {
int h0 = getField0() == null ? 0 : getField0().hashCode();
int h1 = getField1() == null ? 0 : getField1().hashCode();
int h2 = getField2() == null ? 0 : getField2().hashCode();
return h0 + 53 * h1 + 97 * h2;
}
// ---------------------------------------------------------------------------------------------------
public static <A extends Comparable<A>, B, C> Comparator<Tuple3<A, B, C>> comparatorOnField0(Collection<Tuple3<A, B, C>> tupleCollection) {
return new Comparator<Tuple3<A, B, C>>() {
@Override
public int compare(Tuple3<A, B, C> o1, Tuple3<A, B, C> o2) {
return o1.getField0().compareTo(o2.getField0());
}
};
}
public static <A extends Comparable<A>, B, C> Comparator<Tuple3<A, B, C>> comparatorOnField0Rev(Collection<Tuple3<A, B, C>> tupleCollection) {
return new Comparator<Tuple3<A, B, C>>() {
@Override
public int compare(Tuple3<A, B, C> o1, Tuple3<A, B, C> o2) {
return -o1.getField0().compareTo(o2.getField0());
}
};
}
public static <A, B extends Comparable<B>, C> Comparator<Tuple3<A, B, C>> comparatorOnField1(Collection<Tuple3<A, B, C>> tupleCollection) {
return new Comparator<Tuple3<A, B, C>>() {
@Override
public int compare(Tuple3<A, B, C> o1, Tuple3<A, B, C> o2) {
return o1.getField1().compareTo(o2.getField1());
}
};
}
public static <A, B extends Comparable<B>, C> Comparator<Tuple3<A, B, C>> comparatorOnField1Rev(Collection<Tuple3<A, B, C>> tupleCollection) {
return new Comparator<Tuple3<A, B, C>>() {
@Override
public int compare(Tuple3<A, B, C> o1, Tuple3<A, B, C> o2) {
return -o1.getField1().compareTo(o2.getField1());
}
};
}
public static <A, B, C extends Comparable<C>> Comparator<Tuple3<A, B, C>> comparatorOnField2(Collection<Tuple3<A, B, C>> tupleCollection) {
return new Comparator<Tuple3<A, B, C>>() {
@Override
public int compare(Tuple3<A, B, C> o1, Tuple3<A, B, C> o2) {
return o1.getField2().compareTo(o2.getField2());
}
};
}
public static <A, B, C extends Comparable<C>> Comparator<Tuple3<A, B, C>> comparatorOnField2Rev(Collection<Tuple3<A, B, C>> tupleCollection) {
return new Comparator<Tuple3<A, B, C>>() {
@Override
public int compare(Tuple3<A, B, C> o1, Tuple3<A, B, C> o2) {
return -o1.getField2().compareTo(o2.getField2());
}
};
}
// ---------------------------------------------------------------------------------------------------
@Override
public String toString() {
return "(" + getField0() + ", " + getField1() + ", " + getField2() + ")";
}
}
| 0 | 1,189,452 |
A11759 | A10570 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 posv
*/
public class GoogleDance{
public static void main(String[] args){
int cs = 0;
int n,s,p,ln,count,counts,total,temp;
count = 0; counts = 0; total = 0;
//List<Integer> scores = new ArrayList<Integer>();
try{
File file = new File("lines1.txt");
BufferedReader reader = new BufferedReader(new FileReader(file));
String line = null;
while ((line = reader.readLine()) != null){
String[] tokens = line.split(" ");
//System.out.println("Length : #" +tokens.length);
ln = tokens.length;
if(cs==0){
cs++;
continue;
} else {
n = Integer.parseInt(tokens[0]);
s = Integer.parseInt(tokens[1]);
p = Integer.parseInt(tokens[2]);
for(int i=3;i<ln;i++){
temp = Integer.parseInt(tokens[i]);
if(temp == 0 && p!= 0){
continue;
} else if(temp >= (p*3-2)) {
count++;
}else if(temp >= (p*3-4) && temp < (p*3-2)){
counts++;
}
}
if(counts >= s){
total = count + s;
} else{
total = count + counts;
}
System.out.println("Case #" +cs+": " +total);
}
cs++;
count = 0; counts = 0; total = 0;
}
} catch(Exception ex){
ex.printStackTrace();
}
}
}
| 0 | 1,189,453 |
A11759 | A10016 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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
{
String inputfilename = args[0];
String outputfilename = args[1];
BufferedReader br = new BufferedReader(new FileReader(inputfilename));
BufferedWriter bw = new BufferedWriter(new FileWriter(outputfilename));
int cases = Integer.valueOf(br.readLine());
for(int i = 0; i < cases; i++) {
String[] ele = br.readLine().split(" ");
int n = Integer.valueOf(ele[0]);
int s = Integer.valueOf(ele[1]);
int p = Integer.valueOf(ele[2]);
List<Integer> total = new ArrayList<Integer>();
for(int j = 0; j < n; j++) {
total.add(Integer.valueOf(ele[3 + j]));
}
int result = B.solve(n,s,p,total);
bw.write("Case #" + (i + 1) + ": " + result + "\n");
}
br.close();
bw.close();
}
public static int solve(int n,int s,int p,List<Integer> total)
{
int cnt = 0;
for(Integer t : total) {
int divide = t / 3;
int left = t - divide * 3;
if(divide >= p) {
cnt++;
continue;
}
if(left == 1) {
if(divide + 1 >= p) cnt++;
} else if(left == 2) {
if(divide + 1 >= p) cnt++;
else if(divide + 2 >= p && s > 0) {cnt++;s--;}
} else if(divide > 0){
if(divide + 1 >= p && s > 0) {cnt++;s--;}
}
}
return cnt;
}
}
| 0 | 1,189,454 |
A11759 | A12826 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.IOException;
import java.util.ArrayList;
import java.util.List;
public class FileRW {
public static List<String> readFile(String fileName) throws IOException{
List<String> lines = new ArrayList<>();
BufferedReader reader = new BufferedReader(new FileReader(fileName));
String line = reader.readLine();
while(line != null){
lines.add(line.trim());
line = reader.readLine();
}
reader.close();
lines.remove(0);
return lines;
}
public static void writeOutput(String fileName, List<String> result) throws IOException{
StringBuilder out = new StringBuilder();
String prefix = "Case #";
for (int i = 0; i < result.size(); i++) {
out.append(prefix + (i + 1) + ": " + result.get(i) + "\n");
}
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
writer.write(out.toString());
writer.close();
}
}
| 0 | 1,189,455 |
A11759 | A12350 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.*;
/**
*
* @author jgao
*/
public class CodeJam {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String file = "B-small-attempt1.in";
List<String> input;
try {
input = readFile(file);
} catch(Exception e) {
return;
}
for (int i=1; i<input.size(); i++) {
System.out.print("Case #"+i+": ");
String[] strs = input.get(i).split(" ");
int N = Integer.parseInt(strs[0]);
int S = Integer.parseInt(strs[1]);
int p = Integer.parseInt(strs[2]);
if (p==0) {
System.out.println(N);
continue;
}
int[] scores = new int[N];
for (int j=0; j<N; j++) {
scores[j] = Integer.parseInt(strs[j+3]);
}
int go=0, sgo=0;
int thgo=p*3-2, thsgo=thgo-2;
for (int score : scores) {
if (score>=thgo) {
go++;
} else if (score>=thsgo) {
sgo++;
}
}
System.out.println(go+(p==1?0:Math.min(sgo,S)));
}
}
public static List<String> readFile(String file) throws Exception {
List<String> content = new ArrayList<String>();
BufferedReader in = new BufferedReader(new FileReader(file));
for (String line=in.readLine(); line!=null; line=in.readLine()) {
content.add(line);
}
in.close();
return content;
}
}
| 0 | 1,189,456 |
A11759 | A10955 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.*;
class Main
{
public static void main(String[] args) throws Exception
{
Main m = new Main();
m.foo();
}
long count = 0;
void foo() throws Exception
{
// BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Scanner s = new Scanner(System.in);
int T = s.nextInt();
int testNum = 1;
while(T-->0)
{
int numGooglers = s.nextInt();
int numSurprises = s.nextInt();
int p = s.nextInt();
int[] scores = new int[numGooglers];
for(int k=0; k<scores.length; k++)
{
scores[k] = s.nextInt();
}
Arrays.sort(scores);
int ret = 0;
for(int k=0; k<scores.length; k++)
{
int sc = scores[k];
if(sc < p)
continue;
int d = sc/3;
int r = sc%3;
//System.out.printf("sc: %d, d: %d, r: %d\n", sc, d, r);
if(r==0)
{
if(d >= p)
{
ret++;
continue;
}
// TODO: Handle a surprise
if(d+1 >= p && numSurprises != 0)
{
ret++;
numSurprises--;
continue;
}
}
else if(r==1)
{
if(d+1 >= p)
{
ret++;
continue;
}
// TODO: Handle a surprise
// I can't.
}
else if(r==2)
{
if(d+1 >= p)
{
ret++;
continue;
}
// TODO: Handle a surprise
if(d+2 >= p && numSurprises != 0)
{
ret++;
numSurprises--;
continue;
}
}
}
//ret += numSurprises;
//ret -= Math.max(0, numSurp - numSurprises);
//System.out.printf("Known surprises: %d, Found surprises: %d\n", numSurprises, numSurp);
System.out.printf("Case #%d: %d\n", testNum, ret);
testNum++;
}
}
} | 0 | 1,189,457 |
A11759 | A12609 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
class dance {
int single[][] = new int[4][3];
int doublex[][] = new int[54][3];
dance() {
single[0][0] = 0;
single[0][1] = 0;
single[0][2] = 0;
single[1][0] = 0;
single[1][1] = 0;
single[1][2] = 1;
single[2][0] = 10;
single[2][1] = 10;
single[2][2] = 9;
single[3][0] = 10;
single[3][1] = 10;
single[3][2] = 10;
}
int[][] gen_tuple(int num) {
int tup[][] = new int[2][3];
if (num % 3 == 0) {
tup[0][0] = num / 3;
tup[0][1] = num / 3;
tup[0][2] = num / 3;
tup[1][0] = num / 3 - 1;
tup[1][1] = num / 3;
tup[1][2] = num / 3 + 1;
} else if (num % 3 == 1) {
tup[0][0] = num / 3;
tup[0][1] = num / 3;
tup[0][2] = num / 3 + 1;
tup[1][0] = num / 3 + 1;
tup[1][1] = num / 3 + 1;
tup[1][2] = num / 3 - 1;
} else if (num % 3 == 2) {
tup[0][0] = num / 3;
tup[0][1] = num / 3 + 1;
tup[0][2] = num / 3 + 1;
tup[1][0] = num / 3;
tup[1][1] = num / 3;
tup[1][2] = num / 3 + 2;
}
return tup;
}
int maxx(int a, int b, int c) {
int temp = Math.max(a, b);
temp = Math.max(temp, c);
return temp;
}
public static void main(String[] args) throws IOException {
dance my = new dance();
for (int i = 2; i < 29; i++) {
int temp[][] = my.gen_tuple(i);
// System.out.println((i - 2) * 2);
my.doublex[(i - 2) * 2][0] = temp[0][0];
my.doublex[(i - 2) * 2][1] = temp[0][1];
my.doublex[(i - 2) * 2][2] = temp[0][2];
my.doublex[(i - 2) * 2 + 1][0] = temp[1][0];
my.doublex[(i - 2) * 2 + 1][1] = temp[1][1];
my.doublex[(i - 2) * 2 + 1][2] = temp[1][2];
// System.out.print(my.doublex[(i - 2) * 2][0] + " ");
// System.out.print(my.doublex[(i - 2) * 2][1] + ",");
// System.out.print(my.doublex[(i - 2) * 2][2] + ",");
// System.out.print(my.doublex[(i - 2) * 2 + 1][0] + ",");
// System.out.print(my.doublex[(i - 2) * 2 + 1][1] + ",");
// System.out.println(my.doublex[(i - 2) * 2 + 1][2] + ",");
}
String Path = "C:\\Users\\Dell\\Desktop\\B-small-attempt0.in";
Scanner read = new Scanner(new File(Path));
File file = new File("C:\\Users\\Dell\\Desktop\\out.txt");
PrintWriter Fout = new PrintWriter(new BufferedWriter(new FileWriter(
file)), true);
String line = read.nextLine();
int iter = 0;
while (read.hasNextLine()) {
iter = iter + 1;
line = read.nextLine();
String d = "[ ]+";
String[] SplitD = line.split(d);
for (int x = 0; x < SplitD.length; x++) {
// System.out.println(SplitD[x]);
}
int N = Integer.parseInt(SplitD[0]);
int S = Integer.parseInt(SplitD[1]);
int p = Integer.parseInt(SplitD[2]);
int count = 0;
int surp = 0;
for (int j = 0; j < N; j++) {
int val = Integer.parseInt(SplitD[j + 3]);
if (val < 2) {
if (my.maxx(my.single[val][0], my.single[val][1],
my.single[val][2]) >= p) {
count += 1;
}
} else if (val > 28) {
if (my.maxx(my.single[val - 27][0], my.single[val - 27][1],
my.single[val - 27][2]) >= p) {
count += 1;
}
} else {
if (my.maxx(my.doublex[(val - 2) * 2][0],
my.doublex[(val - 2) * 2][1],
my.doublex[(val - 2) * 2][2]) >= p) {
count += 1;
} else if (my.maxx(my.doublex[(val - 2) * 2 + 1][0],
my.doublex[(val - 2) * 2 + 1][1],
my.doublex[(val - 2) * 2 + 1][2]) >= p) {
surp += 1;
}
}
}
if (surp > S) {
count = count + S;
} else {
count = count + surp;
}
String output_str = "Case #" + iter + ": " + count;
Fout.println(output_str);
}
read.close();
}
} | 0 | 1,189,458 |
A11759 | A11384 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package Codejam;
import java.util.HashMap;
import java.util.Scanner;
public class CodeJamB {
public static void main(String args[]){
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
int n;
int s;
int p;
int triplet;
int result;
int score;
for(int i = 0; i < t; i++){
n = scn.nextInt();
s = scn.nextInt();
p = scn.nextInt();
triplet = 0;
result = 0;
for(int j = 0; j < n; j++){
score = scn.nextInt();
if(score > ((p * 3) - 3)){
result ++;
}else if(score > 2 && score > ((p * 3) - 5) && triplet < s){
result ++;
triplet ++;
}
}
System.out.println("Case #" + ( i + 1 ) + ": " + result);
}
}
}
| 0 | 1,189,459 |
A11759 | A10290 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 common;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.MalformedURLException;
import java.net.URL;
import protocols.ConfigurableStreamHandlerFactory;
public class QuestionHandler {
static {
ConfigurableStreamHandlerFactory.Init();
}
private final ISolver solver;
private String newLine = System.getProperty("line.separator");
public QuestionHandler(ISolver solver) {
this.solver = solver;
}
public void addCase(String problem, String answer) {
solver.addCase(problem, answer);
}
public void addResource(String problemResource, String answerResource) {
try {
addResource(new URL(autoCompleteResourceName(problemResource)),
new URL(autoCompleteResourceName(answerResource)));
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
}
public void addResource(URL problemUrl, URL answerUrl) {
try {
BufferedReader problemReader = new BufferedReader(
new InputStreamReader(problemUrl.openStream()));
BufferedReader answerReader = new BufferedReader(
new InputStreamReader(answerUrl.openStream()));
int numberOfCases = Integer.valueOf(problemReader.readLine());
for (int i = 0; i < numberOfCases; ++i) {
String answerLine = answerReader.readLine();
answerLine = answerLine.substring(answerLine.indexOf(':') + 2);
solver.addCase(problemReader.readLine(), answerLine);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void solve(String problemResource, String answerResource) {
try {
solve(new URL(autoCompleteResourceName(problemResource)), new URL(
autoCompleteResourceName(answerResource)));
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
}
public void solve(URL problemUrl, URL answerUrl) {
try {
String path = answerUrl.getPath().replace('\\', '/');
String curDir = System.getProperty("user.dir").replace('\\', '/')
+ "/";
File outFile = new File(curDir + "src/" + path);
solve(problemUrl, new FileWriter(outFile), new OutputStreamWriter(
System.out) {
@Override
public void close() throws IOException {
}
});
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private void solve(URL problemUrl, Writer... writers) {
try {
BufferedReader problemReader = new BufferedReader(
new InputStreamReader(problemUrl.openStream()));
int numberOfCases = Integer.valueOf(problemReader.readLine());
for (int i = 0; i < numberOfCases; ++i) {
String solution = "Case #" + (i + 1) + ": "
+ solver.solve(problemReader.readLine());
for (Writer writer : writers) {
writer.write(solution);
writer.write(newLine);
}
}
for (Writer writer : writers) {
writer.flush();
writer.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@SuppressWarnings("unchecked")
public <T extends ISolver> T getSolver() {
return (T)solver;
}
private String autoCompleteResourceName(String resource) {
if (resource.indexOf(":") != -1) {
return resource;
}
return "classpath:"
+ solver.getClass().getPackage().getName().replace('.', '/')
+ "/" + resource;
}
}
| 0 | 1,189,460 |
A11759 | A10733 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Blank {
public static int cases = 0;
public static void main(String args[]) {
File input = new File("Input.txt");
File output = new File("Output.txt");
saveGame(output, convertString(loadGame(input)));
}
public static String[] loadGame(File input){
Scanner in;
try {
in = new Scanner(input);
String[] output = new String[30];
cases = in.nextInt();
in.nextLine();
for(int i = 0; i < cases; i++){
output[i] = in.nextLine().toLowerCase();
}
in.close();
return output;
}
catch (StringIndexOutOfBoundsException e) {
}
catch (FileNotFoundException e) {
}
catch (NoSuchElementException e) {
}
catch (NullPointerException e) { }
return null;
}
public static void saveGame(File name, String[] output){
PrintWriter out;
try {
out = new PrintWriter(name);
for(int i = 1; i <= cases; i++){
out.println("Case #" + i + ": " + output[(i-1)]);
}
out.close();
}
catch (FileNotFoundException e) {
}
catch (NullPointerException e) {
}
}
public static String[] convertString(String[] output){
String[] returnString = new String[30];
for(int i = 0; i < cases; i++){
returnString[i] = Character.toString(convert(output[i].charAt(0)));
for(int j = 1; j < output[i].length(); j++){
returnString[i] += convert(output[i].charAt(j));
}
}
return returnString;
}
public static char convert(char letter){
char returnLetter;
switch (letter) {
case 'a': returnLetter = 'y';
break;
case 'b': returnLetter = 'h';
break;
case 'c': returnLetter = 'e';
break;
case 'd': returnLetter = 's';
break;
case 'e': returnLetter = 'o';
break;
case 'f': returnLetter = 'c';
break;
case 'g': returnLetter = 'v';
break;
case 'h': returnLetter = 'x';
break;
case 'i': returnLetter = 'd';
break;
case 'j': returnLetter = 'u';
break;
case 'k': returnLetter = 'i';
break;
case 'l': returnLetter = 'g';
break;
case 'm': returnLetter = 'l';
break;
case 'n': returnLetter = 'b';
break;
case 'o': returnLetter = 'k';
break;
case 'p': returnLetter = 'r';
break;
case 'q': returnLetter = 'z';
break;
case 'r': returnLetter = 't';
break;
case 's': returnLetter = 'n';
break;
case 't': returnLetter = 'w';
break;
case 'u': returnLetter = 'j';
break;
case 'v': returnLetter = 'p';
break;
case 'w': returnLetter = 'f';
break;
case 'x': returnLetter = 'm';
break;
case 'y': returnLetter = 'a';
break;
case 'z': returnLetter = 'q';
break;
default: returnLetter = ' ';
break;
}
return returnLetter;
}
}
| 0 | 1,189,461 |
A11759 | A11922 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 test.cjam;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
public class Triplet {
static HashMap<Integer, Integer> sMap = new HashMap<Integer, Integer>();
static HashMap<Integer, Integer> nsMap = new HashMap<Integer, Integer>();
static void generateMap() {
for (int i = 2; i <= 28; i++) {
// int res = 0
if ((i + 2) % 3 == 0) {
sMap.put(i, (i + 2) / 3);
} else if ((i + 3) % 3 == 0) {
sMap.put(i, (i + 3) / 3);
} else if ((i + 4) % 3 == 0) {
sMap.put(i, (i + 4) / 3);
}
}
}
static void generateNSMap() {
for (int i = 0; i <= 30; i++) {
if (i % 3 == 0) {
nsMap.put(i, i / 3);
} else if ((i + 2) % 3 == 0) {
nsMap.put(i, (i + 2) / 3);
} else if ((i + 1) % 3 == 0) {
nsMap.put(i, (i + 1) / 3);
}
}
}
public static void main(String args[]) throws Exception {
generateMap();
generateNSMap();
BufferedReader br = new BufferedReader(new FileReader(new File(
"input.txt")));
int T = Integer.parseInt(br.readLine());
for (int t = 1; t <= T; t++) {
String[] inArr = br.readLine().split(" ");
int N = Integer.parseInt(inArr[0]);
int S = Integer.parseInt(inArr[1]);
int p = Integer.parseInt(inArr[2]);
Integer tempArr[] = new Integer[N];
int ofs = 3;
for (int i = 0; i < N; i++) {
tempArr[i] = Integer.parseInt(inArr[i + ofs]);
}
Collections.sort(Arrays.asList(tempArr));
int cnt = 0;
int fIndex = -1;
if (S == 0) {
for (int i = 0; i < N; i++) {
int val = tempArr[i];
if (p <= nsMap.get(val)) {
fIndex = i;
cnt = N - fIndex;
break;
}
}
} else {
for (int i = 0; i < N; i++) {
int val = tempArr[i];
if (val < 2 || val > 28)
continue;
if (p <= sMap.get(val)) {
fIndex = i;
S--;
cnt++;
break;
}
}
int ind = fIndex + 1;
while (S > 0) {
if (ind >= N)
break;
int val = tempArr[ind];
if (p <= sMap.get(val)) {
S--;
cnt++;
}
ind++;
}
for (int j = ind; j < N; j++) {
int val = tempArr[j];
if (p <= nsMap.get(val)) {
fIndex = j;
cnt += N - fIndex;
break;
}
}
}
System.out.println("Case #" + t + ": " + cnt);
}
br.close();
}
}
| 0 | 1,189,462 |
A11759 | A12513 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 dancingwithgoogler;
import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
*
* @author WC
*/
public class CodeJamFileManager {
private final static String problemIntro = "Problem reading file: ";
private final static String location = "C:\\CodeJamTests\\";
public static String getStringOfFile(String filename) {
String filepath = location + filename;
byte[] buffer = new byte[(int) new File(filepath).length()];
BufferedInputStream stream = null;
try {
stream = new BufferedInputStream(new FileInputStream(filepath));
stream.read(buffer);
}
catch (Exception ex) {
return problemIntro + ex.getMessage();
}
finally {
if (stream != null) {
try {
stream.close();
}
catch (IOException ex) {
return problemIntro + ex.getMessage();
}
}
}
return new String(buffer);
}
public static int getIntFromFirstLineOfFile(String filename, String separator) {
String[] lines = getTextLinesOfFile(filename, separator);
int i = 1;
return extractInt(lines[0]);
}
public static String[] getTextLinesOfFile(String filename, String separator) {
String fileStr = getStringOfFile(filename);
return fileStr.split(separator);
}
public static void saveOutputFile(String output, String filename, String separator) {
String filepath = location + filename;
try {
File outFile = new File(filepath);
FileWriter writer = new FileWriter(outFile);
BufferedWriter bWriter = new BufferedWriter(writer);
bWriter.write(output);
bWriter.close();
}
catch (Exception ex) {
System.out.println("Failed to save file with error: " + ex.getMessage());
}
}
private static int extractInt(String line) {
Matcher intMatcher = Pattern.compile("[0-9]*").matcher(line);
int i = 0;
if (intMatcher.find()) {
String numStr = intMatcher.group(0);
i = Integer.parseInt(numStr);
}
return i;
}
}
| 0 | 1,189,463 |
A11759 | A13027 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 javaapplication1;
import java.io.*;
public class DancingWithTheGooglers2 {
public static int numberOfGooglers(int scores[],int s,int minScore){
int count=0;
int score=0;
for(int i=0;i<scores.length;i++){
score=scores[i];
int base=(int)score/3;
switch(score%3){
case 0: //System.out.println("0score = "+score);
if(base>=minScore){
count++;
}
else{
if(s>0&&base>0&&(base+1)>=minScore){
count++;
s--;
}
}
break;
case 1://System.out.println("1score = "+score);
if(base>=minScore||(base+1)>=minScore){
count++;
}
else{
if(s>0&&(base+1)>=minScore){
count++;
s--;
}
}
break;
case 2://System.out.println("2score = "+score);
if((base+1)>=minScore||base>=minScore){
count++;
}
else{
if(s>0&&(base+2)>=minScore){
count++;
s--;
}
}
break;
}
}
return count;
}
public static void main(String args[])throws IOException{
BufferedWriter bw= new BufferedWriter(new FileWriter("c:/codejam/testo.txt"));
BufferedReader br=new BufferedReader(new FileReader("c:/codejam/B-small-attempt0.in"));
int t=Integer.parseInt(br.readLine());
for(int i=1;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 arr[]=new int[n];
for(int j=0;j<n;j++){
arr[j]=Integer.parseInt(str[j+3]);
//System.out.println(arr[j]);
}
bw.write("Case #"+i+": "+numberOfGooglers(arr,s,p));
bw.newLine();
}
bw.close();
}
}
| 0 | 1,189,464 |
A11759 | A11441 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 ProblemB {
static Scanner in = new Scanner(System.in);
public static void main(String[] args) throws Exception{
int lineCount = Integer.valueOf(in.nextLine());
int[] lines = new int[lineCount];
for(int n = 0; n < lineCount; n++) {
int N = in.nextInt(),
S = in.nextInt(),
p = in.nextInt();
int max = 0;
for (int i = 0; i < N; i++) {
int score= in.nextInt();
int single = score / 3;
switch (score % 3) {
case 0:
if (single >= p) {
max++;
} else {
if (S > 0 && score >= 2 && score <= 28 && single + 1 >= p) {
max++;
S--;
}
}
break;
case 1:
if (single + 1 >= p) {
max++;
}
break;
case 2:
if (single +1 >= p) {
max++;
} else {
if (S > 0 && score >= 2 && score <= 28 && single + 2 >= p) {
max++;
S--;
}
}
}
}
lines[n] = max;
in.nextLine();
}
for(int i = 1; i <= lineCount; i++) {
System.out.println("Case #" + i + ": " + lines[i-1]);
}
}
} | 0 | 1,189,465 |
A11759 | A12816 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
public class dancing {
public static void main(String[] args)throws Exception{
Scanner f = new Scanner(new File(args[0]));
int count=0;//# tuples >= limit
int res=0; //mult result
int rem=0; //remainder
int N=0; //# tuples
int S=0; //# surprising tuples (t%r==2)
int s=0; //current count of surprising tuples
int l=0; //the limit
int minT=0,maxT=10; //minmum & maximum T values;
ArrayList<Integer> al=new ArrayList<Integer>(); //list of tuples
int C=0; //# cases
C = f.nextInt(); //get # of test cases
for (int c=1;c<=C;c++){ //for each test case
N=f.nextInt();S=f.nextInt();l=f.nextInt();//get params
count=0; //reset # good tuples count
s=0; //reset surprising tuple count
al.clear(); //reset t list
for(int i=1;i<=N;i++)al.add(f.nextInt());//build t list
Collections.sort(al); //sort lowest to highest
Collections.reverse(al);//sort highest to lowest
/*for (Integer x: al)System.out.print(x + " ");*/
for (Integer t:al) {
res=t/3; rem=t%3;
if (res >= l)
count++;
else if (res == l-1)
if (rem != 0)
count++;
else {// rem==0
if (s<S && res>minT) {
count++;
s++;
}
}
else if (res == l-2)
if (rem == 2) {
if (s < S) {
count++;
s++;
}
}
}
System.out.println("Case #"+c+": "+count);//display result
}
}
} | 0 | 1,189,466 |
A11759 | A11563 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.Scanner;
public class B {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int ncases = sc.nextInt();
StringBuilder sb = new StringBuilder();
for ( int ncase = 1; ncase <= ncases; ncase++ ) {
int nGooglers = sc.nextInt();
int nSuprising = sc.nextInt();
int p = sc.nextInt();
int surprises = 0;
int count = 0;
for (int i = 0; i < nGooglers; i++) {
int s = sc.nextInt();
int q = s/3;
int rm = s%3;
int pq = p-q;
if ( s < p)
continue;
if ( q >= p ) {
count++;
}
else if ( pq <= 2 ){
if ( rm == 0 ) {
if ( pq == 1 && surprises < nSuprising ) {
count++;
surprises++;
}
}
else {
if ( pq == 1 )
count++;
else if ( rm == 2 && surprises < nSuprising ) {
count++;
surprises++;
}
}
}
}
sb.append("Case #"+ ncase +": " + count + "\n");
}
BufferedOutputStream bos = null;
bos= new BufferedOutputStream(new FileOutputStream(new File("C:\\Users\\Christian\\workspaceCPDI\\CodeJam2012\\src\\qualificationRound\\res.txt")));
bos.write(sb.toString().getBytes());
bos.close();
}
} | 0 | 1,189,467 |
A11759 | A11838 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BDanceWithGooglers {
public static void solve() throws IOException {
File f = new File("E:\\downloads\\B-small-attempt2.in");
BufferedReader reader = new BufferedReader(new FileReader(f));
File f2 = new File("C:\\Users\\kimo\\Desktop\\out.txt");
BufferedWriter writer = new BufferedWriter(new FileWriter(f2));
int x = Integer.parseInt(reader.readLine());
int a[] = null;
String st[] = null;
for (int i = 0; i < x; i++) {
st = reader.readLine().split(" ");
a = new int[st.length];
for (int j = 0; j < st.length; j++)
a[j] = Integer.parseInt(st[j]);
int s = a[1];
int p = a[2];
int count = 0;
int exact = p + p - 1 + p - 1;
int surp = p + p - 2 + p - 2;
for (int k = 3; k < a.length; k++)
if (a[k] / 3 >= p || a[k] >= exact&&a[k]>=p)
count++;
else
if (a[k] >= surp && s-- > 0&&a[k]>=p)
count++;
writer.write("Case #" + (i + 1) + ": " + count);
writer.newLine();
}
reader.close();
writer.close();
}
public static void main(String[] args) throws IOException {
solve();
}
}
| 0 | 1,189,468 |
A11759 | A11337 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 read = new Scanner(new File("B-small-attempt0.in"));
PrintWriter out = new PrintWriter(new File("b-small.out"));
int numberOfTests = Integer.parseInt(read.nextLine());
for (int i = 1; i <= numberOfTests; i++) {
int result = 0;
int n = read.nextInt();
int countSurp = read.nextInt();
int minScore = read.nextInt();
int[] totalScores = new int[n];
for (int j = 0; j < n; j++) {
totalScores[j] = read.nextInt();
}
double[] avg = new double[n];
for (int j = 0; j < n; j++) {
avg[j] = totalScores[j] / 3.0;
}
for (int j = 0; j < n; j++) {
if (avg[j] >= minScore) {
result++;
} else if (Math.abs(avg[j] - minScore) >= 1.5) {
continue;
} else if (Math.abs(avg[j] - Math.round(avg[j])) < 0.3) {
long t1 = Math.round(avg[j]);
long t2 = t1;
long t3 = t2;
if (countSurp > 0 && t2 >=1) {
t2--;
t3++;
countSurp--;
result++;
}
} else if (avg[j] - Math.round(avg[j]) > 0) {
long t1 = Math.round(avg[j]);
long t2 = t1;
long t3 = t2 + 1;
if (t3 == minScore) {
result++;
}
} else {
long t1 = Math.round(avg[j]) - 1;
long t2 = t1 + 1;
long t3 = t2;
if (t3 == minScore) {
result++;
} else {
if (countSurp > 0 && t2 >= 1) {
countSurp--;
result++;
t2--;
t3++;
}
}
}
}
out.println(String.format("Case #%d: %d", i, result));
}
out.close();
}
}
| 0 | 1,189,469 |
A11759 | A10998 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 BSmall
{
public static boolean getNDWithThreshold(int hs , int threshold )
{
for(int i = 10 ; i >=0 ; i--)
{
int remainder = hs - i ;
if(remainder>0)
{
int second = 0 ;
int third =0;
if(remainder%2 == 0)
{
second = remainder/2 ;
third = remainder/2 ;
}
else
{
second = (remainder/2)+1;
third = (remainder/2) ;
}
if(i-third <=1)
{
if (i>= threshold)
{
return true;
}
}
}
}
return false ;
}
public static boolean getSDWithThreshold(int hs , int threshold )
{
for(int i = 10 ; i >=0 ; i--)
{
int remainder = hs - i ;
if(remainder>0)
{
int second = 0 ;
int third =0;
if(remainder%2 == 0)
{
second = remainder/2 ;
third = remainder/2 ;
}
else
{
second = (remainder/2)+1;
third = (remainder/2) ;
}
if(i-third <=2)
{
if (i>= threshold)
{
return true;
}
}
}
}
return false ;
}
public static boolean getND(int hs )
{
for(int i = 10 ; i >=0 ; i--)
{
int remainder = hs - i ;
int second = 0 ;
int third =0;
if(remainder%2 == 0)
{
second = remainder/2 ;
third = remainder/2 ;
}
else
{
second = (remainder/2)+1;
third = (remainder/2) ;
}
if(i-third <=1)
{
return true;
}
}
return false ;
}
public static int[] insertionSort(int[] input)
{
int [] output = new int[input.length];
for (int i = 0; i < input.length; i++)
{
int j = 0 ;
boolean isAdded = false ;
while(!isAdded && j<i)
{
if(input[i]<= output[j])
{
for (int k = i; k > j; k--)
{
output[k]=output[k-1];
}
output[j]=input[i];
isAdded = true;
}
j++;
}
if(!isAdded)
{
output[j]=input[i];
}
}
return output ;
}
public static void main(String[] args) throws IOException
{
Scanner reader = new Scanner(new File("B-small-attempt3.in"));
Scanner reader2 = new Scanner(new File("test1.txt"));
FileWriter writer = new FileWriter(new File("output.out"));
reader.nextLine();
int n = 0 ;
while(reader.hasNext())
{
n++;
String input = reader.nextLine();
// System.out.println(input);
String[] inputArray = input.split(" ");
int size = Integer.parseInt(inputArray[0]);
int surbCases = Integer.parseInt(inputArray[1]);
int threshold = Integer.parseInt(inputArray[2]);
int scores[] = new int[size];
int output=0;
if(threshold!=0)
{
for (int i = 3; i < inputArray.length; i++)
{
scores[i-3]= Integer.parseInt(inputArray[i]);
}
scores = insertionSort(scores);
output = 0 ;
for (int i = 0; i < scores.length; i++)
{
if(getNDWithThreshold(scores[i], threshold))
{
output++;
}
else if(surbCases>0&&getSDWithThreshold(scores[i], threshold))
{
output++;
surbCases -- ;
}
}
}else
{
output = size;
}
writer.write("Case #"+n+": "+output+"\r\n");
System.out.println(("Case #"+n+": "+output));
}
writer.close();
}
}
| 0 | 1,189,470 |
A11759 | A12718 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;
public class SecondQuestions {
private static long getLeastScore(long maxScore, long subtract) {
return (maxScore - subtract) < 0 ? 0 : (maxScore - subtract);
}
public static void main(String[] args) throws Exception {
try {
Scanner sc = new Scanner(new File("large.in"));
BufferedWriter bufferedWriter = null;
bufferedWriter = new BufferedWriter(new FileWriter("output.txt"));
long totalCases = sc.nextLong();
for (int i = 1; i <= totalCases; i++) {
long numContestants = sc.nextLong();
long numSurprises = sc.nextLong();
long maxScore = sc.nextLong();
long minSurpriseTotalScore = maxScore + getLeastScore(maxScore, 2) + getLeastScore(maxScore, 2);
long minTotalScore = maxScore + getLeastScore(maxScore, 1) + getLeastScore(maxScore, 1);
long qualifiers = 0;
for (int j = 0; j < numContestants; j++) {
long nextScore = sc.nextLong();
if ((nextScore >= minTotalScore)) {
qualifiers++;
} else if (((nextScore < minTotalScore) && ((nextScore >= minSurpriseTotalScore) && (numSurprises > 0)))) {
qualifiers++;
numSurprises--;
}
}
bufferedWriter.append("Case #" + i + ": ");
bufferedWriter.append(String.valueOf(qualifiers));
bufferedWriter.append("\n");
}
bufferedWriter.flush();
bufferedWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,471 |
A11759 | A12391 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 code3 {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
FileWriter fos = new FileWriter("outfile",false);
BufferedWriter bw = new BufferedWriter(fos);
int T=Integer.parseInt(br.readLine()), j=1, N , s, p, ti, i , ans ,cancellable;String str[];
for(;T>0;T--,j++)
{
str=(br.readLine()).split(" ").clone();
N= Integer.parseInt(str[0]);
s= Integer.parseInt(str[1]);
p= Integer.parseInt(str[2]);
i=0;
ans=0;
cancellable=0;
while(i<N)
{
ti=Integer.parseInt(str[i+3]); i++;
if(p==1 || p==0)
{ if(ti>=p)
ans++;
}
else{
if(ti == 3*p-4 || ti==3*p-3)
{
if(s!=0)
{s--;ans++;cancellable++;}
}
else if(ti >= 3*p-2)
{
ans++;
}
}
}
if(s>N-cancellable)
ans=ans-s;
bw.write("Case #"+j+": "+ans+"\n");
}
bw.close();
}
} | 0 | 1,189,472 |
A11759 | A12741 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.Pre;
import java.util.Scanner;
public class B {
static Scanner sc = new Scanner(System.in);
public static void main(String[] a){
long numCases = Long.parseLong(sc.nextLine());
for(long kase = 0 ; kase < numCases ; kase++){
String[] ss = sc.nextLine().split(" ");
int n = Integer.parseInt(ss[0]);
int s = Integer.parseInt(ss[1]);
int p = Integer.parseInt(ss[2]);
int[] scores= new int[n];
for(int i = 0 ; i < n ; i++)
scores[i] = Integer.parseInt(ss[3+i]);
int ret = 0;
if(p == 0){
ret = n;
}else if(p == 1){
for(Integer i : scores){
if(i > 0){
ret++;
}
}
}else{
int canCntSurNotNeed = 0;
int canCntSurNeed = 0;
int canSurOnly = 0;
int canCntOnly = 0;
for(int i = 0 ; i < n ; i++){
if(scores[i] > 28){
canCntOnly++;
}else if(scores[i] >= p+p-1+p-1){
canCntSurNotNeed++;
}else if(scores[i] >= p+p-2+p-2){
canCntSurNeed++;
}else if(scores[i] >= 2){
canSurOnly++;
}
}
if(s <= canCntSurNeed){
ret = canCntOnly + canCntSurNotNeed + s;
}else{
ret = canCntOnly + canCntSurNotNeed + canCntSurNeed;
}
}
System.out.println("Case #" + (kase+1) + ": " + ret);
}
}
}
| 0 | 1,189,473 |
A11759 | A11081 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Second {
public static void main(String[] args) throws FileNotFoundException {
String path = ClassLoader.getSystemClassLoader().getResource("codejam/").getPath();
Second worker = new Second();
worker.scan(new File(path, "second-s.in"), new File(path, "second-s.out"));
// worker.scan(new File(path, "second-x.in"), new File(path, "second-x.out"));
}
private void scan(File input, File output) throws FileNotFoundException {
Scanner in = new Scanner(input);
PrintWriter out = new PrintWriter(output);
int n = Integer.parseInt(in.nextLine());
for (int i = 0; i < n; i++) {
out.printf("Case #%d: %s\n", i + 1, solve(in.nextLine()));
}
out.flush();
out.close();
in.close();
}
public String solve(String line) {
String[] tokens = line.split(" ");
int n = Integer.parseInt(tokens[0]);
int s = Integer.parseInt(tokens[1]);
int p = Integer.parseInt(tokens[2]);
int[] points = new int[n];
for (int i = 0; i < points.length; i++) {
points[i] = Integer.parseInt(tokens[3 + i]);
}
int result = 0;
for (int pc : points) {
int r = solve(pc, p);
if (r == 3 && s > 0) {
result++;
s--;
} else if (r == 1 || r == 2) {
result++;
}
}
return "" + result;
}
public int solve(int pc, int p) {
if (pc == 0) {
return p == 0 ? 1 : 0;
}
int m = pc / 3;
while ( m < p) m++;
int k = 0;
do {
k = 3 * m;
if (k == pc || k - 1 == pc) {
return 1;
}
if (k - 2 == pc) {
return 2;
}
if (k - 3 == pc || k - 4 == pc) {
return 3;
}
m++;
} while (k - pc <= 4);
return 0;
}
}
| 0 | 1,189,474 |
A11759 | A11820 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
import java.io.*;
class ProblemB
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader(args[0]);
BufferedReader br = new BufferedReader(fr);
String[] splittArray;
int[] points;
int N,S,p,res;
int T = Integer.parseInt(br.readLine());
//System.out.println(T);
String dummy;
String result="";
for(int i=1;i<=T;i++) {
dummy=br.readLine();
splittArray=dummy.split(" ");
N=Integer.parseInt(splittArray[0]);
S=Integer.parseInt(splittArray[1]);
p=Integer.parseInt(splittArray[2]);
res=0;
points=new int[N];
for(int j=3;j<splittArray.length;j++) {
points[j-3]=Integer.parseInt(splittArray[j]);
}
//sortiere(points);
for(int j=0;j<points.length;j++) {
if(points[j]>=3*p-2) {
res++;
} else if(points[j]<3*p-2 && points[j]>=3*p-4 && 3*p-4>=0 && S>0) {
S--;
res++;
}
}
result+="Case #"+i+": "+res;
if(i<T) result+="\r\n";
}
br.close();
FileWriter writer;
File file;
file = new File(args[1]);
try {
writer = new FileWriter(file ,true);
// Text wird in den Stream geschrieben
writer.write(result);
// Schreibt den Stream in die Datei
// Sollte immer am Ende ausgeführt werden, sodass der Stream
// leer ist und alles in der Datei steht.
writer.flush();
// SchlieÃt den Stream
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,475 |
A11759 | A11051 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 gcj.b;
import java.util.Scanner;
/**
*
* @author S_Malindi
*/
public class B {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int z = 1; z <= T; z++) {
int N = in.nextInt();
int S = in.nextInt();
int P = in.nextInt();
int t = 0;
int ans = 0;
int mscore = (P * 3);
for (int i = 1; i <= N; i++) {
t = in.nextInt();
if (t >= (mscore - 2)) {
ans++;
} else if (t >= (mscore - 4)) {
if ((S > 0 )&& ( t > 0) ) {
S--;
ans++;
}
}
}
System.out.format("Case #%d: %d\n", z, ans);
}
}
}
| 0 | 1,189,476 |
A11759 | A13201 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.InputStreamReader;
public class GooglersDance {
static int output = 0;
static int numberOfDancers = 0;
static int surprise = 0;
static int bestResult = 0;
public static void main(String[] args) {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(new FileReader("e:/B-small-attempt0.in"));
int totalLines = Integer.parseInt(reader.readLine());
for(int k=0;k<totalLines;k++)
{
String[] input = reader.readLine().split(" ");
numberOfDancers = Integer.parseInt(input[0]);
surprise = Integer.parseInt(input[1]);
bestResult = Integer.parseInt(input[2]);
output = 0;
int [] totalPoints = new int[numberOfDancers];
for (int i = 0; i < totalPoints.length; i++) {
totalPoints[i] = Integer.parseInt(input[3+i]);
isBestReesult(totalPoints[i]);
}
System.out.println("Case #" + (k+1) + ": " + output);
}
} catch (Exception ex) {
System.out.println(ex);
}
}
private static void isBestReesult(int i) {
int av = i/3;
int rem = i%3;
if(av+2 < bestResult)
return;
if(rem == 0)
{
if(av >= bestResult)
{
output++;
}else if(av+1 >= bestResult && av+1 <= i && surprise > 0)
{
output++;
surprise--;
}
}else if(rem == 1)
{
if((av >= bestResult || av+1 >= bestResult) && av+1 <= i)
output++;
}else
{
if((av >= bestResult || av+1 >= bestResult) && av+1 <= i )
{
output++;
}else if(av+2 >= bestResult && surprise > 0 && av+1 <= i )
{
output++;
surprise--;
}
}
}
}
| 0 | 1,189,477 |
A11759 | A10146 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.PrintStream;
import java.util.Scanner;
class B {
static public void main(String[] args) {
try {
PrintStream out = new PrintStream(new File("b.out"));
System.setOut(out);
Scanner theIn=new Scanner(new File("B-small-attempt0.in"));
int t=theIn.nextInt();
int n;
int s;
int p;
for (int i=1; i<=t; i++) {
System.out.print("Case #"+i+": ");
n=theIn.nextInt();
s=theIn.nextInt();
p=theIn.nextInt();
int numberP=0;
int leftS=s;
for (int j=1; j<=n; j++) {
int current=theIn.nextInt();
if (((current%3==0) && (current/3>=p)) ||((current%3!=0) && (current/3+1>=p)) ) numberP+=1; else {
if (leftS==0) continue;
if (current<2) continue;
if ((current%3==0) && ((current-3)/3+2>=p)) {
numberP+=1;
leftS-=1;
continue;
}
if ((current%3==1) && ((current-4)/3+2>=p)) {
numberP+=1;
leftS-=1;
continue;
}
if ((current%3==2) && ((current-2)/3+2>=p)) {
numberP+=1;
leftS-=1;
continue;
}
}
}
System.out.println(numberP);
}
} catch (Exception e) {}
}
} | 0 | 1,189,478 |
A11759 | A10799 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.io.*;
public class B{
public static int calculate(String str){
String[] numbers = str.split(" ");
int googlers = Integer.parseInt(numbers[0]);
int surprising = Integer.parseInt(numbers[1]);
int p = Integer.parseInt(numbers[2]);
int loc = 3;
int ret = 0;
for(int i = 0; i < googlers; i++){
int total = Integer.parseInt(numbers[loc]);
loc ++;
if(total % 3 == 0){
if((total / 3) > (p - 1))
ret++;
else if((total / 3) == (p - 1) && surprising > 0 && total != 0 && total != 30){
surprising--;
ret++;
}
}
else if(total % 3 == 1){
if((total / 3) > (p - 2))
ret++;
}
else if(total % 3 == 2){
if((total / 3) > (p - 2))
ret++;
else if((total / 3) == (p - 2) && surprising > 0 && total != 29){
surprising--;
ret++;
}
}
}
return ret;
}
public static void main(String[] args){
Scanner sc = null;
String next;
int out;
try{
sc = new Scanner(new File("B-small-attempt0.in"));
int cases = Integer.parseInt(sc.nextLine());
int current = 0;
FileWriter fs = new FileWriter("output.txt");
BufferedWriter buff = new BufferedWriter(fs);
while(current < cases){
next = sc.nextLine();
current++;
out = calculate(next);
buff.write("Case #" + current + ": " + out + "\n");
}
buff.close();
}
catch(Exception ex){}
}
} | 0 | 1,189,479 |
A11759 | A12697 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;
public class CodeJamB
{
public static void main(String args[]) throws Exception
{
Scanner in = new Scanner(new File("in.txt"));
BufferedWriter out = new BufferedWriter(new FileWriter("out.txt"));
int cases = in.nextInt();
for(int casenum = 1;casenum <= cases;casenum++)
{
int N = in.nextInt();
int S = in.nextInt();
int P = in.nextInt();
int count = 0;
for(int i=0;i<N;i++)
{
int curr = in.nextInt();
if(curr==0 && P==0)
{
count++;
continue;
}
if(curr%3 == 0 && curr!=0)
{
if(curr/3 >= P)
{
count++;
continue;
}
if(curr/3+1 >= P && S>0)
{
S--;
count++;
continue;
}
}
else if(curr%3 == 1)
{
if((curr+2)/3 >= P)
{
count++;
continue;
}
}
else if(curr%3 == 2)
{
if((curr+1)/3 >= P)
{
count++;
continue;
}
if((curr+1)/3+1 >= P && S>0)
{
S--;
count++;
continue;
}
}
}
out.write("Case #" + casenum + ": "+count+"\n");
}
in.close();
out.close();
}
} | 0 | 1,189,480 |
A11759 | A12386 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.util.Vector;
public class dance {
static Vector <String>surprise = new Vector<String>();
static Vector <String>notSurprise = new Vector<String>();
static int sur =0;
public static void set(int mark,int p){
int total =0;
Vector <String>v = new Vector<String>();
for(int x=0;x<=10;x++){
for(int y=0;y<=10;y++){
for(int z=0;z<=10;z++){
//System.out.println(x+","+y+","+z);
total=x+y+z;
if(total==mark){
if((x-y)>-3 && (x-y)<3){
if((y-z)>-3 && (y-z)<3){
if((z-x)>-3 && (z-x)<3){
if(x>=y && y>=z){
if((x-z)==2){
v.add("y,"+mark+","+z+","+y+","+x);
}else{
v.add("n,"+mark+","+z+","+y+","+x);
}
}else if(x>=z && z>=y){
if((x-y)==2){
v.add("y,"+mark+","+y+","+z+","+x);
}else{
v.add("n,"+mark+","+y+","+z+","+x);
}
}else if(y>=z && z>=x){
if((y-x)==2){
v.add("y,"+mark+","+x+","+z+","+y);
}else{
v.add("n,"+mark+","+x+","+z+","+y);
}
}else if(y>=x && x>=z){
if((y-z)==2){
v.add("y,"+mark+","+z+","+x+","+y);
}else{
v.add("n,"+mark+","+z+","+x+","+y);
}
}else if(z>=y && y>=x){
if((z-x)==2){
v.add("y,"+mark+","+x+","+y+","+z);
}else{
v.add("n,"+mark+","+x+","+y+","+z);
}
}else if(z>=x && x>=y){
if((z-y)==2){
v.add("y,"+mark+","+y+","+x+","+z);
}else{
v.add("n,"+mark+","+y+","+x+","+z);
}
//System.out.println(y+","+x+","+z);
}
}
}
}
}
}
}
}
for(int i=0;i<v.size();i++){
//System.out.println(v.get(i));
for(int j=i;j<v.size();j++){
if(v.get(i).equals(v.get(j)) && i!=j){
v.remove(j);
j=i-1;
}
}
}
for(int k=0;k<v.size();k++){
String []split = v.get(k).split(",");
if(split[0].equals("y")){
if(Integer.valueOf(split[split.length-1])>=p){
//selected.add(v.get(k));
surprise.add(v.get(k));
}
}else{
if(Integer.valueOf(split[split.length-1])>=p){
//selected.add(v.get(k));
notSurprise.add(v.get(k));
}
}
}
}
public static void main(String args[])
{
int result=0;
Vector <String>finalList = new Vector<String>();
String line;
int i=0;
try{
FileInputStream fstream1 = new FileInputStream("tB.txt");
DataInputStream in1 = new DataInputStream(fstream1);
BufferedReader br1 = new BufferedReader(new InputStreamReader(in1));
FileWriter fw = new FileWriter("oB.txt");
BufferedWriter out = new BufferedWriter(fw);
while ((line = br1.readLine()) != null) {
if(i!=0){
String outpt = "Case #"+i+": ";
String brkline[]=line.split(" ");
sur = Integer.valueOf(brkline[1]);
int p = Integer.valueOf(brkline[2]);
for(int j=3;j<brkline.length;j++){
set(Integer.valueOf(brkline[j]),p);
}
Vector <String>selected = (Vector) surprise.clone();
for(int k=0;k<notSurprise.size();k++){
String linei[] = notSurprise.get(k).split(",");
for(int m=0;m<selected.size();m++){
String linej[] = selected.get(m).split(",");
if(linei[1].equals(linej[1])){
selected.remove(m);
break;
}
}
}
if(sur==0){
result = notSurprise.size();
outpt = outpt+result;
}else{
for(int x=0;x<selected.size() && finalList.size() < sur;x++){
finalList.add(selected.get(x));
}
if(sur>finalList.size()){
for(int y=0;y<surprise.size() && finalList.size() < sur;y++){
finalList.add(surprise.get(y));
String line1[] = surprise.get(y).split(",");
for(int z=0;z<notSurprise.size();z++){
String line2[] = notSurprise.get(z).split(",");
if(line1[1].equals(line2[1])){
notSurprise.remove(z);
break;
}
}
}
}
for(int x=0;x<notSurprise.size();x++){
finalList.add(notSurprise.get(x));
}
result = finalList.size();
outpt = outpt+result;
}
out.write(outpt+"\n");
System.out.println(outpt);
}
surprise.clear();
notSurprise.clear();
finalList.clear();
i++;
}
//Close the input stream
in1.close();
//Close the output stream
out.close();
}catch (Exception e){//Catch exception if any
System.err.println("Error: " + e);
}
}
}
| 0 | 1,189,481 |
A11759 | A10557 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package codeJam;
import java.util.ArrayList;
import utilities.FileReadWrite;
public class DancingWiththeGooglers {
public static int noOfGooglers;
public static int noOfSurprisingTriplets;
public static int score;
public static int[] howManyPlayesGotScore;
public static void main(String[] args)
{
FileReadWrite myFile = new FileReadWrite();
String outputString ="";
ArrayList<String> lines = myFile.readFile();
int N = Integer.parseInt(lines.get(0));
howManyPlayesGotScore=new int[N];
String[] numbers;
for (int i = 1; i < lines.size(); i++)
{
numbers = lines.get(i).split(" ");
noOfGooglers = Integer.parseInt(numbers[0]);
noOfSurprisingTriplets = Integer.parseInt(numbers[1]);
score = Integer.parseInt(numbers[2]);
System.out.println(noOfGooglers+" "+noOfSurprisingTriplets+" "+score);
int[] scores = new int[noOfGooglers];
for (int j = 3; j < numbers.length; j++)
scores[j-3]=Integer.parseInt(numbers[j]);
if(i==3)
System.out.println();
ArrayList<ArrayList<int[]>> arrayConstruc = new ArrayList<ArrayList<int[]>>();
ArrayList<int[]> e = null;
for (int j = 0; j < scores.length; j++)
{
// System.out.println("score="+scores[j]);
ArrayList<int[]> noOfPossibilities = DancingWiththeGooglers.getAllPosibilities(scores[j]);
// System.out.println("#="+noOfPossibilities.size());
e = new ArrayList<int[]>();
for (int k = 0; k < noOfPossibilities.size(); k++)
{
int[] uu = noOfPossibilities.get(k);
// for (int jj = 0; jj < 5; jj++)
// System.out.print(uu[jj]+" ");
// System.out.println();
e.add(uu);
}
arrayConstruc.add(e);
}
//
System.out.println(arrayConstruc.size());
for (int j = 0; j < arrayConstruc.size(); j++)
{
ArrayList<int[]> ziki = arrayConstruc.get(j);
System.out.println(ziki.size());
}
//
DancingWiththeGooglers.z(arrayConstruc, i-1);
System.out.println(howManyPlayesGotScore[i-1]);
String tempLine = "Case #"+(i)+": ";
int z = howManyPlayesGotScore[i-1];
outputString = outputString + tempLine + String.valueOf(z) + "\n";
System.out.println("========================");
}
System.out.println(outputString);
myFile.writeFile(outputString);
}
public static ArrayList<int[]> getAllPosibilities (int x)
{
ArrayList<int[]> allP = new ArrayList<int[]>();
int[] y;
for (int i = 0; i < 11; i++)
{
for (int j = i; j < 11; j++)
{
if(j-i>2)
continue;
for (int k = j; k < 11; k++)
{
if(k-j>2 || k-i>2)
continue;
if(i+j+k==x)
{
y = new int[5];
y[0] = i;
y[1] = j;
y[2] = k;
// maximum point
if(i>=j && i>=k)
y[3]=i;
else if(j>=i && j>=k)
y[3]=j;
else if(k>=i && k>=j)
y[3]=k;
// 1 for surprising case. 0 for normal case
if(j-i==2 || k-j==2 || k-i==2)
y[4]=1;
else
y[4]=0;
allP.add(y);
}
}
}
}
return allP;
}
public static int getNoOfGooglers (ArrayList<int []> x, int maxScore, int noOfSurp)
{
int[] y;
int sumOfSurp=0;
int noOfGooglers=0;
for (int i = 0; i < x.size(); i++)
{
y = x.get(i);
sumOfSurp = sumOfSurp + y[4];
if(y[3] >= maxScore)
noOfGooglers++;
}
if(sumOfSurp<=noOfSurp)
return noOfGooglers;
else
return -1;
}
public static void z (ArrayList<ArrayList<int[]>> x, int counter)
{
ArrayList<ArrayList<int[]>> A = recursiveFunction(x);
int y;
System.out.println("A.size()="+A.size());
for (int i = 0; i < A.size(); i++)
{
ArrayList<int[]> B = A.get(i);
// System.out.println("B.size()="+B.size());
// for (int j = 0; j < B.size(); j++)
// {
// int[] C = B.get(j);
// for (int k = 3; k < C.length; k++)
// {
// System.out.print(C[k]+" ");
//
// }
// System.out.println();
// }
// System.out.println("~~~~~~~~~~~~");
for (int j = 0; j < B.size(); j++)
{
y = getNoOfGooglers(B, score, noOfSurprisingTriplets);
if(y>howManyPlayesGotScore[counter])
howManyPlayesGotScore[counter] = y;
// System.out.println("no of googlers = "+y);
}
}
}
public static ArrayList<ArrayList<int[]>> recursiveFunction (ArrayList<ArrayList<int[]>> x)
{
ArrayList<ArrayList<int[]>> rows = new ArrayList<ArrayList<int[]>>();
if(x.size()==1)
{
for (int i = 0; i < x.size(); i++)
{
ArrayList<int[]> x1 = x.get(0);
for (int i1 = 0; i1 < x1.size(); i1++)
{
ArrayList<int[]> z = new ArrayList<int[]>();
int[] y1 = x1.get(i1);
z.add(y1);
rows.add(z);
}
}
return rows;
}
if(x.size()==2)
{
ArrayList<int[]> x1 = x.get(0);
ArrayList<int[]> x2 = x.get(1);
ArrayList<int[]> x3 = null;
for (int i1 = 0; i1 < x1.size(); i1++)
{
int[] y1 = x1.get(i1);
for (int i2 = 0; i2 < x2.size(); i2++)
{
int[] y2 = x2.get(i2);
x3 = new ArrayList<int[]>();
x3.add(y1);
x3.add(y2);
rows.add(x3);
}
}
/*for (int i = 0; i < rows.size(); i++)
{
ArrayList<int[]> xx = rows.get(i);
for (int j = 0; j < xx.size(); j++)
{
int[] xxx = xx.get(j);
for (int k = 3; k < xxx.length; k++)
System.out.print(xxx[k]+" ");
System.out.println("");
}
System.out.println("--");
}*/
}
else
{
ArrayList<ArrayList<int[]>> remainedArray = new ArrayList<ArrayList<int[]>>();
for (int i = 1; i < x.size(); i++)
remainedArray.add(x.get(i));
ArrayList<ArrayList<int[]>> addRows = recursiveFunction(remainedArray);
// for (int i = 0; i < addRows.size(); i++)
// {
// ArrayList<int[]> xx = addRows.get(i);
// System.out.println("xx.size()="+xx.size());
// for (int j = 0; j < xx.size(); j++)
// {
// int[] y = xx.get(j);
// for (int k = 0; k < y.length; k++)
// {
// System.out.print(y[k]+" ");
// }
// System.out.println();
// }
// }
// System.out.println("addRows.size()="+addRows.size());
ArrayList<int[]> xx = x.get(0);
// System.out.println("xx.size()="+xx.size());
for (int i = 0; i < xx.size(); i++)
{
int[] o = xx.get(i);
// System.out.println("addRows.size()="+addRows.size());
for (int ii = 0; ii < addRows.size(); ii++)
{
ArrayList<int[]> h = new ArrayList<int[]>();
h.add(o);
ArrayList<int[]> hh = addRows.get(ii);
// System.out.println("hh.size()="+hh.size());
for (int j = 0; j < hh.size(); j++)
{
int[] oo = hh.get(j);
h.add(oo);
}
// System.out.println("h.size()="+h.size());
rows.add(h);
}
}
// System.out.println("rows.size()="+rows.size());
// for (int i = 0; i < rows.size(); i++)
// {
// ArrayList<int[]> xex = rows.get(i);
// System.out.println("xex.size()="+xex.size());
// System.out.println("i="+i+".");
// for (int j = 0; j < xex.size(); j++)
// {
// System.out.println("j="+j+".");
// int[] xxx = xex.get(j);
//
// for (int k = 3; k < xxx.length; k++)
// System.out.print(xxx[k]+" ");
// System.out.println("");
// }
// System.out.println("--");
// }
}
return rows;
}
}
| 0 | 1,189,482 |
A11759 | A11628 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
public class a
{
public static void main(String[] args) throws IOException
{
BufferedReader in = new BufferedReader(new FileReader("B-small.in"));
FileWriter fr = new FileWriter("small.out");
int num = Integer.parseInt(in.readLine());
for(int cases = 1 ; cases<=num ; cases++)
{
String []temp = in.readLine().split(" ");
//for (int i=0;i<temp.length;i++)
int numberofgooglers = Integer.parseInt(temp[0]);
int suprisingtriplets = Integer.parseInt(temp[1]);
int maxvalue = Integer.parseInt(temp[2]);
int availablesurprisingtriplets = suprisingtriplets;
int result = 0;
for (int i=0;i<numberofgooglers ; i++)
{
int score = Integer.parseInt(temp[i+3]);
if(score >= ((maxvalue*3)-2))
{
result++;
}
else if((score >= ((maxvalue*3)-4)) && (availablesurprisingtriplets > 0) && (maxvalue > 1))
{
result++;
availablesurprisingtriplets--;
}
}
fr.write("Case #"+cases+": "+result+"\n");
//System.out.println("Case #"+cases+": "+result);
}
fr.close();
}
}
| 0 | 1,189,483 |
A11759 | A12681 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Dancing
{
public static void main(String[] inteettskit)
{
int line = 0;
int T = 0;
int N = 0; // Number of googlers
int S = 0; // Surprises
int p = 0; // p
Scanner line_scanner = new Scanner(System.in);
while(line_scanner.hasNextLine())
{
String apa = line_scanner.nextLine();
Scanner int_scanner = new Scanner(apa);
// System.out.println("line: " + line);
if(line == 0)
{
T = int_scanner.nextInt();
// System.out.println("T: " + T);
}
else
{
int[] input = null;
int counter = 0;
while (int_scanner.hasNextInt())
{
if(counter == 0)
{
N = int_scanner.nextInt();
input = new int[N+3];
input[0] = N;
}
else
{
int number = int_scanner.nextInt();
input[counter] = number;
// System.out.println("Scanner: " + number + " counter: " + counter);
}
counter++;
}
N = input[0]; // Number of googlers
S = input[1]; // Surprises
p = input[2]; // p
int t[] = new int[N]; // total scores of the googlers
int possible = 0;
for( int i = 0; i < N; i++)
{
// System.out.println(input[i+3]);
t[i] = input[i+3];
}
// System.out.println("Googlers: " + N);
// System.out.println("Surprises: " + S);
// System.out.println("p: " + p);
// System.out.print("Scores:");
for(int score: t)
{
// System.out.print(" " + score);
}
// System.out.println();
for(int i = 0; i < N ; i++)
{
int retur = pp(p, t[i]);
if(retur >= 1)
{
if(retur >=2)
{
if(S > 0)
{
possible++;
S--;
}
}
else
{
possible ++;
}
}
}
System.out.println("Case #" + (line) +": " + possible);
}
line++;
}
}
public static int pp(int p, int totalscore)
{
int min_normal_score = 0;
int min_surprise_score = 0;
if(p-1 >= 0)
{
min_normal_score = (p + (p-1) + (p-1));
}
else
{
min_normal_score = p;
}
if(p-2 >= 0)
{
min_surprise_score = (p + (p-2) + (p-2));
}
else
{
min_surprise_score = p;
}
// System.out.println("Minimum surprise score for p = " + p + " is " + min_surprise_score);
// System.out.println("Minimum normal score for p = " + p + " is " + min_normal_score);
if(totalscore >= min_normal_score)
{
// System.out.println("Always!");
return 1;
}
else if(totalscore >= min_surprise_score)
{
// System.out.println("Requires surprise");
return 2;
}
else
{
// System.out.println("Never!");
return 0;
}
}
}
| 0 | 1,189,484 |
A11759 | A10552 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 B
{
public static void main(String []args)
{
int j,c,i,T, N, S, P,maior,menor,soma;
java.util.Scanner sc = new java.util.Scanner(System.in);
T = sc.nextInt();
for (i = 0; i < T; i++)
{
c = 0;
N = sc.nextInt();
S = sc.nextInt();
P = sc.nextInt();
for (j = 0; j < N; j++)
{
soma = sc.nextInt();
maior = (int)Math.ceil(soma/3.0);
menor = (int)Math.floor(soma/3.0);
if (maior>= P)
c++;
else if (S>0 && (
(maior - menor == 0 && maior + 1 >= P && menor>0) ||
(maior - menor == 1 && maior + 1 >= P && 2*menor + maior + 1 <= soma))
)
{
c++;
S--;
}
}
System.out.println("Case #"+(i+1)+": "+c);
}
}
}
| 0 | 1,189,485 |
A11759 | A10212 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.code.jam;
import java.io.File;
import java.io.PrintStream;
import java.util.Scanner;
public class BDancingWithGooglers {
public static void main(String[] args) throws Exception {
Scanner in = new Scanner (new File("C:/codeJam/ficheros2012/BDancingWithGooglers-practice.in"));
PrintStream ps = new PrintStream("C:/codeJam/ficheros2012/BDancingWithGooglers-practice.out");
int T = new Integer (in.nextLine());
for (int nCase = 1; nCase < T + 1; nCase++) {
Scanner inLine = new Scanner(in.nextLine());
int numberGooglers = inLine.nextInt();
int surprisingScore = inLine.nextInt();
int p = inLine.nextInt();
int maxGooglersWithScoreX = 0;
for (int i = 0; i < numberGooglers; i++) {
int scoreGoogler = inLine.nextInt();
int desviationScore = scoreGoogler % 3;
int maxScore = (scoreGoogler - desviationScore) / 3;
if (desviationScore > 0){
maxScore++;
}
if (maxScore >= p){
maxGooglersWithScoreX++;
}
else{
if (scoreGoogler >= p
&& surprisingScore > 0
&& maxScore + 1 >= p){
maxGooglersWithScoreX++;
surprisingScore--;
}
}
}
System.out.format("Case #%d: %d\n", nCase, maxGooglersWithScoreX);
ps.format("Case #%d: %d\n", nCase, maxGooglersWithScoreX);
}
ps.flush();
ps.close();
}
}
| 0 | 1,189,486 |
A11759 | A11310 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.LinkedList;
import java.util.Scanner;
public class dancing {
public static int maxScore(int a){
if(a==0) return 0;
return ((a%3)==0)?(a/3)+1:(a%3)+a/3;
}
public static int maxScoreSanSurprise(int a){
return (a/3)+Math.min(1, a%3);
}
public static int solveOne(Scanner scan){
int n = scan.nextInt();
int s = scan.nextInt();
int p = scan.nextInt();
int nbok =0;
LinkedList<Integer> possible = new LinkedList<Integer>();
for(int i=0; i<n; i++){
int tmp = scan.nextInt();
if(maxScoreSanSurprise(tmp)>=p){
// System.out.println("sans surprise"+tmp);
nbok++;
}
else if(maxScore(tmp)>= p){
//System.out.println("avec surprise"+tmp);
possible.add(tmp);
}
else{
//System.out.println("impossible"+tmp+" "+maxScore(tmp)+" "+maxScoreSanSurprise(tmp));
}
}
return nbok+Math.min(s, possible.size());
}
public static void main(String[] args) throws FileNotFoundException{
Scanner s = new Scanner(new File("input.txt"));
int nbcas = s.nextInt();
for(int i=0; i<nbcas; i++){
System.out.println("Case #"+(i+1)+": "+solveOne(s));
}
}
}
| 0 | 1,189,487 |
A11759 | A11963 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileReader;
import java.io.FileWriter;
public class Try2 {
/**
* @param args
*/
static BufferedWriter out;
static String inputFile = "input";
static String outputFile = "out.txt";
public static void main(String[] args) {
File file = new File(inputFile);
if (file.exists()) {
try {
BufferedReader inFile = new BufferedReader(new FileReader(file));
FileWriter fstream = new FileWriter (outputFile);
out = new BufferedWriter (fstream);
String sLine = null;
int counter = 0;
while ((sLine=inFile.readLine())!=null) {
if (counter > 0) {
out.write("Case #" + counter + ": ");
handleIt(sLine);
}
counter++;
}
out.close();
} catch (Exception e) {System.err.println(e);}
}
}
private static void handleIt(String sLine) throws Exception{
String [] array;
array = sLine.split(" ");
int numGooglers = Integer.parseInt(array[0]);
int numSurprises = Integer.parseInt(array[1]);
int N = Integer.parseInt(array[2]);
int result = 0;
for (int i=0; i<numGooglers; i++) {
int currentNum = Integer.parseInt(array[i+3]);
if (currentNum == 1) {
if (N > 1)
continue;
result++;
}
else if (currentNum == 0) {
if (N > 0)
continue;
result++;
}
else if (currentNum >= 3*N-2)
result++;
else if (currentNum == 3*N-3 || currentNum == 3*N-4) {
if (numSurprises > 0) {
numSurprises--;
result++;
}
}
}
out.write(result+'0');
out.newLine();
}
}
| 0 | 1,189,488 |
A11759 | A11671 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 qualifiers12.b;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
public class Dancing {
public static Set<Triple>[] combs;
public static class Triple {
protected final int total;
protected final int v1;
protected final int v2;
protected final int v3;
public Triple(int total, int v1, int v2, int v3) {
this.total = total;
this.v1 = v1;
this.v2 = v2;
this.v3 = v3;
}
public int getMax() {
return max2(max2(v1, v2), v3);
}
private int max2(int n1, int n2) {
return (n1 > n2) ? n1 : n2;
}
public int getTotal() {
return v1 + v2 + v3;
}
public boolean isTriplet() {
if (v1 < 0 || v2 < 0 || v3 < 0) {
return false;
}
if (Math.abs(v1 - v2) > 2 || Math.abs(v1 - v3) > 2 || Math.abs(v2 - v3) > 2) {
return false;
}
return v1 + v2 + v3 == total;
}
public boolean isSurprising() {
return Math.abs(v1 - v2) == 2 || Math.abs(v1 - v3) == 2 || Math.abs(v2 - v3) == 2;
}
@Override
public String toString() {
return total + "(" + v1 + "," + v2 + "," + v3 + ")";
}
@Override
public int hashCode() {
List<Integer> list = new ArrayList<Integer>();
list.add(v1);
list.add(v2);
list.add(v3);
Collections.sort(list);
return list.get(0) * 100 + list.get(1) * 10 + list.get(2);
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Triple) {
Triple that = (Triple) obj;
if ((this.v1 == that.v1 || this.v1 == that.v2 || this.v1 == that.v3)
&& (this.v2 == that.v1 || this.v2 == that.v2 || this.v2 == that.v3)
&& (this.v3 == that.v1 || this.v3 == that.v2 || this.v3 == that.v3)) {
return true;
} else {
return false;
}
} else {
return false;
}
}
}
public static void computeCombination(int k, int total) {
int avgPart = Math.round((total + 0.0f) / 3.0f);
for (int i = -1; i < 2; i++) {
computeCombinationGiven(k, total, avgPart + i);
}
}
private static void computeCombinationGiven(int k, int total, int part) {
int missing = total - part;
int avgPart = Math.round((missing + 0.0f) / 2.0f);
for (int i = -1; i < 2; i++) {
computeWithOne(k, total, part, avgPart + i, avgPart);
}
}
private static void computeWithOne(int k, int total, int part1, int part2, int lastAvg) {
for (int i = -1; i < 2; i++) {
Triple triple = new Triple(total, part1, part2, lastAvg + i);
if (triple.isTriplet()) {
combs[k].add(triple);
}
}
}
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String s = in.readLine();
int cases = Integer.parseInt(s);
for (int i = 0; i < cases; i++) {
s = in.readLine();
StringTokenizer tokenizer = new StringTokenizer(s, " ");
int[] totals = new int[Integer.parseInt(tokenizer.nextToken())];
combs = new Set[totals.length];
for (int k = 0; k < combs.length; k++) {
combs[k] = new HashSet<Triple>();
}
int surprising = Integer.parseInt(tokenizer.nextToken());
int p = Integer.parseInt(tokenizer.nextToken());
int k = 0;
while (tokenizer.hasMoreTokens()) {
totals[k] = Integer.parseInt(tokenizer.nextToken());
computeCombination(k, totals[k]);
k++;
}
// for (k = 0; k < combs.length; k++) {
//
// String tmp = "";
// for (Triple triple : combs[k]) {
// tmp += triple.toString() + " ";
// }
// System.out.println(tmp);
//
// }
int usedSurprising = 0;
for (k = 0; k < combs.length; k++) {
if (containsSurprisingSequence(combs[k])) {
Triple triple = containsNonSurprisingAboveOrEqualP(combs[k], p);
if (triple != null) {
combs[k].clear();
combs[k].add(triple);
} else if (usedSurprising < surprising) {
triple = containsSurprisingAboveOrEqualP(combs[k], p);
if (triple != null) {
combs[k].clear();
combs[k].add(triple);
usedSurprising++;
}
} else {
Iterator<Triple> iter = combs[k].iterator();
while (iter.hasNext()) {
triple = iter.next();
if (triple.isSurprising()) {
continue;
}
combs[k].clear();
combs[k].add(triple);
break;
}
}
} else {
// choose one above P, otherwise random one
Triple triple = containsNonSurprisingAboveOrEqualP(combs[k], p);
if (triple != null) {
combs[k].clear();
combs[k].add(triple);
} else {
Iterator<Triple> iter = combs[k].iterator();
while (iter.hasNext()) {
triple = iter.next();
if (triple.isSurprising()) {
continue;
}
combs[k].clear();
combs[k].add(triple);
break;
}
}
}
}
int res = 0;
for (k = 0; k < combs.length; k++) {
for (Triple triple : combs[k]) {
if (triple.getMax() >= p) {
res++;
}
}
}
String result = "Case #" + (i + 1) + ": " + res;
System.out.println(result);
}
}
private static boolean containsSurprisingSequence(Set<Triple> triples) {
for (Triple triple : triples) {
if (triple.isSurprising()) {
return true;
}
}
return false;
}
private static Triple containsSurprisingAboveOrEqualP(Set<Triple> triples, int p) {
for (Triple triple : triples) {
if (triple.isSurprising()) {
if (triple.getMax() >= p) {
return triple;
}
}
}
return null;
}
private static Triple containsNonSurprisingAboveOrEqualP(Set<Triple> triples, int p) {
for (Triple triple : triples) {
if (!triple.isSurprising()) {
if (triple.getMax() >= p) {
return triple;
}
}
}
return null;
}
}
| 0 | 1,189,489 |
A11759 | A11426 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.dennis.codejam;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class DancingGoogle {
/**
* @param args
*/
public static void main(String[] args) throws IOException{
BufferedReader fin = new BufferedReader(new FileReader("dancing.in"));
PrintWriter fout = new PrintWriter(new BufferedWriter(new FileWriter("dancing.out")));
StringTokenizer stringy;
int times = Integer.parseInt(fin.readLine());
for(int x= 0 ; x<times; x++){
stringy= new StringTokenizer(fin.readLine());
int numg = Integer.parseInt(stringy.nextToken());
int surprises = Integer.parseInt(stringy.nextToken());
int limit = Integer.parseInt(stringy.nextToken());
int[] googlers = new int[numg];
for(int a = 0; a<numg; a++){
googlers[a] = Integer.parseInt(stringy.nextToken());
}
Arrays.sort(googlers);
int[] less = new int[numg];
for(int a = 0; a<numg; a++){
if(googlers [a] <= 1){
if(googlers[a]==1) less[a] = 1;
if(googlers[a]==0) less[a] = 0;
}
else if(googlers[a]%3 == 0){
less[a] = googlers[a]/3;
}
else if(googlers[a]%3 == 1){
less[a] = googlers[a]/3+1;
}
else if(googlers[a]%3 == 2){
less[a] = googlers[a]/3+1;
}
}
int[] more = new int[numg];
for(int a = 0; a<numg; a++){
if(googlers [a] <= 1){
if(googlers[a]==1) more[a] = 1;
if(googlers[a]==0) more[a] = 0;
}
else if(googlers[a]%3 == 0){
more[a] = googlers[a]/3+1;
}
else if(googlers[a]%3 == 1){
more[a] = googlers[a]/3+1;
}
else if(googlers[a]%3 == 2){
more[a] = googlers[a]/3+2;
}
}
for(int a= 0 ; a<numg;a++){
if(surprises==0) break;
if(more[a]!= less[a] && more[a] == limit){
surprises--;
less[a] = more[a];
}
}
int count =0;
for(int c=0; c<numg; c++){
System.out.println(less[c]);
if(less[c]>=limit) count++;
}
fout.println("Case #" + (x+1) + ": " + count);
}
fout.close();
System.exit(0);
}
}
| 0 | 1,189,490 |
A11759 | A11870 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 DancingWithTheGooglers {
public static void main(String args[]){
try {
Scanner scanner = new Scanner(new File("B-small-attempt0.in"));
int noOfCase = scanner.nextInt();
scanner.nextLine();
// System.out.println(noOfCase);
String [] cases = new String [noOfCase];
int counter=0;
while(scanner.hasNextLine()){
cases[counter] = scanner.nextLine();
// System.out.println(cases[counter]);
counter++;
}
for(int i =0 ;i<noOfCase;i++){
System.out.println("Case #"+(i+1)+": "+processInt(cases[i]));
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static int processInt(String caseString){
Scanner processer = new Scanner(caseString);
int noOfPeople = processer.nextInt();
int noOfSuprise = processer.nextInt();
int leastScore = processer.nextInt();
int [] scoreOfPeople = new int [noOfPeople] ;
int counter=0;
while(processer.hasNextInt()){
scoreOfPeople [counter]=processer.nextInt();
// System.out.print(scoreOfPeople [counter]+" ");
counter++;
}
int leastScoreCounter = 0;
int superisingCounter = 0;
for(int i =0; i<noOfPeople;i++){
int averageScore= scoreOfPeople [i]/3;
int extraScore = scoreOfPeople [i]%3;
int diff = (leastScore-averageScore);
// System.out.println(scoreOfPeople [i]+" "+averageScore+" "+extraScore+" "+diff+" "+superisingCounter+" "+noOfSuprise+" "+leastScoreCounter);
if (scoreOfPeople[i] > 0) {
if (extraScore == 0) {
if (superisingCounter < noOfSuprise) {
if (diff == 1) {
leastScoreCounter++;
superisingCounter++;
}
}
if (diff < 1) {
leastScoreCounter++;
} else {
}
} else if (extraScore == 1) {
if (diff <= 1) {
leastScoreCounter++;
} else {
}
} else {
// extraScore ==2
if (superisingCounter < noOfSuprise) {
if (diff == 2) {
leastScoreCounter++;
superisingCounter++;
}
}
if (diff <= 1) {
leastScoreCounter++;
}
}
} else if (scoreOfPeople[i] == 0) {
if(diff ==0 ){
leastScoreCounter++;
}
}
}
// System.out.println();
return leastScoreCounter;
}
}
| 0 | 1,189,491 |
A11759 | A12234 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 mar2012;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
public class ProblemB {
public static void main(String[] args) throws Exception {
PrintStream out = new PrintStream(new File(
"/Users/asingh/Desktop/gcj2012/prob.b.out.txt"));
ProblemB prob = new ProblemB();
String input = "/Users/asingh/Desktop/gcj2012/prob.b.in.txt";
InputStream in = new FileInputStream(new File(input));
prob.solveAll(in, out);
// prob.solveTestCase(1, 3, 1, 5, new int[] { 15, 13, 11 }, out);
// 3 0 8 23 22 21
// prob.solveTestCase(2, 3, 0, 8, new int[] { 23, 22, 21 }, out);
// 2 1 1 8 0
// prob.solveTestCase(3, 2, 1, 1, new int[] { 8, 0 }, out);
// 6 2 8 29 20 8 18 18 21
// prob.solveTestCase(4, 6, 2, 8, new int[] { 29, 20, 8, 18, 18, 21 },
// out);
}
private void solveAll(InputStream in, PrintStream out) throws Exception {
Scanner scanner = new Scanner(in);
int numTestCases = Integer.parseInt(scanner.nextLine());
for (int i = 0; i < numTestCases; i++) {
int numParticipants = scanner.nextInt();
int numSurprisingScores = scanner.nextInt();
int bestResult = scanner.nextInt();
int[] scores = new int[numParticipants];
for (int c = 0; c < numParticipants; c++) {
scores[c] = scanner.nextInt();
}
if (i < numTestCases - 1)
scanner.nextLine();
solveTestCase(i + 1, numParticipants, numSurprisingScores,
bestResult, scores, out);
}
}
private void solveTestCase(int testCaseId, int numParticipants,
int numSurprisingScores, int bestResult, int[] totalPoints,
PrintStream out) {
// System.out.println("testCaseId: " + testCaseId +
// ", numParticipants: "
// + numParticipants + ", numSurprisingScores: "
// + numSurprisingScores + ", bestResult: " + bestResult
// + ", scores: " + Arrays.toString(totalPoints));
List<Set<TripletScore>> possibleScores = new ArrayList<Set<TripletScore>>();
for (int total : totalPoints) {
Set<TripletScore> set = AllPossibleScores
.getPossibleScoresForTotalPoint(total).toSet();
possibleScores.add(set);
// System.out.println("Score: " + total + " => " + set);
}
// choose as many scores that >= bestResult
// but numSurprise == numSurprisingScores
ChosenScores chosen = chooseBestScores(numParticipants,
numSurprisingScores, bestResult, possibleScores);
String result = "Case #" + testCaseId + ": "
+ chosen.getNumParticipantsCrossingBestResult();
System.out.println(result);
out.println(result);
}
private ChosenScores chooseBestScores(int numParticipants,
int numSurprisingScores, int bestResult,
List<Set<TripletScore>> possibleScores) {
ChosenScores chosen = new ChosenScores(numParticipants,
numSurprisingScores, bestResult);
AtomicReference<ChosenScores> best = new AtomicReference<ProblemB.ChosenScores>();
chooseBest(0, possibleScores.get(0).iterator(), possibleScores, chosen,
best);
return best.get();
}
private void chooseBest(int index, Iterator<TripletScore> iterator,
List<Set<TripletScore>> possibleScores, ChosenScores chosen,
AtomicReference<ChosenScores> bestChosen) {
while (iterator.hasNext()) {
TripletScore next = iterator.next();
if (chosen.add(next)) {
if (index < possibleScores.size() - 1) {
chooseBest(index + 1, possibleScores.get(index + 1)
.iterator(), possibleScores, chosen, bestChosen);
if (chosen.isMaxPossibleResult()) {
return;
}
} else {
updateBetter(chosen, bestChosen);
}
chosen.remove(next);
}
}
}
private void updateBetter(ChosenScores chosen,
AtomicReference<ChosenScores> bestChosen) {
if (chosen.satisfiesSurprises()) {
ChosenScores best = bestChosen.get();
if (best == null) {
bestChosen.set(chosen.clone());
return;
}
if (chosen.getNumParticipantsCrossingBestResult() > best
.getNumParticipantsCrossingBestResult()) {
ChosenScores newBest = chosen.clone();
// System.out.println("==>> Found better: currentBest: "
// + bestChosen.get() + ", updating to new: " + newBest);
bestChosen.set(newBest);
}
}
}
private static class ChosenScores {
private final Set<TripletScore> scores;
private final int maxNumSurprises;
private final int maxNumParticipants;
private final int leastBestResult;
private int numParticipantsCrossingBestResult;
private int numSurpriseScores;
protected ChosenScores(ChosenScores copy) {
this.maxNumParticipants = copy.maxNumParticipants;
this.maxNumSurprises = copy.maxNumSurprises;
this.leastBestResult = copy.leastBestResult;
this.numParticipantsCrossingBestResult = copy.numParticipantsCrossingBestResult;
this.numSurpriseScores = copy.numSurpriseScores;
this.scores = new LinkedHashSet<ProblemB.TripletScore>(copy.scores);
}
public ChosenScores(int maxNumParticipants, int maxNumSurprises,
int leastBestResult) {
this.maxNumParticipants = maxNumParticipants;
this.maxNumSurprises = maxNumSurprises;
this.leastBestResult = leastBestResult;
this.scores = new LinkedHashSet<ProblemB.TripletScore>();
}
public boolean add(TripletScore score) {
if (score.isSurprisingScore()
&& numSurpriseScores + 1 > maxNumSurprises) {
return false;
}
if (score.isSurprisingScore()) {
numSurpriseScores++;
}
if (score.getBestResult() >= leastBestResult) {
numParticipantsCrossingBestResult++;
}
scores.add(score);
return true;
}
public void remove(TripletScore score) {
if (score.isSurprisingScore()) {
numSurpriseScores--;
}
if (score.getBestResult() >= leastBestResult) {
numParticipantsCrossingBestResult--;
}
scores.remove(score);
}
public boolean isMaxPossibleResult() {
return numParticipantsCrossingBestResult == maxNumParticipants;
}
public int getNumParticipantsCrossingBestResult() {
return numParticipantsCrossingBestResult;
}
public boolean satisfiesSurprises() {
return numSurpriseScores == maxNumSurprises;
}
public ChosenScores clone() {
return new ChosenScores(this);
}
@Override
public String toString() {
return "ChosenScores [numSurpriseScores=" + numSurpriseScores
+ ", scores=" + scores
+ ", numParticipantsCrossingBestResult="
+ numParticipantsCrossingBestResult + "]";
}
}
private static class TripletScore {
private final int a;
private final int b;
private final int c;
private final int distance;
private final int bestResult;
private final int totalPoints;
private final boolean surprisingScore;
public TripletScore(int a, int b, int c) {
int[] sortedArray = { a, b, c };
Arrays.sort(sortedArray);
this.a = sortedArray[0];
this.b = sortedArray[1];
this.c = sortedArray[2];
this.bestResult = Math.max(a, Math.max(b, c));
this.distance = bestResult - Math.min(a, Math.min(b, c));
this.totalPoints = a + b + c;
surprisingScore = distance == 2;
}
public boolean isSurprisingScore() {
return surprisingScore;
}
public int getTotalPoints() {
return totalPoints;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + a;
result = prime * result + b;
result = prime * result + c;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TripletScore other = (TripletScore) obj;
if (a != other.a)
return false;
if (b != other.b)
return false;
if (c != other.c)
return false;
return true;
}
@Override
public String toString() {
return "{" + a + ", " + b + ", " + c + " (" + bestResult + ", "
+ (surprisingScore ? "S" : "X") + ")}";
}
public int getBestResult() {
return bestResult;
}
public boolean isValid() {
return distance <= 2;
}
}
private static class TripletScoreSet {
private final Set<TripletScore> sortedSet;
private final int numSurprisingScores;
// private final int bestResult;
public TripletScoreSet(Set<TripletScore> set) {
this.sortedSet = set;
this.sortedSet.addAll(set);
int c = 0;
for (TripletScore score : set) {
if (score.isSurprisingScore()) {
c++;
}
}
numSurprisingScores = c;
// bestResult = this.sortedSet.last().getBestResult();
}
// public int getBestResult() {
// return bestResult;
// }
public Set<TripletScore> toSet() {
return Collections.unmodifiableSet(sortedSet);
}
@Override
public String toString() {
return "{" + sortedSet + ", numSurprisingScores: "
+ numSurprisingScores + "}";
}
}
private static class AllPossibleScores {
private final static Map<Integer, TripletScoreSet> possibleScores;
static {
Map<Integer, Set<TripletScore>> tmpMap = new HashMap<Integer, Set<TripletScore>>();
for (int a = 0; a <= 10; a++) {
final int mid = a;
for (int b = mid - 2; b <= mid + 2; b++) {
for (int c = mid - 2; c <= mid + 2; c++) {
if (betweenInclusive(a, 0, 10)
&& betweenInclusive(b, 0, 10)
&& betweenInclusive(c, 0, 10)) {
TripletScore score = new TripletScore(a, b, c);
if (score.isValid()) {
Set<TripletScore> list = tmpMap.get(score
.getTotalPoints());
if (list == null) {
list = new LinkedHashSet<TripletScore>();
}
list.add(score);
tmpMap.put(score.getTotalPoints(), list);
if (!score.isValid()) {
System.out.println("WRONG - " + score);
System.exit(1);
}
}
}
}
}
}
possibleScores = new HashMap<Integer, ProblemB.TripletScoreSet>();
for (Entry<Integer, Set<TripletScore>> e : tmpMap.entrySet()) {
possibleScores.put(e.getKey(),
new TripletScoreSet(e.getValue()));
}
// for (int i = 0; i <= 30; i++) {
// TripletScoreSet scores = AllPossibleScores
// .getPossibleScoresForTotalPoint(i);
// System.out.println("Total point: " + i + ", scores: " + scores);
// }
}
private static boolean betweenInclusive(int num, int min, int max) {
return num >= min && num <= max;
}
public static TripletScoreSet getPossibleScoresForTotalPoint(
int totalPoint) {
return possibleScores.get(totalPoint);
}
}
}
| 0 | 1,189,492 |
A11759 | A12452 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.TreeMap;
public class Gcj2 {
private static Map<Integer, LinkedHashSet<Triplet>> pointsTripletMap = new TreeMap<Integer, LinkedHashSet<Triplet>>();
private static void loadPointsTripletMap() {
for (int i = 0; i <= 30; i++) {
pointsTripletMap.put(Integer.valueOf(i),
new LinkedHashSet<Triplet>());
}
for (int a = 0; a <= 10; a++) {
for (int b = 0; b <= 10; b++) {
for (int c = 0; c <= 10; c++) {
try {
int pointsSum= a + b + c;
Triplet triplet = new Triplet(a,b,c);
pointsTripletMap.get(Integer.valueOf(pointsSum)).add(
triplet);
} catch (NotValidTripletRuntimeException ex) {
//bad practice!
}
}
}
}
}
static {
loadPointsTripletMap();
System.out.println(pointsTripletMap);
}
/**
* @param args
*/
public static void main(String[] args) {
String input = args[0];
String output = args[1];
try {
File fileInput = new File(input);
System.out.println(fileInput.getAbsolutePath());
FileReader fr = new FileReader(fileInput);
BufferedReader br = new BufferedReader(fr);
File fileOutput = new File(output);
FileWriter fw = new FileWriter(fileOutput);
BufferedWriter bw = new BufferedWriter(fw);
String numberOfCases = br.readLine();
Integer n = Integer.parseInt(numberOfCases.trim());
for (int i = 0; i < n; i++) {
int result = 0;
String line = br.readLine();
String[] lineArgs = line.split(" ");
int googlers = Integer.parseInt(lineArgs[0]);
int surprisingTriplets = Integer.parseInt(lineArgs[1]);
int pointsNumberMin = Integer.parseInt(lineArgs[2]);
int[] googlersResults = new int[lineArgs.length - 3];
for (int m = 3; m < lineArgs.length; m++) {
int mGooglerResult = Integer.parseInt(lineArgs[m]);
googlersResults[m - 3] = mGooglerResult;
}
Arrays.sort(googlersResults);
for (int m = 0; m < googlersResults.length; m++) {
LinkedHashSet<Triplet> triplets = pointsTripletMap
.get(Integer.valueOf(googlersResults[m]));
Triplet choosenTriplet = null;
for (Triplet triplet : triplets) {
if (triplet.getC() >= pointsNumberMin) {
if (choosenTriplet == null) {
choosenTriplet = triplet;
} else if (choosenTriplet.isSurprising()
&& !triplet.isSurprising()) {
choosenTriplet = triplet;
}
}
}
if (choosenTriplet != null) {
if (!choosenTriplet.isSurprising()) {
result++;
} else if (surprisingTriplets > 0) {
result++;
surprisingTriplets--;
}
}
}
String msg = "Case #" + (i + 1) + ": " + result;
System.out.println(msg);
if (i > 0) {
bw.newLine();
}
bw.write(msg);
}
bw.flush();
bw.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Triplet {
private final int pointsA, pointsB, pointsC;
public Triplet(int pointsA, int pointsB, int pointsC) {
int[] ints = new int[3];
ints[0] = pointsA;
ints[1] = pointsB;
ints[2] = pointsC;
Arrays.sort(ints);
if (ints[2] - ints[0] > 2) {
throw new NotValidTripletRuntimeException(
"Points in triplet can't vary more than 2 points!");
}
this.pointsA = ints[0];
this.pointsB = ints[1];
this.pointsC = ints[2];
}
boolean isSurprising() {
if (pointsC - pointsA > 1) {
return true;
} else {
return false;
}
}
public int getA() {
return pointsA;
}
public int getB() {
return pointsB;
}
public int getC() {
return pointsC;
}
private int[] getMinMax(int... ints){
int[] minMax = new int[2];
minMax[0]=10;
minMax[1]=0;
for (int i : ints) {
minMax[0] = Math.min(minMax[0], i);
minMax[1] = Math.max(minMax[1], i);
}
return minMax;
}
@Override
public int hashCode() {
// Using Joshua Bloch's recipe:
int result = 17;
result = 37 * result + pointsA;
result = 37 * result + pointsB;
result = 37 * result + pointsC;
return result;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj instanceof Triplet) {
Triplet triplet = (Triplet) obj;
if (this.getA() == triplet.getA() && this.getB() == triplet.getB()
&& this.getC() == triplet.getC()) {
return true;
}
}
return false;
}
@Override
public String toString() {
return "" + pointsA + "," + pointsB + "," + pointsC;
}
}
class NotValidTripletRuntimeException extends RuntimeException {
private static final long serialVersionUID = 1L;
public NotValidTripletRuntimeException(String message) {
super(message);
}
}
| 0 | 1,189,493 |
A11759 | A11718 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 InvalidInputException extends Exception {
/**
*
*/
private static final long serialVersionUID = -3613289305328322102L;
public InvalidInputException() {
super();
// TODO Auto-generated constructor stub
}
public InvalidInputException(String arg0, Throwable arg1, boolean arg2,
boolean arg3) {
super(arg0, arg1, arg2, arg3);
// TODO Auto-generated constructor stub
}
public InvalidInputException(String arg0, Throwable arg1) {
super(arg0, arg1);
// TODO Auto-generated constructor stub
}
public InvalidInputException(String arg0) {
super(arg0);
// TODO Auto-generated constructor stub
}
public InvalidInputException(Throwable arg0) {
super(arg0);
// TODO Auto-generated constructor stub
}
}
| 0 | 1,189,494 |
A11759 | A12247 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 asem.googe.codejam.qround;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @author A.Alathwari
*
* Problem C :
*
*/
public class ProblemC implements Runnable {
asem.core.util.InputReader fin;
java.io.PrintWriter fout;
/**
* @param fin
* @param fout
*/
public ProblemC(asem.core.util.InputReader fin, PrintWriter fout) {
this.fin = fin;
this.fout = fout;
}
/**
* @param fin
* @param fout
* @throws IOException
* @throws FileNotFoundException
*/
public ProblemC(String fin, String fout) throws FileNotFoundException, IOException {
this.fin = new asem.core.util.InputReader(new FileReader(fin));
this.fout = new PrintWriter(System.out);
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
// TODO Auto-generated method stub
try {
for (int tNum = 1, inT = fin.readInt(); tNum <= inT; tNum++) {
System.out.println("Case #" + tNum + ": " + "");
}
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} | 0 | 1,189,495 |
A11759 | A11495 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.jam.eaque.stub;
import java.io.IOException;
public abstract class Stub {
private String outputFileName;
public String getOutputFileName() {
return outputFileName;
}
public void setOutputFileName(String outputFileName) {
this.outputFileName = outputFileName;
}
public abstract String runTestCase(InputFileManager ifm)
throws NumberFormatException, IOException;
}
| 0 | 1,189,496 |
A11759 | A10381 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class Solution2 {
private static int maxScoreWithSurprise(int media) {
if (media == 0)
return 0;
Double realAverrage = new Double((double) media / 3);
Double m = Math.ceil(realAverrage);
int mediaDeNota = m.intValue();
int notaMaxima = 0;
if (realAverrage == realAverrage.longValue()) {
notaMaxima = media - (mediaDeNota * 2);
notaMaxima++;
} else {
notaMaxima = media - ((mediaDeNota - 1) * 2);
}
return Math.max(mediaDeNota, notaMaxima);
}
private static int maxScore(int media) {
if (media == 0)
return 0;
Double m = Math.ceil(new Double((double) media / 3));
int mediaDeNota = m.intValue();
int notaMaxima = media - (mediaDeNota * 2);
return Math.max(mediaDeNota, notaMaxima);
}
public static String parser(String input) {
String[] lines = input.split("\n");
StringBuilder sb = new StringBuilder();
for (int index = 1; index < lines.length; index++) {
String[] current = lines[index].split(" ");
int numberSurprise = Integer.parseInt(current[1]);
int minimalAverrage = Integer.parseInt(current[2]);
int normalSum = 0;
int withSurpriseSum = 0;
for (int j = 3; j < current.length; j++) {
int num = Integer.parseInt(current[j]);
boolean normal = maxScore(num) >= minimalAverrage;
if (normal)
normalSum++;
else if (maxScoreWithSurprise(num) >= minimalAverrage)
withSurpriseSum++;
}
int result = withSurpriseSum + normalSum;
result = (result <= normalSum + numberSurprise) ? result
: normalSum + numberSurprise;
sb.append("Case #");
sb.append(index);
sb.append(": ");
sb.append(result);
if (index != lines.length - 1)
sb.append("\n");
}
return sb.toString();
}
public static String parseOfFile(File file) throws Exception {
FileInputStream fstream = new FileInputStream(file);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
StringBuffer sb = new StringBuffer();
String strLine;
while ((strLine = br.readLine()) != null) {
sb.append(strLine.trim());
sb.append("\n");
}
return parser(sb.toString());
}
public static void main(String[] args) throws Exception {
// System.out.println(maxScoreWithSurprise(21));
System.out.println(parseOfFile(new File("C:\\cide\\teste.txt")));
}
}
| 0 | 1,189,497 |
A11759 | A10578 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package codejam2012.qualification.b;
public final class Triplet {
public final int a;
public final int b;
public final int c;
public final int total;
public final boolean surprising;
private Triplet(int a, int b, int c, int total) {
this.a = a;
this.b = b;
this.c = c;
this.total = total;
surprising = Math.abs(a - b) > 1 || Math.abs(a - c) > 1 || Math.abs(b - c) > 1;
}
public static Triplet of(int a, int b, int c, int total) {
return new Triplet(a, b, c, total);
}
public boolean hasAtLeast(int p) {
return a >= p || b >= p || c >= p;
}
@Override
public String toString() {
return String.format("(%d,%d,%d)%s = %d", a, b, c, surprising ? "*" : "", total);
}
}
| 0 | 1,189,498 |
A11759 | A10506 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.*;
/**
* Created by IntelliJ IDEA.
* User: YC14RP1
* Date: 4/14/12
* Time: 12:29 AM
* To change this template use File | Settings | File Templates.
*/
public class Test2 {
public static void main(String[] args) throws FileNotFoundException {
String path = "C:\\Users\\YC14rp1\\Downloads\\B-small-attempt0.in";
try{
// Open the file that is the first
// command line parameter
FileInputStream fstream = new FileInputStream(path);
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
//Read File Line By Line
strLine = br.readLine();
int n = Integer.valueOf(strLine);
for (int i=1;i<=n;i++) {
strLine = br.readLine();
String[] split = strLine.split(" ");
int k = Integer.valueOf(split[0]);
int s = Integer.valueOf(split[1]);
int m = Integer.valueOf(split[2]);
int res = 0;
int res2 = 0;
for (int j=3;j<=2+k;j++) {
int score = Integer.valueOf(split[j]);
int c_m = score % 3;
if (score>3*m-3) {
res++;
} else {
if ((score-1>3*m-6) && (res2<s) && (m>=2)) {
//System.out.println(score-1);
//System.out.println(3*m-6);
res2++;
}
}
}
// Print the content on the console
res = res + res2;
System.out.println("Case #" + i + ": " + res);
}
//Close the input stream
in.close();
} catch (IOException e) {
e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
}
}
}
| 0 | 1,189,499 |