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 | A10805 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 qualification.Dancing;
import java.util.*;
/**
*
* @author farshid
*/
public class Dancing {
public Dancing() {
}
public int solve(String problem) {
String[] arr = problem.split(" ");
int n = Integer.parseInt(arr[0]);
int s = Integer.parseInt(arr[1]);
int p = Integer.parseInt(arr[2]);
int[] scores = new int[arr.length - 3];
for (int i = 3; i < arr.length; i++) {
scores[i - 3] = Integer.parseInt(arr[i]);
}
LinkedList<LinkedList<Combination>> combs =
new LinkedList<LinkedList<Combination>>();
for (int i = 0; i < scores.length; i++) {
LinkedList<Combination> l = this.dancerPossibleCombs(scores[i], p);
combs.add(l);
}
int max = this.processCombination(combs, s);
return max;
}
public void test() {
}
private int processCombination(LinkedList<LinkedList<Combination>> combs, int maxSur) {
int max = 0;
int currentSur = 0;
for (int i = 0; i < combs.size(); i++) {
LinkedList<Combination> current = combs.get(i);
boolean increased = false;
for (int j = 0; j < current.size(); j++) {
if (!current.get(j).isSurprising()){
max++;
increased = true;
break;
}
}
if (!increased && !current.isEmpty() && currentSur < maxSur){
max++;
currentSur++;
}
}
return max;
}
private LinkedList<Combination> dancerPossibleCombs(int total, int p) {
LinkedList<Combination> list = new LinkedList<Combination>();
// Get all possible combs
for (int i = 0; i <= 10; i++) {
if ((i + 2) >= p && (3 * i) + 4 >= total) { // otherwise no possible/useful combination
// 8 possible combs
if (3 * i == total && i >= p) {
Combination c = new Combination(
new int[]{i, i, i}, false);
list.add(c);
continue;
}
if ((3 * i + 1) == total && (i + 1) >= p) {
Combination c = new Combination(
new int[]{i, i, i + 1}, false);
list.add(c);
continue;
}
if ((3 * i + 2) == total) {
if (i + 2 >= p) {
Combination c1 = new Combination(
new int[]{i, i, i + 2}, true);
list.add(c1);
}
if (i + 1 >= p) {
Combination c2 = new Combination(
new int[]{i, i + 1, i + 1}, false);
list.add(c2);
}
continue;
}
if (3 * i + 3 == total && (i + 2) >= p) {
Combination c = new Combination(
new int[]{i, i + 1, i + 2}, true);
list.add(c);
continue;
}
if (3 * i + 4 == total && (i + 2) >= p) {
Combination c1 = new Combination(
new int[]{i, i + 2, i + 2}, true);
list.add(c1);
}
}
}
return list;
}
}
| 0 | 1,189,200 |
A11759 | A10603 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 base;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import assignments.AssignmentB;
public class Solver {
public static void main(String... args) throws IOException {
List<Assignment> assignments = readAssignments("test");
PrintWriter pw = new PrintWriter(new FileWriter("output.txt"));
int i = 0;
for (Assignment assignment : assignments) {
String answer = "Case #" + ++i + ": " + assignment.solve();
pw.println(answer);
System.out.println(answer);
}
pw.flush();
pw.close();
}
private static List<Assignment> readAssignments(String filename) throws FileNotFoundException {
Scanner scanner = new Scanner(new File(filename));
int amountOfAssignments = scanner.nextInt();
scanner.nextLine();
List<Assignment> result = new ArrayList<Assignment>();
for (int i = 0; i < amountOfAssignments; i++) {
result.add(AssignmentB.createFromScanner(scanner));
}
scanner.close();
return result;
}
}
| 0 | 1,189,201 |
A11759 | A10260 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 files;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
public class Googler3 {
public static void main(String[] args) {
try
{
//BufferedReader br = new BufferedReader(new FileReader("/Users/Sush/Documents/workspace1/CJ/src/files/Input.txt"));
BufferedReader br = new BufferedReader(new FileReader("/Users/Sush/Downloads/B-small-attempt0.in.txt"));
String line;
StringBuffer sb = new StringBuffer();
while((line= br.readLine())!= null)
{
sb = sb.append(line + "\n");
}
String[] cases = sb.toString().split("\n");
String data = "";
for(int i= 1;i<cases.length;i++)
{
int count = 0;
String[] num = cases[i].split(" ");
int surp = Integer.parseInt(num[1]);
int p = Integer.parseInt(num[2]);
int track = surp;
for (int j = 3; j< num.length; j++)
{
int n = Integer.parseInt(num[j]);
if (surp == 0)
{
int min = p + (p-1) + (p-1);
if (n>=min)
{
count = count +1;
}
}
else
{
int upper = p + (p-1) + (p-1);
int lower = p + (p-2) + (p-2);
if (p==1)
{
lower = 1;
}
if (n >= upper)
{
count = count +1;
}
else if(n>=lower && n < upper && track >0)
{
count = count + 1;
track = track - 1;
}
}
}
data = data + "Case #"+i+": "+count+"\n";
System.out.print("Case #"+i+": "+count+"\n");
}
File ff = new File("Output3.txt");
if (ff.exists())
{
ff.delete();
}
BufferedWriter bw = new BufferedWriter(new FileWriter(ff, true));
bw.write(data);
bw.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}
| 0 | 1,189,202 |
A11759 | A12468 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 CodeJam2012Ex2Small {
public static void main(String arg[]) throws FileNotFoundException {
File file = new File("B-small-attempt0.in");
Scanner scanner = new Scanner(file);
String output;
int numTestCases = scanner.nextInt();
for (int i = 0; i < numTestCases; i++) {
StringBuffer buffer = new StringBuffer("Case #" + (i + 1) + ": ");
int N = scanner.nextInt();
int S = scanner.nextInt();
int p = scanner.nextInt();
int[] googlersPoints = new int[N];
int bestResults = 0;
for (int j = 0; j < N; j++) {
googlersPoints[j] = scanner.nextInt();
if ((googlersPoints[j] >= (p * 3 - 2))){
bestResults++;
} else if ((googlersPoints[j] >= (p * 3 - 4))
&& S > 0 && googlersPoints[j] != 0) {
bestResults++;
S--;
}
}
buffer.append(bestResults);
if (i != numTestCases - 1) {
buffer.append("\n");
}
output = buffer.toString();
System.out.print(output);
}
}
}
| 0 | 1,189,203 |
A11759 | A12911 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.menzus.gcj._2012.qualification.b;
import com.menzus.gcj.common.OutputEntry;
public class BOutputEntry implements OutputEntry {
private int maximumGooglersNumber;
public void setMaximumGooglersNumber(int maximumGooglersNumber) {
this.maximumGooglersNumber = maximumGooglersNumber;
}
@Override
public String formatOutput() {
return Integer.toString(maximumGooglersNumber);
}
}
| 0 | 1,189,204 |
A11759 | A11558 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.util.HashMap;
public class B {
public static int b(String str){
int retVal = 0;
String arr[] = str.split(" ");
int N = Integer.parseInt(arr[0]);
int S = Integer.parseInt(arr[1]);
int P = Integer.parseInt(arr[2]);
if(P == 0){
return N;
}
int sum = 3*P - 2;
for(int i = 3; i < arr.length ; i++){
int Ti = Integer.parseInt(arr[i]);
if(Ti >= sum){
retVal++;
}
else if(S >0 && Ti > 0 && Ti >= sum - 2){
retVal++;
S--;
}
}
return retVal;
}
public static void main(String args[]){
File file = new File("B-small-attempt0.in");
int T = 0;
try{
FileInputStream fstream = new FileInputStream(file);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
if ((strLine = br.readLine()) != null) {
T = Integer.parseInt(strLine);
}
int currentCase = 1;
while(T > 0 && currentCase <= T){
String str= br.readLine();
System.out.println("Case #"+currentCase+": " + b(str));
currentCase++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
}
| 0 | 1,189,205 |
A11759 | A12670 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import Triple.Triple;
public class Dancing
{
/*@formatter:off*/
/**
* Problem B. Dancing With the Googlers
* Problem:
*
* You're watching a show where Googlers (employees of Google) dance, and
* then each dancer is given a triplet of scores by three judges. Each
* triplet of scores consists of three integer scores from 0 to 10
* inclusive. The judges have very similar standards, so it's surprising if
* a triplet of scores contains two scores that are 2 apart. No triplet of
* scores contains scores that are more than 2 apart.
*
* For example: (8, 8, 8) and (7, 8, 7) are not surprising. (6, 7, 8) and
* (6, 8, 8) are surprising. (7, 6, 9) will never happen.
*
* The total points for a Googler is the sum of the three scores in that
* Googler's triplet of scores. The best result for a Googler is the maximum
* of the three scores in that Googler's triplet of scores. Given the total
* points for each Googler, as well as the number of surprising triplets of
* scores, what is the maximum number of Googlers that could have had a best
* result of at least p?
*
* For example, suppose there were 6 Googlers, and they had the following
* total points: 29, 20, 8, 18, 18, 21. You remember that there were 2
* surprising triplets of scores, and you want to know how many Googlers
* could have gotten a best result of 8 or better.
*
* With those total points, and knowing that two of the triplets were
* surprising, the triplets of scores could have been:
*
* 10 9 10
* 6 6 8 (*)
* 2 3 3
* 6 6 6
* 6 6 6
* 6 7 8 (*)
* The cases marked with a (*) are the surprising cases. This gives us 3 Googlers who got at least one
* score of 8 or better. There's no series of triplets of scores that would
* give us a higher number than 3, so the answer is 3. Input
*
* 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.
*
* Output
*
* For each test case, output one line containing "Case #x: y", where x is
* the case number (starting from 1) and y is the maximum number of Googlers
* who could have had a best result of greater than or equal to p.
*
* Limits
*
* 1 <= T <= 100.
* 0 <= S <= N.
* 0 <= p <= 10.
* 0 <= ti <= 30.
* At least S of the ti values will be between 2 and 28, inclusive.
* Small dataset
* 1 <= N <= 3.
* Large dataset
* 1 <= N <= 100.
* Sample
* Input
* 4
* 3 1 5 15 13 11
* 3 0 8 23 22 21
* 2 1 1 8 0
* 6 2 8 29 20 8 18 18 21
*
* Output
* Case #1: 3
* Case #2: 2
* Case #3: 1
* Case #4: 3
*/
/*@formatter:on*/
private static String CASE = "Case #";
public static void main(String[] args)
{
Scanner in = null;
PrintWriter out = null;
int T = 0; // number of test cases
int N = 0; // number of contestants in current test case
int S = 0; // number of surprising triplets in current test case
int p = 0; // individual judge's score threshold for current test case
if (args.length < 2)
{
System.out.println("Syntax: java Dancing \"infile\" \"outfile\"");
System.exit(1);
}
// Opening infile
try
{
in = new Scanner(new File(args[0]));
} catch (Exception e)
{
e.printStackTrace();
System.exit(1);
}
// Opening outfile
try
{
out = new PrintWriter(new FileWriter(args[1]));
} catch (Exception e1)
{
e1.printStackTrace();
System.exit(1);
}
try
{
T = in.nextInt();
//System.out.println(T);
for (int i = 0; i < T; i++)
{
int k = 0;
int higher = 0;
Triple t = null;
N = in.nextInt();
S = in.nextInt();
p = in.nextInt();
//System.out.println("N=" + N + ", S=" + S + ", p=" + p);
for (int j = 0; j < N; j++)
{
k = in.nextInt();
t = new Triple(k);
//System.out.print(k + ": ");
if (t.isHigher(p))
{
//System.out.print(t + "[!] ");
higher += 1;
} else if ((t.couldBeHigher(p)) && (S > 0))
{
//System.out.print(t + "->");
t.Unusify();
S -= 1;
//System.out.print(t + "[*] ");
higher += 1;
} else
{
//System.out.print(t + " ");
}
}
//System.out.println("; Total = " + higher);
out.println(CASE + (i + 1) + ": " + higher);
System.out.println(CASE + (i + 1) + ": " + higher);
}
out.close();
} catch (Exception e)
{
e.printStackTrace();
System.exit(1);
}
}
}
| 0 | 1,189,206 |
A11759 | A11113 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.lang.*;
import java.io.*;
class googler
{
public static void main(String args[])
{
try
{
PrintWriter pw=new PrintWriter("out.txt");
//creating file reader instance and reading first line
BufferedReader br=new BufferedReader(new FileReader(args[0]));
String line=br.readLine();
int T=Integer.parseInt(line); //number of test cases T
//-------------------------
for(int i=0;i<T;++i)
{
String[] testcase=br.readLine().split(" ");
int N = Integer.parseInt(testcase[0]);
int S = Integer.parseInt(testcase[1]);
int p = Integer.parseInt(testcase[2]);
if(p==0)
{
//System.out.println("Case #"+(i+1)+": " + N);
pw.println("Case #"+(i+1)+": " + N);
continue;
}
int answer=0;
for(int j=1;j<=N;++j)
{
int total=Integer.parseInt(testcase[2+j]);
if(total==0)
continue;
int x=total/3;
//if(x>=p)
//{
// answer++;
// continue;
//}
int modulo=total%3;
switch(modulo)
{
case 0:
if(x>=p)
{
answer++;
}
else if((x+1)>=p && S>0)
{
answer++;
S--;
}
break;
case 1:
if((x+1)>=p)
answer++;
break;
case 2:
if((x+1)>=p)
{
answer++;
}
else if((x+2)>=p && S>0)
{
answer++;
S--;
}
break;
}//end switch
}
//System.out.println("Case #"+(i+1)+": " + answer);
pw.println("Case #"+(i+1)+": " + answer);
/*------------------------**/
}
br.close();
pw.close();
}//end of try
catch(Exception e)
{
System.out.println("Exception caught: "+e);
}
}
} | 0 | 1,189,207 |
A11759 | A10173 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package qualification;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class DancingWithTheGooglers {
static int T;
static int[] result;
public static void main(String[] args) throws IOException {
System.out.println(new File("prd.txt").getAbsolutePath());
read();
write();
}
static void read() throws IOException {
File input = new File("input.txt");
Scanner scanner = new Scanner(input);
T = scanner.nextInt();
result = new int[T];
for (int t=0; t<T; t++) {
int N = scanner.nextInt();
int S = scanner.nextInt();
int p = scanner.nextInt();
int r = 0;
for (int i=0; i<N; i++) {
int score = scanner.nextInt();
if (score >= 3*p-2) {
r++;
} else if ((score >= 3*p-4) && (S > 0) && (p >= 2)) {
r++;
S--;
}
}
result[t] = r;
}
}
static void write() throws IOException {
File output = new File("output.txt");
PrintWriter pw = new PrintWriter(output);
for (int t=0; t<T; t++) {
pw.println("Case #"+(t+1)+": "+result[t]);
}
pw.close();
}
}
| 0 | 1,189,208 |
A11759 | A12100 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 dancingwithgooglers;
import java.util.Scanner;
/**
*
* @author topik
*/
public class DancingWithGooglers
{
/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
final Scanner scanner = new Scanner(System.in);
final int testCases = scanner.nextInt();
for( int tc=1; tc <= testCases; tc++ )
{
final int googlers = scanner.nextInt();
int surprising = scanner.nextInt();
final int p = scanner.nextInt();
int goodGooglers = 0;
for( int i=0; i < googlers; i++ )
{
final int score = scanner.nextInt();
if( score == 0 )
{
if( p == 0 )
{
goodGooglers++;
}
continue;
}
final int d = score / 3;
final int r = score % 3;
if( d >= p )
{
goodGooglers++;
}
else if( d+1 >= p )
{
if( r > 0 )
{
goodGooglers++;
}
else if( surprising > 0 )
{
surprising--;
goodGooglers++;
}
}
else if( d+2 >= p )
{
if( r == 2 && surprising > 0 )
{
surprising--;
goodGooglers++;
}
}
}
System.out.println("Case #" + tc + ": " + goodGooglers);
}
}
}
| 0 | 1,189,209 |
A11759 | A12577 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.ArrayList;
import java.util.List;
public class JamUtil {
static int[] parseIntList(String str, int count) {
int[] res = new int[count];
String[] parts = str.split(" ");
for (int i = 0; i < parts.length; i++) {
String part = parts[i];
res[i] = Integer.parseInt(part);
}
return res;
}
static List<Integer> parseIntList(String str) {
ArrayList<Integer> res = new ArrayList<Integer>();
String[] parts = str.split(" ");
for (int i = 0; i < parts.length; i++) {
String part = parts[i];
res.add(Integer.parseInt(part));
}
return res;
}
static<T> String printTable(T[][] t) {
StringBuilder res = new StringBuilder();
for (int i = 0; i < t.length; i++) {
T[] ts = t[i];
for (int j = 0; j < ts.length; j++) {
T t1 = ts[j];
res.append(t1+ " ");
}
res.append("\n");
}
return res.toString();
}
}
| 0 | 1,189,210 |
A11759 | A12637 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class jam {
public static void main(String args[])
{
ArrayList<String> inp=read_fil("D:\\google_Jam\\B-small-attempt1.in");
// ArrayList<String> inp=read_fil("D:\\google_Jam\\A-large-practice.in");
int lin_num=0;
int T=Integer.valueOf(inp.get(lin_num));
lin_num++;
for(int kk=0;kk<T;kk++){
String lin=inp.get(lin_num);
lin_num++;
String[] lins=lin.split(" ");
int N=Integer.valueOf(lins[0]);
int S=Integer.valueOf(lins[1]);
int p=Integer.valueOf(lins[2]);
int[] t=new int[N];
int y=0;
for(int i=0;i<N;i++){
t[i]=Integer.valueOf(lins[i+3]);
}
for(int i=0;i<N;i++){
int s1=0;int s2=0;int s3=0;
while((s1+s2+s3)<t[i] && s1<=10 && s2<=10 && s3<=10){
if(s3<10) s3++;
if((s1+s2+s3)==t[i]) break;
if(s2<10) s2++;
if((s1+s2+s3)==t[i]) break;
if(s1<10) s1++;
if((s1+s2+s3)==t[i]) break;
}
if(s1+s2+s3!=t[i]) continue;
int max=getmax(s1,s2,s3);
if(max>=p){
y++;
continue;
}else if(S>0 && s2==s3){
s3++;
s2--;
if(s1+s2+s3==t[i] && s3>=p && s3>=p && s1>=0 && s2>=0 && s3>=0){
S--;
y++;
continue;
}
}
}
if(S>0){
y=0;
for(int i=0;i<N;i++){
int s1=0;int s2=0;int s3=0;
while((s1+s2+s3)<t[i] && s1<=10 && s2<=10 && s3<=10){
if(s3<10) s3++;
if((s1+s2+s3)==t[i]) break;
if(s2<10) s2++;
if((s1+s2+s3)==t[i]) break;
if(s1<10) s1++;
if((s1+s2+s3)==t[i]) break;
}
if(s1+s2+s3!=t[i]) continue;
if(S>0 && s2==s3){
s3++;
s2--;
if(s1+s2+s3==t[i] && s3>=p && s1>=0 && s2>=0 && s3>=0){
S--;
y++;
continue;
}
}else{
int max=getmax(s1,s2,s3);
if(max>=p){
y++;
continue;
}
}
}
}
writeFile("Case #"+(kk+1)+": "+y);
}
}
private static int getmax(int s1, int s2, int s3) {
int max=0;
if(max<s1) max=s1;
if(max<s2) max=s2;
if(max<s3) max=s3;
return max;
}
public static ArrayList<String> read_fil(String file){
ArrayList<String> arr=new ArrayList<String>();
try{
FileInputStream fstream = new FileInputStream(file);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
while ((strLine = br.readLine()) != null) {
arr.add(strLine);
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
return arr;
}
public static void writeFile(String ss) {
String fileName = "D:\\google_Jam\\Output.txt";
try {
FileWriter writer = new FileWriter(fileName,true);
writer.write(ss);
writer.write('\n');
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} | 0 | 1,189,211 |
A11759 | A12208 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 first;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
/**
*
* @author tal
*/
public class Second {
public static final int MAX_NUMBER = 11;
public static Map<Integer, Map<Collection<Integer>, Boolean>> fullLearnedMap;
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
fullLearnedMap = learn();
InputStreamReader converter = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(converter);
String readLine = in.readLine();
int n = Integer.parseInt(readLine);
for (int i = 0; n > 0; i++) {
String caseText = in.readLine();
if (caseText == null || caseText.isEmpty()) {
break;
}
System.out.println("Case #" + (i + 1) + ": " + maxPoints(caseText));
n--;
}
in.close();
}
public static Map<Integer, Map<Collection<Integer>, Boolean>> learn() {
Map<Integer, Map<Collection<Integer>, Boolean>> map = new TreeMap<Integer, Map<Collection<Integer>, Boolean>>();
int N = 0;
for (int i = 0; i < MAX_NUMBER; i++) {
for (int j = i; j < MAX_NUMBER; j++) {
for (int k = j; k < MAX_NUMBER; k++) {
if (Math.abs(i - j) > 2 || Math.abs(i - k) > 2 || Math.abs(j - k) > 2) {
continue;
}
int sum = i + j + k;
Map<Collection<Integer>, Boolean> triples = map.get(sum);
Boolean surprise = false;
if (Math.abs(i - j) > 1 || Math.abs(i - k) > 1 || Math.abs(j - k) > 1) {
surprise = true;
}
Integer[] triple = {i, j, k};
if (triples == null) {
triples = new HashMap<Collection<Integer>, Boolean>();
map.put(sum, triples);
}
triples.put(Arrays.asList(triple), surprise);
N++;
}
}
}
//System.out.println("Total: " + N);
return map;
}
public static Integer maxPoints(String input) {
String[] split = input.split(" ");
int N = Integer.parseInt(split[0]);
int S = Integer.parseInt(split[1]);
int p = Integer.parseInt(split[2]);
int[] dancersScores = new int[N];
for (int i = 3; i < 3 + N; i++) {
dancersScores[i - 3] = Integer.parseInt(split[i]);
}
return findMaxRec(dancersScores, p, S);
}
public static Integer findMaxRec(int[] reducedDancersScores, Integer p, Integer S) {
if (reducedDancersScores == null || reducedDancersScores.length == 0 || S < 0) {
return 0;
}
int localMax = 0;
int[] copyOfRange;
if (reducedDancersScores.length == 1) {
copyOfRange = null;
} else {
copyOfRange = Arrays.copyOfRange(reducedDancersScores, 1, reducedDancersScores.length);
}
Map<Collection<Integer>, Boolean> triples = fullLearnedMap.get(reducedDancersScores[0]);
for (Map.Entry<Collection<Integer>, Boolean> triple : triples.entrySet()) {
if (relevantTriple(triple.getKey(), p)) {
if (triple.getValue()) {
if (S > 0) {
Integer foundMaxOnSubset = findMaxRec(copyOfRange, p, S - 1); // recursive call
if (localMax < 1 + foundMaxOnSubset) {
localMax = 1 + foundMaxOnSubset;
}
} else {
continue;
}
} else {
Integer foundMaxOnSubset = findMaxRec(copyOfRange, p, S); // recursive call
if (localMax < 1 + foundMaxOnSubset) {
localMax = 1 + foundMaxOnSubset;
}
}
}
}
Integer foundMaxRec = findMaxRec(copyOfRange, p, S);
if (localMax < foundMaxRec) {
localMax = foundMaxRec;
}
return localMax;
}
public static boolean relevantTriple(Collection<Integer> triple, int min) {
for (Integer judgeScore : triple) {
if (judgeScore >= min) {
return true;
}
}
return false;
}
}
| 0 | 1,189,212 |
A11759 | A10213 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.Scanner;
//javac B.java && java B x.in x.out
public class B {
public static void main(String[] args) throws FileNotFoundException {
InputStream in = System.in;
if(args.length>0)
in = new FileInputStream(args[0]);
PrintStream out = System.out;
if(args.length>1)
out = new PrintStream(args[1]);
Solver s = new Solver(new Scanner(in),out);
//Multiple case input
s.cases();
//Single case input
//s.go();
}
}
class Solver {
Scanner in;
PrintStream out;
public Solver(Scanner scanner, PrintStream printStream) {
in = scanner;
out = printStream;
}
public void cases() {
int numCases = in.nextInt();
in.nextLine();
for(int i=0;i<numCases;i++) {
out.print("Case #"+(i+1)+": ");
go();
}
}
public void go() {
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
//Surprise x-2,x-2,x || x-2,x-1,x || x-2,x,x
//Non-surp x,x,x || x-1,x,x || x-1,x-1,x
int tS = p*3-4;
int tN = p*3-2;
if(p==0) {
tS=0;
tN=0;
}
if(p==1) {
tS=p*3-2;
tN=p*3-2;
}
int[] t = new int[N];
for(int i=0;i<N;i++)
t[i]=in.nextInt();
int ans = 0;
for(int i=0;i<N;i++) {
if(t[i]>=tN)
ans++;
else if(S>0 && t[i]>=tS) {
ans++;
S--;
}
}
out.println(ans);
}
} | 0 | 1,189,213 |
A11759 | A12119 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.util.List;
import java.util.ArrayList;
public class GCJ_qr_b {
public static void main(String[] args) {
GCJReader in = new GCJReader(args[0]);
GCJWriter out = new GCJWriter(args[1]);
int numTestCases = Integer.parseInt(in.readLine());
for(int i = 1; i <= numTestCases; i+=1) {
String[] input = in.readLine().split(" ");
//always >= 1
final int googlers = Integer.parseInt(input[0]);
final int surprisingScores = Integer.parseInt(input[1]);
final int p = Integer.parseInt(input[2]);
int maxGooglers = 0;
int rSurprisingScores = surprisingScores;
System.out.println("Googlers=" + googlers + ", surprisingScores=" + surprisingScores + ", p="+ p);
for(int j = 3; j < 3 + googlers; j += 1) {
int totalScore = Integer.parseInt(input[j]);
int[] scores = getOrderedScores(totalScore);
System.out.print(" From " + totalScore + " , got (" + scores[0] + "," + scores[1] + "," + scores[2] + ")");
boolean gotMax = false;
//The score in the final sorted position is >= p, so no more checks required.
if (scores[2] >= p) {
maxGooglers += 1;
System.out.println(" | not surprising, satisfied");
continue;
}
//the largest score does not satisfy the maximum, but we might still have a chance if
//we have some surprising scores remaining
if(rSurprisingScores == 0) {
System.out.println(" | no surprising scores left");
continue;
}
//We have at least one surprising score to work with, which means that the scores as is
//do not satisfy p, but if they are surprising they may
//This scenario now breaks down into 3 cases, in general seeming to correspond to the situation where
//Algorithm could be greatly improved if we analyzed the properties of the score for 3-divisibily but who has time for that
if(scores[0] == scores[1] && scores[0] == scores[2]) {
//Case 1: The scores are equal
if(scores[0] == 0) {
//edge case, if all scores are 0, then we can do nothing
gotMax = false;
} else if((scores[2] + 1) >= p) {
//if the scores are equal and >=1, then we can make these scores surprising by increasing
//one score and decreasing another. For example (1,1,1) can become (1,0,2)
gotMax = true;
}
} else if (scores[0] == scores[1]) {
//Case 2: We have a triplet of two smaller scores and a larger score, as (1, 1, 2)
// in this case we cannot adjust for a surprising score, as the gap between the largest score (i.e. 2) and the smaller score (i.e. 1)
// will become too large (i.e. 1, 0, 3), and adjusting the smaller numbers is irrelevant (i.e. (0, 2, 2) )
// So, just continue on
gotMax = false;
} else if (scores[1] == scores[2]) {
//Case 3: We have a triplet of two larger scores and a smaller score, as (1, 2, 2)
// We can adjust this number to be a surprising score in pretty much every case, i.e. (1, 1, 3)
if((scores[2] + 1) >= p) {
gotMax = true;
}
}
//made the score surprising and see if we can satisfy p
if (gotMax) {
rSurprisingScores--;
maxGooglers++;
System.out.println(" | surprising, satisfied, remaining surprising=" + rSurprisingScores);
} else {
System.out.println(" | can't be satisfied, remaining surprising=" + rSurprisingScores);
}
}
String outLine = "" + maxGooglers;
out.writeLine(String.format("Case #%d: %s", i, outLine));
}
}
//the neat part of this breakdown is that scores[3] will always contain the largest number regardless
private static int[] getOrderedScores(int total) {
int[] scores = new int[3];
scores[0] = total / 3;
scores[1] = (total - scores[0]) / 2;
scores[2] = (total - scores[0] - scores[1]);
return scores;
}
private static class GCJWriter {
private String outFile = null;
private BufferedWriter out = null;
public GCJWriter(String outFile) {
this.outFile = outFile;
try {
out = new BufferedWriter(new FileWriter(outFile));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void writeLine(String output) {
try {
out.write(output + "\n");
out.flush();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
private static class GCJReader {
private String inFile = null;
private BufferedReader in = null;
public GCJReader(String inFile) {
this.inFile = inFile;
try {
in = new BufferedReader(new FileReader(inFile));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public String readLine() {
try {
return in.readLine();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
} | 0 | 1,189,214 |
A11759 | A10226 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 B2 {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nbrCases = sc.nextInt();
for (int i = 1; i <= nbrCases; ++i) {
sc.nextLine();
System.out.print("Case #" + i + ": ");
int nbrGooglers = sc.nextInt();
int nbrSurprising = sc.nextInt();
int atLeast = sc.nextInt();
// The lowest value of a triplet which isn't surprising with
// at least N is a triplet with the values N, N-1 and N-1
int lowestNonSurprisingSum = 3 * atLeast - 2;
// The lowest value of a triplet which is surprising with
// at least N is a triplet with the values N, N-2 and N-2
int lowestSurprisingSum = 3 * atLeast - 4;
// Base cases
if (atLeast == 0) {
lowestNonSurprisingSum = 0;
lowestSurprisingSum = 0;
} else if (atLeast == 1) {
lowestNonSurprisingSum = 1;
lowestSurprisingSum = 1;
}
int nbrNonSurprisingFound = 0;
int nbrSurprisingFound = 0;
for (int j = 0; j < nbrGooglers; ++j) {
int score = sc.nextInt();
if (score >= lowestNonSurprisingSum) {
++nbrNonSurprisingFound;
} else if (score >= lowestSurprisingSum) {
++nbrSurprisingFound;
}
}
int max = nbrNonSurprisingFound + Math.min(nbrSurprisingFound, nbrSurprising);
System.out.println(max);
}
}
}
| 0 | 1,189,215 |
A11759 | A11822 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package qualification_2012;
import java.io.PrintWriter;
import java.util.Scanner;
public class PB {
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
public static void main(String[] args) {
int t = sc.nextInt();
for (int i = 1; i <= t; i++) {
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int[][] d1 = new int[n + 1][s + 1];
int[][] d2 = new int[n + 1][s + 1];
for (int j = 1; j <= n; j++) {
int x = sc.nextInt();
for (int k = 0; k <= Math.min(s, j); k++) {
if (k != 0)
d1[j][k] = Math.max(d1[j - 1][k - 1], d2[j - 1][k - 1])
+ (check(x, p, true) ? 1 : 0);
if (k < j)
d2[j][k] = Math.max(d2[j - 1][k], d1[j - 1][k])
+ (check(x, p, false) ? 1 : 0);
}
}
pw.println("Case #" + i + ": " + Math.max(d1[n][s], d2[n][s]));
}
pw.flush();
}
static boolean check(int a, int p, boolean surprised) {
if (surprised) {
switch (a % 3) {
case 0:
return (a > 0 && a < 28 && ((a + 3) / 3) >= p);
case 1:
return (a > 1 && a < 29 && ((a + 2) / 3) >= p);
case 2:
return (a < 27 && ((a + 4) / 3) >= p);
}
} else {
switch (a % 3) {
case 0:
return (a / 3) >= p;
case 1:
return ((a + 2) / 3) >= p;
case 2:
return ((a + 1) / 3) >= p;
}
}
return false;
}
}
| 0 | 1,189,216 |
A11759 | A12664 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.StringTokenizer;
public class DancingWithGooglers {
BufferedReader br;
StringTokenizer st = new StringTokenizer("");
private void solve() throws IOException {
// final String IO_FILE = null;
final String IO_FILE = "./B/B-small-attempt0";
final PrintWriter pw;
if (IO_FILE == null) {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(System.out);
} else {
br = new BufferedReader(new FileReader(IO_FILE + ".in"));
pw = new PrintWriter(IO_FILE + ".out");
}
int testCases = nextInt();
for (int ti = 1; ti <= testCases; ti++) {
int n = nextInt();
int s = nextInt();
int p = nextInt();
int[] pointSums = new int[n];
for (int i = 0; i < n; i++) {
pointSums[i] = nextInt();
}
int ans = find(n, s, p, pointSums);
pw.println("Case #" + ti + ": " + ans);
}
br.close();
pw.close();
}
private int find(int n, int s, int p, int[] pointSums) {
int[][] d = new int[n + 1][s + 1];
d[0][0] = 0;
for (int i = 0; i < n; i++) {
final int sum = pointSums[i];
for (int j = 0; j <= s; j++) {
int maxRegularPoint = calcMaxRegularPoint(sum);
if (p <= maxRegularPoint) {
d[i + 1][j] = Math.max(d[i + 1][j], d[i][j] + 1);
}
else {
d[i + 1][j] = Math.max(d[i + 1][j], d[i][j]);
int maxSurprisingPoint = calcMaxSurprisingPoint(sum);
if (sum >= 2 && p <= maxSurprisingPoint && j != s) {
d[i + 1][j + 1] = Math.max(d[i + 1][j + 1], d[i][j] + 1);
}
}
}
}
int ans = 0;
for (int j = 0; j <= s; j++) {
ans = Math.max(ans, d[n][j]);
}
return ans;
}
private int calcMaxRegularPoint(int sum) {
return (sum + 2) / 3;
}
int calcMaxSurprisingPoint(int sum) {
return (sum + 4) / 3;
}
String nextString() throws IOException {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextString());
}
public static void main(String[] args) throws IOException {
new DancingWithGooglers().solve();
}
}
| 0 | 1,189,217 |
A11759 | A12133 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileInputStream;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Recycle {
public Recycle()
{
readFile("Files/recycle.in");
}
public void readFile(String file)
{
try{
FileInputStream fstream = new FileInputStream(file);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine = "";
br.readLine();
int count = 1;
while ((strLine = br.readLine()) != null)
{
System.out.print("Case #" + (count++) + ": ");
Scanner scanner = new Scanner(strLine);
int numSurprising = 0;
int p = 0;
scanner.nextInt();
int numMax = 0;
numSurprising = scanner.nextInt();
p = scanner.nextInt();
while(scanner.hasNextInt())
{
int current = scanner.nextInt();
if(current == 0 && p != 0)
continue;
else if(current == 0 && p == 0)
numMax++;
else if(current >= (3*p-2))
{
numMax++;
}
else if(numSurprising > 0 && ((3*p-2) - current) <= 2)
{
numSurprising--;
numMax++;
}
}
System.out.print(numMax);
System.out.println();
}
}catch(Exception e){}
}
public static void main(String [] args)
{
Recycle r = new Recycle();
}
}
| 0 | 1,189,218 |
A11759 | A11835 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileOutputStream;
import java.io.FileReader;
@SuppressWarnings("CallToThreadDumpStack")
public class Utils
{
private static FileOutputStream outStream;
private static BufferedReader reader;
private static boolean debug = false;
public static void openOutFile(String str, boolean debug)
{
Utils.debug = debug;
try { outStream = new FileOutputStream(str, false); }
catch (Exception e) { e.printStackTrace(); }
}
public static void openInFile(String str)
{
try { reader = new BufferedReader(new FileReader(str)); }
catch (Exception e) { e.printStackTrace(); }
}
public static void closeOutFile()
{
try { outStream.close(); }
catch (Exception e) { e.printStackTrace(); }
}
public static void closeInFile()
{
try { outStream.close(); }
catch (Exception e) { e.printStackTrace(); }
}
public static String readFromFile()
{
try { return reader.readLine(); }
catch (Exception e) { e.printStackTrace(); }
return null; // shouldn't get here
}
public static void writeToFile(String str)
{
if (debug) System.out.println(str);
try
{
for(int k=0; k<str.length(); k++)
{
outStream.write(str.charAt(k));
}
outStream.write(13);
outStream.write(10);
}
catch (Exception e)
{ e.printStackTrace(); }
}
}
| 0 | 1,189,219 |
A11759 | A11077 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.*;
import java.math.*;
public class Solver
{
private String key = "yhesocvxduiglbkrztnwjpfmaq";
public int[] convert(String[] s) {
int[] res = new int[s.length];
for(int i = 0;i < s.length; i++) {
res[i] = Integer.parseInt(s[i]);
}
return res;
}
private String decode(String str, String res) {
if (str.length() == 0) {return res;}
String nextchar = "";
if (str.charAt(0) == ' ') {nextchar = " ";}
else {nextchar = key.substring(str.charAt(0) - 'a',str.charAt(0) - 'a' + 1);}
return decode(str.substring(1),res + nextchar);
}
public String solve(BufferedReader reader) {
try {
String word = reader.readLine();
return decode(word,"");
}
catch(Exception e) {e.printStackTrace(); return "";}
}
public String solve2(BufferedReader reader) {
try {
int[] dims = convert(reader.readLine().split(" "));
int num = dims[0];
int sups = dims[1];
int target = dims[2];
int total = 0;
for(int i = 0; i < num; i++) {
if(dims[3+i] > (target -1)*3) {total++;}
else if(dims[3+i] < Math.max((target-1)*3 - 1,1)) {}
else {
if(sups > 0) {total++; sups--;}
}
}
return ""+total;
}
catch(Exception e) {e.printStackTrace(); return "";}
}
public static void main(String[] args)
{
try
{
FileReader flrdr = new FileReader(new File("test.in"));
BufferedReader br = new BufferedReader(flrdr);
FileWriter writer = new FileWriter("output.txt");
int n = Integer.parseInt(br.readLine());
Solver s = new Solver();
for(int i = 1; i < n+1; i++)
{
//System.out.println("Case #" + i + ": " + s.solve4(br) + "\n");
writer.write("Case #" + i + ": " + s.solve2(br) + "\n");
}
writer.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
public static void checkFiles(String f1, String f2) {
try {
FileReader flrd1 = new FileReader(new File(f1));
FileReader flrd2 = new FileReader(new File(f2));
BufferedReader br1 = new BufferedReader(flrd1);
BufferedReader br2 = new BufferedReader(flrd2);
int count = 1;
while(br1.readLine().equals(br2.readLine())) {
count++;
}
System.out.println(count);
}
catch(Exception e) {e.printStackTrace();}
}
} | 0 | 1,189,220 |
A11759 | A12301 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.StringTokenizer;
public class ProblemB {
private static final String OUT = "C:/workspaces/tc/CodeJam/src/B.out";
private static final String IN = "D:/downloads/B-small-attempt1.in";
public static boolean canHaveScoreWithoutSurprise(int score, int requiredScore) {
if (requiredScore == 0) {
return true;
}
return Math.max(0, requiredScore - 1) * 3 + 1 <= score;
}
public static boolean canHaveScoreWithSurprise(int score, int requiredScore) {
return Math.max(0, requiredScore - 2) * 3 + 2 <= score;
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new FileReader(IN));
BufferedWriter bw = new BufferedWriter(new FileWriter(OUT));
int T = Integer.parseInt(br.readLine());
for (int i = 0; i < T; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
int[] t = new int[N];
for (int j = 0; j < N; j++) {
t[j] = Integer.parseInt(st.nextToken());
}
int withoutSurpriseTotal = 0;
int withSurpriseTotal = 0;
for (int score : t) {
if (canHaveScoreWithoutSurprise(score, p)) {
withoutSurpriseTotal++;
} else {
if (canHaveScoreWithSurprise(score, p)) {
withSurpriseTotal++;
}
}
}
int res = withoutSurpriseTotal + Math.min(withSurpriseTotal, S);
bw.write("Case #" + (i + 1) + ": " + res + "\n");
}
bw.close();
}
}
| 0 | 1,189,221 |
A11759 | A10428 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 MyAllgoritmicLib;
public class Hungary {
int INF = 1000*1000*1000;
int n;
int[][] a;
int[] xy, yx;
boolean[] vx, vy;
int[] minrow, mincol;
public Hungary(int[][] a) {
// TODO Auto-generated constructor stub
this.a = a.clone();
}
private boolean dotry (int i) {
if (vx[i]) return false;
vx[i] = true;
for (int j=0; j<n; ++j)
if (a[i][j]-minrow[i]-mincol[j] == 0)
vy[j] = true;
for (int j=0; j<n; ++j)
if (a[i][j]-minrow[i]-mincol[j] == 0 && yx[j] == -1) {
xy[i] = j;
yx[j] = i;
return true;
}
for (int j=0; j<n; ++j)
if (a[i][j]-minrow[i]-mincol[j] == 0 && dotry (yx[j])) {
xy[i] = j;
yx[j] = i;
return true;
}
return false;
}
@SuppressWarnings("unused")
private int hungary(int num) {
mincol = new int[num];
minrow = new int[num];
xy = new int[num];
yx = new int[num];
vx = new boolean[num];
vy = new boolean[num];
n = num;
for (int q = 0; q<n; q++) {
mincol[q] = INF;
minrow[q] = INF;
}
for (int i=0; i<n; ++i)
for (int j=0; j<n; ++j)
minrow[i] = Math.min(minrow[i], a[i][j]);
for (int j=0; j<n; ++j)
for (int i=0; i<n; ++i)
mincol[j] = Math.min (mincol[j], a[i][j] - minrow[i]);
for (int q = 0; q<n; q++) {
xy[q] = -1;
yx[q] = -1;
}
for (int c=0; c<n; ) {
for (int q = 0; q<n; q++) {
vx[q] = false;
vy[q] = false;
}
int k = 0;
for (int i=0; i<n; ++i)
if (xy[i] == -1 && dotry (i))
++k;
c += k;
if (k == 0) {
int z = INF;
for (int i=0; i<n; ++i)
if (vx[i])
for (int j=0; j<n; ++j)
if (!vy[j])
z = Math.min (z, a[i][j]-minrow[i]-mincol[j]);
for (int i=0; i<n; ++i) {
if (vx[i]) minrow[i] += z;
if (vy[i]) mincol[i] -= z;
}
}
}
int ans = 0;
for (int i=0; i<n; ++i)
ans += a[i][xy[i]];
return ans;
}
}
| 0 | 1,189,222 |
A11759 | A11507 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 DancingWithGooglers;
public class Googler implements Comparable {
/**
* @param args
*/
private int base;
private int remainder;
private int max;
private int total;
private boolean mayBeSurprising;
public Googler(int score){
total = score;
remainder = score %3 ;
base = (score - remainder) /3;
}
public int getTotal(){
return total;
}
public int getMax(boolean canbeSur){
if(canbeSur){
if(remainder <= 1){
if(base !=0){
return base + 1;
}
else{
return base;
}
}
else{
return base + 2;
}
}
else{
if(remainder <= 1){
return base + remainder;
}
else{
return base+1;
}
}
}
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
int otherTotal = ((Googler)o).getTotal();
if(total < otherTotal){
return -1;
}
else if (total == otherTotal){
return 0;
}
else{
return 1;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
| 0 | 1,189,223 |
A11759 | A12942 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 P {
public static void main(String[] arg) {
//greedyPossibleTuple(new int[] {29,20,8,18, 18,21},8,2);
//greedyPossibleTuple(new int[] {8,0}, 1,1);
//greedyPossibleTuple(new int[] {23, 22, 21, 20, 29}, 8, 0);
//System.out.println(parseLine("6 2 8 29 20 8 18 18 21"));
java.io.BufferedReader in = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
try {
String line;
java.util.ArrayList<String> lines = new java.util.ArrayList<String>();
while((line = in.readLine())!=null) {
lines.add(line);
}
for(int i=1;i<lines.size();i++) {
line = lines.get(i);
System.out.println("Case #"+i+": "+parseLine(line));
}
} catch(Exception e) {
}
}
public static String parseLine(String l) {
String[] pt = l.split(" ");
int N = Integer.valueOf(pt[0]);
int S = Integer.valueOf(pt[1]);
int p = Integer.valueOf(pt[2]);
int t[] = new int[N];
for(int i=3;i<pt.length;i++) {
t[i-3]=Integer.valueOf(pt[i]);
}
//System.out.println("AAA:"+p + "," +S+","+N);
return ""+greedyPossibleTuple(t, p, S);
}
public static int greedyPossibleTuple(int[] data, int least, int maxsup) {
boolean marker[] = new boolean[data.length];
int scount = 0;
for(int i=0;i<data.length;i++) {
marker[i] = false;
int m = computeTuple(data[i], true);
if(m>=least) {
scount++;
marker[i]=true;
//System.out.println("S:"+data[i]+","+m);
}
}
int count = scount;
for(int i=0;i<data.length;i++) {
int m = computeTuple(data[i], false);
if(m >= least) {
//System.out.println("A:"+data[i]);
if(marker[i]) {
scount--;
} else {
marker[i] = true;
count++;
}
}
}
if(scount > maxsup) {
count -= (scount - maxsup );
}
//System.out.println(count + "," +scount + "," + maxsup);
//System.out.println("....");
return count;
}
public static int computeTuple(int a, boolean s) {
int min = (int)Math.floor((double)a/3);
int g = s?2:1;
int[] mines = {min, min, min};
int i=0;
int j=1;
if(mines[0]+mines[1]+mines[2] == a && g<a) {
mines[0]+=g-1;
mines[2]-=g-1;
}
while(mines[0] + mines[1] + mines[2] < a) {
mines[i]++;
if(j%g==0) {
i++;
if(i>g) i=0;
}
j++;
}
//System.out.println(mines[0]);
return mines[0];
}
}
| 0 | 1,189,224 |
A11759 | A11100 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 caseHandler {
int N;
int S;
int P;
int bestNum;
int[] scores;
public caseHandler(int N, int S, int P, int[] scores){
this.N = N;
this.S = S;
this.P = P;
this.scores = scores;
this.bestNum = 0;
}
public int solveCase(){
loopCase(scores[0], 0, 0, 0);
return bestNum;
}
private void loopCase(int score, int currN, int Scount, int pNumCount){
int currSCount = Scount;
int currpNumCount = pNumCount;
int aproxMinScore = score/3 - 1;
if (aproxMinScore < 0) aproxMinScore = 0;
for(int i=aproxMinScore;i<=10;i++){
for(int j=aproxMinScore;j<=10;j++){
if(Math.abs(i-j)>2) continue;
for(int k=aproxMinScore;k<=10;k++){
int min = Math.min(Math.min(i, j), k);
if(Math.abs(min-i)>2 || Math.abs(min-j)>2 || Math.abs(min-k)>2) continue;
if(i+j+k == score){
int s = 0;
int p = 0;
if(Math.abs(i-j)==2 || Math.abs(k-j)==2 || Math.abs(k-i)==2) s = 1;
if(currSCount+s > S) continue;
else{
if(i>=P || j>=P || k>=P) p = 1;
if(currN == N-1){
if(currpNumCount+p > bestNum) bestNum=currpNumCount+p;
}
else loopCase(scores[currN+1], currN+1, currSCount+s, currpNumCount+p);
}
}
}
}
}
}
}
| 0 | 1,189,225 |
A11759 | A12456 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 at.neiti.codejam2012;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class DancingWithTheGooglers {
public static void main(String[] args) throws IOException {
BufferedReader r = new BufferedReader(new FileReader("B-small-attempt0.in"));
int n = Integer.parseInt(r.readLine());
StringBuilder output = new StringBuilder();
for(int i=0; i<n; i++) {
String line = "Case #" + (i+1) + ": ";
String tokens[] = r.readLine().split(" ");
int numGooglers = Integer.parseInt(tokens[0]);
int surprising = Integer.parseInt(tokens[1]);
int p = Integer.parseInt(tokens[2]);
int googlersGreaterP = 0;
for(int j=3; j<tokens.length; j++) {
int total = Integer.parseInt(tokens[j]);
//See if Googler points are > p not surprising
int bestNotSurprising = total/3 + (total%3 != 0 ? 1 : 0);
if(bestNotSurprising >= p) {
googlersGreaterP++;
continue;
}
//See if Googler points are > p surprising
if(surprising > 0) {
int add = 0;
if(total%3 == 0) {
add = 1;
} else if(total%3 == 2) {
add = 2;
}
int bestSurprising = total == 0 ? 0 : total/3 + add;
if(bestSurprising >= p) {
googlersGreaterP++;
surprising--;
}
}
}
line += googlersGreaterP + "\n";
output.append(line);
}
r.close();
FileWriter fw = new FileWriter("output_dancing.txt");
fw.write(output.toString());
fw.flush();
fw.close();
}
}
| 0 | 1,189,226 |
A11759 | A12366 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
public class Dancing {
Map<Integer, Map<Integer, Boolean>> bestResultsMap;
public static void main(String[] args) {
String inFile = args[0];
//String inFile = "resources/B-small-attempt0.in";
try {
new Dancing().countGooglers(inFile, inFile+".out");
} catch (Exception e) {
e.printStackTrace();
}
}
public void countGooglers(String inFile, String outFile) throws NumberFormatException, IOException{
StringBuffer out = new StringBuffer();
BufferedReader br = new BufferedReader(new FileReader(new File(inFile)));
String line;
int currentLineNumber = 0;
int totalTestCases = 0;
while((line = br.readLine()) != null) {
if(currentLineNumber == 0){
totalTestCases = Integer.valueOf(line);
currentLineNumber++;
continue;
}
String[] tokenizedLine = line.split(" ");
int numberOfGooglers = Integer.valueOf(tokenizedLine[0]);
int suprisingTriplets = Integer.valueOf(tokenizedLine[1]);
int minBestResult = Integer.valueOf(tokenizedLine[2]);
/*
System.out.println("numberOfGooglers"+numberOfGooglers);
System.out.println("suprisingTriplets"+suprisingTriplets);
System.out.println("minBestResult"+minBestResult);
System.out.println("tokenizedLine length: "+tokenizedLine.length);
*/
int[] resultTotals = new int[tokenizedLine.length - 3 ];
for(int i = 3; i < tokenizedLine.length; i++){
resultTotals[i-3] = Integer.valueOf(tokenizedLine[i]);
}
int googlers = calculateMaxGooglersForBestResult(numberOfGooglers, suprisingTriplets, minBestResult, resultTotals);
out.append("Case #"+currentLineNumber+": "+googlers +System.getProperty("line.separator"));
currentLineNumber++;
}
writeTextToFile(out.toString(), outFile);
}
private int calculateMaxGooglersForBestResult(int numberOfGooglers, int suprisingTriplets, int minBestResult, int[] totalPoints){
int googlerCount = 0;
int surprisedTriplets = 0;
for (int totalPoint : totalPoints) {
if(totalPoint < minBestResult){
continue;
}
int twoResults = totalPoint - minBestResult;
int r1 = twoResults / 2;
int r2 = twoResults - r1;
int apart = getMaxApart(minBestResult, r1, r2);
if(apart < 2){
googlerCount++;
}else if(apart == 2){
if(surprisedTriplets < suprisingTriplets){
surprisedTriplets++;
googlerCount++;
}
}
//System.out.println("tot: "+totalPoint +" minbest "+minBestResult+" surp: "+suprisingTriplets+"-> "+minBestResult +":"+r1+":"+r2 +" apart: "+apart);
}
return googlerCount;
}
private int getMaxApart(int r1, int r2, int r3){
int apart = 0;
if(Math.abs(r1-r2) > Math.abs(apart)) apart = r1-r2;
if(Math.abs(r3-r3) > Math.abs(apart)) apart = r2-r3;
if(Math.abs(r1-r3) > Math.abs(apart)) apart = r1-r3;
return apart;
}
private void writeTextToFile(String text, String outputFileName) throws IOException{
BufferedWriter out = new BufferedWriter(new FileWriter(outputFileName));
out.write(text);
out.close();
}
}
| 0 | 1,189,227 |
A11759 | A11630 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 DancingWithGooglers {
public static class Googlers {
public int T;
public int surp;
public boolean surprising;
public boolean pSurprising;
public boolean antiSurprising;
public boolean pAntiSurprising;
public Googlers(int T, int surp) {
this.T = T;
this.surp = surp;
}
public void set(int a, int b, int c) {
if (c >= 0 && (a + b + c) == T) {
int diff = (Math.max(a, Math.max(b, c)) - Math.min(a, Math.min(b, c)));
if (diff <= 2) {
if (diff == 2) {
if (a >= surp || b >= surp || c >= surp) {
pSurprising = true;
} else {
surprising = true;
}
} else {
if (a >= surp || b >= surp || c >= surp) {
pAntiSurprising = true;
} else {
antiSurprising = true;
}
}
}
}
}
}
public static void main(String... args) throws IOException {
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedReader reader = new BufferedReader(new FileReader("B-small-attempt0.in"));
// PrintWriter writer = new PrintWriter(System.out);
PrintWriter writer = new PrintWriter("B-small-attempt0.out");
int len, cases = Integer.parseInt(reader.readLine());
List<Googlers> satisfied = new ArrayList<Googlers>();
List<Googlers> unsatisfied = new ArrayList<Googlers>();
String[] inputs;
int N, S, p;
for (int i = 1; i <= cases; i++) {
inputs = reader.readLine().split(" ");
p = Integer.parseInt(inputs[1]);
S = Integer.parseInt(inputs[2]);
satisfied.clear();
unsatisfied.clear();
for (int j = 3; j < inputs.length; j++) {
int t = Integer.parseInt(inputs[j]);
Googlers googlers = new Googlers(t, S);
for (int k = 0; k <= 10; k++) {
int till = k + 2 > 10 ? 10 : k + 2;
for (int l = k; l <= till; l++) {
googlers.set(k, l, (t - (k + l)));
}
}
if (googlers.pAntiSurprising) {
satisfied.add(googlers);
} else {
unsatisfied.add(googlers);
}
}
int pSurprising = 0;
if (p > 0) {
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
pSurprising++;
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
iter.remove();
pSurprising++;
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
writer.print("Case #" + i + ": 0");
}else {
writer.print("Case #" + i + ": " + (satisfied.size() + pSurprising));
}
writer.println();
}
writer.flush();
}
}
| 0 | 1,189,228 |
A11759 | A11700 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Main {
public static void main(String args[]) {
(new Main()).solve();
}
void solve() {
Scanner cin = new Scanner(System.in);
int T = cin.nextInt();
for(int C=1; C<=T; ++C) {
int N = cin.nextInt();
int S = cin.nextInt();
int P = cin.nextInt();
int arr[] = new int[N];
for(int i=0; i<N; ++i) { arr[i] = cin.nextInt(); }
int dp[][] = new int[N+1][S+1];
for(int i=0; i<=N; ++i) {
for(int j=0; j<=S; ++j) {
dp[i][j] = -1;
}
}
dp[0][0] = 0;
for(int i=0; i<N; ++i) {
int V = arr[i];
for(int j=0; j<=S; ++j) {
if( dp[i][j] == -1 ) { continue; }
for( int d = 0; d <= (j < S ? 2 : 1); ++d ) {
for(int k=0; k<=10; ++k) {
if( k + d > 10 ) { continue; }
int rest = V - k - k - d;
if( k <= rest && rest <= (k + d) ) {
int gain = (k + d >= P) ? 1 : 0;
int s = d == 2 ? 1 : 0;
dp[i + 1][j + s] = Math.max(dp[i + 1][j + s], dp[i][j] + gain);
}
}
}
}
}
System.out.println("Case #" + C + ": " + dp[N][S]);
}
}
}
| 0 | 1,189,229 |
A11759 | A12216 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.google.codejam;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class GooglerDanceSolver {
public static int getMaximumPassCount(int passScore, int surpriseCount, List<Integer> scores) {
int passCount = 0;
int lowerBound = (passScore > 1) ? 3 * passScore - 4 : passScore;
for (int score : scores) {
if (score < lowerBound) {
continue;
} else if (score > 3 * passScore - 3) {
passCount++;
} else if (surpriseCount > 0) {
passCount++;
surpriseCount--;
}
}
return passCount;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
int totalCount = Integer.parseInt(scanner.nextLine());
for (int i = 0; i < totalCount; i++) {
String[] inputs = scanner.nextLine().split(" ");
int n = Integer.parseInt(inputs[0]);
int s = Integer.parseInt(inputs[1]);
int p = Integer.parseInt(inputs[2]);
List<Integer> scores = new ArrayList<Integer>(n);
for (int j = 0; j < n; j++) {
scores.add(Integer.parseInt(inputs[j+3]));
}
int answer = GooglerDanceSolver.getMaximumPassCount(p, s, scores);
System.out.printf("Case #%d: %d%n", i+1, answer);
//System.err.printf("[Debug Info] p=%d, s=%d, scores=%s%n", p, s, scores.toString());
}
}
}
| 0 | 1,189,230 |
A11759 | A11182 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
public class DancingGooglers {
/**
* @param args
*/
public int maxDancer(int N,int S,int p,int score[])
{
int maxNo=0;
int q=p-1;
int A,B,C;
for (int i = 0; i < N; i++) {
int X=score[i];
A=X/3;
B=(X-A)/2;
C=X-(A+B);
//System.out.println("X="+X+"A="+A+"B="+B+"C="+C);
if(A>=p || B>=p || C>=p)
maxNo++;
else
{
if(S>0 && X!=0)
{
if(A==q)
{
if(B==q || C==q)
{
maxNo++;
S--;
}
}
else
{
if(B==q && C==q)
{
maxNo++;
S--;
}
}
}
}
}
//System.out.println(maxNo);
return maxNo;
}
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
DancingGooglers dg=new DancingGooglers();
FileInputStream fis = new FileInputStream("c:/small.txt");
DataInputStream dis = new DataInputStream(fis);
BufferedReader br = new BufferedReader(new InputStreamReader(dis));
FileWriter fstream = new FileWriter("c:/out.txt");
BufferedWriter out = new BufferedWriter(fstream);
String str=br.readLine();
int[] score=new int[100];
int T=Integer.parseInt(str);
int maxNo=0;
int S=0,p=0;
int caseNo=1;
int N=0;
while( (str = br.readLine()) != null && T>0)
{
if(caseNo>1)
out.newLine();
String[] line=str.split(" ");
N=Integer.parseInt(line[0]);
S=Integer.parseInt(line[1]);
p=Integer.parseInt(line[2]);
for (int i = 3,j=0; i < line.length; i++,j++) {
score[j]=Integer.parseInt(line[i]);
}
maxNo=dg.maxDancer(N,S, p, score);
out.write("Case #"+caseNo+": "+maxNo);
caseNo++;
T--;
}
//Close the output stream
out.close();
}
}
| 0 | 1,189,231 |
A11759 | A10771 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileInputStream;
import java.io.InputStreamReader;
public class Dance {
public int run ( int N, int S, int p, int[] G ) {
int results = 0;
java.util.Arrays.sort( G );
for( int i = G.length -1; i >= 0; --i ) {
int t = G[ i ];
int r = t % 3;
int x = t / 3;
if ( r == 0 ) {
// x + x + x
// ( x + 1 ) + x + ( x -1 ) ***
if ( x >= p ) {
++results;
continue;
}
if ( t > 0 && x + 1 >= p && S > 0) {
--S;
++results;
continue;
}
break;
}
if ( r == 1 ) {
// ( x + 1) + x + x
// No surpising because max range 2 ***
if ( x + 1 >= p ) {
++results;
continue;
}
break;
}
if ( r == 2 ) {
// ( x + 1) + (x + 1) + x
// ( x + 2 ) + x + x
if ( x + 1 >= p ) {
++results;
continue;
}
if ( x + 2 >= p && S > 0) {
--S;
++results;
continue;
}
break;
}
}
return results;
}
public Dance( String input ) throws Exception {
FileInputStream fstream = new FileInputStream(input);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
int t = Integer.parseInt( br.readLine() );
for( int i = 1; i <= t; i++ ) {
String test = br.readLine();
String[] tokens = test.split( " " );
int N = Integer.parseInt( tokens[0] );
int S = Integer.parseInt( tokens[1] );
int p = Integer.parseInt( tokens[2] );
int[] G = new int[N];
for( int j = 0; j < N; ++j ) {
G[ j ] = Integer.parseInt( tokens[ 3 + j ] );
}
System.out.print( "Case #" );
System.out.print( i );
System.out.print( ": " );
System.out.println( run( N, S, p, G ) );
}
in.close();
}
public static void main( String[] args ) throws Exception {
new Dance( "dance-test.in" );
}
}
| 0 | 1,189,232 |
A11759 | A12180 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 hk.polyu.cslhu.codejam;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import hk.polyu.cslhu.codejam.lib.FileStream;
import hk.polyu.cslhu.codejam.lib.ResultCollector;
import hk.polyu.cslhu.codejam.solution.Solution;
import hk.polyu.cslhu.codejam.solution.impl.StoreCredit;
import hk.polyu.cslhu.codejam.solution.impl.qualificationround.DancingWithTheGooglers;
import hk.polyu.cslhu.codejam.solution.impl.qualificationround.SpeakingInTongues;
import hk.polyu.cslhu.codejam.thread.JamThreadManager;
/**
* Hello world!
*
*/
public class App
{
public static Logger logger = Logger.getLogger(App.class);
public List<List<String>> getTestCaseList(String filePath) {
List<List<String>> testCaseList = new ArrayList<List<String>>();
List<String> content = FileStream.read(filePath);
logger.info("The amount of lines: " + content.size());
logger.info("The amount of test cases: " + content.get(0));
for (int i = 1; i < content.size(); i++)
testCaseList.add(content.subList(i, i + 1));
return testCaseList;
}
public static void main( String[] args )
{
String filePath = "C:\\Users\\Allen HU\\Dropbox\\Misc\\B-small-attempt0.in";
String resultFile = filePath + ".result";
String resultPattern = "Case #" + ResultCollector.IndexPartInRow + ": " + ResultCollector.ResultPartInRow + "\n";
boolean allowMultiThreads = false;
List<List<String>> testCaseList = new App().getTestCaseList(filePath);
Solution solution = new DancingWithTheGooglers();
JamThreadManager jtm = new JamThreadManager(solution, testCaseList, resultFile, resultPattern, allowMultiThreads);
try {
jtm.runThreads();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
| 0 | 1,189,233 |
A11759 | A11137 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.google.codejam;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class Main {
/**
* @param args
* @throws FileNotFoundException
*/
static Scanner in;
static BufferedWriter writer;
public static void main(String[] args) throws IOException {
in = new Scanner(new File("src/B-small-attempt0.in"));
writer = new BufferedWriter(new FileWriter(new File("src/b.out")));
int T = in.nextInt();
for (int i = 1; i <= T; i++) {
int N = in.nextInt();
int S = in.nextInt();
int P = in.nextInt();
int[] t = new int[N];
for (int j = 0; j < N; j++) {
t[j] = in.nextInt();
}
solveCase(i, N, S, P, t);
}
writer.close();
}
public static int solveCase(int TEST_CASE, int N, int S, int P, int[] t) throws IOException {
int ans = 0;
int minSc = 3*P-2;
int minScSup = (P==1)?1:3*P-4;
int validCom = 0;
int validSup = 0;
for (int i = 0; i < t.length; i++) {
if(t[i]>=minSc)
validCom++;
else if (t[i]<minSc && t[i]>=minScSup) {
validSup++;
}
}
if(validSup<=S) ans = validCom + validSup;
else {
ans = validCom + S;
}
writer.write("Case #" + TEST_CASE + ": " + ans);
writer.newLine();
return 0;
}
}
| 0 | 1,189,234 |
A11759 | A11251 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | /**
* Copyright 2012 Christopher Schmitz. All Rights Reserved.
*/
package com.isotopeent.codejam.lib;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
public class SolutionWriter extends PrintWriter {
private static final String FORMAT = "Case #%1$s: %2$s%n";
private String[] args = new String[2];
public SolutionWriter(File file) throws FileNotFoundException {
super(file);
}
public void writeSolution(int caseNumber, String solution) {
args[0] = Integer.toString(caseNumber);
args[1] = solution;;
printf(FORMAT, (Object[]) args);
}
}
| 0 | 1,189,235 |
A11759 | A11120 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 jam;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class CodeJam2012Q2 {
public static void main(String [] args){
final String FILE_NAME="B-small-attempt0.in";
StringTokenizer st;
//IOUsage Variables
String lineIn="";
int numCases=0;
//Index Variables
//Contest Vars
int numGooglers = 0;
int numSurprising = 0;
int atLeastResult = 0;
int[] googlerScores;
int numGP = 0;
try
{
BufferedReader br = new BufferedReader(new FileReader(FILE_NAME));
lineIn = br.readLine();
numCases = Integer.parseInt(lineIn);
for(int i=0; i<numCases; i++)
{
lineIn = br.readLine();
st = new StringTokenizer(lineIn);
numGooglers = Integer.parseInt(st.nextToken());
numSurprising = Integer.parseInt(st.nextToken());
atLeastResult = Integer.parseInt(st.nextToken());
googlerScores = new int[numGooglers];
for(int j=0; j<numGooglers; j++)
{
googlerScores[j] = Integer.parseInt(st.nextToken());
}
for(int j=0; j<numGooglers; j++)
{
if(googlerScores[j]==0)
{
if(atLeastResult==0)
{
numGP++;
}
}
else if(googlerScores[j]==1)
{
if(atLeastResult==0 || atLeastResult==1)
{
numGP++;
}
}
else if(googlerScores[j]==2)
{
if(atLeastResult==0 || atLeastResult==1)
{
numGP++;
}
else if(atLeastResult==2)
{
if(numSurprising>0)
{
numGP++;
numSurprising--;
}
}
}
else
{
if((googlerScores[j] % 3) == 0)
{
if((googlerScores[j]/3) - atLeastResult > -1 )
{
numGP++;
}
else if((((googlerScores[j]/3) - atLeastResult) == -1) && numSurprising>0)
{
numGP++;
numSurprising--;
}
}
else if((googlerScores[j] % 3) == 1)
{
if (((googlerScores[j]/3)+1) - atLeastResult >= 0)
{
numGP++;
}
}
else if((googlerScores[j] % 3) == 2)
{
if((googlerScores[j]/3) - atLeastResult + 1 > -1 )
{
numGP++;
}
else if((((googlerScores[j]/3) - atLeastResult + 1) == -1) && numSurprising>0)
{
numGP++;
numSurprising--;
}
}
}
}
System.out.println("Case #"+(i+1)+": "+numGP);
numGP=0;
}
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
}
}
| 0 | 1,189,236 |
A11759 | A11115 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.googlecode.codejam.model;
import java.util.Iterator;
import java.util.concurrent.Callable;
public abstract class JamCaseResolverFactory {
public abstract Callable<String> newJamCaseResolver(int caseNumber, Iterator<String> lineIterator);
}
| 0 | 1,189,237 |
A11759 | A11394 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
import javax.imageio.IIOException;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author abood
*/
public class proba {
public static void main(String[] args) throws IIOException, FileNotFoundException, IOException{
//String alpha="abcdefghojklmnopqrstuvwxyzabcdefghojklmnopqrstuvwxyz";
BufferedReader br =new BufferedReader(new FileReader("A-small-attempt0.in"));
PrintWriter out =new PrintWriter(new BufferedWriter(new FileWriter("A-small-attempt0.out")));
int loop=Integer.parseInt(br.readLine());
StringTokenizer st;
for (int i = 1; i <= loop; i++) {
int res=0;
st=new StringTokenizer(br.readLine());
int n=Integer.parseInt(st.nextToken());
int s=Integer.parseInt(st.nextToken());
int p=Integer.parseInt(st.nextToken());
for (int j = 0; j < n; j++) {
int x=Integer.parseInt(st.nextToken());
if(x<p)continue;
x-=p;
x/=2;
if(x>=p-1)res++;
else if(x==p-2){
if(s>0){res++;s--;}
}
}
//System.out.println("Case #"+i+": "+res);
out.println("Case #"+i+": "+res);
}
out.close();
System.exit(0);
}
}
| 0 | 1,189,238 |
A11759 | A12650 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.io.InputStreamReader;
import java.util.Scanner;
public class Dancing {
public static void main(String[] args) throws NumberFormatException, IOException {
Scanner read = new Scanner(new InputStreamReader(System.in));
int cases = Integer.parseInt(read.next());
int counter =1;
while(cases>0){
int n = Integer.parseInt(read.next());
int s = Integer.parseInt(read.next());
int p = Integer.parseInt(read.next());
int bests = 0;
int p2 =0;
int googler;
for(int i=0; i<n; i++){
googler = Integer.parseInt(read.next());
int x = googler/3;
if(googler == 1 || googler ==2 || googler == 0 ){
if(googler == 1 && 1>=p)
bests++;
else if(googler == 2){
if(1>=p)
bests++;
else if(2 >= p && p2<s){
bests++;
p2++;
}
}else if( googler == 0 && 0>=p)
bests++;
}else{
if((x*3) == googler){
if(x>=p)
bests++;
else if((x+1)>= p && p2<s){
bests++;
p2++;
}
}else if((x+x+x+1)== googler){
if((x+1) >= p )
bests++;
}else if((x+x+x+2) == googler){
if((x+1)>=p)
bests++;
else if((x+2)>=p && p2<s){
bests++;
p2++;
}
}
}
}
System.out.println("Case #"+counter+": "+bests);
cases--;
counter++;
}
}
}
| 0 | 1,189,239 |
A11759 | A10310 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
public class CodeJam2
{
private class Data
{
private int num;
private int surprise;
private int threshold;
private Integer[] values;
public Data(int num, int surprise, int threshold, Integer[] values)
{
this.num = num;
this.surprise = surprise;
this.threshold = threshold;
this.values = values;
}
public int getNum()
{
return num;
}
public int getSurprise()
{
return surprise;
}
public int getThreshold()
{
return threshold;
}
public Integer[] getValues()
{
return values;
}
public String toString()
{
return num + " " + surprise + " " + threshold + " " + values.length;
}
}
private List<Data> getInputValue()
{
List<Data> inpVal = new ArrayList<Data>();
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
try
{
final String tc_ = stdin.readLine();
Integer testCase = Integer.parseInt(tc_);
while (testCase-- > 0)
{
// System.err.println("tc#" + testCase);
final String[] input = stdin.readLine().split(" ");
int num = Integer.parseInt(input[0]);
Integer[] values = new Integer[num];
for (int i = 3; i < input.length; ++i)
values[i - 3] = Integer.parseInt(input[i]);
Data data = new Data(num, Integer.parseInt(input[1]), Integer.parseInt(input[2]), values);
inpVal.add(data);
}
return inpVal;
}
catch (IOException e)
{
e.printStackTrace();
}
return null;
}
private static int getMaxWOSurprise(int a)
{
if (a % 3 == 0)
return a / 3;
else
return (a / 3) + 1;
}
private static int getMaxWithSurprise(int a)
{
if (a == 0)
return -1;
else if ((a % 3) == 0)
return (a / 3) + 1;
else if (a % 3 == 1)
return -1;
else
return (a / 3) + 2;
}
private static Integer[] sort(Integer[] arr)
{
for (int i = 0; i < arr.length - 1; ++i)
for (int j = i + 1; j < arr.length; ++j)
if (arr[i] < arr[j])
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
return arr;
}
public static void main(String[] args)
{
CodeJam2 cj = new CodeJam2();
List<Data> inp = cj.getInputValue();
// System.err.println(inp);
// System.err.println(getMaxWithSurprise(15));
int count = 1;
// operating for each tc
for (Data data : inp)
{
int surprise = data.getSurprise();
int threshold = data.getThreshold();
int answer = 0;
Integer[] scores = sort(data.getValues());
for (Integer score : scores)
{
// System.err.println(score + " " + getMaxWithSurprise(score) +
// " " + getMaxWOSurprise(score));
if (getMaxWOSurprise(score) >= threshold)
answer++;
else if (surprise > 0 && getMaxWithSurprise(score) >= threshold)
{
answer++;
surprise--;
}
}
System.out.println("Case #" + count++ + ": " + answer);
}
// System.err.println(cj.generateCombination(24, 40));
}
}
| 0 | 1,189,240 |
A11759 | A10147 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.FileInputStream;
import java.util.Scanner;
// Dancing With the Googlers
// https://code.google.com/codejam/contest/1460488/dashboard#s=p1
public class B {
private static String process(Scanner in) {
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int notsurp = 0;
int surp = 0;
for(int i = 0; i < N; i++) {
int t = in.nextInt();
if ( p * 3 <= t + 2 && t >= p )
notsurp++;
else if ( p * 3 <= t + 4 && t >= p )
surp++;
}
return Integer.toString(notsurp + (surp <= S ? surp : S));
}
public static void main(String[] args) throws Exception {
Scanner in = new Scanner(System.in.available() > 0 ? System.in :
new FileInputStream(Thread.currentThread().getStackTrace()[1].getClassName() + ".practice.in"));
int T = in.nextInt();
for(int i = 1; i <= T; i++)
System.out.format("Case #%d: %s\n", i, process(in));
}
}
| 0 | 1,189,241 |
A11759 | A12390 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 glycine.gcj2012.qr;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ProblemB {
private static Map<Integer, Integer> normal = new HashMap<Integer, Integer>();
private static Map<Integer, Integer> surprise = new HashMap<Integer, Integer>();
private static void init() {
for (int i = 0; i <= 1; ++i) {
normal.put(new Integer(i), new Integer(i));
surprise.put(new Integer(i), new Integer(i));
}
for (int i = 2; i <= 10; ++i) {
normal.put(new Integer(i), new Integer((i - 1) * 3 + 1));
surprise.put(new Integer(i), new Integer((i - 2) * 3 + 2));
}
}
private static int solve(int n, int s, int th, List<Integer> valList) {
Integer normalThMin = normal.get(new Integer(th));
Integer surpriseThMin = surprise.get(new Integer(th));
// System.out.println("normalThMin = " + normalThMin +
// ": surpriseThMin = " + surpriseThMin);
int count = 0;
int index;
for (index = valList.size() - 1; index >= 0; --index) {
if (valList.get(index) < normalThMin)
break;
++count;
}
int indexDiff;
for (indexDiff = 0; indexDiff < s; ++indexDiff) {
if (index - indexDiff < 0)
break;
if (valList.get(index - indexDiff) < surpriseThMin)
break;
++count;
}
return count;
}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
if (args.length != 1) {
System.err.println("Usage: <program> inputFilename");
return;
}
init();
BufferedReader reader = new BufferedReader(new FileReader(args[0]));
String line = reader.readLine();
int times = Integer.parseInt(line);
List<Integer> valList = new ArrayList<Integer>();
for (int i = 0; i < times; ++i) {
line = reader.readLine();
String[] tokens = line.split(" ");
int n = Integer.valueOf(tokens[0]);
int s = Integer.valueOf(tokens[1]);
int th = Integer.valueOf(tokens[2]);
valList.clear();
for (int j = 0; j < n; ++j) {
valList.add(new Integer(tokens[j + 3]));
}
Collections.sort(valList);
int result = solve(n, s, th, valList);
System.out.println("Case #" + (i + 1) + ": " + result);
}
}
}
| 0 | 1,189,242 |
A11759 | A10971 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
public class dancing {
static String next() {
if (st == null || !st.hasMoreTokens())
nextLine();
return st.nextToken();
}
static int nextInt() {
return Integer.parseInt(next());
}
static void nextLine() {
try {
st = new StringTokenizer(f.readLine());
} catch (Exception e) {
e.printStackTrace();
}
}
static StringTokenizer st;
static PrintWriter out;
static BufferedReader f;
public static void main(String[] args) throws IOException {
String progName = (dancing.class.getCanonicalName()) + ".out";
f = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
out = new PrintWriter(new BufferedWriter(new FileWriter(progName)));
int T = nextInt();
for (int test = 1; test <= T; test++) {
int N = nextInt(), S = nextInt(), p = nextInt();
int a = 3 * p - 4, b = 3 * p - 2;
if (p == 1)
a = 1;
int count = 0;
for (int i = 0; i < N; i++) {
int x = nextInt();
if (x >= b) {
count++;
} else if (x >= a && S > 0) {
S--;
count++;
}
}
out.printf("Case #%d: %d\n", test, count);
}
out.close();
// System.exit(0);
}
} | 0 | 1,189,243 |
A11759 | A12481 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 QualB {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int z = Integer.parseInt(br.readLine());
int[] u = {0, 0, 3, 6, 9, 12, 15, 18, 21, 24, 27};
int[] ul = {0, 0, 1, 4, 7, 10, 13, 16, 19, 22, 25};
for(int i=0; i<z; i++){
String[] s = br.readLine().split("\\s+");
int n = Integer.parseInt(s[0]);
int ss = Integer.parseInt(s[1]);
int p = Integer.parseInt(s[2]);
int l = 3 + n;
int index = 0;
int[] arr = new int[n];
for(int j=3; j<l; j++){
arr[index] = Integer.parseInt(s[j]);
index++;
}
if(p == 0){
System.out.println("Case #" + (i+1) + ": " + n);
}else{
int ctr = 0;
for(int j=0; j<n; j++){
int t = arr[j];
if(t > u[p]){
ctr++;
}else if(t > ul[p] && ss > 0){
ss--;
ctr++;
}
}
System.out.println("Case #" + (i+1) + ": " + ctr);
}
}
}
}
| 0 | 1,189,244 |
A11759 | A13087 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Triplet
{
public static void main (String [] args) throws IOException
{
BufferedReader in = new BufferedReader(new FileReader("B-small-attempt0.in"));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("B-small-attempt0.out")));
StringTokenizer st = new StringTokenizer(in.readLine());
int numCases = Integer.parseInt(st.nextToken());
for (int i = 0; i < numCases; i++)
{
out.print("Case #" + (i+1) + ": ");
st = new StringTokenizer(in.readLine());
int n = Integer.parseInt(st.nextToken());
int numSurprisings = Integer.parseInt(st.nextToken());
int P = Integer.parseInt(st.nextToken());
int min = 0;
int minNoSurprising = 0;
if (P > 1)
{
min = 3*P - 4;
minNoSurprising = 3*P - 2;
}
else if (P == 1)
{
min = 1;
minNoSurprising = 1;
}
else
{
min = 0;
minNoSurprising = 0;
}
int[] totalPoint = new int[n];
for (int j = 0; j < n; j++)
{
totalPoint[j] = Integer.parseInt(st.nextToken());
}
int maxCandidateWithNoSurprisings = 0;
int maxCandidateWithSurprisings = 0;
for (int j = 0; j < n; j++)
{
if (totalPoint[j] >= minNoSurprising)
{
maxCandidateWithNoSurprisings++;
}
else if (totalPoint[j] >= min)
{
maxCandidateWithSurprisings++;
}
}
if (maxCandidateWithSurprisings <= numSurprisings)
{
out.print((maxCandidateWithNoSurprisings + maxCandidateWithSurprisings));
}
else
{
out.print((maxCandidateWithNoSurprisings + numSurprisings));
}
out.println();
}
out.close();
}
} | 0 | 1,189,245 |
A11759 | A12469 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
public final class Googlers {
/**
* @param args
*/
public static void main(String[] args) {
// * /3 %3
// 0 0 000 0 0
// 1 1 100 0 1
// 2 1 2 110 200* 0 2
// 3 1 2 111 210* 1 0
// 4 2 2 112 022* 1 1
// 5 2 3 122 113* 1 2
// 6 2 3 222 123* 2 0
// 7 3 3 223 133* 2 1
// 8 3 4 233 224* 2 2
// 9 3 4 333 234* 3 0
// ...
// 28 10 10 9 9 10 9 1
// 29 10 10 9 10 10 9 2
// 30 10 10 10 0
// max = x/3 + x%3>=1
// *max = x/3 + x%3=2
//prepare table
int[][] max = new int[31][2];
max[0][0] = 0;
max[0][1] = 0;
for (int i = 1; i <=27; i++) {
int quotient = i / 3;
int reminder = i % 3;
max[i][0] = quotient + (reminder>=1?1:0);
max[i][1] = quotient + (reminder==2?2:1);
}
max[28][0] = 10;
max[28][1] = 10;
max[29][0] = 10;
max[29][1] = 10;
max[30][0] = 10;
max[30][1] = 10;
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("solution.txt")));
int count = 1;
int cases = Integer.valueOf(br.readLine());
String input;
while (((input = br.readLine()) != null) && (count <= cases)) {
String output = "Case #"+(count++)+": "+process(input, max);
System.out.println(output);
bw.write(output);
bw.newLine();
}
} catch (Exception e) {// Catch exception if any
System.err.println("Error: " + e.getMessage());
} finally {
if (br!=null) try { br.close(); } catch(IOException e) {}
if (bw!=null) try {
bw.flush();
bw.close();
} catch(IOException e) {}
}
}
private static final int process(String input, int[][] max) {
String[] s = input.split(" ");
int N = Integer.valueOf(s[0]);
int S = Integer.valueOf(s[1]);
int p = Integer.valueOf(s[2]);
//int t[] = new int[N];
int count = 0;
for (int i = 0; i < N; i++) {
int t = Integer.valueOf(s[i+3]);
if (max[t][0] >= p) count++;
else if (S > 0 && max[t][1] >= p) {
count++;
S--;
}
}
return count;
}
}
| 0 | 1,189,246 |
A11759 | A12820 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
public class Googlers {
static int judgeGooglersNum(String input) {
int result = 0;
String[] s = input.split(" ");
int N = Integer.parseInt(s[0]);
int S = Integer.parseInt(s[1]);
int p = Integer.parseInt(s[2]);
int total = p > 0 ? p + (p - 1) + (p - 1) : 0;
int totalS = p > 1 ? p + (p - 2) + (p - 2) : total;
// System.out.println(N + "," + S + "," + p + "," +
// total + "," + totalS);
for(int i = 3; i < N + 3; i++) {
int now = Integer.parseInt(s[i]);
if(now >= total || (now >= totalS && S-- > 0)) {
result++;
}
}
return result;
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("src/B-small-attempt0.in"));
BufferedWriter bw = new BufferedWriter(new FileWriter("src/B-small.out"));
int T = Integer.parseInt(br.readLine());
for(int i = 0; i < T; i++) {
bw.write("Case #" + (i+1) + ": " +
judgeGooglersNum(br.readLine()));
bw.newLine();
}
bw.flush();
bw.close();
br.close();
}
}
| 0 | 1,189,247 |
A11759 | A12107 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package Codejam2012;
import java.io.*;
/**
*
* @author Brian
*/
public class googlers {
public static void main(String [] args) throws FileNotFoundException, IOException{
String data;
String printout="";
String [] output;
int numOfGooglers;
int numOfSurprising;
int leastScore;
int [] scores;
String [] splitData;
String inputFileName = "C:/input/googlersIn.txt";
String outputFileName = "C:/input/googlersOut.txt";
BufferedReader reader = new BufferedReader(new FileReader(inputFileName));
FileWriter out = new FileWriter(outputFileName);
PrintWriter print = new PrintWriter(out);
data = reader.readLine();
int size = Integer.parseInt(data);
output = new String[size];
data = reader.readLine();
int k =0;
while(data!=null){
splitData = data.split("\\s");
numOfGooglers = Integer.parseInt(splitData[0]);
numOfSurprising = Integer.parseInt(splitData[1]);
leastScore = Integer.parseInt(splitData[2]);
scores = new int[numOfGooglers];
for(int b=3;b<splitData.length;b++){
scores[b-3] = Integer.parseInt(splitData[b]);
}
int diff = leastScore-2;
if(diff<0){
diff = 0;
}
int total = 0;
int greatCount =0;
int outSide = 0;
int obvious = 0;
int minScore = leastScore + (diff*2);
int minScore_alt = leastScore + ((leastScore-1)*2);
if(numOfSurprising==0){
if(leastScore==1){
minScore = 1;
}
else{
if(leastScore==0){
minScore = 0;
}
else{
//minScore += 2;
minScore = leastScore + ((leastScore-1)*2);
}
}
for(int a=0;a<numOfGooglers;a++){
if(scores[a] >= minScore){
total ++;
}
}
}
else{
for(int a=0;a<numOfGooglers;a++){
if(scores[a]>=minScore){
greatCount++;
}
if(scores[a]>=minScore_alt){
obvious++;
}
}
// for(int a=0;a<numOfGooglers;a++){
// if(scores[a]>=2 && scores[a]<minScore){
// outSide++;
// }
// }
if(greatCount-obvious>=numOfSurprising){
total = obvious + numOfSurprising;
}
else{
total = greatCount;
}
}
output[k++] = String.valueOf(total);
data = reader.readLine();
}
for(int p=0; p<output.length;p++){
printout += "Case #"+(p+1)+": "+output[p]+"\n";
}
print.println(printout);
print.close();
reader.close();
}
}
| 0 | 1,189,248 |
A11759 | A12777 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.ArrayList;
public class Logic {
public static void solve() {
//First input line
//Texter.readLine();
int noOfCases = Integer.valueOf(Texter.readLine());
//Texter.writeText("Output");
for (int i = 1; i <= noOfCases; i++) {
int caseNo = i;
String nextLine = Texter.readLine();
if (nextLine == null) {
nextLine = Texter.readLine();
System.out.println("HHH");
}
System.out.println("HHHsda");
ArrayList<Integer> numbers = Texter.parseNumberList(nextLine);
//ArrayList<Integer> numbers = (ArrayList<Integer>) numbersOrig.clone();
ArrayList<Integer[]> triplets = new ArrayList<Integer[]>();
int noOfGooglers = numbers.get(0);
int surprises = numbers.get(1);
int minBest = numbers.get(2);
numbers.remove(0);
numbers.remove(0);
numbers.remove(0);
for (int q = 0; q < noOfGooglers; q++) {
int curScore = numbers.get(q);
triplets.add(crunch(curScore));
}
int[] surpriseIndexes = new int[surprises];
//Count how many above min
int answer = 0;
for (int z = 0; z < numbers.size(); z++) {
if (triplets.get(z)[0] >= minBest) {
answer++;
}
}
//Loop number of surprises
ArrayList<Integer> triedOnes = new ArrayList<Integer>();
for (int t = 0; t < surprises; t++) {
Integer[] reCrunched = null;
//while (reCrunched == null) {
for (int y = 0; y < triplets.size(); y++) {
int curMin = -1;
int surpriseIndex = -1;
//Find the highest one that is below min
//Start there
for (int r = 0; r < triplets.size(); r++) {
if (triedOnes.contains(r)) {
continue;
}
int highestNum = triplets.get(r)[0];
if (highestNum < minBest && highestNum > curMin) {
curMin = highestNum;
//surpriseIndexes[t] = r;
surpriseIndex = r;
}
}
//Remove so don't find again
//triplets.remove(surpriseIndex);
if (surpriseIndex == -1) {
break;
}
triedOnes.add(surpriseIndex);
//See if it can be made a surprise one
// + y to account for the number that have been removed
reCrunched = surpriseCrunch(numbers.get(surpriseIndex));
if (reCrunched != null) {
reCrunched = getHighest(reCrunched[0], reCrunched[1], reCrunched[2]);
}
//If still too low set to null so will continue looping
if (reCrunched != null) {
if (reCrunched[0] < minBest) {
reCrunched = null;
}
}
if (reCrunched != null) {
if (reCrunched[0] >= minBest) {
answer++;
break;
}
}
}
}
Texter.writeText("Case #" + caseNo + ": " + answer);
//int no = 15;
//triplets.add(crunch(no));
}
}
static Integer[] crunch(int score) {
/*for (int i = 10; i >= 0; i--) {
for (int q = 10; q >= 0; q--) {
for (int w = 10; w >= 0; w--) {*/
int i = 10;
int q = 10;
int w = 10;
while (true) {
if (i + q + w == score) {
return getHighest(i, q, w);
}
w--;
if (i + q + w == score) {
return getHighest(i, q, w);
}
q--;
if (i + q + w == score) {
return getHighest(i, q, w);
}
i--;
}
/*}
}
}*/
}
static Integer[] surpriseCrunch(int score) {
for (int i = 10; i >= 0; i--) {
for (int q = 10; q >= 0; q--) {
for (int w = 10; w >= 0; w--) {
if (i + q + w == score) {
if (checkSurprise(i, q, w)) {
return new Integer[] { i, q, w };
}
}
}
}
}
return null;
}
static boolean checkSurprise(int i, int q, int w) {
if (i >= 0 && q >= 0 && w >= 0) {
//Check if a diff of 2
if (i - q == 2 || i - w == 2 || q - i == 2 || q - w == 2 || w - i == 2 || w - q == 2) {
//No greater than 2 diff
if (i - q <= 2 && i - w <= 2 && q - i <= 2 && q - w <= 2 && w - i <= 2 && w - q <= 2) {
return true;
}
}
}
return false;
}
static Integer[] getHighest(int i, int q, int w) {
if (i >= q && i >= w) {
return new Integer[] { i, q, w };
}
if (q >= i && q >= w) {
return new Integer[] { q, i, w };
}
if (w >= i && w >= q) {
return new Integer[] { w, i, q };
}
return null;
}
}
| 0 | 1,189,249 |
A11759 | A10211 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.util.*;
import java.io.*;
public class DancingWithGooglers {
public static void main(String[] args) throws Exception
{
Scanner input = new Scanner(new File("C:\\temp\\B-small.in"));
int A = input.nextInt();
for (int c = 1; c <= A; c++)
{
int N = input.nextInt();
int S = input.nextInt();
int p = input.nextInt();
double[] t = new double[N];
for (int n = 0; n < N; n++)
{
t[n] = input.nextInt();
}
int a = 0;
for (int i = 0; i < t.length; i++)
{
for (int j = p; j <= 10; j++)
{
if (p == 0 && t[i] == 0)
{
a++;
break;
}
else if (j >= p && j*3-t[i] <= 2 && t[i] > j)
{
a++;
break;
}
else if (j >= p && j*3-t[i] <=4 && t[i] > j && S>0)
{
S--;
a++;
break;
}
}
}
System.out.println("Case #" + c + ": " + a);
}
}
}
| 0 | 1,189,250 |
A11759 | A10111 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 org.alaoui.googledance;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class App {
public static void main(String[] args) throws NumberFormatException,
IOException {
InputStream is = App.class
.getResourceAsStream("/org/alaoui/googledance/input/sample.in");
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String line;
int lineNumber = 0;
while ((line = br.readLine()) != null) {
if (lineNumber > 0) {
String[] lineArray = line.split(" ");
int s = Integer.parseInt(lineArray[1]);
int p = Integer.parseInt(lineArray[2]);
int okWithoutSurprise = 0;
int okWithSurprise = 0;
for (int i = 3; i < lineArray.length; i++) {
Dancer dancer = new Dancer(Integer.parseInt(lineArray[i]));
if (dancer.getMaxOrdinaryScore() >= p) {
okWithoutSurprise++;
} else if (dancer.getMaxSurprisingScore() != null
&& dancer.getMaxSurprisingScore() >= p) {
okWithSurprise++;
}
}
int result = okWithoutSurprise + Math.min(okWithSurprise, s);
System.out.println("Case #" + lineNumber + ": " + result);
}
lineNumber++;
}
br.close();
}
}
| 0 | 1,189,251 |
A11759 | A11947 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.nolmecolindor.gcj2012.round0;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;
public class Problem_B_0 {
private int solve(final Scanner input) {
final int N = input.nextInt();
final int S = input.nextInt();
final int P = input.nextInt();
final int[] points = new int[31];
for (int i = 0; i < N; i++) points[input.nextInt()]++;
// System.out.println("Point distribution: ");
// for (int i = 0; i <= 30; i++) System.out.println(points[i] + " dancers got " + i + " points.");
int remainingSurprises = S;
int result = 0;
for (int i = 30; i >= 0; i--) {
if (points[i] == 0) continue;
final int min;
final int max;
switch (i % 3) {
case 0:
min = i / 3;
max = min;
if (max >= P) { // We reach the limit by default
result += points[i];
} else if ((max + 1 == P) && (min > 0) && (max < 10)) { // We can reach the limit with surprises
final int useSurprises = Math.min(points[i], remainingSurprises);
remainingSurprises -= useSurprises;
result += useSurprises;
} else { // We can not reach the limit anyway
// We are not interested
}
break;
case 1:
max = (i - 1) / 3 + 1;
if (max >= P) result += points[i];
break;
case 2:
min = (i - 2) / 3;
max = min + 1;
if (max >= P) { // We reach the limit by default
result += points[i];
} else if ((max + 1 == P) && (max < 10)) { // We can reach the limit with surprises
final int useSurprises = Math.min(points[i], remainingSurprises);
remainingSurprises -= useSurprises;
result += useSurprises;
} else { // We can not reach the limit anyway
// We are not interested
}
break;
}
}
return result;
}
private void solveAll(final Scanner input) throws NumberFormatException, IOException {
final int cases = input.nextInt();
input.nextLine();
for (int caseNum = 1; caseNum <= cases; caseNum++) {
System.out.println("Case #" + caseNum + ": " + solve(input));
}
}
public static void main(final String[] args) {
try {
final Scanner input = new Scanner(((args.length == 2) && args[0].equals("--input")) ? new FileInputStream(args[1]) : System.in);
new Problem_B_0().solveAll(input);
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,252 |
A11759 | A13161 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 tr0llhoehle.cakemix.utility.googleCodeJam;
public interface Solver<T extends Problem> {
public String solve(T p);
}
| 0 | 1,189,253 |
A11759 | A11918 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 jam2012;
import jam.util.Utilities;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author sam
*/
public class DancingGooglers {
private int T;//number of testcases
private int N;//number of googlers
private int S;//number of surprising triplets of scores
private int p;//best result for each case
private int[] scores;
private int ti;//score for each googler
private Scanner input;
private static Utilities utility=new Utilities();
//method to calculate maximum number of googlers
public void openFile() {
Scanner cin = new Scanner(System.in);
System.out.println("Enter File Path containing test data: ");
String filePath = cin.nextLine();
try {
input = new Scanner(new File(filePath));
} catch (FileNotFoundException ex) {
System.err.println("Error opening file!");
System.exit(1);
Logger.getLogger(DancingGooglers.class.getName()).log(Level.SEVERE, null, ex);
}
}
//small input
public void readFile() throws Exception {
if (input.hasNext()) {
//read number of test cases
T = input.nextInt();
//enforce T limit
//move to first case
int test_count = 0;
input.nextLine();
//for each test case read N, S, p, and N values to array ti and call output method
while (input.hasNext() && (test_count <= T)) {
test_count++;
N = input.nextInt();
//proceed for this input
S = input.nextInt();
p = input.nextInt();
scores = new int[N];
//populate scores
for (int i = 0; i < N; i++) {
scores[i] = input.nextInt();
}
Arrays.sort(scores);
//call output method
output(test_count, S, p, scores);
}
}
}
public void closeFile() {
input.close();
}
public void output(int test_case, int surprises, int best_result, int[] scores) throws Exception {
String output="";
if (p > 1) {
int q = p * 3 - 2;
int s = p * 3 - 4;
int count = 0;
int pt = N - 1;
for (int i = N - 1; i >= 0; i--) {
if (scores[i] >= q) {
count++;
pt--;
}
}
while (pt >= 0 && scores[pt] >= s && S > 0) {
count++;
pt--;
S--;
}
output="Case #" + test_case + ": " + count;
System.out.println("Case #" + test_case + ": " + count);
// Utilities.writeToFile("googld.in","Case #" + test_case + ": " + count);
} else if (p == 1) {
int j = 0;
for (j = 0; j < N; j++) {
if (scores[j] > 0) {
break;
}
}
output="Case #" + test_case + ": " + (N - j);
System.out.println("Case #" + test_case + ": " + (N - j));
//Utilities.writeToFile("googled.in","Case #" + test_case + ": " + (N - j));
} else if (p == 0) {
output="Case #" + test_case + ": " + N;
System.out.println("Case #" + test_case + ": " + N);
}
Utilities.writeToFile("googld.in",output);
}
public static void main(String[] str) throws Exception {
DancingGooglers dG = new DancingGooglers();
dG.openFile();
dG.readFile();
dG.closeFile();
}
}
| 0 | 1,189,254 |
A11759 | A11067 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.lewis.codeJamInJava;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.StringTokenizer;
public class DancingWithTheGooglers {
/**
* @param args
*/
public static void main(String[] args) {
try {
File outpuFile = new File("output.txt");
FileWriter fileWriter = new FileWriter(outpuFile);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
BufferedReader bufferedReader;
File inputFile = new File("input.txt");
FileReader fileReader = new FileReader(inputFile);
bufferedReader = new BufferedReader(fileReader);
int numTestCases = Integer.parseInt(bufferedReader.readLine());
for (int i = 1; i <= numTestCases; i++) {
StringTokenizer st = new StringTokenizer(
bufferedReader.readLine());
int numGooglers = Integer.parseInt(st.nextToken());
int numSurprisingScores = Integer.parseInt(st.nextToken());
int passingScore = Integer.parseInt(st.nextToken());
int scores[] = new int[numGooglers];
for (int j = 0; j < numGooglers; j++) {
scores[j] = Integer.parseInt(st.nextToken());
}
int passingGrades = getNumPassingScores(scores, passingScore,
numSurprisingScores);
bufferedWriter
.write("Case #" + i + ": " + passingGrades + "\r\n");
}
bufferedWriter.flush();
bufferedWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Given scores, passing score and surpising scores, generates the number of
* passes.
*
* @param scores
* @param passingScore
* @param numSurprisingScores
* @return
*/
public static int getNumPassingScores(int[] scores, int passingScore,
int numSurprisingScores) {
int numPassing = 0;
int easyPass = passingScore * 3 - 2;
int surprisingPass = passingScore * 3 - 4;
if (easyPass < 0) {
surprisingPass = 0;
easyPass = 0;
} else if(surprisingPass < 0){
surprisingPass = 0;
}
for (int i = 0; i < scores.length; i++) {
if(scores[i] < passingScore){
} else if (scores[i] >= easyPass) {
numPassing++;
} else if (numSurprisingScores > 0 && scores[i] >= surprisingPass) {
numSurprisingScores--;
numPassing++;
}
}
return numPassing;
}
}
| 0 | 1,189,255 |
A11759 | A11836 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 QualBDancingWithTheGooglers
{
static boolean debug = false;
public static void main(String[] args)
{
Utils.openInFile("B-small-attempt0.in");
Utils.openOutFile("out.txt", debug);
String input = Utils.readFromFile();
int lineCount = Integer.parseInt(input);
//while ((input = Utils.readFromFile()) != null)
for (int line = 1; line <= lineCount; line++)
{
if (debug) System.out.println();
input = Utils.readFromFile();
String[] split = input.split(" ");
int Number = Integer.parseInt(split[0]),
Surprising = Integer.parseInt(split[1]),
points = Integer.parseInt(split[2]);
int[] allPoints = new int[Number];
for (int j = 0; j < Number; j++)
allPoints[j] = Integer.parseInt(split[j+3]);
String output = "";
int mustBeSurprisingCount = 0, count = 0;
for (int sumP: allPoints)
{
int mod = sumP%3;
int third = sumP/3;
int minP = third, maxP = third, minPSup = third, maxPSup = third;
switch (mod)
{
case 0: minPSup--; maxPSup++; break;
case 1: maxP++; minPSup--; maxPSup++; break;
case 2:
default:maxP++; maxPSup+=2;
}
if (debug) System.out.println("third="+third);
if (points <= maxP)
count++;
else if (2 <= sumP && sumP <= 28 && points <= maxPSup)
mustBeSurprisingCount++;
}
if (debug)
{
System.out.println("input="+input);
System.out.println("count="+count);
System.out.println("mustBeSurprisingCount="+mustBeSurprisingCount);
}
output = "Case #" + line + ": ";
output += (count + Math.min(mustBeSurprisingCount, Surprising));
Utils.writeToFile(output);
}
Utils.closeInFile();
Utils.closeOutFile();
}
}
| 0 | 1,189,256 |
A11759 | A10738 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 ProblemB {
final long MOD = 1000003;
final int MAX_LEN = 500000;
long pow(long x, long y) {
if (y == 0) return 1;
long res = pow(x, y/2);
res = (res * res) % MOD;
if (y % 2 == 1) res = (res * x) % MOD;
return res;
}
long inv(long x) {
return pow(x, MOD-2);
}
long[] fact, invfact;
void precalc() {
fact = new long[MAX_LEN + 1];
fact[0] = 1;
for (int i=1; i<=MAX_LEN; i++)
fact[i] = (i * fact[i-1]) % MOD;
invfact = new long[MAX_LEN + 1];
invfact[0] = 1;
for (int i=1; i<=MAX_LEN; i++)
invfact[i] = (inv(i) * invfact[i-1]) % MOD;
}
long comb(int N, int M) {
long res = fact[N];
res = (res * invfact[M]) % MOD;
res = (res * invfact[N-M]) % MOD;
return res;
}
class Testcase {
long ans;
public Testcase() {
}
public Testcase(int seed) {
Random rnd = new Random(seed);
}
String s;
int N;
int S;
// int T;
int P;
// ArrayList<Integer> ti = new ArrayList<Integer>();
int [] ti = new int[0];
public void loadInput(Scanner sc) {
// s = sc.next();
N = sc.nextInt();
S = sc.nextInt();
P = sc.nextInt();
ti = new int[N];
for(int i=0;i<N;i++) {
ti[i] =sc.nextInt();
}
}
public void solveSlow() {
}
public void solveFast() {
int n1 = 0;
int n2 =0;
if(P==0) {
ans = N;
return;
}
int c1 = P*3 -2;
int c2 = P*3 -4;
for(int i=0;i<ti.length;i++){
int tai = ti[i];
if(tai>=c1){
n1++;
} else if(tai<c1 && tai>=c2) {
n2++;
}
}
if(P==1) {
ans =n1;
return;
}
n2 = Math.min(S, n2);
ans = n1+ n2;
// ans = F[26][runs][0];
}
public void printSelf(PrintWriter pw) {
pw.println(ans);
}
public boolean sameAnswers(Testcase other) {
return false;
}
}
final String AFTER_CASE = " ";
public void go() throws Exception {
precalc();
Scanner sc = new Scanner(new FileReader("src\\input.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("src\\output.txt"));
int caseCnt = sc.nextInt();
for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
System.out.println("solving case " + caseNum);
Testcase tc = new Testcase();
tc.loadInput(sc);
tc.solveFast();
pw.print("Case #" + (caseNum + 1) + ":");
pw.print(AFTER_CASE);
tc.printSelf(pw);
}
pw.flush();
pw.close();
sc.close();
}
public void stresstest() {
int it = 0;
Random rnd = new Random();
while (true) {
it++;
if (it % 1000 == 0)
System.out.println(it + " iterations");
int seed = rnd.nextInt();
Testcase tc1 = new Testcase(seed);
tc1.solveFast();
Testcase tc2 = new Testcase(seed);
tc2.solveSlow();
if (!tc1.sameAnswers(tc2)) {
System.out.println("ERROR: it failed");
System.exit(0);
}
}
}
public static void main(String[] args) throws Exception {
new ProblemB().go();
}
}
| 0 | 1,189,257 |
A11759 | A11184 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 DataModel extends Thread {
private int googlersNo;
private int suprScore;
private int minScore;
private int[] googScore;
private int caseNo;
private int output;
private boolean stateCalc;
public DataModel(String input, int caseNo) {
this.caseNo = caseNo;
String[] temp = input.split(" ");
stateCalc = false;
try {
googlersNo = Integer.parseInt(temp[0]);
suprScore = Integer.parseInt(temp[1]);
minScore = Integer.parseInt(temp[2]);
googScore = new int[googlersNo];
for(int i = 0;i<googlersNo;i++) {
googScore[i] = Integer.parseInt(temp[3+i]);
}
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
private boolean isOverReqScore(int i) {
int[] temp = {i/3,i/3,i/3};
int diff = (i-(temp[0]+temp[1]+temp[2]));
int minDiff = minScore-temp[0];
if(diff > 0) {
temp[0] += 1;
if(diff > 1 && minDiff < 3 && minDiff > 0 && suprScore > 0) {
temp[0] += 1;
suprScore--;
} else if(diff > 1) {
temp[1] += 1;
}
} else if (minDiff == 1 && temp[0]!=0 && suprScore > 0) {
temp[0] += 1;
temp[2] -= 1;
suprScore--;
}
return (temp[0]>=minScore||temp[1]>=minScore||temp[2]>=minScore);
}
@Override
public void run() {
for(int i = 0;i<googlersNo;i++) {
if(isOverReqScore(googScore[i])) {
output++;
}
}
stateCalc = true;
}
public boolean isDone() {
return stateCalc;
}
public void getOutput() {
System.out.println("Case #"+caseNo+": "+output);
}
} | 0 | 1,189,258 |
A11759 | A11612 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.PrintStream;
import java.util.Scanner;
public class InputOutputProcessor {
private int numberOfCases;
private boolean doesInputHaveDataSetLines;
private int indexOfDataSetLine;
private int numberOfDataSetLines;
private final static String DELIMITER = " ";
private Scanner scanInput;
public void initializeInput(String strInputFileName) {
readInput(strInputFileName);
numberOfCases = Integer.parseInt(scanInput.nextLine());
}
/*
* read input
*/
private void readInput(String strInputFileName) {
try {
scanInput = new Scanner(new BufferedReader(new FileReader(
strInputFileName)));
}
catch (Exception exp) {
// exp.printStackTrace();
System.out.println(" Please provide File Name with proper location ");
}
}
public String[] getDataSet() throws Exception {
String[] dataSet;
String strDataSetLine = "";
strDataSetLine = scanInput.nextLine();
if (doesInputHaveDataSetLines) {
String[] DataSetLineArray = strDataSetLine.split(DELIMITER);
numberOfDataSetLines = Integer
.parseInt(DataSetLineArray[indexOfDataSetLine]);
}
dataSet = new String[numberOfDataSetLines];
dataSet[0] = strDataSetLine;
for (int i = 1; i < numberOfDataSetLines; i++) {
dataSet[i] = scanInput.nextLine();
}
return dataSet;
}
/**
* * @return Returns the numberOfDataSetLines.
*/
public int getNumberOfDataSetLines() {
return numberOfDataSetLines;
}
/**
* @param numberOfDataSetLines
* The numberOfDataSetLines to set.
*/
public void setNumberOfDataSetLines(int numberOfDataSetLines) {
this.numberOfDataSetLines = numberOfDataSetLines;
}
/**
* * @return Returns the numberOfCases.
*/
public int getNumberOfCases() {
return numberOfCases;
}
/**
* * @return Returns the doesInputHaveDataSetLines.
*/
public boolean isDoesInputHaveDataSetLines() {
return doesInputHaveDataSetLines;
}
/**
* @param doesInputHaveDataSetLines
* The doesInputHaveDataSetLines to set.
*/
public void setDoesInputHaveDataSetLines(boolean doesInputHaveDataSetLines) {
this.doesInputHaveDataSetLines = doesInputHaveDataSetLines;
}
/**
* * @return Returns the indexOfDataSetLine.
*/
public int getIndexOfDataSetLine() {
return indexOfDataSetLine;
}
/**
* @param indexOfDataSetLine
* The indexOfDataSetLine to set.
*/
public void setIndexOfDataSetLine(int indexOfDataSetLine) {
this.indexOfDataSetLine = indexOfDataSetLine;
}
public void closeScanner() {
scanInput.close();
}
public void writeOutput(String outputFileName, String[] resultArray) {
PrintStream out = null;
try {
out = new PrintStream(new FileOutputStream(outputFileName));
for (int i = 0; i < resultArray.length; i++) {
out.print(resultArray[i]);
out.print("\n");
}
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
}
}
| 0 | 1,189,259 |
A11759 | A13062 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.Scanner;
class Main{
public static void main(String[] args){
Scanner S= new Scanner(System.in);
int T= S.nextInt(),i,j; //Variables de Control
int n,s,p,val; //Variables del Problema
int score,aux;
for(i=0;i<T;i++){
n= S.nextInt();
s= S.nextInt();
p= S.nextInt();
val=0;
for(j=0;j<n;j++){
score= S.nextInt();
aux= (int)(Math.ceil(score/3.0));
if(aux>=p){
val++;
}else if((score%3==2 || score%3==0) && score>1 && score<29 && s>0 && (aux+1)==p){
val++;
s--;
}
}
System.out.println("Case #" + (i+1) + ": " + val);
}
}
} | 0 | 1,189,260 |
A11759 | A12306 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileNotFoundException;
import java.io.FileWriter;
import java.util.Scanner;
public class Googlers {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
int[] minScoreWithSurprise = new int[11];
int[] minScoreWithoutSurprise = new int[11];
minScoreWithoutSurprise[0] = 0;
minScoreWithSurprise[0] = 0;
minScoreWithoutSurprise[1] = 1;
minScoreWithSurprise[1] = 1;
for(int i=2; i<minScoreWithoutSurprise.length; i++){
int score = i * 3;
minScoreWithoutSurprise[i] = score - 2 ;
minScoreWithSurprise[i] = score - 4 ;
}
Scanner sc = new Scanner(new File("B-small-attempt0.in"));
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Output.txt")));
StringBuilder sb = new StringBuilder(50);
int numOfTestcase = sc.nextInt();
int ans,p,googlers,minSWithoutS,minSwithS,numOfsurprisingTriplets,current;
for(int i=0;i<numOfTestcase;i++){
sb.setLength(0);
googlers = sc.nextInt();
numOfsurprisingTriplets = sc.nextInt();
p = sc.nextInt();
ans = 0;
minSWithoutS = minScoreWithoutSurprise[p];
minSwithS = minScoreWithSurprise[p];
for(int j=0;j<googlers;j++){
current = sc.nextInt();
if(current >= minSWithoutS){
ans++;
}
else if(numOfsurprisingTriplets > 0 && current>=minSwithS){
ans++;numOfsurprisingTriplets--;
}
}
sb.append("Case #").append(i+1).append(": ").append(ans);
bw.write(sb.toString());
bw.newLine();
}
bw.close();
}
}
| 0 | 1,189,261 |
A11759 | A10076 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package qualification;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Comparator;
public class B {
private static final char[] CASE = "Case #".toCharArray();
public static void main(String[] args) throws Throwable {
// in = System.in;
// out = System.out;
// in = new FileInputStream("in/B.in");
in = new FileInputStream("in/B-small-attempt0.in");
out = new PrintStream(new FileOutputStream("out/B.out"));
int T = readInt();
int[] t = new int[128];
for (int test = 1; test <= T; test++) {
int N = readInt();// number of googlers
int S = readInt();// number of surprising triplets
int p = readInt();// minimal result
for (int i = 0; i < N; i++) {
t[i] = readInt();
}
// TODO need to test it with 10's and 0's
// Arrays.sort(t, 0, N);
int result = 0;
//for (int i = N-1; i >= 0; i--) {
for (int i = 0; i < N; i++) {
int v = t[i];
// int aThird = v/3;
// if (aThird >= p) {
// result++;
// } else if (aThird*3 < v && aThird+1 == p) {// for example: 5 6 6 or 5 5 6
// result++;
// } else if (S > 0 && aThird*3 == v && aThird*3 == (p-1)*3 && p > 1) {// 6 7 8 'anomally'
// result++;
// S--;
// } else if (S > 0 && v == (p*3)-4 && p > 1) {// 6 6 8 'anomally'
// result++;
// S--;
// } else {
// break;// no more will do
// }
if (v >= (p*3) - 2) {
result++;
} else if (S>0 && v >= 2 && v >= (p*3)-4) {
result++;
S--;
}
}
writeOut(CASE);
writeOutNumber(test);
writeOut(':');
writeOut(' ');
writeOutNumber(result);
writeOutLn();
}
flush();
}
static InputStream in;
static PrintStream out;
static byte[] buffer = new byte[8192];
static int pos;
static int max;
static final int maxOut = 8192;
static byte[] output = new byte[maxOut];
static int posOut = 0;
static char[] tmpcharr = new char[128];
static int pow2(int v) {
return v * v;
}
static boolean reachedEndOfLine() throws Throwable {
while (true) {
int data = read();
if (data == -1)
return true;
if (data == '\r' || data == '\n') {
return true;
}
if (data == ' ') {
continue;
}
pos--;
return false;
}
}
// COMPARISION FUNCTIONS
static boolean isValidChar(int v) {
// nao verifica o 'DELETE' (127)
return (v & 0xE0) != 0;
}
static boolean isNum(int v) {
return v >= '0' && v <= '9';
}
static boolean isLowercase(int cur) {
return cur >= 'a' && cur <= 'z';
}
static boolean isUppercase(int cur) {
return cur >= 'A' && cur <= 'Z';
}
// is a letter (alphabetic)
static boolean isAlpha(int cur) {
return isLowercase(cur) || isUppercase(cur);
}
// is alphanumeric (letters and numbers)
static boolean isAlphaNum(int cur) {
return isAlpha(cur) || isNum(cur);
}
static boolean isMinus(int cur) {
return cur == '-';
}
static boolean isPlus(int cur) {
return cur == '+';
}
// INPUT FUNCTIONS
static void goToBeginOfNextWord() throws Throwable {
int cur;
// se for -1 já sai do método
while ((cur = read()) != -1) {
// se for um char válido então deixa o ponteiro nele
if (cur > 32) {
pos--;
return;
}
}
}
// return the length of the string read
static String readWord() throws Throwable {
int len = 0;
int cur;
// descarta os espacos em branco primeiro
while ((cur = read()) < 33) {
if (cur == -1) return "";
}
tmpcharr[len++] = (char) cur;
while ((cur = (char) read()) > 32) {
tmpcharr[len++] = (char) cur;
}
return new String(tmpcharr, 0, len);
}
static void discardWord() throws Throwable {
int cur;
// descarta os espacos em branco primeiro
while ((cur = read()) < 33) {
if (cur == -1)
return;
}
// descarta os valores 'validos'
while ((cur = read()) > 32)
;
}
static int readInt() throws Throwable {
int cur;
while (!isNum(cur = read()) && !isMinus(cur))
if (cur == -1)
return -1;
int v = 0;
boolean minus = false;
if (isMinus(cur)) {
minus = true;
cur = read();
}
while (isNum(cur)) {
v *= 10;
v += (cur - '0');
cur = read();
}
return minus ? -v : v;
}
static char readChar() throws Throwable {
int cur;
for (;;) {
cur = read();
if (cur == -1)
return 0;
if (cur == '\r' || cur == '\n' || cur == ' ')
continue;
return (char) cur;
}
}
static long readLong() throws Throwable {
int cur;
while (!isNum(cur = read()) && !isMinus(cur))
if (cur == -1)
return -1;
long v = 0;
boolean minus = false;
if (isMinus(cur)) {
minus = true;
cur = read();
}
while (isNum(cur)) {
v *= 10;
v += (cur - '0');
cur = read();
}
return minus ? -v : v;
}
static boolean hasInput() throws Throwable {
while (true) {
int data = read();
if (data == -1)
return false;
if ((data & 0xE0) != 0) {
pos--;
return true;
}
}
}
static int read() throws Throwable {
if (pos >= max) {
max = in.read(buffer);
if (max < 0)
return -1;
pos = 0;
}
return buffer[pos++] & 0xff;
}
// OUTPUT FUNCTIONS
// escreve um char
static void writeOut(char c) {
if (posOut >= maxOut) {
writeOutToStream();
}
output[posOut++] = (byte) c;
}
// escreve a quebra de linha
static void writeOutLn() {
writeOut('\n');
}
// escreve um char[]
static void writeOut(char[] cs) {
writeOut(cs, 0, cs.length);
}
// escreve uma cadeia de caracteres
static void writeOut(char[] chars, int offset, int length) {
final int end = offset + length;
for (int i = offset; i < end; i++) {
writeOut(chars[i]);
}
}
static void writeOutNumber(int value) {
int len = 0;
int pos = tmpcharr.length;
if (value == 0) {
writeOut('0');
return;
}
boolean negative = value < 0;
if (negative)
value = -value;
while (value > 0) {
tmpcharr[--pos] = (char) ((value % 10) + '0');
len++;
value /= 10;
}
if (negative)
writeOut('-');
writeOut(tmpcharr, pos, len);
}
static void writeOutNumberAsBin(int num) {
int len = 0;
int pos = tmpcharr.length;
if (num == 0) {
writeOut('0');
return;
}
while (num > 0) {
tmpcharr[--pos] = ((num & 1) == 1) ? '1' : '0';
len++;
num >>>= 1;
}
writeOut(tmpcharr, pos, len);
}
static void flush() {
writeOutToStream();
out.flush();
}
// PRIVATE methods must be used only by the utility methods
private static void writeOutToStream() {
out.write(output, 0, posOut);
posOut = 0;
}
} | 0 | 1,189,262 |
A11759 | A12317 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 br.com.atama.google.jam;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import br.com.atama.google.jam.dancing.ScoreCalculator;
public class Solver {
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("src/input-small.txt");
BufferedReader bReader = new BufferedReader(reader);
final int t = Integer.valueOf(bReader.readLine());
for (int i = 1; i <= t; i++) {
String[] tokens = bReader.readLine().split(" ");
final int n = Integer.valueOf(tokens[0]);
final int s = Integer.valueOf(tokens[1]);
final int p = Integer.valueOf(tokens[2]);
final int[] totals = new int[n];
for (int j = 0; j < n; j++)
totals[j] = Integer.valueOf(tokens[3 + j]);
final ScoreCalculator calculator = new ScoreCalculator(s, p, totals);
System.out.format("Case #%d: %d\n", i, calculator.calculate());
}
bReader.close();
reader.close();
}
}
| 0 | 1,189,263 |
A11759 | A11402 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.
*/
/**
*
* @author Conny
*/
public class ProbQ2 {
public static void main(String[] args) {
String fileContent = CodeJamTools.readFileAsString("c:\\temp\\inputQ2.txt");
String[] rows = fileContent.split("\\n");
int T = new Integer(rows[0]);
String output = "";
int counter = 1;
for (int i=0; i<T; i++) {
System.out.println(rows[counter]);
long[] data = CodeJamTools.readLongsFromRow(rows[counter]);
counter++;
long Ni = data[0];
long p = data[2];
long S = data[1];
long limit1 = Math.max(1,3*p-4);
long limit2 = 3*p-2;
long overs = 0;
long borderlines = 0;
for (int j=3; j<data.length; j++) {
if (data[j] >= limit2)
overs++;
else if (data[j] >= limit1)
borderlines++;
}
output += "Case #"+(i+1)+": ";
output += (overs+Math.min(borderlines, S));
output += "\n";
}
System.out.print(output);
CodeJamTools.writeStringToFile("C:\\Users\\Conny\\Documents\\conny\\own files\\java_workspace\\codejam2\\src\\outputQ2.txt", output);
}
}
| 0 | 1,189,264 |
A11759 | A10793 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.math.*;
import java.util.*;
import java.text.*;
public class b {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int T = sc.nextInt();
for (int casenumber = 1; casenumber <= T; ++casenumber) {
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int[] ts = new int[n];
for (int i = 0; i < n; ++i)
ts[i] = sc.nextInt();
int thresh1 = (p == 1 ? 1 : (3 * p - 4));
int thresh2 = (3 * p - 2);
int count1 = 0, count2 = 0;
for (int i = 0; i < n; ++i) {
if (ts[i] >= thresh2) {
++count2;
continue;
}
if (ts[i] >= thresh1) {
++count1;
}
}
if (count1 > s) {
count1 = s;
}
System.out.format("Case #%d: %d%n", casenumber, count1 + count2);
}
}
}
| 0 | 1,189,265 |
A11759 | A12174 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 hk.polyu.cslhu.codejam.solution.impl;
import hk.polyu.cslhu.codejam.solution.Solution;
import java.util.ArrayList;
import java.util.List;
public class StoreCredit extends Solution {
private int amountOfCredits, numOfItems;
private List<Integer> priceList;
@Override
public void setProblem(List<String> testCase) {
this.initial(testCase);
}
private void initial(List<String> testCase) {
// TODO Auto-generated method stub
this.amountOfCredits = Integer.valueOf(testCase.get(0));
this.numOfItems = Integer.valueOf(testCase.get(1));
this.setPriceList(testCase.get(2));
}
private void setPriceList(String string) {
// TODO Auto-generated method stub
String[] splitArray = string.split(" ");
if (splitArray.length != numOfItems)
logger.error("The price list does not include all items ("
+ splitArray.length
+ "/" + this.numOfItems + ")");
this.priceList = new ArrayList<Integer>();
for (String price : splitArray) {
this.priceList.add(Integer.valueOf(price));
}
}
@Override
public void solve() {
for (int itemIndex = 0; itemIndex < this.priceList.size() - 1; itemIndex++) {
for (int anotherItemIndex = itemIndex + 1; anotherItemIndex < this.priceList.size(); anotherItemIndex++) {
if (this.priceList.get(itemIndex) + this.priceList.get(anotherItemIndex) == this.amountOfCredits) {
this.result = (itemIndex + 1) + " " + (anotherItemIndex + 1);
break;
}
}
}
}
@Override
public String getResult() {
return this.result;
}
}
| 0 | 1,189,266 |
A11759 | A10467 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.suraj.quals2012.googledancers;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import javax.swing.event.TreeExpansionEvent;
import codejam.suraj.quals2012.CodeJamSkeleton;
import codejam.suraj.quals2012.googlerese.Googlerese;
public class GoogleDancers extends CodeJamSkeleton {
@Override
protected void handleTestCase(int testCaseNumber) throws IOException {
// TODO Auto-generated method stub
String line = readLine();
String[] lineSplits = line.split("\\s+");
int numberOfG = Integer.parseInt(lineSplits[0]);
int surprises = Integer.parseInt(lineSplits[1]);
int p = Integer.parseInt(lineSplits[2]);
List<Integer> scores = new ArrayList<Integer>(lineSplits.length - 3);
for (int i = 3; i < numberOfG + 3; ++i){
scores.add(Integer.parseInt(lineSplits[i]));
}
Iterator<Integer> iter = scores.iterator();
int requiredSurprises = 0;
int bestAndRequired = 0;
int numBestResults = 0;
System.out.println("Test Case " + testCaseNumber);
System.out.println(line);
while(iter.hasNext()){
int score = iter.next();
int max = score/3;
if(score > 0 && score%3 != 0)
max = max + 1;
if(p == max){
++numBestResults;
}
else if(p > max){
if(score == 2 || score > 2 && score%3 == 0 ||
score > 2 && score%3 == 2){
int possibleMax = max + 1;
if(possibleMax == p){
++requiredSurprises;
}
}
}
else if (p < max){
int min = 0;
if(score <= 2){
min = 0;
if(p == min){
++numBestResults;
}
}
else{
if(score%3 == 0){
min = max - 1;
if(min == p){
++requiredSurprises;
++numBestResults;
++bestAndRequired;
}
else{
++numBestResults;
}
}
else if (score%3 == 1 || score%3 == 2){
min = max - 1;
if(min == p){
++numBestResults;
}
else if (min - 1 == p){
++requiredSurprises;
++numBestResults;
++bestAndRequired;
}
else{
++numBestResults;
}
}
}
}
else if (p == max){
++numBestResults;
}
}
int result = numBestResults + Math.min(requiredSurprises - bestAndRequired, surprises);
addOutput(testCaseNumber, ""+result);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
CodeJamSkeleton testCase = new GoogleDancers();
testCase.handleAllTestCases(args[0], args[1]);
}
}
| 0 | 1,189,267 |
A11759 | A12844 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.common;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author chenling
*/
public class FileUtil {
public static List<String> readLines(String fileName) {
List<String> result = new ArrayList<String>();
FileReader in = null;
try {
in = new FileReader(fileName);
BufferedReader reader = new BufferedReader(in);
String line = null;
while ((line = reader.readLine()) != null) {
if (line.trim().length() > 0) {
result.add(line);
}
}
} catch (Exception ex) {
throw new RuntimeException(ex);
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException ex) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, null, ex);
}
}
return result;
}
public static void writeLines(String fileName, List<String> lines) {
FileWriter writer = null;
try {
writer = new FileWriter(fileName);
PrintWriter printWriter = new PrintWriter(writer);
for (String line : lines) {
printWriter.println(line);
}
} catch (IOException ex) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, null, ex);
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException ex) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
}
| 0 | 1,189,268 |
A11759 | A10907 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package gcj2012.qual;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Scanner;
public class B {
final boolean DEBUG = false;
final String PACKAGE = "gcj2012/qual";
final String PROBLEM = "B";
boolean noSurprise(int x, int p){
int y = x-p;
if(y<0)return false;
if(1<=p){
if(y==p-1+p-1)return true;
if(y==p+p-1)return true;
}
if(y==p+p)return true;
if(p+1<=10){
if(y==p+p+1)return true;
if(y==p+1+p+1)return true;
}
return false;
}
boolean surprise(int x, int p){
int y = x-p;
if(y<0)return false;
if(2<=p){
if(y==p-2+p)return true;
if(y==p-2+p-2)return true;
if(y==p-2+p-1)return true;
}
if(p+2<=10){
if(y==p+2+p)return true;
if(y==p+2+p+1)return true;
if(y==p+2+p+2)return true;
}
return false;
}
void run(){
if(!DEBUG){
try {
System.setIn(new FileInputStream(new File("./src/"+PACKAGE+"/"+PROBLEM+"-small.in")));
// System.setIn(new FileInputStream(new File("./src/"+PACKAGE+"/"+PROBLEM+"-large.in")));
System.setOut(new PrintStream(new File("./src/"+PACKAGE+"/"+PROBLEM+"-small_out.txt")));
// System.setOut(new PrintStream(new File("./src/"+PACKAGE+"/"+PROBLEM+"-large_out.txt")));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
boolean[][] nosup = new boolean[31][11], sup = new boolean[31][11], ns = new boolean[31][11], s = new boolean[31][11];
for(int x=0;x<=30;x++)for(int p=0;p<=10;p++){
nosup[x][p] = noSurprise(x, p); sup[x][p] = surprise(x, p);
}
for(int x=0;x<=30;x++)for(int p=0;p<=10;p++){
boolean f = false;
for(int k=p;k<=10;k++)f|=nosup[x][k];
ns[x][p] = f;
f = false;
for(int k=p;k<=10;k++)f|=sup[x][k];
s[x][p] = f;
}
for(int CASE=1;CASE<=T;CASE++){
int N = sc.nextInt(), S = sc.nextInt(), P = sc.nextInt();
int[] t = new int[N];
for(int i=0;i<N;i++)t[i]=sc.nextInt();
boolean[] proc = new boolean[N];
for(int i=0;i<N&&0<S;i++)if(!ns[t[i]][P]&&s[t[i]][P]){
S--; proc[i] = true;
}
for(int i=0;i<N&&0<S;i++){
if(proc[i])continue;
if(s[t[i]][P]){
proc[i] = true; S--;
}
}
for(int i=0;i<N&&0<S;i++){
if(proc[i])continue;
if(s[t[i]][0]){
proc[i] = true; S--;
}
}
int res = 0;
for(int i=0;i<N;i++){
if(proc[i])res+=s[t[i]][P]?1:0;
else res+=ns[t[i]][P]?1:0;
}
System.out.println("Case #"+CASE+": "+res);
}
}
public static void main(String[] args) {
new B().run();
}
}
| 0 | 1,189,269 |
A11759 | A13024 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class B_small {
public B_small() throws Exception {
int caseCount = in.nextInt();
for (int caseNum=1;caseNum<=caseCount;caseNum++) {
out.printf("Case #%d: ", caseNum);
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int ans = 0;
int reserv = 0;
for (int i=0; i<n; i++) {
int c = in.nextInt();
if (c>=3*p-2) ans++;
else if (c>=3*p-4&&p-2>=0) reserv++;
}
out.println(ans+min(s, reserv));
}
}
// {{{
Scanner in = new Scanner(System.in);
public static void main(String[] args) throws Exception {
new B_small();
}
public static void debug(Object... arr) {
System.err.println(Arrays.deepToString(arr));
}
// }}}
}
| 0 | 1,189,270 |
A11759 | A10297 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.palantir;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Googlers {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int numTests = s.nextInt();
for (int i = 1; i <= numTests; ++i) {
System.out.println("Case #" + i + ": " + solve(s));
}
}
private static int solve(Scanner s) {
int numGooglers = s.nextInt();
int numSurprising = s.nextInt();
int maxScore = s.nextInt();
List<Integer> scores = new ArrayList<Integer>();
for (int i = 0; i < numGooglers; ++i) scores.add(s.nextInt());
int lowestGoodScore = (maxScore * 3) - 2;
int lowestSurpriseScore = (maxScore * 3) - 4;
if (maxScore == 0) {
lowestGoodScore = 0;
lowestSurpriseScore = 0;
} else if (maxScore == 1) {
lowestGoodScore = 1;
lowestSurpriseScore = 1;
}
int goodScores = 0, surpriseScores = 0;
for (int score : scores) {
if (score >= lowestGoodScore) ++goodScores;
else if (score >= lowestSurpriseScore) ++ surpriseScores;
}
if (numSurprising < surpriseScores) surpriseScores = numSurprising;
return goodScores + surpriseScores;
}
}
| 0 | 1,189,271 |
A11759 | A12868 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 JudgeScores{
int jc1;
int jc2;
int jc3;
private boolean isSurprising = false;
public JudgeScores(int jc1, int jc2, int jc3) {
this.jc1 = jc1;
this.jc2 = jc2;
this.jc3 = jc3;
}
public JudgeScores(int jc1, int jc2, int jc3, boolean isSurprising) {
this.jc1 = jc1;
this.jc2 = jc2;
this.jc3 = jc3;
this.isSurprising = isSurprising;
}
public int getJC1(){
return jc1;
}
public int getJC2(){
return jc2;
}
public int getJC3(){
return jc3;
}
public void isSurprising(boolean isSurprising){
this.isSurprising = isSurprising;
}
public boolean isSurprising(){
return this.isSurprising;
}
public int getMaxScore(){
return Math.max(Math.max(jc1, jc2), jc3);
}
public int getMinScore(){
return Math.min(Math.min(jc1, jc2), jc3);
}
} | 0 | 1,189,272 |
A11759 | A13199 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 dancing;
import java.io.BufferedReader;
import java.io.FileReader;
public class MaxScoreDetector {
/**
* @param args
*/
public static void main(String[] args) {
String fileName = null;
if(args.length == 1){
fileName = args[0];
}else{
System.err.println("Requires a command line argument: fileName");
System.exit(1);
};
new MaxScoreDetector(fileName);
}
public MaxScoreDetector(String fileName){
try{
BufferedReader in = new BufferedReader(new FileReader(fileName));
int cases = Integer.parseInt(in.readLine());
for(int i=0; i<cases; i++){
String[] line = in.readLine().split(" ");
int numScores = Integer.parseInt(line[0]);
int specials = Integer.parseInt(line[1]);
int min = Integer.parseInt(line[2]);
int[] scores = new int[numScores];
for(int j=0; j<scores.length; j++){
scores[j] = Integer.parseInt(line[j+3]);
}
System.out.println("Case #" + (i+1) + ": " + testScores(scores, min, specials));
}
}catch(Exception e){
e.printStackTrace();
}
}
public int testScores(int[] scores, int min, int specials){
int over = specials;
int count = 0;
for(int i=0; i<scores.length; i++){
if(scores[i] < min) continue;
double avg = scores[i]/3.;
if(avg >= min || Math.ceil(avg)>=min){
count++;
continue;
}
if(Math.round(avg) == (int)avg + 1 && Math.round(avg) + 1 >= min && over > 0){
count++;
over--;
continue;
}
if(avg == (int)avg && avg + 1 >= min && over > 0){
over--;
count++;
continue;
}
}
return count;
}
}
| 0 | 1,189,273 |
A11759 | A13223 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.first;
public class MainClass {
/**
* @Author Nimitz
*/
public static void main(String[] args) {
// CodeJamSolution solution = new CodeJamSolution();
// ASpeakingInTongues solution = new ASpeakingInTongues();
BDancingWiththeGooglers solution = new BDancingWiththeGooglers();
}
}
| 0 | 1,189,274 |
A11759 | A11924 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
/**
* Created by IntelliJ IDEA.
* User: Linkov Mikl
* Date: 15.04.12
* Time: 2:51
* To change this template use File | Settings | File Templates.
*/
public class ProblemB {
public static void main(String [] args) {
Scanner scanner = new Scanner(System.in);
int testCount = scanner.nextInt();
for (int i = 0; i < testCount; i++) {
int n = scanner.nextInt();
int s = scanner.nextInt();
int p = scanner.nextInt();
int answer = 0;
for (int j = 0; j < n; j++) {
int point = scanner.nextInt();
int flag = 0;
int max1 = -1;
int max2 = -1;
for (int k1 = 0; k1 < 11; k1++) {
for (int k2 = 0; k2 < 11; k2++) {
for (int k3 = 0; k3 < 11; k3++) {
if (k3 + k2 + k1 == point) {
if ((Math.abs(k3 - k2) < 3) && (Math.abs(k1 - k2) < 3) && (Math.abs(k3 - k1) < 3)) {
if ((Math.abs(k3 - k2) == 2) || (Math.abs(k2 - k1) == 2) || (Math.abs(k3 - k1) == 2)) {
flag = 1;
max1 = Math.max(k1, max1);
max1 = Math.max(k2, max1);
max1 = Math.max(k3, max1);
} else {
max2 = Math.max(k1, max2);
max2 = Math.max(k2, max2);
max2 = Math.max(k3, max2);
}
}
}
}
}
}
if (max2 >= p) {
answer++;
} else {
if (s > 0) {
if (max1 >= p) {
answer++;
s--;
}
}
}
}
System.out.println("Case #" + (i + 1) + ": " + answer);
}
}
}
| 0 | 1,189,275 |
A11759 | A11474 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileInputStream;
import java.io.InputStreamReader;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Observable;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
*
* @author dante
*/
public class dancers {
public dancers(String filename)
{
base_size=0;
init_database();
contests = new int[100][6];
parsing(filename);
}
public void init_database()
{
int min,max;
database= new int[30*27+1][5];
for(int num=30;num>2;num=num-1)
{
min= (int)Math.ceil(((double)num-3)/3);
max= (int)Math.ceil(((double)num+3)/3);
for(int i=max; i>=min; i--)
{
for(int j=max; j>=min; j--)
{
for(int k=max; k>=min; k--)
{
if(((i+j+k)== num) && is_acceptable(i,j,k))
{
put_database(i,j,k);
}
}
}
}
//2
database[base_size][0]=2;
database[base_size][1]=1;
database[base_size][2]=1;
database[base_size][3]=0;
database[base_size][4]=is_surprising(1,1,0);
base_size++;
//1
database[base_size][0]=1;
database[base_size][1]=1;
database[base_size][2]=0;
database[base_size][3]=0;
database[base_size][4]=is_surprising(1,0,0);
base_size++;
//0
database[base_size][0]=0;
database[base_size][1]=0;
database[base_size][2]=0;
database[base_size][3]=0;
database[base_size][4]=is_surprising(0,0,0);
base_size++;
}
}
void put_database(int i, int j, int k)
{
database[base_size][0]=i+j+k;
database[base_size][1]=i;
database[base_size][2]=j;
database[base_size][3]=k;
database[base_size][4]=is_surprising(i,j,k);
base_size++;
}
int is_surprising(int i, int j, int k)
{
if(Math.abs(i-j)== 2)
{
return 1;
}
else if(Math.abs(i-k)==2)
{
return 1;
}
else if(Math.abs(j-k)==2)
{
return 1;
}
return 0;
}
boolean is_acceptable(int i, int j, int k)
{
if(Math.abs(i-j) > 2)
{
return false;
}
else if( Math.abs(j-k) > 2)
{
return false;
}
else if(Math.abs(i-k) > 2)
{
return false;
}
return true;
}
void parsing(String filename)
{
//String filename = args[1];
String strLine = null;
String [] temp= new String [150];
String delimeter=" ";
int num_contestants;
int best,index,found_index=0;
// int i;
// Open the file that is the first
// command line parameter
try{
final FileInputStream stream = new FileInputStream(filename);
// Get the object of DataInputStream
final DataInputStream dataInputStream = new DataInputStream(stream);
final BufferedReader reader = new BufferedReader(new InputStreamReader(dataInputStream));
PrintWriter out = new PrintWriter(new FileWriter("Bsmall"));
// out.print("Hello ");
// out.println("world");
// out.close();
//Read File Line By Line
int surp_events,my_surp_events;
int diafora=0,ptr_change;
if((strLine = reader.readLine()) != null)
{
System.out.println("Num_cases: "+ strLine);
}
//ena reader.readLine gia to prwto noumero
int my_case=0;
while ((strLine = reader.readLine()) != null) {
my_case++;
temp=strLine.split(delimeter);
num_contestants=Integer.parseInt(temp[0]);
surp_events=Integer.parseInt(temp[1]);
best=Integer.parseInt(temp[2]);
for(int i=0;i<num_contestants;i++)
{
contests[i][0]=Integer.parseInt(temp[3+i]);
contests[i][5]=-1;
}
//search strline for pattern
//contests new...
//geimzw to contests[][0] me ta noumera kai ta [][5] me to -1
for(int i=0;i<num_contestants;i++)
{
//find first triplet
for(int ptr=0;ptr<base_size;ptr++)
{
if(database[ptr][0]== contests[i][0])
{
found_index=ptr;
break;
}
}
//copy first triplet
for(int cell=1;cell<5;cell++)
{
contests[i][cell]=database[found_index][cell];
}
contests[i][5]=find_best(i);
}
my_surp_events=count_surp(num_contestants);
if(surp_events >= my_surp_events)
{
count_best(best,num_contestants);//apo reading
out.println("Case #"+my_case+ ": " + count_best(best,num_contestants));
//print
}
else
{
diafora=my_surp_events-surp_events;
index=0;
while(diafora>0 && index<num_contestants)
{
if(contests[index][4]==1) //if surprising
{
if(contests[index][5] >=best)
{
ptr_change=find_other(contests[index][0],best,1); //1 for want best
}
else
{
ptr_change=find_other(contests[index][0],best,0);
}
if(ptr_change!=-1)
{
contests[index][1]=database[ptr_change][1];
contests[index][2]=database[ptr_change][2];
contests[index][3]=database[ptr_change][3];
contests[index][4]=database[ptr_change][4];
contests[index][5]=find_best(index);
diafora--;
}
}
index++;
} //end while
my_surp_events=count_surp(num_contestants);
if(surp_events >= my_surp_events)
{
count_best(best,num_contestants);//apo reading
out.println("Case #"+my_case+ ": " + count_best(best,num_contestants));
//print
}
else //sencond parsing
{
index=0;
ptr_change=-1;
diafora=my_surp_events-surp_events;
while(diafora>0 && index<num_contestants)
{
if(contests[index][4]==1) //if surprising
{
ptr_change=find_other(contests[index][0],best,0);
}
if(ptr_change!=-1)
{
contests[index][1]=database[ptr_change][1];
contests[index][2]=database[ptr_change][2];
contests[index][3]=database[ptr_change][3];
contests[index][4]=database[ptr_change][4];
contests[index][5]=find_best(index);
diafora--;
}
index++;
}
if(diafora!=0)
{
System.out.println("ERROR ME TI DIAFORA");
}
else
{
out.println("Case #"+my_case+ ": " + count_best(best,num_contestants));
}
}
}
}
reader.close();
out.close();
} catch (Exception e) {//Catch exception if any
System.out.println("Error: " + e.toString() + " line: " + strLine);
}
}
int find_other(int total,int best,int choice)
{
for(int i=0;i<base_size;i++)
{
if(database[i][0]== total && database[i][4]==0) //not surspising
{
if(choice==1)
{
if(has_best(best,database[i][1],database[i][2],database[i][3]))
return i;
}
else
{
return i;
}
break;
}
}
return -1;
}
boolean has_best(int best, int i, int j,int k)
{
if(i>=best || j>=best || k>=best)
return true;
return false;
}
int find_best(int ptr_change)
{
int total_max=-1;
for(int i=1;i<4;i++)
{
if(total_max<contests[ptr_change][i])
total_max=contests[ptr_change][i];
}
return total_max;
}
int count_best(int best, int num_cont)
{
int count=0;
for(int i=0;i<num_cont;i++)
{
if(contests[i][5] >=best)
{
count++;
}
}
return count;
}
int count_surp(int num_cont)
{
int count=0;
for(int i=0;i<num_cont;i++)
{
count+=contests[i][4];
}
return count;
}
public static void main(String[] args) {
System.out.println(args[0]);
new dancers(args[0]);
}
private int [][]database;
private int [][]contests;
private int base_size;
}
| 0 | 1,189,276 |
A11759 | A11701 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 test2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;
/**
*
* @author Student
*/
public class Test2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws FileNotFoundException {
// TODO code application logic here
int i=1;
Scanner ss=new Scanner(new File("B-small-attempt1.in.txt"));
PrintWriter x=new PrintWriter(new File("B-small-attempt1.out.txt"));
if(ss.hasNext()) ss.next();
while(ss.hasNextLine()&&i<=100){
int n = 0;
if(ss.hasNext()) n=Integer.parseInt(ss.next());
int s = 0;
if(ss.hasNext()) s=Integer.parseInt(ss.next());
int p = 0;
if(ss.hasNext()) p=Integer.parseInt(ss.next());
LinkedList<Integer> l=new LinkedList<>();
for(int index=0;index<n;index++) l.add(Integer.parseInt(ss.next()));
x.println("Case #"+i+": "+Best.opt(n,s,p, l));
i++;
}
x.close();
}
}
| 0 | 1,189,277 |
A11759 | A12876 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 qual_b;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Formatter;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author Bart
*/
public class Qual_B {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
try {
String file = "B-small-attempt0";
Scanner scanner = new Scanner(new FileInputStream(file + ".in"));
Formatter formatter = new Formatter(new File(file + ".out"));
int numberOfCases = scanner.nextInt();
System.out.println("Number of cases: " + numberOfCases);
for (int caseNr = 0; caseNr < numberOfCases; caseNr++) {
// ** Code Here ** //
int n = scanner.nextInt();
int nSpecialCases = scanner.nextInt();
int max =scanner.nextInt();
int[] numbers = new int[n];
System.out.println("n: " + n);
for(int i=0;i<n;i++){
numbers[i] = scanner.nextInt();
}
int minAccepted = max + (max-1)*2;
int maxAccepted = max*3;
int minSpecial = max + (max-2)*2;
if (minSpecial <= 0)
minSpecial = 1;
System.out.printf("[%d, %d] (%d)%n", minAccepted, maxAccepted, minSpecial);
int score=0;
for(int i: numbers){
if(i>=minAccepted){
System.out.println("Binnen grens: " + i);
score++;
}
else if(nSpecialCases >0 && i>=minSpecial){
System.out.println("Binnen grens(speciaal)");
score++;
nSpecialCases--;
}
}
System.out.println("Score: " + score);
formatter.format("Case #%d: %d%n", caseNr + 1, score);
}
formatter.close();
} catch (FileNotFoundException ex) {
Logger.getLogger(Qual_B.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
| 0 | 1,189,278 |
A11759 | A10401 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Scanner;
public class GoogleCodeB {
public static void main(String args[]) throws Exception {
FileReader fr = new FileReader("C:/Users/moez/Desktop/B-small-attempt1.in");
BufferedReader br = new BufferedReader(fr);
FileWriter fstream = new FileWriter("C:/Users/moez/Desktop/out.txt");
BufferedWriter out = new BufferedWriter(fstream);
int l= 1;
String s;
int N, S, P, X, Y, nsurp, surp, temp;
int i = 0;
int[] t = new int[6];
String[] st = new String [6];
br.readLine();
while((s = br.readLine()) != null) {
Scanner sc = new Scanner(s);
i = 0;
N = sc.nextInt();
S = sc.nextInt();
P = sc.nextInt();
X = 3*P-2;
Y = ((3*P-4 > 0) ? 3*P-4 : P);
nsurp = surp= 0;
for (i=0; i<N ;i++){
temp = sc.nextInt();
if ( temp >= X){
nsurp++;
}else if ( temp >= Y)
surp++;
}
nsurp+=((surp > S) ? S : surp);
out.write("Case #"+l+": "+nsurp);
out.write("\r\n");
l++;
}
out.close();
fr.close();
}
}
| 0 | 1,189,279 |
A11759 | A11216 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.google.codejam;
public class CodeJamTest {
public static void main(String[] args){
Utils.run(DancingGoogler.class);
}
}
| 0 | 1,189,280 |
A11759 | A11518 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Array;
public class MainB {
final static String FNAME = "B-small-attempt0";
public BufferedReader in;
public PrintWriter out;
void open() throws IOException {
in = new BufferedReader( new FileReader( new File( FNAME+".in" ) ) );
out = new PrintWriter( new File( FNAME + ".out" ) );
}
void close() throws IOException {
out.close();
}
private boolean isBetterThanP(int num,int P)
{
int diff=num-P;
int num1=diff/2;
int num2=diff-num1;
if(num1+1<P)return false;
if(num1==num2||(num1+1==num2)) return true;
return false;
}
private boolean isBetterThanPCaseSupersing(int num,int P)
{
int diff=num-P;
if(diff<0) return false;
int diff1=diff-P+2;
if(diff1+2>=P) return true;
return false;
}
void run() throws IOException {
Integer T=Integer.parseInt(in.readLine()) ;
for(int i=1;i<=T;i++)
{
StringBuffer res=new StringBuffer();
res.append("Case #" + i + ": ");
String line=in.readLine();
String nums[]=line.split(" ");
int N=Integer.parseInt(nums[0]);
int S=Integer.parseInt(nums[1]);
int P=Integer.parseInt(nums[2]);
int c=0;
int[] arr=new int[N];
for(int k=0;k<N;k++)
{
arr[k]=Integer.parseInt(nums[3+k]);
if(isBetterThanP(arr[k],P))
{
c++;
}
else if(S>0&&isBetterThanPCaseSupersing(arr[k],P))
{
S--;
c++;
}
}
res.append(c);
out.println(res.toString());
}
}
public static void main( String[] args ) throws IOException {
new Thread() {
public void run() {
try {
MainB solution = new MainB();
solution.open();
solution.run();
solution.close();
} catch ( Exception e ) {
throw new RuntimeException( e );
}
}
}.start();
}
}
| 0 | 1,189,281 |
A11759 | A13139 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 IO;
import java.util.HashSet;
import java.util.Iterator;
/**
*
* @author dannocz
*/
public class Googler {
private int score; //A score per googler
private HashSet<Triplet> triplets; //A set of triplets per score
private int surprisedCases;
public Googler(int score, int surprisedCases) {
this.score = score;
this.surprisedCases=surprisedCases;
this.triplets= new HashSet<Triplet>();
}
public void addTriplet(Triplet triplet)
{
triplets.add(triplet);
}
public boolean result(int p){
Iterator iterator=triplets.iterator();
while (iterator.hasNext()) {
Triplet triplet = (Triplet)iterator.next();
if(triplet.compliesWithP(p) && triplet.surprised())
return true;
}
iterator=triplets.iterator();
while (iterator.hasNext()) {
Triplet triplet = (Triplet)iterator.next();
if(triplet.compliesWithP(p) && !triplet.surprised() && surprisedCases>0)
{
surprisedCases--;
return true;
}
}
return false;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public HashSet<Triplet> getTriplets() {
return triplets;
}
public void setTriplets(HashSet<Triplet> triplets) {
this.triplets = triplets;
}
}
| 0 | 1,189,282 |
A11759 | A12863 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class gcjq1 {
public static void main(String[] args) {
try{
FileInputStream ifstream = new FileInputStream("files/B-small-attempt0.in");
DataInputStream in = new DataInputStream(ifstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
FileOutputStream ofstream = new FileOutputStream("files/output");
DataOutputStream out = new DataOutputStream(ofstream);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
int numCases = Integer.parseInt(br.readLine());
for(int i=0; i<numCases; i++){
bw.write("Case #" + Integer.toString(i+1) + ": " + compute(br.readLine()) + "\n");
bw.flush();
}
in.close();
out.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
public static String compute(String in){
String[] parms = in.split(" ");
int N = Integer.parseInt(parms[0]);
int s = Integer.parseInt(parms[1]);
int p = Integer.parseInt(parms[2]);
int []t = new int[N];
for(int i=0; i<N; i++){
t[i] = Integer.parseInt(parms[i+3]);
}
int c = 0;
for(int i=0; i<N; i++){
int n = p+(2*(p-1));
if(t[i] >= n){
c++;
}
else {
n = p+(2*(p-2));
if(t[i] >= n && t[i] > 0 && s>0){
c++;
s--;
}
}
}
return Integer.toString(c);
}
}
| 0 | 1,189,283 |
A11759 | A13150 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 CodeJamProblem implements Runnable {
public int getRisultato(int n, int s, int p, int[] points) {
// n=6 s=2 p=8 29 20 8 18 18 21
int vincitori = 0;
int suprise = s;
//Arrays.sort(points);
System.out.println("CASE:"+Arrays.toString(points));
for(int i =0;i<points.length;i++) {
int base = (int)(points[i] / 3);
int resto = points[i]%3;
System.out.print(" Resto: " + resto);
System.out.println("");
switch (resto)
{
case 0:
if (base >=p)
{
vincitori++;
}
else
{
// check for surprise case:
if (suprise > 0 && base > 0 &&base + 1 >= p)
{
vincitori++;
suprise--;
}
}
break;
case 1:
if (base >= p || base + 1 >= p)
{
vincitori++;
}
else
{
// surprise case:
if (suprise > 0 && base + 1 >= p)
{
vincitori++;
suprise--;
}
}
break;
case 2:
if (base + 1 >= p || base >= p)
{
vincitori++;
}
else
{
if (suprise > 0 && base + 2 >= p)
{
System.out.println("Winner");
vincitori++;
suprise--;
}
}
break;
}
}
System.out.println("Winner["+p+","+s+"]:"+ vincitori);
return vincitori;
}
public void solve() throws IOException {
String test = "small";
//String test = "large";
Scanner in = new Scanner(new File("B-small-attempt0.in")).useDelimiter(System.getProperty("line.separator"));
PrintWriter out = new PrintWriter(new File("B-small-attempt3.out"));
int lineNum = 0;
int testNum = 0;
int totalTests = 0;
/*
3 1 5 15 13 11
3 0 8 23 22 21
2 1 1 8 0
6 2 8 29 20 8 18 18 21
*/
int n = 0;
int s = 0;
int p = 0;
int[] points = new int[1];
/*
String[] x = ("3 1 5 15 13 11").split(" ");
for(int i = 0;i<x.length;i++) {
if(i==0){
n = Integer.parseInt(x[i]);
}
if(i==1) {
s = Integer.parseInt(x[i]);
}
if(i==2) {
p = Integer.parseInt(x[i]);
}
if(i>2) {
if(i==3) points = new int[n];
points[i-3] = Integer.parseInt(x[i]);
}
}
int risultato = getRisultato(n,s,p,points);
*/
while (in.hasNext()) {
String currentLine = in.next();
if(lineNum ==0 ) {
//Do Nothing!
totalTests = Integer.parseInt(currentLine);
lineNum++;
continue;
}
if(lineNum>0) {
String[] x = currentLine.split(" ");
for(int i = 0;i<x.length;i++) {
if(i==0){
n = Integer.parseInt(x[i]);
}
if(i==1) {
s = Integer.parseInt(x[i]);
}
if(i==2) {
p = Integer.parseInt(x[i]);
}
if(i>2) {
if(i==3) points = new int[n];
points[i-3] = Integer.parseInt(x[i]);
}
}
int risultato = getRisultato(n,s,p,points);
System.out.println("Case #"+(testNum+1)+": "+ risultato);
out.println("Case #"+(testNum+1)+": "+ risultato);
testNum++;
}
lineNum++;
}
in.close();
out.close();
}
public void run() {
try {
solve();
} catch (IOException e) {
System.exit(1);
}
}
public static void main(String[] s) {
new Thread(new CodeJamProblem()).start();
}
}
| 0 | 1,189,284 |
A11759 | A12455 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 OleGG
*/
public class QualTaskB {
public static void main(String[] args) throws Throwable {
//StreamTokenizer st = new StreamTokenizer(new BufferedReader(new FileReader("B-small-attempt0.in.txt")));
PrintWriter pw = new PrintWriter(new FileWriter("B-small-attempt0.out.txt"));
StreamTokenizer st = new StreamTokenizer(new InputStreamReader(System.in));
st.nextToken();
int t = (int)st.nval;
for (int test = 1; test <= t; ++test) {
st.nextToken();
int n = (int)st.nval;
st.nextToken();
int s = (int)st.nval;
st.nextToken();
int p = (int)st.nval;
int[] val = new int[n];
for (int i = 0; i < n; ++i) {
st.nextToken();
val[i] = (int)st.nval;
}
int[][] dyn = new int[n + 1][s + 1];
for (int i = 0; i <= n; ++i) {
Arrays.fill(dyn[i], 0);
}
for (int i = 0; i < n; ++i) {
dyn[i + 1][0] = dyn[i][0];
if ((val[i] + 2) / 3 >= p) {
++dyn[i + 1][0];
}
for (int j = 0; j < s; ++j) {
int add = (val[i] + 2) / 3 >= p ? 1 : 0;
int addS = Integer.MIN_VALUE;
if (val[i] >= 2 && val[i] <= 28) {
switch (val[i] % 3) {
case 0:
case 1:
addS = val[i] / 3 + 1 >= p ? 1 : 0;
break;
case 2:
addS = val[i] / 3 + 2 >= p ? 1 : 0;
break;
}
}
dyn[i + 1][j + 1] = Math.max(dyn[i][j+1] + add, dyn[i][j] + addS);
}
}
pw.printf("Case #%d: %d\n", test, dyn[n][s]);
}
pw.close();
}
}
| 0 | 1,189,285 |
A11759 | A10681 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Dancing
{
public static void main(String args[]) throws IOException
{
BufferedReader in=new BufferedReader(new FileReader("in.txt"));
PrintWriter out=new PrintWriter(new FileWriter("out.txt"));
int tests=Integer.parseInt(in.readLine());
for(int i=0;i<tests;i++)
{
String data[]=in.readLine().split("\\s+");
int people=Integer.parseInt(data[0]);
int surprise=Integer.parseInt(data[1]);
int min_score=Integer.parseInt(data[2]);
int count=0;
for(int j=3;j<data.length;j++)
{
int quot=Integer.parseInt(data[j])/3;
switch (Integer.parseInt(data[j]) % 3)
{
case 0:
if (quot>=min_score)
{
count++;
}
else
{
if (surprise>0 && quot>0 && quot+1>=min_score)
{
count++;
surprise--;
}
}
break;
case 1:
if (quot>=min_score || quot+1>=min_score)
{
count++;
}
else
{
if (surprise>0 && quot+1>=min_score)
{
count++;
surprise--;
}
}
break;
case 2:
if (quot+1>=min_score || quot>=min_score)
{
count++;
}
else
{
if (surprise>0 && quot+2>=min_score)
{
count++;
surprise--;
}
}
break;
}
}
out.println("Case #"+(i+1)+": "+count);
out.flush();
}
}
}
| 0 | 1,189,286 |
A11759 | A10104 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Problem2 {
public Problem2(){
Scanner scan = new Scanner(System.in);
int inputs = scan.nextInt();
for(int i=1; i<=inputs; i++){
int googlers = scan.nextInt();
int sur = scan.nextInt();
int bResult = scan.nextInt();
int num = 0;
int[] results = new int[googlers];
for(int j=0; j<googlers; j++){
results[j]=scan.nextInt();
}
num = calc(googlers, sur, bResult, results);
System.out.println("Case #"+i+": "+num);
}
}
public int calc(int g, int s, int bS, int[] r){
int[][] score = new int[g][5];
for(int i=0; i<g; i++){
if(r[i]%3 == 0){
score[i][0] = 0;
score[i][1] = r[i]/3;
score[i][2] = r[i]/3;
score[i][3] = r[i]/3;
score[i][4] = 1;
}else{
double h = r[i];
h = h/3;
if(Math.floor(h) == Math.round(h)){ //means the value is x.3333, should now add two rounded down and add one rounded up
score[i][0] = 0;
score[i][1] = (int)Math.floor(h);
score[i][2] = (int)Math.floor(h);
score[i][3] = (int)Math.ceil(h);
}else{ //catches values with x.6666, should now add two rounded up and add one rounded down
score[i][0] = 0;
score[i][1] = (int)Math.floor(h);
score[i][2] = (int)Math.ceil(h);
score[i][3] = (int)Math.ceil(h);
score[i][4] = 1;
}
}
if(score[i][1]>=bS || score[i][2]>=bS || score[i][3]>=bS){
score[i][0]=1;
}
}
int x = 0;
List<Integer> z = new ArrayList<Integer>();
for(int i=0; i<g; i++){
if(score[i][0] != 1){
z.add(i);
x++;
}
}
int f = 0;
for(int a:z){
if(score[a][3] >= bS-1 && f<s && score[a][1]+score[a][2]+score[a][3]>1 && score[a][4]==1){
f++;
}
}
x = x-f;
return g-x;
}
public static void main(String[] args){
new Problem2();
}
}
| 0 | 1,189,287 |
A11759 | A13011 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.FileWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class MainB {
private static Integer maxDif(Integer n1,Integer n2,Integer n3)
{
return Math.max(Math.max(n1, n2),n3)-Math.min(Math.min(n1, n2), n3);
}
private static Integer maxDif(Integer n1,Integer n2)
{
if (n1>n2)
{
return n1-n2;
}
else
{
return n2-n1;
}
}
private static Boolean esPosible(Integer p,Integer i)
{
Boolean res=false;
if (p<i)
{
for (int j=p;j<11;j++)
{
for (int k=0;k<11 && (j+k)<i;k++)
{
for (int l=0;l<11 && (j+k+l)<=i;l++)
{
if (maxDif(j,k,l)<2 && j+k+l==i)
{
//System.out.println("Posible puntuacion "+j+" "+k+ " "+l + " para "+i);
return true;
}
}
}
}
}
return res;
}
private static Boolean esPosibleSorp(Integer p,Integer i)
{
Boolean res=false;
if (p<i)
{
for (int j=p;j<11;j++)
{
for (int k=0;k<11 && (j+k)<i;k++)
{
for (int l=0;l<11 && (j+k+l)<=i;l++)
{
if (maxDif(j,k,l)==2 && j+k+l==i)
{
//System.out.println("Posible puntuacion sorprendente "+j+" "+k+ " "+l+ " para "+i);
return true;
}
}
}
}
}
return res;
}
public static void main(String[] args) {
File archivo = null;
FileReader fr = null;
FileWriter wr = null;
PrintWriter pw = null;
BufferedReader br = null;
Integer num = 0;
String linea;
Integer N,S,p;
ArrayList<Integer> punt;
ArrayList<Integer> noPos;
String aux;
Integer cont;
StringTokenizer st;
try {
archivo = new File("C:/Users/Pc/Desktop/input.in");
fr = new FileReader(archivo);
br = new BufferedReader(fr);
wr = new FileWriter("C:/Users/Pc/Desktop/output.out");
pw = new PrintWriter(wr);
// Lectura del fichero
while ((linea = br.readLine()) != null) {
if (num != 0) {
aux = "Case #" + num.toString() + ": "; // Inicialización
// del case #N:
st=new StringTokenizer(linea," ");
N=Integer.parseInt(st.nextToken());
S=Integer.parseInt(st.nextToken());
p=Integer.parseInt(st.nextToken());
punt=new ArrayList<Integer>();
noPos=new ArrayList<Integer>();
while (st.hasMoreTokens())
{
punt.add(Integer.parseInt(st.nextToken()));
}
cont=0;
for (Integer i:punt)
{
if (esPosible(p,i))
{
cont+=1;
}
else
{
noPos.add(i);
}
}
//Ahora de los no posibles intentamos que sean posibles mediante sorprendente
for(Integer i:noPos)
{
if (S!=0)
{
if (esPosibleSorp(p,i))
{
cont++;
S--;
}
}
else
{
break;
}
}
aux+=cont;
pw.println(aux);
}
num++;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (null != fr) {
fr.close();
wr.close();
}
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
| 0 | 1,189,288 |
A11759 | A12731 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 ProblemB extends FileWrapper {
private int N[] = null;
private int S[] = null;
private int P[] = null;
private int t[][] = null;
public ProblemB(String fileName) {
this.processInput(fileName);
this.calculate();
this.processOutput(OUTPUT);
}
private int getResult(int caseNum) {
int total = 0;
for (int i=0; i<this.t[caseNum].length; i++) {
if (this.t[caseNum][i]/3 >= this.P[caseNum]) {
total++;
}else if (this.t[caseNum][i]/3 == this.P[caseNum] - 1) {
if (this.t[caseNum][i]%3 >= 1) {
total++;
}else if (S[caseNum] > 0 && this.t[caseNum][i]/3 > 0) {
total++;
S[caseNum]--;
}
}else if (this.t[caseNum][i]/3 == this.P[caseNum] - 2 && this.t[caseNum][i]%3 == 2 && this.t[caseNum][i]/3 > 0 && S[caseNum] > 0) {
total++;
S[caseNum]--;
}
}
return total;
}
@Override
protected void processInput(String fileName) {
try {
this.openReadFile(fileName);
this.caseNum = Integer.parseInt(this.readLine());
this.output = new String[this.caseNum];
this.N = new int[this.caseNum];
this.S = new int[this.caseNum];
this.P = new int[this.caseNum];
this.t = new int[this.caseNum][];
for (int i = 0; i < this.caseNum; i++) {
String elem[] = this.readLine().split(" ");
this.N[i] = Integer.parseInt(elem[0]);
this.S[i] = Integer.parseInt(elem[1]);
this.P[i] = Integer.parseInt(elem[2]);
this.t[i] = new int[N[i]];
for (int j=0; j<N[i]; j++) {
this.t[i][j] = Integer.parseInt(elem[3+j]);
}
}
this.closeReadFile();
} catch (Exception e) {
}
}
@Override
protected void calculate() {
for (int i=0; i<this.caseNum; i++) {
this.output[i] = CASE + (i+1) + ": " + this.getResult(i);
}
}
public static void main(String argv[]) {
if (argv.length > 0) {
new ProblemB(argv[0]);
} else {
new ProblemB("B-small-attempt1.in");
}
}
} | 0 | 1,189,289 |
A11759 | A10294 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.Scanner;
public class surprisingTriplets
{
public static Scanner sc;
public static void main(String args[]) throws IOException
{
Scanner sc = new Scanner(System.in);
int numCasos = sc.nextInt();
int numConcursants;
int surprisingTriplets;
int p;
int resultat;
int qt = 0;
while(qt < numCasos)
{
numConcursants = sc.nextInt();
surprisingTriplets = sc.nextInt();
p = sc.nextInt();
resultat = totalPoints(numConcursants,surprisingTriplets,p,sc);
System.out.println("Case #"+(qt+1)+": "+resultat);
qt++;
}
}
public static int totalPoints(int numConcursants, int surprisingTriplets, int p, Scanner sc)
{
int qt = 0;
int bons=0;
int votacio;
int minimNormal;
int minimSurprising;
if(p > 1){ minimSurprising = p + (p-2) + (p-2); minimNormal = p + (p-1) + (p-1);}
else if(p == 1){ minimSurprising = 1; minimNormal = 1;}
else{ minimSurprising = 0; minimNormal = 0;}
while(qt < numConcursants)
{
votacio = sc.nextInt();
if(votacio >= minimNormal)
{
bons++;
}
else
{
if(votacio >= minimSurprising && surprisingTriplets > 0)
{
bons++;
surprisingTriplets--;
}
}
qt++;
}
return bons;
}
} | 0 | 1,189,290 |
A11759 | A12151 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Prof2ProB {
public static void main(String args[]) {
try {
BufferedReader breader = new BufferedReader(new FileReader("F:\\test.txt"));
int noo;
noo= Integer.parseInt(breader.readLine());
int casen=0;
int noofgglrs;
int specialcases;
int maxnumber,i;
String tempstr;
String outp;
outp="";
String nos[];
int tmp;
int count;
while( casen < noo ) {
tempstr = breader.readLine();
nos = tempstr.split(" ");
outp += "Case #"+(casen+1)+": ";
noofgglrs = Integer.parseInt(nos[0]);
specialcases = Integer.parseInt(nos[1]);
maxnumber = Integer.parseInt(nos[2]);
count = 0;
for(i=0;i<noofgglrs;i++) {
tmp = Integer.parseInt(nos[i+3]);
if( tmp / 3 >= maxnumber )
count++;
else if( tmp%3 == 1 && (tmp/3)+(tmp%3) >= maxnumber) {
System.out.println("here2:" + tmp);
count++;
}
else if( tmp%3 == 2 && specialcases > 0 && (tmp%3)+(tmp/3) >= maxnumber ) {
System.out.println("here: " + tmp);
count++;
specialcases--;
}
else if( tmp%3 == 2 && ((tmp/3)+((tmp/3)+1)*2) == tmp && (tmp/3)+1>=maxnumber ) {
System.out.println("here3: " + tmp);
count++;
}
else if( tmp!=0 && tmp%3 == 0 && specialcases > 0 && (tmp/3)+1 >= maxnumber ) {
System.out.println("here1: " + tmp);
count++;
specialcases--;
}
}
outp += count;
if( casen != noo-1 )
outp += "\n";
casen++;
}
System.out.println(outp);
BufferedWriter bwrtr = new BufferedWriter( new FileWriter("F:\\result.txt"));
bwrtr.write(outp);
bwrtr.close();
breader.close();
}
catch( Exception e ) {
e.printStackTrace();
}
}
}
| 0 | 1,189,291 |
A11759 | A13001 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package qualification.q2;
/**
* Created by IntelliJ IDEA.
* User: ofer
* Date: 14/04/12
* Time: 18:47
* To change this template use File | Settings | File Templates.
*/
public class Q2Solver {
public int solve(int n,int s,int p, int[] sums){
int res = 0;
int surprisesLeft = s;
for (int sum : sums){
int div = sum / 3;
int mod = sum % 3;
if (div >= p){
res++;
}
else if( p - div == 1){
if (div > 0 && mod == 0 && surprisesLeft > 0){
res++;
surprisesLeft--;
}
else if (mod > 0){
res++;
}
}
else if (p -div ==2 && mod == 2 && surprisesLeft > 0){
res++;
surprisesLeft--;
}
}
return res;
}
}
| 0 | 1,189,292 |
A11759 | A10288 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package gcj;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class DancingWithTheGooglers {
/**
* @param args
*/
private static int[] values = null;
private static int[] googlers= null;
private static int total =0;
public static void main(String[] args) {
BufferedReader fin = null;
int t = 0;
StringTokenizer str = null;
try {
fin = new BufferedReader(new FileReader(new File("B-small-attempt1.in")));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
try {
t = Integer.parseInt(fin.readLine());
//System.out.println(t);
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
values = new int[3];
for(int i=0;i<t;i++){
System.out.print("Case #"+(i+1)+": ");
try {
total = 0;
str=new StringTokenizer(fin.readLine());
int ctr =0;
while(ctr<3) {
values[ctr]=Integer.parseInt(str.nextToken());
ctr++;
}
//System.out.print(values[0]+" "+values[1]+" "+values[2]+" ");
ctr=0;
googlers = new int[values[0]];
while(str.hasMoreElements()){
googlers[ctr]=Integer.parseInt(str.nextToken());
//System.out.print(googlers[ctr]+" ");
ctr++;
}
//System.out.println();
} catch (IOException e) {
e.printStackTrace();
}
calculate();
}
}
private static void calculate() {
int value = 0 ;
int remainder = 0;
for(int i=0;i<values[0];i++){ //values[1] is the number of surprising solutions
//values[2] is p
//values[0] is number of cases
//googlers is the totals of the each googler
//value is the division of total by 3
value = googlers[i]/3;
remainder = googlers[i]%3;
if (googlers[i]==0&&values[2]!=0)
continue;
if(value>=values[2])
total++;
else if(remainder==0&&values[1]>0&&(value+1)>=values[2]){
values[1]--;
total++;
}
else if(remainder>0&&(value+1)>=values[2])
total++;
else if(remainder==2&&(value+2)>=values[2]&&values[1]>0){
total++;
values[1]--;
}
}
System.out.println(total);
}
}
| 0 | 1,189,293 |
A11759 | A11791 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 dancinggooglers;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
public class DancingGooglers {
public static void main(String[] args) {
String input;
String output = "";
int i = 0, googler, div, under, valid, remains;
int cases, surp, point;
try {
FileReader fr = new FileReader(new File("B-small-attempt0.in"));
BufferedReader br = new BufferedReader(fr);
FileWriter fstream = new FileWriter("B-small-attempt0.out");
BufferedWriter out = new BufferedWriter(fstream);
cases = Integer.parseInt(br.readLine());
i = 0;
while(i < cases) {
input = br.readLine();
output += "Case #"+(++i)+": ";
String[] split = input.split(" ");
surp = Integer.parseInt(split[1]);
point = Integer.parseInt(split[2]);
under = 0;
valid =0;
for (int j=0; j<Integer.parseInt(split[0]); j++){
googler = Integer.parseInt(split[3+j]);
div = googler - point*3;
remains = googler - point;
if((div > -3)&&(remains >= 0)){ valid++; }
else if((div > -5)&&(remains >= 0)){ under++; }
}
if(under <= surp) { valid += under; }
else { valid += surp; }
output += valid;
out.write(output);
output = "\n";
}
out.close();
br.close();
}catch (Exception e) { System.err.println("Error: " + e.getMessage()); }
}
}
| 0 | 1,189,294 |
A11759 | A12567 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.text.NumberFormat;
import java.util.List;
public class Welcome extends JamProblem {
String welc = "welcome to code jam";
public static void main(String[] args) throws IOException {
Welcome p = new Welcome();
p.go();
}
@Override
String solveCase(JamCase jamCase) {
WelcomeCase cas = (WelcomeCase) jamCase;
int length = welc.length();
int strL = cas.str.length();
String str = cas.str;
int[][] tab = new int[length][strL];
for (int i = length - 1; i >= 0; i--) {
char c = welc.charAt(i);
for (int j = strL - 1; j >= 0; j--) {
if (i == length - 1) {
if (j == strL - 1) {
tab[i][j] = str.charAt(j) == c ? 1 : 0;
} else {
tab[i][j] = mod(tab[i][j + 1] + (str.charAt(j) == c ? 1 : 0));
}
} else {
if (j == strL - 1) {
tab[i][j] = 0;
} else {
tab[i][j] = mod(tab[i][j + 1] + (str.charAt(j) == c ? 1 : 0) * tab[i + 1][j]);
}
}
}
}
NumberFormat nf = NumberFormat.getInstance(); // Get Instance of NumberFormat
nf.setMinimumIntegerDigits(4); // The minimum Digits required is 5
nf.setMaximumIntegerDigits(4); // The maximum Digits required is 5
nf.setGroupingUsed(false);
return nf.format(tab[0][0]); //To change body of implemented methods use File | Settings | File Templates.
}
@Override
JamCase parseCase(List<String> file, int line) {
WelcomeCase cas = new WelcomeCase();
cas.lineCount = 1;
cas.str = file.get(line);
return cas;
}
int mod(int i) {
return i % 10000;
}
}
class WelcomeCase extends JamCase {
String str;
}
| 0 | 1,189,295 |
A11759 | A10861 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.com;
import java.util.Scanner;
public class problemB {
public static void main(String[] Args) {
Scanner sc = new Scanner(System.in);
int tests = sc.nextInt();
int n, s, p;
sc.nextLine();
for (int i = 1; i <= tests; i++) {
int t;
int count = 0;
int uCount = 0;
n = sc.nextInt();
s = sc.nextInt();
p = sc.nextInt();
for (int j = 1; j <= n; j++) {
t = sc.nextInt();
if (suprise(t) >= p && unsuprise(t) >= p)
count++;
else if (suprise(t) >= p)
count++;
else if (unsuprise(t) >= p)
uCount++;
}
if (s < uCount)
uCount = s;
System.out.println("Case #" + i + ": " + (count + uCount));
sc.nextLine();
}
}
public static int max(int a, int b, int c) {
int max = Integer.MIN_VALUE;
if (a > max)
max = a;
if (b > max)
max = b;
if (c > max)
max = c;
return max;
}
public static int suprise(int t) {
int dim;
dim = t / 3;
if (t == 0)
return 0;
if (t == 30)
return 30;
if (dim > 0) {
int p;
p = (dim + 1) + (dim + 1) + (dim);
if (p == t)
return max((dim + 1), (dim + 1), (dim));
p = (dim + 1) + (dim) + (dim);
if (p == t)
return max((dim + 1), (dim), (dim));
p = (dim) + (dim) + (dim);
if (p == t)
return max((dim), (dim), (dim));
p = (dim - 1) + (dim) + (dim);
if (p == t)
return max((dim - 1), (dim), (dim));
p = (dim - 1) + (dim - 1) + (dim);
if (p == t)
return max((dim - 1), (dim - 1), (dim));
} else
return 1;
return -1;
}
public static int unsuprise(int t) {
int dim;
int p;
dim = t / 3;
if (t == 0)
return 0;
if (t == 30)
return 30;
if (dim > 1 && dim < 9) {
p = (dim + 2) + (dim + 1) + (dim);
if (p == t)
return max((dim + 2), (dim + 1), (dim));
p = (dim + 2) + (dim + 2) + (dim);
if (p == t)
return max((dim + 2), (dim + 2), (dim));
p = (dim + 2) + (dim) + (dim);
if (p == t)
return max((dim + 2), (dim), (dim));
p = (dim - 2) + (dim - 1) + (dim);
if (p == t)
return max((dim - 2), (dim - 1), (dim));
p = (dim - 2) + (dim) + (dim);
if (p == t)
return max((dim - 2), (dim), (dim));
p = (dim - 2) + (dim - 2) + (dim);
if (p == t)
return max((dim - 2), (dim - 2), (dim));
p = (dim - 1) + (dim + 1) + (dim);
if (p == t)
return max((dim - 1), (dim + 1), (dim));
}
if (dim <= 1) {
p = (dim + 2) + (dim) + (dim);
if (p == t)
return max((dim + 2), (dim), (dim));
p = (dim + 2) + (dim + 2) + (dim);
if (p == t)
return max((dim + 2), (dim + 2), (dim));
p = (dim + 2) + (dim + 1) + (dim);
if (p == t)
return max((dim + 2), (dim + 1), (dim));
if (dim == 1) {
p = (dim - 1) + (dim + 1) + (dim);
if (p == t)
return max((dim - 1), (dim + 1), (dim));
}
}
if (dim >= 9) {
p = (dim - 2) + (dim - 2) + (dim);
if (p == t)
return max((dim - 2), (dim - 2), (dim));
p = (dim - 2) + (dim) + (dim);
if (p == t)
return max((dim - 2), (dim), (dim));
p = (dim - 2) + (dim - 1) + (dim);
if (p == t)
return max((dim - 2), (dim - 1), (dim));
if (dim == 9) {
p = (dim - 1) + (dim + 1) + (dim);
if (p == t)
return max((dim - 1), (dim + 1), (dim));
}
}
return -1;
}
}
| 0 | 1,189,296 |
A11759 | A10774 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
public class Dance {
/* Returns pair (max if not surprising, max if surprising */
private static int[] max(int score) {
int max, maxsurpr;
if(score == 0) {
max = 0;
maxsurpr = 0;
} else if(score == 1) {
max = 1;
maxsurpr = 1;
} else if(score == 2) {
max = 1;
maxsurpr = 2;
} else if((score % 3) == 0) {
max = score/3;
maxsurpr = score/3 + 1;
} else if((score % 3) == 1) {
max = score/3 + 1;
maxsurpr = score/3 + 1;
} else {
max = score/3 + 1;
maxsurpr = score/3 + 2;
}
return new int[] {max, maxsurpr};
}
private static int process(String l) {
String[] parts = l.split(" ");
int N = Integer.parseInt(parts[0]);
int S = Integer.parseInt(parts[1]);
int p = Integer.parseInt(parts[2]);
if(parts.length != N+3) {
System.err.println("Error: " + l);
}
int good = 0;
for(int i=0; i<N; i++) {
int[] max = max(Integer.parseInt(parts[i+3]));
if(max[0] >= p) good++;
else {
if(max[1] >= p && S > 0) {
good++;
S--;
}
}
}
return good;
}
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader(args[0]));
PrintWriter out = new PrintWriter(args[1]);
// number of testcases
String sCount = in.readLine();
int count = Integer.parseInt(sCount);
for(int idx=1; idx<=count; idx++) {
String l = in.readLine();
out.println("Case #" + idx + ": " + process(l));
}
out.close();
}
}
| 0 | 1,189,297 |
A11759 | A13121 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//n cases
for (int i = 1; i <= n+1; i++) {
//for each case
int dancers = sc.nextInt();
int surprising = sc.nextInt();
int minscore = sc.nextInt();
int res=0;
for (int j = 0; j < dancers; j++) {
int scoretotal = sc.nextInt();
if (minscore!=0 && scoretotal/minscore>=1) {
if (surprising>=1) {
if (scoretotal>minscore*3-3) {
res++;
}else if (scoretotal==minscore*3-4 || scoretotal==minscore*3-3) {
res++;
surprising--;
}
}else if (surprising==0) {
if (scoretotal>=minscore*3-2) {
res++;
}
}
}else if (minscore==0) {
res = dancers;
}
}
System.out.println("Case #"+i+": "+res);
}
}
}
| 0 | 1,189,298 |
A11759 | A11231 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Q2 {
/**
* @param args
* @throws Throwable
*/
public static void main(String[] args) throws Throwable {
BufferedReader br = new BufferedReader(new FileReader("a-small.in"));
PrintWriter pr = new PrintWriter(new FileWriter("output.txt"));
int T = Integer.parseInt(br.readLine());
for(int cas = 1; cas<=T; cas++)
{
String[] input = br.readLine().split(" ");
int N = Integer.parseInt(input[0]);
int S = Integer.parseInt(input[1]);
int p = Integer.parseInt(input[2]);
int score = 0;
int normalMin = p + 2*(p-1);
int sMin = p + 2*(p-2);
if(p == 0)
{
normalMin = 0;
sMin = 0;
}
else if(p == 1)
{
normalMin = 1;
sMin = 1;
}
for(int person = 0; person<N;person++)
{
int total = Integer.parseInt(input[person+3]);
if(total >= normalMin)
{
score++;
}
else if(total >= sMin && S > 0)
{
score++;
S--;
}
}
pr.println("Case #" + cas + ": " + score);
}
pr.close();
}
}
| 0 | 1,189,299 |