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 | A11144 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
public class B implements Runnable
{
//private String IFILE = "input.txt";
private String IFILE = "B-small-attempt0.in";
private Scanner in;
private PrintWriter out;
public void Run() throws IOException
{
in = new Scanner(new File(IFILE));
out = new PrintWriter("output.txt");
int ntest = in.nextInt();
for(int test = 1; test <= ntest; test++)
{
out.print("Case #" + test + ": ");
int n = in.nextInt();
int m = in.nextInt();
int p = in.nextInt();
int[] mas = new int[n];
for(int i = 0; i < n; i++)
mas[i] = in.nextInt();
int[] max1 = new int[31];
for(int i = 1; i <= 10; i++)
max1[Math.max(0, Math.min(30, 3 * i - 2))] = i;
int[] max2 = new int[31];
for(int i = 1; i <= 10; i++)
max2[Math.max(1, Math.min(30, 3 * i - 4))] = i;
for(int i = 1; i <= 30; i++)
max1[i] = Math.max(max1[i], max1[i - 1]);
for(int i = 1; i <= 30; i++)
max2[i] = Math.max(max2[i], max2[i - 1]);
int n1 = 0;
int n2 = 0;
for(int i = 0; i < n; i++)
{
if (max1[mas[i]] >= p)
n1++;
else if (max2[mas[i]] >= p)
n2++;
}
out.println(n1 + Math.min(n2, m));
}
in.close();
out.close();
}
public void run()
{
try
{
Run();
}
catch(IOException e)
{
}
}
public static void main(String[] args) throws IOException
{
new B().Run();
//new Thread(new XXX()).start();
}
}
| 0 | 1,189,600 |
A11759 | A12359 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
/**
*
* @author Nikhil
*/
public class b {
public static void main(String[] args) throws FileNotFoundException, IOException {
File fInput = new File(args[0]);
String tmp;
if (fInput.exists() && fInput.isFile()) {
BufferedReader br = new BufferedReader(new FileReader(fInput));
int iTestCases = Integer.parseInt(br.readLine());
int iCase = 1;
while (null != (tmp = br.readLine())) {
Danscore d = new Danscore(tmp);
d.solve();
System.out.println("Case #" + iCase + ": " + d);
iCase++;
}
br.close();
}
}
}
class Danscore {
private int iBestScoreDancers;
private int iDancers;
private int iSurprises;
private int iBestScore;
private List<Integer> scores;
Danscore(String tmp) {
String[] inp = tmp.split(" ");
iDancers = Integer.parseInt(inp[0]);
iSurprises = Integer.parseInt(inp[1]);
iBestScore = Integer.parseInt(inp[2]);
scores = new ArrayList<Integer>();
for (int i = 3; i < inp.length; i++) {
scores.add(Integer.parseInt(inp[i]));
}
Collections.sort(scores, Collections.reverseOrder());
}
void solve() {
iBestScoreDancers = 0;
// Minimum score required to qualify as best score + has Surprises
int iMinimumReq = iBestScore + (iBestScore - 2) + (iBestScore - 2);
// Make sure minimum required score is positive
iMinimumReq = iMinimumReq<0? 0:iMinimumReq;
// Normal scores required if Suprises are exausted
int iNormalScore = iBestScore + (iBestScore - 1) + (iBestScore - 1);
iNormalScore = iNormalScore<0? 0:iNormalScore;
Iterator<Integer> itr = scores.iterator();
while (itr.hasNext()) {
int iscore = itr.next();
if (iscore < iBestScore) continue;
if (iscore >= iNormalScore) {
iBestScoreDancers++;
continue;
}
if (iSurprises > 0 && iscore >= iMinimumReq) {
iBestScoreDancers++;
iSurprises--;
}
}
}
@Override
public String toString() {
return String.valueOf(iBestScoreDancers);
}
}
| 0 | 1,189,601 |
A11759 | A11697 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 dg.gcj.bdancing;
import java.io.*;
/**
* Created by IntelliJ IDEA.
* User: Dmitry
* Date: 14.04.12
* Time: 23:28
* To change this template use File | Settings | File Templates.
*/
public class DancingEntryPoint
{
public static void main(String[] args) throws IOException {
// String inputFileName = "test.txt";
String inputFileName = "B-small-attempt0.in";
// String inputFileName = "B-large-practice.in";
final RandomAccessFile ra = new RandomAccessFile(inputFileName,"r");
String line = ra.readLine();
final int testsCount = Integer.parseInt(line.trim());
Parser testParser = new Parser();
Solver solver = new Solver();
final File resultFile = new File(inputFileName + ".out.txt");
resultFile.delete();
resultFile.createNewFile();
final OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(resultFile), "UTF-8");
for(int i = 0; i < testsCount; ++ i)
{
String testLine = ra.readLine();
final World world = testParser.parse(testLine);
int result = solver.solve(world);
StringBuilder formattedResult = new StringBuilder();
formattedResult.append("Case #").append(i + 1).append(": ");
formattedResult.append(result);
formattedResult.append("\r\n");
writer.write(formattedResult.toString(), 0, formattedResult.length());
System.out.print(formattedResult);
}
writer.close();
ra.close();
}
}
| 0 | 1,189,602 |
A11759 | A10341 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 implements Runnable {
public static void main(String[] args) throws IOException {
new Thread(new DancingWithGooglers()).start();
}
public BufferedReader br;
public StringTokenizer in;
public PrintWriter out;
public String nextToken() throws IOException {
while (in == null || !in.hasMoreTokens()) {
in = new StringTokenizer(br.readLine());
}
return in.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public void solve() throws IOException {
int n = nextInt();
int S = nextInt();
int p = nextInt();
int[] t = new int[n];
for (int i = 0; i < n; i++) {
t[i] = nextInt();
}
Arrays.sort(t);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if ((t[i] + 2) / 3 >= p) {
ans++;
} else {
if (((t[i] % 3 == 0 && t[i] / 3 + 1 >= p && t[i] != 0) || (t[i] % 3 == 2 && (t[i] + 1) / 3 + 1 >= p))
&& S > 0) {
ans++;
S--;
}
}
}
out.println(ans);
}
public void run() {
try {
br = new BufferedReader(new FileReader("B-small.in"));
out = new PrintWriter("b.out");
int t = nextInt();
for (int i = 0; i < t; i++) {
out.print("Case #" + (i + 1) + ": ");
solve();
}
out.close();
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
}
| 0 | 1,189,603 |
A11759 | A11028 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package fixjava;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class CollectionUtils {
/**
* @return the single value in the collection, throws an exception if there isn't exactly one item.
* @throws IllegalArgumentException
* if there is more than one value in the set.
*/
public static <T> T getSingleVal(Collection<T> collection) {
if (collection.size() != 1)
throw new IllegalArgumentException(collection.size() + " objects in collection, expected exactly 1");
T ret = null;
for (T val : collection) {
ret = val;
break;
}
return ret;
}
/**
* @return the first value returned by an iterator on the collection, throws an exception if there isn't exactly one item.
* @throws IllegalArgumentException
* if collection is empty
*/
public static <T> T getFirstVal(Collection<T> collection) {
if (collection.size() == 0)
throw new IllegalArgumentException(collection.size() + " objects in collection, expected at least 1");
T ret = null;
for (T val : collection) {
ret = val;
break;
}
return ret;
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* Pass values in an Iterable through a function to produce an ArrayList of mapped values, one output value generated per input
* value. Returns null if input is null.
*/
public static <S, T> ArrayList<T> map(Iterable<S> values, Lambda<S, T> mapFunction) {
if (values == null)
return null;
ArrayList<T> result = new ArrayList<T>();
for (S val : values)
result.add(mapFunction.apply(val));
return result;
}
/**
* Pass values in an Iterable through a function to produce an ArrayList of mapped values, one output value generated per input
* value. Returns null if input is null.
*/
public static <S, T> ArrayList<T> map(S[] values, Lambda<S, T> mapFunction) {
if (values == null)
return null;
ArrayList<T> result = new ArrayList<T>();
for (S val : values)
result.add(mapFunction.apply(val));
return result;
}
/**
* Pass values in an Iterable through a function to produce an ArrayList of mapped values, zero or more output values generated
* per input value. Returns null if input is null.
*/
public static <S, T> ArrayList<T> mapMultiple(Iterable<S> values, Lambda<S, ? extends Collection<T>> mapFunction) {
if (values == null)
return null;
ArrayList<T> result = new ArrayList<T>();
for (S val : values)
result.addAll(mapFunction.apply(val));
return result;
}
/**
* Pass values in an Iterable through a function to produce a HashSet of mapped values, one output value generated per input
* value. Returns null if input is null.
*/
public static <S, T> HashSet<T> mapSet(Iterable<S> values, Lambda<S, T> mapFunction) {
if (values == null)
return null;
HashSet<T> result = new HashSet<T>();
for (S val : values)
result.add(mapFunction.apply(val));
return result;
}
/**
* Pass values in an Iterable through a function to produce a HashSet of mapped values, one output value generated per input
* value. Returns null if input is null.
*/
public static <S, T> HashSet<T> mapSet(S[] values, Lambda<S, T> mapFunction) {
if (values == null)
return null;
HashSet<T> result = new HashSet<T>();
for (S val : values)
result.add(mapFunction.apply(val));
return result;
}
/**
* Pass values in an Iterable through a function to produce a HashSet of mapped values, zero or more output values generated per
* input value. Returns null if input is null.
*/
public static <S, T> HashSet<T> mapSetMultiple(Iterable<S> values, Lambda<S, ? extends Collection<T>> mapFunction) {
if (values == null)
return null;
HashSet<T> result = new HashSet<T>();
for (S val : values)
result.addAll(mapFunction.apply(val));
return result;
}
// ---------------------------------------------------------------------------------------------------------------------
public static <T> HashSet<T> filterSet(Iterable<T> values, Lambda<T, Boolean> filterFunction) {
if (values == null)
return null;
HashSet<T> result = new HashSet<T>();
for (T val : values)
if (filterFunction.apply(val))
result.add(val);
return result;
}
public static <T> ArrayList<T> filter(Iterable<T> values, Lambda<T, Boolean> filterFunction) {
if (values == null)
return null;
ArrayList<T> result = new ArrayList<T>();
for (T val : values)
if (filterFunction.apply(val))
result.add(val);
return result;
}
public static <T> HashSet<T> filterSet(T[] values, Lambda<T, Boolean> filterFunction) {
if (values == null)
return null;
HashSet<T> result = new HashSet<T>();
for (T val : values)
if (filterFunction.apply(val))
result.add(val);
return result;
}
public static <T> ArrayList<T> filter(T[] values, Lambda<T, Boolean> filterFunction) {
if (values == null)
return null;
ArrayList<T> result = new ArrayList<T>();
for (T val : values)
if (filterFunction.apply(val))
result.add(val);
return result;
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* Iterate through multiple Iterables of the same element type, e.g. for (Integer i : CollectionUtils.iterateThroughAllOf(x, y,
* z)) { }
*
* N.B. you will get a warning "Type safety: A generic array of type Iterable<T> is created for a Varargs parameter" (lame
* Java).
*/
@SafeVarargs
public static <T> Iterable<T> iterateThroughAllOf(final Iterable<T>... iterables) {
if (iterables.length == 0) {
return (Iterable<T>) new ArrayList<T>();
} else {
return new Iterable<T>() {
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
Iterable<T>[] iters = iterables;
int iterIdx = -1;
Iterator<T> currIter = null;
private void advanceIfNecessary() {
if (currIter == null || (iterIdx < iters.length - 1 && !currIter.hasNext()))
currIter = iterables[++iterIdx].iterator();
}
@Override
public boolean hasNext() {
advanceIfNecessary();
return iterIdx < iters.length && (iterIdx < iters.length - 1 || currIter.hasNext());
}
@Override
public T next() {
advanceIfNecessary();
if (iterIdx == iters.length)
throw new RuntimeException("Out of elements");
return currIter.next();
}
@Override
public void remove() {
advanceIfNecessary();
if (iterIdx == iters.length)
throw new RuntimeException("Out of elements");
else
currIter.remove();
}
};
}
};
}
}
/**
* Iterate through multiple Arrays of the same element type, e.g. for (Integer i : CollectionUtils.iterateThroughAllOf(x, y, z))
* { }
*/
@SafeVarargs
public static <T> Iterable<T> iterateThroughAllOf(final T[]... arrays) {
if (arrays.length == 0) {
return (Iterable<T>) new ArrayList<T>();
} else {
return new Iterable<T>() {
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
T[][] arrs = arrays;
int arrIdx = 0, arrSubIdx = 0;
private void advanceIfNecessary() {
if (arrIdx < arrs.length && arrSubIdx == arrs[arrIdx].length) {
arrIdx++;
arrSubIdx = 0;
}
}
@Override
public boolean hasNext() {
advanceIfNecessary();
return arrIdx < arrs.length && (arrIdx < arrs.length - 1 || arrSubIdx < arrs[arrIdx].length);
}
@Override
public T next() {
advanceIfNecessary();
if (arrIdx == arrs.length)
throw new RuntimeException("Out of elements");
return arrs[arrIdx][arrSubIdx++];
}
@Override
public void remove() {
throw new RuntimeException("Not implemented");
}
};
}
};
}
}
/**
* Iterate through multiple Iterables of the same element type (skipping over null iterables, *not* null elements), e.g. for
* (Integer i : CollectionUtils.iterateThroughAllOf(x, y, z)) { }
*
* N.B. you will get a warning "Type safety: A generic array of type Iterable<T> is created for a Varargs parameter" (lame
* Java).
*/
@SuppressWarnings("unchecked")
public static <T> Iterable<T> iterateThroughAllOfIgnoringNulls(Iterable<T>... iterables) {
ArrayList<Iterable<T>> filter = filter(iterables, new Lambda<Iterable<T>, Boolean>() {
@Override
public Boolean apply(Iterable<T> param) {
return param != null;
}
});
Iterable<T>[] nonNulls = new Iterable[filter.size()];
filter.toArray(nonNulls);
return iterateThroughAllOf(nonNulls);
}
/**
* Iterate through multiple arrays of the same element type (skipping over null arrays, *not* null elements), e.g. for (Integer
* i : CollectionUtils.iterateThroughAllOf(x, y, z)) { }
*/
@SuppressWarnings("unchecked")
public static <T> Iterable<T> iterateThroughAllOfIgnoringNulls(T[]... arrays) {
ArrayList<T[]> filter = filter(arrays, new Lambda<T[], Boolean>() {
@Override
public Boolean apply(T[] param) {
return param != null;
}
});
Iterable<T>[] nonNulls = new Iterable[filter.size()];
filter.toArray(nonNulls);
return iterateThroughAllOf(nonNulls);
}
// public static void main(String[] args) {
// ArrayList<Integer> x = new ArrayList<Integer>();
// ArrayList<Integer> y = new ArrayList<Integer>();
// ArrayList<Integer> z = new ArrayList<Integer>();
// x.add(1);
// x.add(2);
// x.add(3);
// y.add(19);
// y.add(23);
// z.add(100);
// z.add(999);
// for (Integer i : iterateThroughAllOf(x, y, z))
// System.out.println(i);
// Integer[] a = new Integer[3];
// Integer[] b = new Integer[2];
// a[0] = 10;
// a[1] = 11;
// a[2] = 12;
// b[0] = 7;
// b[1] = 8;
// for (Integer i : iterateThroughAllOf(a, b))
// System.out.println(i);
// }
/**
* Iterate through a varargs list of iterable objects of type T, and return all the objects in a list. Null iterables are
* skipped.
*/
@SafeVarargs
public static <T> ArrayList<T> toListIgnoringNulls(Iterable<T>... iterables) {
ArrayList<T> result = new ArrayList<T>();
for (T item : iterateThroughAllOfIgnoringNulls(iterables))
result.add(item);
return result;
}
/**
* Iterate through a varargs list of iterable objects of type T, and return all the objects in a set (removing duplicates). Null
* iterables are skipped.
*/
@SafeVarargs
public static <T> HashSet<T> toSetIgnoringNulls(Iterable<T>... iterables) {
return new HashSet<T>(toListIgnoringNulls(iterables));
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* Look up keys in the map, and return a collection of the corresponding values. Returns null if 'keys' is null.
*
* @throw IllegalArgumentException if key doesn't exist in map or if a key is null, depending on params.
*/
public static <K, V, C extends Collection<V>> C lookup(Collection<K> keys, Map<K, V> map,
LambdaVoid<K> applyIfKeyIsNullWithoutAddingValue, Lambda<K, V> applyIfKeyIsNullAndAddReturnedValue,
LambdaVoid<K> applyWhenKeyDoesntExistWithoutAddingValue, Lambda<K, V> applyWhenKeyDoesntExistAndAddReturnedValue,
C result) {
if (keys == null)
return null;
for (K key : keys) {
V val = null;
boolean addValue = false;
if (applyIfKeyIsNullWithoutAddingValue != null && key == null) {
applyIfKeyIsNullWithoutAddingValue.apply(key);
} else if (applyIfKeyIsNullAndAddReturnedValue != null && key == null) {
val = applyIfKeyIsNullAndAddReturnedValue.apply(key);
addValue = true;
} else if (applyWhenKeyDoesntExistWithoutAddingValue != null && !map.containsKey(key)) {
applyWhenKeyDoesntExistWithoutAddingValue.apply(key);
} else if (applyWhenKeyDoesntExistAndAddReturnedValue != null && !map.containsKey(key)) {
val = applyWhenKeyDoesntExistAndAddReturnedValue.apply(key);
addValue = true;
} else {
val = map.get(key);
addValue = true;
}
if (addValue)
result.add(val);
}
return result;
}
/**
* Look up keys in the map, and return an ArrayList of the corresponding values. Returns null if 'keys' is null.
*
* @throw IllegalArgumentException if key doesn't exist in map or if a key is null, depending on params.
*/
public static <K, V> ArrayList<V> lookup(Collection<K> keys, Map<K, V> map, boolean throwExceptionIfKeyNull,
boolean throwExceptionIfKeyDoesntExist) {
if (keys == null)
return null;
return lookup(keys, map, throwExceptionIfKeyNull ? new LambdaVoid<K>() {
@Override
public void apply(K key) {
throw new IllegalArgumentException("Key is null");
}
} : null, null, throwExceptionIfKeyDoesntExist ? new LambdaVoid<K>() {
@Override
public void apply(K key) {
throw new IllegalArgumentException("Could not find key " + key + " in map");
}
} : null, null, new ArrayList<V>());
}
/**
* Look up keys in the map, and return an ArrayList of the corresponding values. Performs no checking. Returns null if 'keys' is
* null.
*/
public static <K, V> ArrayList<V> lookup(Collection<K> keys, Map<K, V> map) {
if (keys == null)
return null;
ArrayList<V> vals = new ArrayList<V>(keys.size());
for (K key : keys) {
// Simple version for speed
V val = map.get(key);
vals.add(val);
}
return vals;
}
/**
* Look up keys in the map, and return an ArrayList of the corresponding values. Applies the given function if the key doesn't
* exist. Returns null if 'keys' is null.
*/
public static <K, V> ArrayList<V> lookup(Collection<K> keys, Map<K, V> map, LambdaVoid<K> applyWhenKeyDoesntExist) {
return lookup(keys, map, null, null, applyWhenKeyDoesntExist, null, new ArrayList<V>());
}
/**
* Look up keys in the map, and return an ArrayList of the corresponding values. Applies the given function if the key doesn't
* exist to produce a default value. Returns null if 'keys' is null.
*/
public static <K, V> ArrayList<V> lookup(Collection<K> keys, Map<K, V> map, Lambda<K, V> applyWhenKeyDoesntExistToGetDefaultVal) {
return lookup(keys, map, null, null, null, applyWhenKeyDoesntExistToGetDefaultVal, new ArrayList<V>());
}
/**
* Look up keys in the map, and return a HashSet of the corresponding values. Returns null if 'keys' is null.
*
* @throw IllegalArgumentException if key doesn't exist in map or if a key is null, depending on params.
*/
public static <K, V> HashSet<V> lookupAsSet(Collection<K> keys, Map<K, V> map, boolean throwExceptionIfKeyNull,
boolean throwExceptionIfKeyDoesntExist) {
if (keys == null)
return null;
return lookup(keys, map, throwExceptionIfKeyNull ? new LambdaVoid<K>() {
@Override
public void apply(K key) {
throw new IllegalArgumentException("Key is null");
}
} : null, null, throwExceptionIfKeyDoesntExist ? new LambdaVoid<K>() {
@Override
public void apply(K key) {
throw new IllegalArgumentException("Could not find key " + key + " in map");
}
} : null, null, new HashSet<V>());
}
/**
* Look up keys in the map, and return a HashSet of the corresponding values. Performs no checking. Returns null if 'keys' is
* null.
*/
public static <K, V> HashSet<V> lookupAsSet(Collection<K> keys, Map<K, V> map) {
if (keys == null)
return null;
HashSet<V> vals = new HashSet<V>(keys.size());
for (K key : keys) {
// Simple version for speed
V val = map.get(key);
vals.add(val);
}
return vals;
}
/**
* Look up keys in the map, and return a HashSet of the corresponding values. Applies the given function if the key doesn't
* exist. Returns null if 'keys' is null.
*/
public static <K, V> HashSet<V> lookupAsSet(Collection<K> keys, Map<K, V> map, LambdaVoid<K> applyWhenKeyDoesntExist) {
return lookup(keys, map, null, null, applyWhenKeyDoesntExist, null, new HashSet<V>());
}
/**
* Look up keys in the map, and return a HashSet of the corresponding values. Applies the given function if the key doesn't
* exist to produce a default value. Returns null if 'keys' is null.
*/
public static <K, V> HashSet<V> lookupAsSet(Collection<K> keys, Map<K, V> map,
Lambda<K, V> applyWhenKeyDoesntExistToGetDefaultVal) {
return lookup(keys, map, null, null, null, applyWhenKeyDoesntExistToGetDefaultVal, new HashSet<V>());
}
// ---------------------------------------------------------------------------------------------------------------------
/** Take the union of all items in all passed collections/Iterables */
public static <T> HashSet<T> union(Iterable<? extends Iterable<T>> iterables) {
HashSet<T> result = new HashSet<T>();
for (Iterable<T> iterable : iterables)
for (T item : iterable)
result.add(item);
return result;
}
/** Put each item in an array into a set. c.f. makeSet(), toSetIgnoringNulls(). */
public static <T> HashSet<T> union(T[] items) {
HashSet<T> result = new HashSet<T>();
for (T item : items)
result.add(item);
return result;
}
// ---------------------------------------------------------------------------------------------------------------------
/** Varargs constructor for a typed set */
@SafeVarargs
public static <T> HashSet<T> makeSet(T... items) {
HashSet<T> set = new HashSet<T>(items.length);
for (T it : items)
set.add(it);
return set;
}
/** Varargs constructor for a typed list */
@SafeVarargs
public static <T> ArrayList<T> makeList(T... items) {
ArrayList<T> list = new ArrayList<T>(items.length);
for (T it : items)
list.add(it);
return list;
}
/** Varargs constructor for a typed list, specifying initial capacity */
@SafeVarargs
public static <T> ArrayList<T> makeListWithInitialCapacity(int initialCapacity, T... items) {
ArrayList<T> list = new ArrayList<T>(Math.max(items.length, initialCapacity));
for (T it : items)
list.add(it);
return list;
}
// ---------------------------------------------------------------------------------------------------------------------
public static <K, V> ArrayList<Pair<K, V>> mapToListOfPairs(Map<K, V> map) {
ArrayList<Pair<K, V>> result = new ArrayList<Pair<K, V>>();
for (Entry<K, V> ent : map.entrySet())
result.add(Pair.make(ent.getKey(), ent.getValue()));
return result;
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* Generate a sorted ArrayList of values from any collection. Does not sort in-place, but rather sorts a copy of the collection.
*/
public static <T extends Comparable<T>> ArrayList<T> sortCopy(Collection<T> vals) {
ArrayList<T> sorted = new ArrayList<T>(vals);
Collections.sort(sorted);
return sorted;
}
/**
* Generate a sorted ArrayList of values from any collection, using the specified comparator. Does not sort in-place, but rather
* sorts a copy of the collection.
*/
public static <T> ArrayList<T> sortCopy(Collection<T> vals, Comparator<T> comparator) {
ArrayList<T> sorted = new ArrayList<T>(vals);
Collections.sort(sorted, comparator);
return sorted;
}
/**
* Make a comparator by passing in a lambda that simply returns a comparable field for an object, e.g.
*
* <code>
* CollectionUtils.sort(nodeList, CollectionUtils.makeComparator(new Lambda<Node, String>() {
* public String apply(Node obj) {
* return obj.getName();
* }
* });
* </code>
*
* This is not much shorter than declaring a comparator in the sort call (and has more overhead), but may be a little simpler or
* could reduce code duplication in the comparator.
*
* @param <O>
* The type of the objects to compare
* @param <F>
* The type of the field to compare
* @param getFieldToCompare
* A simple getter for the field to compare
* @return A comparator that can be used for sorting
*/
public static <O, F extends Comparable<F>> Comparator<O> makeComparator(final Lambda<O, F> getFieldToCompare) {
return new Comparator<O>() {
@Override
public int compare(O o1, O o2) {
return getFieldToCompare.apply(o1).compareTo(getFieldToCompare.apply(o2));
}
};
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* Build a map from objects in an Iterable to an index mapping that object to its index in the Iterable. Objects must be unique
* (!equals()) or an exception is thrown.
*/
public static <T> HashMap<T, Integer> buildIndex(Iterable<T> collection) {
HashMap<T, Integer> map = new HashMap<T, Integer>();
for (IndexedItem<T> it : IndexedItem.iterate(collection))
if (map.put(it.getItem(), it.getIndex()) != null)
throw new IllegalArgumentException(
"Duplicate object in collection, cannot uniquely map objects to indices (try buildIndexMulti()?): "
+ it.getItem());
return map;
}
/**
* Build a map from objects in an array to an index mapping that object to its index in the array. Objects must be unique
* (!equals()) or an exception is thrown.
*/
public static <T> HashMap<T, Integer> buildIndex(T[] arr) {
HashMap<T, Integer> map = new HashMap<T, Integer>();
for (IndexedItem<T> it : IndexedItem.iterate(arr))
if (map.put(it.getItem(), it.getIndex()) != null)
throw new IllegalArgumentException(
"Duplicate object in collection, cannot uniquely map objects to indices (try buildIndexMulti()?): "
+ it.getItem());
return map;
}
/** Build a map from objects in a collection to a list of indices containing equal objects. */
public static <T> MultiMapKeyToList<T, Integer> buildIndexMulti(Iterable<T> collection) {
MultiMapKeyToList<T, Integer> map = new MultiMapKeyToList<T, Integer>();
for (IndexedItem<T> it : IndexedItem.iterate(collection)) {
T o = it.getItem();
map.put(o, it.getIndex());
}
return map;
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* Count the number of .equal() occurrences of objects of type T in the collection, and produce histogram of the results. The
* histogram can be sorted in order of ascending count if desired.
*/
public static <T> ArrayList<Pair<T, Integer>> countEqualOccurrences(Iterable<T> collection) {
CountedSet<T> set = new CountedSet<T>(collection);
ArrayList<Pair<T, Integer>> result = new ArrayList<Pair<T, Integer>>();
for (Entry<T, Integer> ent : set.iteratableWithCounts())
result.add(Pair.make(ent.getKey(), ent.getValue()));
return result;
}
/**
* Build a histogram of the number of unique objects that occur each number of times. Objects occur multiple times if there are
* multiple instances that match with .equals(). Returns a Pair<Integer, Integer> with number of occurrences of each unique
* object as left and number of unique objects with that number of occurrences as right.
*/
public static <T> ArrayList<Pair<Integer, Integer>> buildHistogramOfNumObjectsThatOccurGivenNumberOfTimesSparse(
Iterable<T> collection) {
// Count unique occurrences of the objects of type T
ArrayList<Pair<T, Integer>> counts = countEqualOccurrences(collection);
// Now count unique occurrences each of the count values to build the histogram
ArrayList<Pair<Integer, Integer>> countCounts = countEqualOccurrences(Pair.getAllRights(counts));
// Sort the result in order of number of occurrences (i.e. left)
Pair.sortPairsByLeft(countCounts, true);
return countCounts;
}
/**
* Build a histogram of the number of unique objects that occur each number of times. Objects occur multiple times if there are
* multiple instances that match with .equals(). Returns an array with the number of occurrences of each unique object as the
* index and number of unique objects with that number of occurrences as the value of the array at that index.
*/
public static <T> int[] buildHistogramOfNumObjectsThatOccurGivenNumberOfTimesNonSparse(Iterable<T> collection) {
// Build histogram
ArrayList<Pair<Integer, Integer>> histList = buildHistogramOfNumObjectsThatOccurGivenNumberOfTimesSparse(collection);
// Desparsify into an array and return
int maxAbscissa = histList.isEmpty() ? -1 : histList.get(histList.size() - 1).getLeft();
int[] result = new int[maxAbscissa + 1];
for (Pair<Integer, Integer> pair : histList)
result[pair.getLeft()] = pair.getRight();
return result;
}
// ---------------------------------------------------------------------------------------------------------------------
/** Reverse a list */
public static <T> ArrayList<T> reverse(List<T> list) {
ArrayList<T> result = new ArrayList<T>(list.size());
for (int i = list.size() - 1; i >= 0; --i)
result.add(list.get(i));
return result;
}
/**
* Arrayify/rectangularize a list of lists, inserting the given filler element to make the result rectangular if lists are not
* the same length
*/
public static <T> ArrayList<ArrayList<T>> rectangularize(List<? extends List<T>> input, T filler) {
int numRows = input.size();
int numCols = 0;
for (int i = 0; i < numRows; i++)
numCols = Math.max(numCols, input.get(i).size());
ArrayList<ArrayList<T>> output = new ArrayList<ArrayList<T>>(numRows);
for (int i = 0; i < numRows; i++) {
ArrayList<T> outRow = new ArrayList<T>(input.get(i));
output.add(outRow);
while (outRow.size() < numCols)
outRow.add(filler);
}
return output;
}
public static <S, T> MultiMapKeyToSet<T, S> invertMap(HashMap<S, T> map) {
MultiMapKeyToSet<T, S> result = new MultiMapKeyToSet<T, S>();
for (Entry<S, T> ent : map.entrySet())
result.put(ent.getValue(), ent.getKey());
return result;
}
}
| 0 | 1,189,604 |
A11759 | A11587 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package ru.sidorkevich.google.jam.qualification.b;
import java.util.List;
public class Task {
int n;
int s;
int p;
List<Integer> t;
public Task(int n, int s, int p, List<Integer> t) {
this.n = n;
this.s = s;
this.p = p;
this.t = t;
}
public int getN() {
return n;
}
public int getS() {
return s;
}
public int getP() {
return p;
}
public List<Integer> getT() {
return t;
}
@Override
public String toString() {
return "Task{" +
"n=" + n +
", s=" + s +
", p=" + p +
", t=" + t +
'}';
}
}
| 0 | 1,189,605 |
A11759 | A12070 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.Scanner;
import java.io.*;
public class Dancing {
public static void main(String[] args) throws FileNotFoundException, IOException {
Scanner input = new Scanner(new File(args[0]));
Scanner lin;
int lines = 0;
if (input.hasNextInt()) {
lines = input.nextInt();
input.nextLine();
}
String nLine;
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
int googlers, surprising, p;
int divThree, rem, cases, surprisingCases, answer;
int[] points;
for (int i = 0; i < lines; i++) {
nLine = input.nextLine();
lin = new Scanner(nLine);
out.print("Case #" + (i + 1) + ": ");
googlers = lin.nextInt();
surprising = lin.nextInt();
p = lin.nextInt();
points = new int[googlers];
for (int j = 0; j < googlers; j++) {
points[j] = lin.nextInt();
}
cases = 0;
surprisingCases = 0;
for (int k = 0; k < googlers; k++) {
divThree = points[k] / 3;
rem = points[k] % 3;
if (rem == 0) {
if (divThree >= p)
cases++;
else if (divThree + 1 >= p && divThree != 0)
surprisingCases++;
}
else if (rem == 1) {
if (divThree + 1 >= p)
cases++;
}
else if (rem == 2) {
if (divThree + 1 >= p)
cases++;
else if (divThree + 2 >= p)
surprisingCases++;
}
}
if (surprisingCases >= surprising) {
answer = surprising;
}
else {
answer = surprisingCases;
}
answer += cases;
out.println(answer);
}
out.close();
}
} | 0 | 1,189,606 |
A11759 | A11071 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.FileOutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class DancingSolution {
public static void main(String[] args) {
String inFilename = "B-small-attempt0.in";
String outFilename = inFilename.substring(0, inFilename.length() - 3)
+ ".out";
try {
Scanner sc = new Scanner(new File(inFilename));
PrintStream ps = new PrintStream(new FileOutputStream(outFilename));
int testCases = Integer.parseInt(sc.nextLine());
for (int i = 1; i <= testCases; i++) {
if (i > 1) {
ps.println();
}
String data = sc.nextLine();
String[] dataParts = data.split(" ");
int googlers = Integer.parseInt(dataParts[0]);
int surprising = Integer.parseInt(dataParts[1]);
int minScore = Integer.parseInt(dataParts[2]);
int found = 0;
for (int person = 0; person < googlers; person++) {
int theirScore = Integer.parseInt(dataParts[person + 3]);
if (findUnsurprisingFor(theirScore).containsAtLeast(
minScore)) {
found++;
continue;
} else if (surprising > 0) {
Set<Triplet> surprisingScores = findSurprisingFor(theirScore);
for (Triplet score : surprisingScores) {
if (score.containsAtLeast(minScore)) {
found++;
surprising--;
break;
}
}
}
}
System.out.println("Case #" + i + ": " + found);
ps.print("Case #" + i + ": " + found);
}
sc.close();
ps.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static Triplet findUnsurprisingFor(int number) {
int biggestBit = (int) Math.ceil(number / 3.0);
int smallerBit = biggestBit - 1;
Triplet answer = new Triplet();
for (int i = 0; i < 3; i++) {
if ((3 - i) * biggestBit + i * smallerBit == number) {
for (int j = 0; j < 3 - i; j++) {
answer.addComponent(biggestBit);
}
for (int j = 0; j < i; j++) {
answer.addComponent(smallerBit);
}
break;
}
}
return answer;
}
public static Set<Triplet> findSurprisingFor(int number) {
Set<Triplet> solutions = new HashSet<Triplet>();
for (int i = 0; i <= 10; i++) {
for (int j = 0; j <= 10; j++) {
for (int k = 0; k <= 10; k++) {
if (i + j + k == number) {
if (Math.abs(k - i) <= 2 && Math.abs(k - j) <= 2
&& Math.abs(j - i) <= 2) {
if (Math.abs(k - i) == 2 || Math.abs(k - j) == 2
|| Math.abs(j - i) == 2) {
solutions.add(new Triplet(i, j, k));
}
}
}
}
}
}
return solutions;
}
public static class Triplet {
public int x, y, z;
private int idx = 0;
boolean isOrdered = false;
public Triplet() {
}
private Triplet(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
this.idx = 3;
this.isOrdered = true;
}
public void addComponent(int component) {
if (idx == 0) {
x = component;
} else if (idx == 1) {
y = component;
} else {
z = component;
}
idx++;
}
public boolean containsAtLeast(int num) {
return (x >= num || y >= num || z >= num);
}
public Triplet orderedSet() {
List<Integer> t = Arrays.asList(new Integer[] { x, y, z });
Collections.sort(t);
return new Triplet(t.get(0), t.get(1), t.get(2));
}
@Override
public int hashCode() {
if (isOrdered) {
final int prime = 31;
int result = 1;
result = result * prime + x;
result = result * prime + y;
result = result * prime + z;
return result;
} else {
return orderedSet().hashCode();
}
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Triplet other = ((Triplet) obj).orderedSet();
if (isOrdered) {
if (x != other.x)
return false;
if (y != other.y)
return false;
if (z != other.z)
return false;
return true;
} else {
Triplet myOrder = orderedSet();
if (myOrder.x != other.x)
return false;
if (myOrder.y != other.y)
return false;
if (myOrder.z != other.z)
return false;
return true;
}
}
}
}
| 0 | 1,189,607 |
A11759 | A12492 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 Solutions;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
public class problemB {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader(new File("smallB.in")));
BufferedWriter out = new BufferedWriter(new FileWriter(new File("outputB.txt")));
int numCases = Integer.parseInt(in.readLine());
for (int i = 0; i < numCases; i++) {
String google = in.readLine();
String output = "Case #" + (i + 1) + ": ";
String[] googlers = google.split(" ");
int numGooglers = Integer.valueOf(googlers[0]);
int numSurprising = Integer.valueOf(googlers[1]);
int best = Integer.valueOf(googlers[2]);
ArrayList<Integer> scores = new ArrayList<Integer>(numGooglers);
for (int j = 3; j < googlers.length; j++) {
scores.add(Integer.valueOf(googlers[j]));
}
Collections.sort(scores);
int count_a = 0;
int count_b = numSurprising;
for (int j = scores.size() - 1; j >= 0; j--) {
int thisscore = scores.get(j);
if (thisscore>=best && thisscore >= 3 * best - 2) {
count_a++;
} else if (thisscore>=best && thisscore >= 3 * best - 4 && count_b > 0) {
count_a++;
count_b--;
} else {
break;
}
}
output += count_a + "\n";
out.write(output);
}
out.close();
}
}
| 0 | 1,189,608 |
A11759 | A12893 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
//package b;
import java.io.*;
import java.util.*;
public class Main {
static int[] good = {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9,10,10,10};
static int[] bad = {0,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9,10,10,10,10,10};
public static void main(String[] args) throws IOException{
BufferedReader in = new BufferedReader(new FileReader("B.in"));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("B.out")));
int T = Integer.parseInt(in.readLine());
for(int C = 1; C <= T; C++) doit(C, in, out);
in.close();
out.close();
System.exit(0);
}
private static void doit(int C, BufferedReader in, PrintWriter out) throws IOException{
StringTokenizer tok = new StringTokenizer(in.readLine());
int N = Integer.parseInt(tok.nextToken());
int surprise = Integer.parseInt(tok.nextToken());
int P = Integer.parseInt(tok.nextToken());
int[] num = new int[N];
for(int i = 0; i < N; i++) num[i] = Integer.parseInt(tok.nextToken());
//SOLUTION
Arrays.sort(num);
int ans = 0;
int countSurprise = 0;
for(int i = 0; i < N; i++){
if(num[i] >= 2 && num[i] < 28 && good[num[i]] != bad[num[i]] && countSurprise < surprise){
if(bad[num[i]] >= P) {
ans++;
countSurprise++;
}
}
else if(good[num[i]] >= P) ans++;
}
out.println("Case #" + C + ": " + ans);
}
}
| 0 | 1,189,609 |
A11759 | A13232 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package codejam2012.qr.dancing;
import codejam2012.qr.googlerese.Translator;
import codejam2012.util.ReadWriteUtil;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author fedez
*/
public class Main
{
/**
* Args0 in file
* Args1 out file
* @param args the command line arguments
*/
public static void main(String[] args) throws Exception
{
List<String> in;
List<String> out;
String[] lineArray;
int caseNumber = 1;
int scores[];
int result, googlers, surprises, scoreTopass;
int i;
in = ReadWriteUtil.readFile(args[0]);
if (in.size() < 2 || Integer.parseInt(in.get(0)) != in.size() - 1)
{
throw new Exception("Input error");
}
in.remove(0);
out = new ArrayList<String>(in.size());
for (String line : in)
{
lineArray = line.split("\\s");
googlers = Integer.parseInt(lineArray[0]);
surprises = Integer.parseInt(lineArray[1]);
scoreTopass = Integer.parseInt(lineArray[2]);
scores = new int[lineArray.length-3];
for ( i = 3; i < lineArray.length; i++ )
{
scores[i-3] = Integer.parseInt(lineArray[i]);
}
result = DancerSolver.solve(googlers, scores, surprises, scoreTopass);
out.add("Case #" + caseNumber + ": " + result);
caseNumber ++;
}
ReadWriteUtil.writeFile(args[1], out);
}
}
| 0 | 1,189,610 |
A11759 | A11052 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
public class B {
BufferedReader ins;
PrintStream outs;
static String INPUT = "B-small-attempt0.in";
static String OUTPUT;
static {
OUTPUT = "B.out";
}
public B(BufferedReader ins, PrintStream outs) {
this.ins = ins;
this.outs = outs;
}
public int go(List<Integer> list, int sr, int p) {
//Collections.sort(list);
//Collections.reverse(list);
// System.out.println("List = " + list);
// System.out.println("Surprises = " + sr);
// System.out.println("P = " + p);
int count = 0;
for(int i = 0; i<list.size(); i++) {
if(list.get(i) >= p + 2 * Math.max(p-1,0)) {
// System.out.println("Easy case = " + list.get(i));
count++;
}
else if((list.get(i) >= p + 2* Math.max(p-2,0)) && (sr > 0)) {
count++;
sr--;
// System.out.println("Tough case = " + list.get(i));
} else {
// System.out.println("Oops case = " + list.get(i));
}
}
return count;
}
public void process() throws Exception {
//Read input
int t = Integer.parseInt(ins.readLine());
for(int T=1; T<=t;T++) {
String x = ins.readLine().trim().replaceAll(" +", " ");
String[] tokens = x.split(" ");
int n = Integer.parseInt(tokens[0]);
int sum = Integer.parseInt(tokens[1]);
int p = Integer.parseInt(tokens[2]);
List<Integer> list = new ArrayList<Integer>();
for(int i = 0; i<n; i++) {
list.add(Integer.parseInt(tokens[i+3]));
}
outs.println("Case #" + T + ": " + go(list, sum, p));
}
}
public static void main(String args[]) throws Exception {
//Input
InputStreamReader fis = new FileReader(INPUT);
BufferedReader bis = new BufferedReader(fis);
//Output
PrintStream ps = OUTPUT!=null ? new PrintStream(OUTPUT) : System.out;
B b = new B(bis, ps);
b.process();
return;
}
}
| 0 | 1,189,611 |
A11759 | A12549 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
import java.util.Scanner;
/**
*
* @author krishna
*/
public class Dance {
public static void main(String [] args)
{
Program();
}
public static void Program()
{
Scanner inp=new Scanner(System.in);
String patt[];
int count;
String line;
// System.out.println("Test Case ");
int test=Integer.parseInt(inp.nextLine());
int num=1;
int S,N,P;
int judge1,judge2,judge3,rem;
int Score[]=new int[100];
while(num<=test)
{
// System.out.println("pattern ");
line=inp.nextLine();
patt=line.split(" ");
N=Integer.parseInt(patt[0]);
S=Integer.parseInt(patt[1]);
P=Integer.parseInt(patt[2]);
count=0;
for(int i=0;i<N;i++)
{
Score[i]=Integer.parseInt(patt[i+3]);
judge1=judge2=judge3=Score[i]/3;
rem=Score[i]%3;
if(Score[i]==0 )
{
if(P==0)
count++;
// System.out.println(judge1+" "+judge2+" "+ judge3);
}
else if( rem==0 )
{
if(judge1 >= P)
count++;
else if( S > 0 && (judge1 + 1)>=P )
{
judge1++;
judge2--;
count++;
S--;
}
// System.out.println(judge1+" "+judge2+" "+ judge3);
}
else if(rem==1)
{
judge1++;
if(judge1 >= P)
{
count++;
}
// System.out.println(judge1+" "+judge2+" "+ judge3);
}
else if(rem==2)
{
judge1++;
judge2++;
if( (judge1 )>=P)
{
count++;
}
else if( S!=0 && ((judge1)+1)>=P)
{
S--;
judge1++;
judge2--;
count++;
}
// System.out.println(judge1+" "+judge2+" "+ judge3);
}
}
System.out.println("Case #"+num+": "+count);
num++;
}
}
}
| 0 | 1,189,612 |
A11759 | A11061 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 com.kaka.codejam.qualification;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
*
* @author Karthik
*/
public class ProblemB {
public static void main(String[] args) {
readInput();
}
static void readInput() {
ProblemB problemB = null;
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
try {
int surprises=0;
int minBestResult=0;
int[] points = null;
int numTests = Integer.parseInt(stdin.readLine());
for (int i = 0; i < numTests; i++) {
String input = stdin.readLine();
String [] inputStr= input.split("\\ ");
for(int j=0;j<inputStr.length;j++){
int num = Integer.parseInt(inputStr[j]);
if(j==0){
points = new int[num];
}else if(j==1){
surprises = num;
}else if(j==2){
minBestResult = num;
}else{
points[j-3] = num;
}
}
int result = new ProblemB(surprises, minBestResult, points).calculateMaxUsers();
System.out.println("Case #"+(1+i)+": "+result);
}
} catch (Exception e) {
System.err.println("Ex in reading input:" + e);
}
}
int surprises;
int minBestResult;
int[] points;
public ProblemB(int surprises, int minBestResult, int[] points) {
this.surprises = surprises;
this.minBestResult = minBestResult;
this.points = points;
}
int calculateMaxUsers() {
int maxUserCount = 0;
Arrays.sort(points);
for (int totalScore : points) {
boolean isGreaterThanN = false;
if (surprises > 0) {
isGreaterThanN = isGreaterThanN(totalScore, minBestResult, true);
if (isGreaterThanN) {
surprises--;
}
} else {
isGreaterThanN = isGreaterThanN(totalScore, minBestResult, false);
}
if (isGreaterThanN) {
maxUserCount++;
}
}
return maxUserCount;
}
boolean isGreaterThanN(int score, int n, boolean isSurprise) {
boolean isGrtThanN = false;
if (score == 0 || score == 1) {
} else if (score == 29 || score == 30) {
score = 30;
} else if (isSurprise) {
score += 4;
} else {
score += 2;
}
if (Math.floor(score / 3) >= n) {
isGrtThanN = true;
}
return isGrtThanN;
}
}
| 0 | 1,189,613 |
A11759 | A11229 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 qualifyingRound;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class DancingWithGooglers {
public static void main (String [] args) throws FileNotFoundException
{
Scanner in = new Scanner (new File ("input.txt"));
int numLines = Integer.parseInt(in.nextLine());
int caseNum = 1;
for (int j = 0; j < numLines; j++)
{
System.out.print("Case #" + caseNum + ": ");
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int noSup = 0;
int sup = 0;
for (int i = 0; i < n; i++)
{
int total = in.nextInt();
int maxNoSup = maxNoSup(total);
int maxSup = maxSup(total);
// System.out.println(total + " " + maxNoSup + " " + maxSup);
if (maxNoSup >= p)
noSup++;
else if (maxSup >= p)
sup++;
}
int temp = s - sup;
if (temp <= 0)
System.out.println((noSup + s));
else
System.out.println((noSup + (sup)));
caseNum++;
}
}
private static int maxNoSup(int totalScore)
{
int i = totalScore % 3;
switch (i)
{
case 0: return totalScore/3;
case 1: return totalScore/3 + 1;
default: return totalScore/3 + 1;
}
}
private static int maxSup(int totalScore)
{
if (totalScore == 0)
return 0;
int i = totalScore % 3;
switch (i)
{
case 0: return totalScore/3 + 1;
case 1: return totalScore/3 + 1;
default: return totalScore/3 + 2;
}
}
}
| 0 | 1,189,614 |
A11759 | A13181 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
public class DancingWithTheGooglers
{
static HashMap<Integer, Integer[]> absoluteMap = new HashMap<Integer, Integer[]>();
static HashMap<Integer, Integer[]> surpriseMap = new HashMap<Integer, Integer[]>();
static class TestCaseData
{
int numberOfGooglers;
int surprisingTripletsOfScores;
int minBestResult;
int[] scores;
int minBestResultCount;
static TestCaseData readTestCaseData(BufferedReader IN) throws IOException
{
TestCaseData result = new TestCaseData();
String[] words = IN.readLine().split(" ");
result.numberOfGooglers = Integer.parseInt(words[0]);
result.surprisingTripletsOfScores = Integer.parseInt(words[1]);
result.minBestResult = Integer.parseInt(words[2]);
result.scores = new int[result.numberOfGooglers];
for (int i = 0; i < result.scores.length; i++)
{
result.scores[i] = Integer.parseInt(words[3+i]);
}
return result;
}
}
public static void computeMaps()
{
HashSet<List<Integer>> absIntSet = new HashSet<List<Integer>>();
HashSet<List<Integer>> surpriseIntSet = new HashSet<List<Integer>>();
for (int i = 0; i <= 10; i++)
{
int pos1 = i;
for (int j = -1; j <= 1; j++)
{
int pos2 = pos1+j;
if (pos2 < 0 || pos2 > 10) continue;
int low, high;
if (pos1 == pos2) {
low = -1;
high = 1;
}
else if (pos1 < pos2) {
low = 0;
high = 1;
}
else {
low = -1;
high = 0;
}
for (int k = low; k <= high ; k++)
{
int pos3 = pos1+k;
if (pos3 < 0 || pos3 > 10) continue;
int fourSum = pos1 + pos2 + pos3;
Integer[] triplet = {pos1, pos2, pos3};
Arrays.sort(triplet);
if (absIntSet.add(Arrays.asList(triplet))) {
//printLn("[%d, %d, %d] = %d", triplet[0], triplet[1], triplet[2], fourSum);
absoluteMap.put(fourSum, triplet);
}
}
}
}
for (int i = 0; i <= 10; i++)
{
int pos1 = i;
for (int j = -2; j <= 2; j++)
{
int pos2 = pos1+j;
if (pos2 < 0 || pos2 > 10) continue;
int low, high;
if (pos1 == pos2) {
low = -2;
high = 2;
}
else if (pos1 < pos2) {
low = 2-j;
high = 2;
}
else {
low = -2;
high = -2-j;
}
for (int k = low; k <= high ; k++)
{
int pos3 = pos1+k;
if (pos3 < 0 || pos3 > 10) continue;
int fourSum = pos1 + pos2 + pos3;
Integer[] triplet = {pos1, pos2, pos3};
Arrays.sort(triplet);
List<Integer> tripletList = Arrays.asList(triplet);
if (!absIntSet.contains(tripletList) && ! surpriseIntSet.contains(tripletList)) {
surpriseIntSet.add(tripletList);
surpriseMap.put(fourSum, triplet);
//printLn("[%d, %d, %d] = %d", triplet[0], triplet[1], triplet[2], fourSum);
}
}
}
}
surpriseMap.put(0, absoluteMap.get(0));
}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException
{
computeMaps();
BufferedReader IN = new BufferedReader(new InputStreamReader(System.in));
int testCaseCount;
try
{
String input = IN.readLine();
testCaseCount = Integer.parseInt(input);
}
catch (Exception e)
{
testCaseCount = 0;
}
if (testCaseCount > 0)
{
TestCaseData[] testCaseData = new TestCaseData[testCaseCount];
for (int i = 0; i < testCaseData.length; i++)
{
testCaseData[i] = TestCaseData.readTestCaseData(IN);
}
for (int i = 0; i < testCaseData.length; i++)
{
testCaseData[i].minBestResultCount = processTestCase(testCaseData[i]);
printLn("Case #%d: %d", i + 1, testCaseData[i].minBestResultCount);
}
}
IN.close();
}
protected static int processTestCase(TestCaseData testCaseData)
{
int absoulteBSCount = 0;
int surpriseBSCount = 0;
int best = testCaseData.minBestResult;
for (int i = 0; i < testCaseData.numberOfGooglers; i++)
{
int score = testCaseData.scores[i];
Integer[] triplet = absoluteMap.get(score);
if (triplet[2] >= best) {
absoulteBSCount++;
}
else
{
triplet = surpriseMap.get(score);
if (triplet != null && triplet[2] >= best) {
surpriseBSCount++;
}
}
}
return absoulteBSCount + Math.min(testCaseData.surprisingTripletsOfScores, surpriseBSCount);
}
// to ensure that '\n' is used as EOL on my Windows Machine, just to be sure ;)
//
static void printLn(String val)
{
System.out.print(val);
System.out.print('\n');
}
static void printLn(String format, Object ... args)
{
System.out.print(String.format(format, args));
System.out.print('\n');
}
}
| 0 | 1,189,615 |
A11759 | A10663 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class Dancers {
public static void main(String args[]) throws IOException {
Scanner s = new Scanner(new File("D:\\input2.txt"));
FileWriter fo = new FileWriter(new File("D:\\workspace\\GC12\\src\\output2.txt"));
int num = s.nextInt();
for(int i = 1; i<= num; i++) {
fo.write("Case #" + i + ": ");
int nd = s.nextInt();
int ns = s.nextInt();
//System.out.println("\n"+ i + " - " + nd + " , "+ ns);
int p = s.nextInt();
int aHigh = Math.max(p, 0) + Math.max(p-1, 0) + Math.max(p-1, 0);
int surpScore = Math.max(p, 0) + Math.max(p-2, 0) + Math.max(p-2, 0);
int bScore = 0;
int canSurprise = 0;
for(int j = 1; j<=nd; j++) {
int score = s.nextInt();
//System.out.print(score + " - ");
if (score == 0) {
continue;
}
if (score >= aHigh) {
bScore ++;
} else if(score >= surpScore) {
canSurprise ++;
}
}
if (canSurprise < ns) {
bScore += canSurprise;
} else {
bScore += ns;
}
if(p==0) {
fo.write(nd + "\n");
} else {
fo.write(bScore + "\n");
}
}
fo.close();
s.close();
}
}
| 0 | 1,189,616 |
A11759 | A12086 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.util.Scanner;
public class DancingGooglers {
public static void calculate(File file){
String output="";
int cases = 0;
String singleLine = "";
try{
Scanner scanner = new Scanner(file);
cases = Integer.parseInt(scanner.nextLine());
int []result = new int[cases];
int counter=0;
for(int i=0; i<cases;i++){
singleLine=scanner.nextLine();
String [] words = singleLine.split(" ");
int [] numbers = new int [words.length];
int player=0;
int surprise=0;
int best=0;
for(int j=0;j<words.length;j++){
numbers[j]=Integer.parseInt(words[j]);
}
player=numbers[0];
surprise=numbers[1];
best=numbers[2];
int[]scores= new int[player];
for(int k=0;k<player;k++){
scores[k]=numbers[k+3];
}
for(int l=0;l<scores.length;l++){
if(scores[l]>=3*best-2){
counter++;
}
if((3*best-4>=0)&&(surprise!=0)&&(scores[l]>=3*best-4)&&(scores[l]<3*best-2)){
counter++;
surprise--;
}
}
result[i]=counter;
output+="Case #"+(i+1)+": ";
output+=result[i]+" ";
output+="\n";
counter=0;
}
}catch(Exception e){
System.out.println("Please debug this program to find the exception.");
}
System.out.println(output);
}
public static void main(String[] args) {
File file = new File("./src/B-small-attempt0.in");
calculate(file);
}
}
| 0 | 1,189,617 |
A11759 | A10390 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 Main {
Scanner in;
PrintWriter out;
static final String problemName = "B";
static void asserT(boolean e) {
if (!e) {
throw new Error();
}
}
static class Triple {
int a;
int b;
int c;
int max;
int min;
Triple(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
max = Math.max(a, Math.max(b, c));
min = Math.min(a, Math.min(b, c));
asserT(max - min <= 2);
}
boolean isSurprising() {
return max - min == 2;
}
}
static class Point {
ArrayList <Triple> list = new ArrayList<Triple>();
int sMax = -1;
int uMax = -1;
void add(int a, int b, int c) {
list.add(new Triple(a, b, c));
}
int getSurpriseMaximum() {
if (sMax == -1) {
sMax = 0;
for (Triple curr : list) {
if (curr.isSurprising()) {
sMax = Math.max(curr.max, sMax);
}
}
}
return sMax;
}
int getUsualMaximum() {
if (uMax == -1) {
uMax = 0;
for (Triple curr : list) {
if (!curr.isSurprising()) {
uMax = Math.max(curr.max, uMax);
}
}
}
return uMax;
}
}
static final int MAX_COUNT = 100;
static final int MAX_POINTS = 10;
Point p[] = new Point[31];
int res[][];
int scores[];
int gen(int idx, int remainSurp, int least) {
if (idx == -1) {
if (remainSurp == 0) {
return 0;
} else {
return Integer.MIN_VALUE / 10;
}
}
if (res[idx][remainSurp] != -1) {
return res[idx][remainSurp];
}
int ans = 0;
int score = scores[idx];
int maxSurp = p[score].getSurpriseMaximum();
int maxUsual = p[score].getUsualMaximum();
if (remainSurp != 0) {
if (maxUsual >= least || maxSurp >= least) {
ans++;
}
ans += gen(idx - 1, remainSurp - 1, least);
}
int ans2 = 0;
if (maxUsual >= least) {
ans2++;
}
ans2 += gen(idx - 1, remainSurp, least);
res[idx][remainSurp] = Math.max(ans, ans2);
return res[idx][remainSurp];
}
int solveOne() {
scores = new int[in.nextInt()];
int nSurprising = in.nextInt();
int least = in.nextInt();
for (int i = 0; i < scores.length; i++) {
scores[i] = in.nextInt();
}
res = new int[scores.length][nSurprising + 1];
for (int []ar : res) {
Arrays.fill(ar, -1);
}
return gen(scores.length - 1, nSurprising, least);
}
void solve() {
for (int i = 0; i < p.length; i++) {
p [i] = new Point();
}
for (int i = 0; i <= 10; i++) {
for (int j = i; j <= 10; j++) {
for (int k = j; k <= 10; k++) {
if (k - i <= 2) {
int sum = i + j + k;
p[sum].add(i, j, k);
}
}
}
}
int nTests = in.nextInt();
in.nextLine();
for (int i = 0; i < nTests; i++) {
out.println("Case #" + (i+1) + ": " + solveOne());
}
}
void run() {
try {
in = new Scanner(new FileReader("C:/GCJ/" + problemName + ".in"));
out = new PrintWriter(new FileWriter("C:/GCJ/" + problemName + ".out"));
} catch (IOException e) {
in = new Scanner(System.in);
out = new PrintWriter(System.out);
// throw new Error();
}
try {
solve();
} finally {
out.close();
}
}
public static void main(String[] args) {
new Main().run();
}
} | 0 | 1,189,618 |
A11759 | A11972 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.priyanka;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class ProblemB {
public static void main(String[] args) throws IOException {
BufferedReader inputfile = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt")));
FileOutputStream outresult = new FileOutputStream("output.txt");
int testcases = Integer.parseInt(inputfile.readLine());
for(int i=0; i< testcases; i++) {
String[] temp = inputfile.readLine().split(" ");
int surprises = Integer.parseInt(temp[1]);
int best = Integer.parseInt(temp[2]);
int t = best - 2;
if(t< 0) { t = 0; }
int var1 = best + 2*t;
t = best - 1;
if(t< 0) { t = 0; }
int min_score_normal = best + 2*t;
int count = 0;
for(int j=3; j<temp.length; j++) {
int score = Integer.parseInt(temp[j]);
if(score >= min_score_normal) {
count++;
} else if(score >= var1 && surprises > 0) {
surprises--;
count++;
}
}
outresult.write(("Case #" + (i+1) + ": " + count + "\n").getBytes());
}
}
}
| 0 | 1,189,619 |
A11759 | A13157 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.BigDecimal;
import java.math.BigInteger;
public class Main {
private void solve() throws Exception {
int test = in.nextInt();
for(int t=1; t <= test; ++t) {
solveTest(t);
out.println();
}
}
private void solveTest(int testNum) {
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int[] t = new int[n];
for(int i = 0; i < n; ++i) {
t[i] = in.nextInt();
}
int[][] d = new int[n + 1][n + 1];
for(int[] dd : d)
Arrays.fill(dd, -1);
d[0][0] = 0;
for(int i = 0; i < n; ++i)
for(int surp = 0; surp <= n; ++surp) {
int cur = d[i][surp];
if (cur == -1)
continue;
{
// surprise
for(int d1=0; d1 <= 10; ++d1)
for(int d2=d1; d2 <= 10; ++d2)
for(int d3=d2; d3 <= 10; ++d3) {
if (d1+d2+d3!=t[i] || d3-d1>2 || d3-d1==1)
continue;
int add = (d3 >= p ? 1 : 0);
d[i + 1][surp + 1] = Math.max(d[i + 1][surp + 1], cur + add);
}
}
{
// not surprise
for(int d1=0; d1 <= 10; ++d1)
for(int d2=d1; d2 <= 10; ++d2)
for(int d3=d2; d3 <= 10; ++d3) {
if (d1+d2+d3!=t[i] || d3-d1 > 1)
continue;
int add = (d3 >= p ? 1 : 0);
d[i + 1][surp] = Math.max(d[i + 1][surp], cur + add);
}
}
}
int ans = d[n][s];
out.print("Case #" + testNum + ": " + ans);
}
private void run() {
try {
long start = System.currentTimeMillis();
in = new FastScanner("input.txt", "output.txt");
solve();
out.flush();
System.err.print("running time = " + (System.currentTimeMillis() - start) * 1e-3);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Main main = new Main();
main.run();
}
FastScanner in;
static PrintWriter out;
static class FastScanner {
public BufferedReader reader;
private StringTokenizer tokenizer;
public FastScanner(String input, String output) {
try {
reader = new BufferedReader(new FileReader(new File(input)));
out = new PrintWriter(new File(output));
tokenizer = null;
} catch (Exception e) {
reader = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
tokenizer = null;
}
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
public String nextToken() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (Exception e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
}
} | 0 | 1,189,620 |
A11759 | A11921 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.*;
import java.io.*;
public class B {
public static void main (String [] args) {
try {
BufferedReader br = new BufferedReader(new FileReader("B-small-0.in"));
PrintWriter pw = new PrintWriter("B-small-0.out");
int inputNo;
inputNo = Integer.parseInt(br.readLine());
for (int i = 1; i <= inputNo; i++) {
// get one input here
String in = br.readLine();
pw.println("Case #" + i + ": " + processInput(in));
}
br.close();
pw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static int processInput(String in) {
int result = 0;
Scanner sc = new Scanner(in);
int gNo = Integer.parseInt(sc.next());
int sup = Integer.parseInt(sc.next());
int max = Integer.parseInt(sc.next());
int supNo = 0;
int goodNo = 0;
for (int i = 0; i < gNo; i++) {
int total = Integer.parseInt(sc.next());
int can = canMax(max, total);
if (can == 1) supNo++;
if (can == 0) goodNo++;
}
if (supNo > sup) result = goodNo + sup;
else result = goodNo + supNo;
return result;
}
public static int canMax(int max, int total) {
int av = total/3;
int r = total%3;
if (r == 0) {
if (av >= max) return 0;
if (av+1 >= max && av+1 <= 10 && av-1 >= 0) return 1;
return -1;
}
if (r == 1) {
if (av+1 >= max && av + 1 <= 10) return 0;
return -1;
}
if (r == 2) {
if (av+1 >= max && av+1 <= 10) return 0;
if (av+2 >=max && av+2 <= 10) return 1;
return -1;
}
return -1;
}
}
| 0 | 1,189,621 |
A11759 | A12067 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package codejam2012.qualification;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class DancingWithTheGooglers {
// general part
private static final String INPUT = "src/main/resources";
private static final String OUTPUT = "target/output";
private static final String ROUND = "codejam2012/qualification";
private static final String SAMPLE = "B-sample.in";
private static final String SMALL = "B-small-attempt0.in";
private static final String LARGE = "B-large.in";
private Scanner scanner;
private PrintWriter writer;
public DancingWithTheGooglers(InputStream is, OutputStream os) {
scanner = new Scanner(is);
writer = new PrintWriter(os);
}
public void close() {
scanner.close();
writer.flush();
}
private static void runTest(String fileName, boolean isConsole) throws Exception {
InputStream is = initInputStream(fileName);
OutputStream os = initOutputStream(fileName, isConsole);
DancingWithTheGooglers problem = new DancingWithTheGooglers(is, os);
problem.solve();
problem.close();
doneStreams(isConsole, is, os);
}
private static InputStream initInputStream(String fileName) throws FileNotFoundException {
File inputDir = new File(INPUT + File.separator + ROUND);
File inputFile = new File(inputDir, fileName);
InputStream is = new FileInputStream(inputFile);
return is;
}
private static OutputStream initOutputStream(String fileName, boolean isConsole) throws FileNotFoundException {
OutputStream os = System.out;
if (isConsole) {
System.out.println(fileName);
System.out.println(" ---] cut [---");
} else {
File outputDir = new File(OUTPUT + File.separator + ROUND);
outputDir.mkdirs();
File outputFile = new File(outputDir, fileName.replace(".in", ".out"));
os = new PrintStream(new FileOutputStream(outputFile));
}
return os;
}
private static void doneStreams(boolean isConsole, InputStream is, OutputStream os) throws IOException {
is.close();
if (isConsole) {
System.out.println(" ---] cut [---");
System.out.println("");
} else {
os.close();
}
}
public static void main(String[] args) {
try {
runTest(SAMPLE, true);
runTest(SMALL, false);
// runTest(LARGE, false);
} catch (Exception e) {
e.printStackTrace();
}
}
// problem part
/**
* Solve the problem
*/
public void solve() {
int t = scanner.nextInt();
for (int i = 1; i <= t; i++) {
writer.print("Case #");
writer.print(i + ": ");
int n = scanner.nextInt();
int s = scanner.nextInt();
int p = scanner.nextInt();
int[] googlers = new int[n];
for (int j = 0; j < n; j++) {
googlers[j] = scanner.nextInt();
}
writer.println(solve(s, p, googlers));
}
}
private int solve(int s, int p, int[] googlers) {
List<Integer> withoutSurprize = new LinkedList<Integer>();
List<Integer> withSurprize = new LinkedList<Integer>();
for(int g: googlers){
int two = g-p;
if(two < 0)
continue;
if (two >= 2*(p-1)) {
withoutSurprize.add(g);
} else {
if( two >= 2*(p-2)) {
withSurprize.add(g);
}
}
}
int ress = withoutSurprize.size();
int ws = (withSurprize.size() <= s) ? withSurprize.size() : s;
return ress += ws;
}
} | 0 | 1,189,622 |
A11759 | A10360 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
public class DancingWiththeGooglers
{
int maxWiner =0;
LinkedList<Integer> x = new LinkedList<Integer>();
ArrayList<Integer> answer = new ArrayList<Integer>();
public DancingWiththeGooglers()
{
}
public void solve(int[] given)
{
int maxNumberOfSur = given[1];
for(int i=3;i<given.length;i++)
{
int min= given[i]/3;
int rest = given[i] %3;
if(min>= given[2])
{
maxWiner++;
}
else if(rest ==1)
{
if(min+rest>=given[2])
{
maxWiner++;
}
}
else if(rest ==2)
{
x.add(min);
}
}
int use = 1;
if(maxNumberOfSur!=0)
{
for(int i=0;i<x.size();i++)
{
if(x.get(i)+2>=given[2] && use<=maxNumberOfSur)
{
maxWiner++;
use++;
}
}
}
else
{
for(int i=0;i<x.size();i++)
{
if(x.get(i)+1>=given[2])
{
maxWiner++;
}
}
}
answer.add(maxWiner);
x=new LinkedList<Integer>();
maxWiner=0;
}
public void write()
{
try{
// Create file
FileWriter fstream = new FileWriter("out.txt");
BufferedWriter out = new BufferedWriter(fstream);
int m=0;
for(int i=0;i<answer.size();i++)
{
m=i;
out.write("Case #"+(m+1)+": "+answer.get(i));
if(i!=answer.size()-1)
out.newLine();
}
//Close the output stream
out.close();
}catch (Exception e){//Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
public void answer()
{
try{
// Open the file that is the first
// command line parameter
FileInputStream fstream = new FileInputStream("input.txt");
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine = br.readLine();
//Read File Line By Line
while ((strLine = br.readLine()) != null) {
// Print the content on the console
String[] k = strLine.split(" ");
int[]u = new int[k.length];
for(int i=0;i<k.length;i++)
{
if(k[i]!=""||k[i]!=" ")
u[i]=Integer.parseInt(k[i]);
}
solve(u);
}
//Close the input stream
in.close();
}catch (Exception e){//Catch exception if
System.err.println("Error: " + e.getMessage());
}
write();
}
public static void main(String[] args) {
DancingWiththeGooglers p=new DancingWiththeGooglers();
p.answer();
}
}
| 0 | 1,189,623 |
A11759 | A10832 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 practice.GC2012;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Dancers {
public static void main(String args[]) throws IOException {
Scanner s = new Scanner(new File("Z:\\junkyard\\practice\\resources\\input2.txt"));
FileWriter fo = new FileWriter(new File("Z:\\junkyard\\practice\\resources\\output2.txt"));
int num = s.nextInt();
for(int i = 1; i<= num; i++) {
fo.write("Case #" + i + ": ");
int nd = s.nextInt();
int ns = s.nextInt();
System.out.println("\n"+ i + " - " + nd + " , "+ ns);
int p = s.nextInt();
int alreadyhigh = Math.max(p, 0) + Math.max(p-1, 0) + Math.max(p-1, 0);
int surpriseScore = Math.max(p, 0) + Math.max(p-2, 0) + Math.max(p-2, 0);
int bestScorers = 0;
int canSurprise = 0;
for(int j = 1; j<=nd; j++) {
int score = s.nextInt();
System.out.print(score + " - ");
if (score == 0) {
continue;
}
if (score >= alreadyhigh) {
bestScorers ++;
} else if(score >= surpriseScore) {
canSurprise ++;
}
}
if (canSurprise < ns) {
bestScorers += canSurprise;
} else {
bestScorers += ns;
}
if(p==0) {
fo.write(nd + "\n");
} else {
fo.write(bestScorers + "\n");
}
}
fo.close();
s.close();
}
}
| 0 | 1,189,624 |
A11759 | A11642 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.codejam;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class ProblemB {
public static void main(String[] args) throws FileNotFoundException {
Scanner sc = new Scanner(new File("B-small-attempt0.in"));
int T = sc.nextInt();
sc.nextLine();
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int S = sc.nextInt();
int p = sc.nextInt();
int[] t = new int[N];
for (int j = 0; j < N; j++) {
t[j] = sc.nextInt();
}
System.out.println("Case #" + (i + 1) + ": " + solve(N, S, p, t));
}
}
private static int solve(int N, int S, int p, int[] t) {
int countA = 0, countB1 = 0, countB2 = 0, countC1 = 0, countC2 = 0, count = 0;
for (int i = 0; i < N; i++) {
int r = t[i] % 3, d = t[i] / 3;
switch (r) {
case 1:
if (d + 1 >= p) {
countA++;
}
break;
case 0:
if (d == 0) {
if (d >= p) {
countB1++;
}
} else if (d >= 10) {
if (d >= p) {
countB1++;
}
} else if (d >= p) {
countB1++;
} else if (d + 1 == p && d > 0) {
countB2++;
}
break;
case 2:
if (d >= 9) {
if (d + 1 >= p) {
countC1++;
}
} else if (d + 1 >= p) {
countC1++;
} else if (d + 2 == p) {
countC2++;
}
break;
default:
break;
}
}
count = countA + countB1 + countC1 + Math.min(countB2 + countC2, S);
return count;
}
}
| 0 | 1,189,625 |
A11759 | A13155 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 proba;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class ProblemB {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
Map<Integer, Set<Score>> map = new HashMap<Integer, Set<Score>>();
Map<Integer, Set<Score>> surprises = new HashMap<Integer, Set<Score>>();
for (int j1 = 0; j1 <= 10; j1++) {
for (int j2 = 0; j2 <= 10; j2++) {
for (int j3 = 0; j3 <= 10; j3++) {
if (Math.abs(j1 - j2) > 2 || Math.abs(j2 - j3) > 2
|| Math.abs(j1 - j3) > 2) {
continue;
}
int sum = j1 + j2 + j3;
if (Math.abs(j1 - j2) == 2 || Math.abs(j2 - j3) == 2
|| Math.abs(j1 - j3) == 2) {
if (!surprises.containsKey(sum)) {
Set<Score> list = new HashSet<Score>();
Score score = new Score(j1, j2, j3);
list.add(score);
surprises.put(sum, list);
} else {
Set<Score> list = surprises.get(sum);
Score score = new Score(j1, j2, j3);
list.add(score);
surprises.put(sum, list);
}
} else {
if (!map.containsKey(sum)) {
Set<Score> list = new HashSet<Score>();
Score score = new Score(j1, j2, j3);
list.add(score);
map.put(sum, list);
} else {
Set<Score> list = map.get(sum);
Score score = new Score(j1, j2, j3);
list.add(score);
map.put(sum, list);
}
}
}
}
}
Scanner s = new Scanner(new FileInputStream("B-small-attempt0.in"));
int cases = s.nextInt();
s.nextLine();
for (int i = 0; i < cases; i++) {
int N = s.nextInt();
int S = s.nextInt();
int p = s.nextInt();
int[] scores = new int[N];
int answer = 0;
int noOfSurprises = 0;
for (int j = 0; j < N; j++) {
scores[j] = s.nextInt();
}
if (s.hasNextLine())
s.nextLine();
for (int j = 0; j < N; j++) {
Set<Score> normal = map.get(scores[j]);
Set<Score> surps = surprises.get(scores[j]);
boolean foundInNormal = false;
for (Score score1 : normal) {
if (score1.isScoreAbove(p)) {
answer++;
foundInNormal = true;
}
}
if (!foundInNormal) {
if (surps != null && noOfSurprises < S ) {
for (Score score1 : surps) {
if (score1.isScoreAbove(p)) {
answer++;
noOfSurprises++;
}
}
}
}
/*
else if (surps != null && noOfSurprises < S
&& surps.size() > S) {
// for()
// comb1(combstr);
Map<Integer, Set<Score>> best = new HashMap<Integer, Set<Score>>();
for (Score score1 : surps) {
int subanswer = 0;
if (score1.isScoreAbove(p)) {
answer++;
foundInNormal = true;
}
if (!best.containsKey(subanswer)) {
Set<Score> list = new HashSet<Score>();
list.add(score1);
best.put(subanswer, list);
} else {
Set<Score> list = map.get(subanswer);
list.add(score1);
best.put(subanswer, list);
}
}
Set<Integer> bests = best.keySet();
List<Integer> bestList = new ArrayList<Integer>(bests);
Collections.sort(bestList);
for (int n = 0; n < S; n++) {
Integer h = bestList.get(bestList.size() - (1 + n));
answer = answer + h;
}
for (Score score : normal) {
if (score.isScoreAbove(p)) {
answer++;
}
}
} else {
for (Score score : normal) {
if (score.isScoreAbove(p)) {
answer++;
googlers[j] = new Googler(score, scores[j]);
}
}
}*/
}
System.out.println("Case #" + (i + 1) + ": " + answer);
}
}
private static class Score {
int a;
int b;
int c;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + a;
result = prime * result + b;
result = prime * result + c;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Score other = (Score) obj;
if (a != other.a)
return false;
if (b != other.b)
return false;
if (c != other.c)
return false;
return true;
}
public Score(int a, int b, int c) {
super();
int[] arr = { a, b, c };
Arrays.sort(arr);
this.a = arr[0];
this.b = arr[1];
this.c = arr[2];
}
public boolean isScoreAbove(int p) {
if (a >= p || b >= p || c >= p)
return true;
return false;
}
@Override
public String toString() {
return "[" + a + ", " + b + ", " + c + "]";
}
}
}
| 0 | 1,189,626 |
A11759 | A12170 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.StringTokenizer;
public class B {
private static String FILENAME = "stdin";
static {
//FILENAME = "B-sample";
FILENAME = "B-small";
//FILENAME = "B-large";
}
public static void main(String[] args) {
new B().run();
}
private PrintStream out;
private final BufferedReader reader;
private StringTokenizer tokenizer = new StringTokenizer("");
public B() {
try {
out = System.out;
if (FILENAME == "stdin") {
reader = new BufferedReader(new InputStreamReader(System.in));
} else {
out = new PrintStream(new FileOutputStream("source/" + FILENAME + ".out"));
reader = new BufferedReader(new FileReader("source/" + FILENAME + ".in"));
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
public void run() {
try {
runCases();
} finally {
closeAll();
}
}
private void runCode() {
int N = getInt();
int S = getInt();
int p = getInt();
int count = 0;
for (int i = 0; i < N; i++) {
int googler = getInt();
int avg = googler / 3;
switch (googler % 3) {
case 0:
if (avg >= p) {
count++;
} else if (S > 0 && 1 + avg >= p && googler > 0 && googler < 30) {
S--;
count++;
}
break;
case 1:
if (1 + avg >= p) {
count++;
}
break;
case 2:
if (1 + avg >= p) {
count++;
} else if (S > 0 && 2 + avg >= p) {
S--;
count++;
}
break;
}
}
out.println(count);
}
private void runCases() {
int cases = getInt();
for (int c = 1; c <= cases; c++) {
out.print("Case #" + c + ": ");
runCode();
}
}
private void closeAll() {
out.close();
}
private String getToken() {
try {
while (true) {
if (tokenizer.hasMoreTokens()) {
return tokenizer.nextToken();
}
String s = reader.readLine();
if (s == null) {
return null;
}
tokenizer = new StringTokenizer(s, " \t\n\r");
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public double getDouble() {
return Double.parseDouble(getToken());
}
public int getInt() {
return Integer.parseInt(getToken());
}
public long getLong() {
return Long.parseLong(getToken());
}
public BigInteger getBigInt() {
return new BigInteger(getToken());
}
public BigDecimal getBigDec() {
return new BigDecimal(getToken());
}
}
| 0 | 1,189,627 |
A11759 | A10670 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.util.Scanner;
import java.util.Arrays;
/**
*
* @author CuteCoke
*/
public class B {
final String TASK_NAME = "B-small-attempt2";
//final String TASK_NAME = "sample";
final String IN_FILE = TASK_NAME+".in";
final String OUT_FILE = TASK_NAME+".out";
public int solve(int N, int S, int p, int[] t){
int res = 0;
for(int i=0; i<N; i++){
if (t[i]>=(p*3-2)){
res++;
}else if (t[i]>=2 && t[i]>=(p*3-4) && S>0){
res++;
S--;
}
}
return res;
}
public void doMain() throws Exception{
try{
Scanner sc1 = null;
BufferedReader br = new BufferedReader(new FileReader(IN_FILE));
BufferedWriter bw = new BufferedWriter(new FileWriter(OUT_FILE));
int T = Integer.parseInt(br.readLine());
for (int a=0; a<T; a++){
bw.write("Case #"+(a+1)+": ");
sc1 = new Scanner(br.readLine());
int N = sc1.nextInt();
int S = sc1.nextInt();
int p = sc1.nextInt();
int[] t = new int[N];
for (int b=0; b<N; b++){
t[b] = sc1.nextInt();
}
int ans = solve(N, S, p, t);
bw.write(ans+"\n");
}
br.close();
bw.close();
}catch(FileNotFoundException e){
System.err.println("In File: "+(new File(IN_FILE)).getAbsolutePath());
System.err.println("Out File: "+(new File(OUT_FILE)).getAbsolutePath());
e.printStackTrace(System.err);
}
}
public static void main(String[] s) throws Exception{
try{
B test = new B();
test.doMain();
}catch(Exception e){
e.printStackTrace(System.err);
}
}
}
| 0 | 1,189,628 |
A11759 | A11523 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.is;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
/**
* Created with IntelliJ IDEA.
* User: ofer
* Date: 4/13/12
* Time: 8:53 PM
* To change this template use File | Settings | File Templates.
*/
public class TestRunner {
public void runTests(String inputFilePath, String outputFilePath, Class testClass) {
try {
BufferedReader br = new BufferedReader(new FileReader(inputFilePath));
int numOfTests = Integer.parseInt(br.readLine());
Test[] tests = new Test[numOfTests];
for (int i = 0; i < numOfTests; i++) {
tests[i] = (Test)testClass.newInstance();
tests[i].run(br.readLine());
}
br.close();
BufferedWriter bw = new BufferedWriter(new FileWriter(outputFilePath));
for (int i = 0; i < numOfTests; i++) {
bw.write(tests[i].getOutput(i+1));
}
bw.close();
} catch (Exception e) {
System.out.println("Caught exception: " + e);
e.printStackTrace();
}
}
}
| 0 | 1,189,629 |
A11759 | A10355 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
public class Dancing {
public static void main(String [] args) throws Exception{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(in.readLine());
for(int i = 0; i < T; i++){
StringTokenizer st = new StringTokenizer(in.readLine());
int N = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
int[] scores = new int[N];
for(int j = 0; j < N; j++){
scores[j] = Integer.parseInt(st.nextToken());
}
int ans = 0;
for(int j = 0; j < N; j++){
if(p==0){
ans++;
continue;
}
if(scores[j]==0) continue;
if(scores[j]/3>=p){
ans++;
} else if(scores[j]/3==p-1&&scores[j]%3>0){
ans++;
} else if(scores[j]/3==p-1&&scores[j]%3==0 && S>0){
ans++;
S--;
} else if(scores[j]/3==p-2&&scores[j]%3==2 && S>0){
ans++;
S--;
}
}
System.out.println("Case #" + (i+1) + ": " + ans);
}
}
} | 0 | 1,189,630 |
A11759 | A11395 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 Main {
public static void main(String[] args) throws Exception {
FileReader in = new FileReader("F:\\download\\B-small-attempt0.in");
BufferedReader br = new BufferedReader(in);
FileWriter out = new FileWriter("F:\\download\\out.txt");
BufferedWriter bw = new BufferedWriter(out);
int t = Integer.parseInt(br.readLine());
for (int c = 0; c < t; c++){
String line = br.readLine();
StringTokenizer aSt = new StringTokenizer(line, " ");
int number = Integer.valueOf(aSt.nextToken()).intValue();
int surprise = Integer.valueOf(aSt.nextToken()).intValue();
int p = Integer.valueOf(aSt.nextToken()).intValue();
int sum_ok = 0;
int sum_surprise = 0;
for (int n = 0; n < number; n++){
int ti = Integer.valueOf(aSt.nextToken()).intValue();
int judge = judge(ti, p);
switch (judge){
case 2:
sum_ok++;
break;
case 1:
sum_surprise++;
break;
default:
break;
}
}
int result;
if (sum_surprise <= surprise){
result = sum_ok + sum_surprise;
}
else{
result = sum_ok + surprise;
}
bw.write(String.format("Case #%d: %d\n", c+1, result));
}
br.close();
in.close();
bw.close();
out.close();
}
private static int judge(int score, int p){
int p1 = (p-1 >= 0) ? p-1: 0;
if (score >= p + p1 + p1){
return 2;
}
int p2 = (p-2 >= 0) ? p-2: 0;
if (score >= p + p2 + p2){
return 1;
}
return 0;
}
}
| 0 | 1,189,631 |
A11759 | A11177 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 leider.ken;
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
/**
*
* @author ken
*/
public class CommandLine {
public static void main(String args[]) throws Exception {
Parser parser = new DancingParser();
ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
//ExecutorService executor = Executors.newFixedThreadPool(1);
for (String file : args) {
Map<Integer, Callable<String>> tests = parser.parse(file);
Map<Integer, String> results = new ConcurrentSkipListMap<Integer, String>();
List<Future<String>> futures = executor.invokeAll(createCommands(results, tests));
for (Future<String> future : futures) {
if (future.get() == null) {
System.err.println("Failed on test of " + file);
break;
}
}
final String outputFile = changeExtension(file, ".out");
PrintStream out = new PrintStream(new FileOutputStream(outputFile));
for (Map.Entry<Integer, String> entry : results.entrySet()) {
out.println(entry.getValue());
System.out.println(tests.get(entry.getKey()) + " ===> " + entry.getValue());
}
System.out.println("Results in " + outputFile);
}
executor.shutdown();
}
public static Collection<Callable<String>> createCommands(Map<Integer, String> results, Map<Integer, Callable<String>> tests) {
List<Callable<String>> retval = new ArrayList<Callable<String>>();
for (Map.Entry<Integer, Callable<String>> entry : tests.entrySet()) {
retval.add(new CommandLine.Command(entry.getKey(), entry.getValue(), results));
}
return retval;
}
private static class Command implements Callable<String> {
private final int testID;
private final Callable<String> test;
private final Map<Integer, String> results;
private Command(int testID, Callable<String> test, Map<Integer, String> results) {
this.testID = testID;
this.test = test;
this.results = results;
}
public String call() throws Exception {
try {
final String retval = test.call();
results.put(testID, retval);
return retval;
} catch (Exception e) {
System.err.println("Exception during test case " + testID);
e.printStackTrace();
}
return null;
}
}
static String changeExtension(String originalName, String newExtension) {
int lastDot = originalName.lastIndexOf(".");
if (lastDot != -1) {
return originalName.substring(0, lastDot) + newExtension;
} else {
return originalName + newExtension;
}
}
}
| 0 | 1,189,632 |
A11759 | A10142 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.FileOutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;
public class Problem2 {
public static void main(String[] args) throws FileNotFoundException {
String inputFile = "B-small-attempt0.in";
Scanner inputScanner = new Scanner(new FileInputStream("d:\\input\\"
+ inputFile));
PrintStream ps = new PrintStream(new FileOutputStream(
"d:\\output\\pro2.txt"));
int totalCaseNum = inputScanner.nextInt();
inputScanner.nextLine();
// -----------------------------------------------
// -----------------------------------------------
for (int caseNum = 1; caseNum <= totalCaseNum; caseNum++) {
String line = inputScanner.nextLine();
String prefix = "Case #" + caseNum + ": ";
StringBuilder output = new StringBuilder(prefix);
// -----------------------------------------------
Scanner in = new Scanner(line);
int N = in.nextInt();
int S = in.nextInt();
int P = in.nextInt();
int[] T = new int[N];
int count = 0;
if (0 == P) {
count = N;
} else {
int minScore = Math.max(0, (P - 2)) * 2 + P;
int maxScore = Math.max(0, (P - 1) * 3);
for (int i = 0; i < T.length; i++) {
int ti = in.nextInt();
if (ti > maxScore) {
count++;
continue;
}
if (ti < minScore) {
continue;
}
if (S > 0 && 2 <= ti && ti <= 28) {
count++;
S--;
}
}
}
output.append(count);
// -----------------------------------------------
System.out.println(output);
ps.println(output);
}
}
}
| 0 | 1,189,633 |
A11759 | A10541 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.FileNotFoundException;
import java.io.FileReader;
public class B {
final static String CASE_NO = "Case #";
final static String SUFFIX = ": ";
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
int total;
int T; // nuber of test cases
int N; // number of googlers
int S; // number of surprising triplets
int P;
BufferedReader br = readFile("B-small.txt");
T = Integer.parseInt(br.readLine());
total = T;
while (T > 0) {
T--;
String line = br.readLine();
String[] input = line.split(" ");
int i = 0;
N = Integer.parseInt(input[i++]);
S = Integer.parseInt(input[i++]);
P = Integer.parseInt(input[i++]);
int countP = 0;
while (N > 0) {
N--;
int t = Integer.parseInt(input[i++]);
int mod3 = t % 3;
int bestResult = 0;
// getting best result from triplet
if (mod3 == 0) {
bestResult = t / 3;
} else if (mod3 == 1)
bestResult = ((t + 2) / 3);
else if (mod3 == 2)
bestResult = ((t + 1) / 3);
else {
throw new Exception("something's wrong with mod3");
}
// satisfies P?
if (bestResult >= P) {
countP++;
} else {
// surprising score allowed?
if (S > 0 && t > 0 && mod3 != 1) {
bestResult += 1;
if (bestResult >= P) {
countP++;
S--;
}
}
}
}
System.out.println(CASE_NO + (total - T) + SUFFIX + countP);
// System.out.println(N + " " + S + " " + P);
}
}
private static BufferedReader readFile(String fileName)
throws FileNotFoundException {
FileReader fr = new FileReader(fileName);
BufferedReader br = new BufferedReader(fr);
return br;
}
}
| 0 | 1,189,634 |
A11759 | A11689 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.network172.com;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class CodeJam {
public static void main(String[] args) {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("/home/harry/Downloads/cj.in")));
PrintWriter out = new PrintWriter(new FileWriter("/home/harry/Downloads/cj.out"));
jam(in, out);
out.close();
} catch (Exception e) {
System.out.print("Exception thrown: " + e.toString());
}
}
private static void jam(BufferedReader in, PrintWriter out) throws NumberFormatException, IOException {
int cases = Integer.parseInt(in.readLine());
for (int i = 0; i < cases; i++) {
solveCase(i, in, out);
}
}
private static void solveCase(int i, BufferedReader in, PrintWriter out) throws NumberFormatException, IOException {
String[] inStrs = in.readLine().split(" ");
int googlers = Integer.parseInt(inStrs[0]);
int surprises = Integer.parseInt(inStrs[1]);
int p = Integer.parseInt(inStrs[2]);
int max = 0;
for (int j = 0; j < googlers; j++) {
int points = Integer.parseInt(inStrs[j+3]);
int high = points/3;
if (3*high < points)
high++;
if (high >= p)
max++;
else if (((high+1) >= p) && (3*high <= (points+1)) && (points >= 2) && (surprises > 0)) {
max++;
surprises--;
}
}
out.printf("Case #%d: %d\n", i+1, max);
}
}
| 0 | 1,189,635 |
A11759 | A12241 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
import java.io.File;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class B {
public static void main(String args[]) throws Exception {
final String PATH = "/home/goalboy/software installation/codejam-commandline-1.0-beta4/source/";
final String FILE = "B-small-0";
Scanner in = new Scanner(new File(PATH + FILE + ".in"));
PrintWriter out = new PrintWriter(PATH + FILE + ".out");
int test = in.nextInt();
for (int t = 1; t <= test; t++) {
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int totals[] = new int[N];
int bests[] = new int[N];
boolean addables[] = new boolean[N];
for (int i = 0; i < N; i++) {
totals[i] = in.nextInt();
}
Arrays.sort(totals);
for (int i = 0; i < N; i++) {
if (totals[i] % 3 == 0) {
bests[i] = totals[i] / 3;
addables[i] = (bests[i] > 0);
} else if (totals[i] % 3 == 1) {
bests[i] = totals[i] / 3 + 1;
addables[i] = false;
} else {
bests[i] = totals[i] / 3 + 1;
addables[i] = (bests[i] > 0);
}
}
int result = 0;
for (int i = N - 1; i >= 0; i--) {
if (bests[i] >= p) {
result++;
} else if (addables[i] && bests[i] + 1 >= p && S > 0) {
result++;
S--;
}
}
out.println("Case #" + t + ": " + result);
}
out.close();
}
}
| 0 | 1,189,636 |
A11759 | A10904 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} |
/**
* Name: Shivam99
* email: shivthedestroyer99@gmail.com
*/
import java.io.*;
public class ProblemB
{
public static void main(String[] args) throws IOException{
FileReader fr=new FileReader(args[0]);
BufferedReader br=new BufferedReader(fr);
String str=br.readLine();
int t=Integer.parseInt(str);
String ss="";
int c=1;
while(c<=t){
str=br.readLine();
int n=0,s=0,p=0,surp=0,count=0,ans=0;
int arr[]=new int[100];
String word="";
for(int ind=0;ind<str.length();ind++){
char ch=str.charAt(ind);
if(ch!=' ')
word+=ch;
else{
count++;
int num=Integer.parseInt(word);
if(count==1){
n=num;
arr=new int[n];
}
else
if(count==2)
s=num;
else
if(count==3)
p=num;
else
arr[count-4]=num;
word="";
}
}
arr[count-3]=Integer.parseInt(word);
int min=p+p+p-4;
ss+="Case #"+c+": ";
for(int ind=0;ind<arr.length;ind++){
if(arr[ind]>=p && arr[ind]>=min)
ans++;
if(arr[ind]==(min) || arr[ind]==(min+1))
if(arr[ind]>1)
surp++;
}
if(s<surp)
ans=ans+s-surp;
ss+=ans+"\n";
c++;
}
System.out.print(ss);
br.close();
fr.close();
}
} | 0 | 1,189,637 |
A11759 | A10947 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
public class ProblemB {
public int[] deriveScores(int totalScore) {
if (totalScore < 0 || totalScore > 30) {
throw new IllegalArgumentException("invalid totalScore passed: " + totalScore);
}
int n = totalScore / 3;
int r = totalScore % 3;
int[] scores = new int[3];
scores[0] = n;
scores[1] = n + r / 2;
scores[2] = n + r - (r / 2);
// if (n == 0) {
// if (surprise) {
// scores[2] += r;
// } else {
// scores[1] += r / 2;
// scores[2] += r - (r / 2);
// }
// } else if (n == 9) {
// scores[1] += r / 2;
// scores[2] += r - (r / 2);
// } else if (0 < n && n < 9) {
// if (surprise) {
// if (r == 0) {
// scores[0]--;
// scores[2]++;
// } else if (r == 1) {
// scores[0]--;
// scores[1]++;
// scores[2] += 1;
// } else if (r == 2) {
// scores[2] += r;
// }
// } else {
// scores[1] += r / 2;
// scores[2] += r - (r / 2);
// }
// }
return scores;
}
public int[] makeSurprise(int[] scores) {
int[] newScores = scores.clone();
if (scores[0] >= 1 && scores[2] <= 9) {
if (scores[2] == scores[0]) {
newScores[0]--;
newScores[2]++;
} else if (scores[2] == scores[1]) {
newScores[1]--;
newScores[2]++;
}
}
return newScores;
}
public boolean checkIfSurprisingScore(int[] scores) {
return scores[scores.length - 1] - scores[0] >= 2;
}
public void solve(String inputFileName, String outputFileName) {
try {
BufferedReader reader = new BufferedReader(new FileReader(new File(inputFileName)));
BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileName));
int testCount = Integer.parseInt(reader.readLine());
for (int i = 0; i < testCount; i++) {
String testCase = reader.readLine();
String[] fields = testCase.split(" ");
int manCount = Integer.parseInt(fields[0]);
int surpriseCount = Integer.parseInt(fields[1]);
int bestScore = Integer.parseInt(fields[2]);
int bestScoreCount = 0;
for (int j = 0; j < manCount; j++) {
int totalScore = Integer.parseInt(fields[j + 3]);
int[] scores = this.deriveScores(totalScore);
if (scores[2] < bestScore) {
if (surpriseCount > 0) {
int[] tempScores = this.makeSurprise(scores);
if (tempScores[2] >= bestScore) {
scores = tempScores;
surpriseCount--;
}
}
}
if (scores[2] >= bestScore) {
bestScoreCount++;
// System.out.println(totalScore + ", best");
} else {
// System.out.println(totalScore);
}
}
writer.write("Case #" + (i + 1) + ": " + bestScoreCount);
writer.newLine();
}
reader.close();
writer.close();
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}
public static void main(String[] args) {
ProblemB problem = new ProblemB();
// problem.solve("B-small-attempt.in", "B-small-attempt.out");
problem.solve("B-small-attempt0.in", "B-small-attempt0.out");
// problem.solve("B-small-attempt.in", "B-small-attempt.out");
// problem.solve("B-small-attempt.in", "B-small-attempt.out");
// problem.solve("B-small-attempt.in", "B-small-attempt.out");
}
}
| 0 | 1,189,638 |
A11759 | A11221 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 Dancing {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt(), N, S, p, total;
int[] scores;
String output = "";
for (int i = 0; i < T; i++) {
N = in.nextInt();
S = in.nextInt();
p = in.nextInt();
scores = new int[N];
for (int j = 0; j < N; j++)
scores[j] = in.nextInt();
Arrays.sort(scores);
total = 0;
for (int j = N-1; j >= 0; j--) {
if (p == 0)
total++;
else if (scores[j] == 0)
continue;
else if (scores[j]/3 >= p || (scores[j]/3 == p - 1 && scores[j]%3 > 0))
total++;
else if (S > 0 && (scores[j]/3 == p - 1 || (scores[j]/3 == p - 2 && scores[j]%3 == 2))) {
S--;
total++;
}
}
if (p > 10)
total = 0;
output += "Case #" + (i+1) + ": " + total + "\n";
}
System.out.print(output);
}
}
| 0 | 1,189,639 |
A11759 | A11066 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class B {
public static final String FILENAME = "B-small-0";
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("src/"+FILENAME+".in"));
BufferedWriter out = new BufferedWriter(new FileWriter("src/"+FILENAME+".out"));
Scanner s = new Scanner(in);
int T = s.nextInt();
for(int i = 1; i <= T; i++) {
int N = s.nextInt();
int S = s.nextInt();
int p = Math.min(10, s.nextInt());
int ok = 0;
int maybe = 0;
for(int j = 0; j < N; j++) {
int total = s.nextInt();
if(total >= p + 2*Math.max(0, p-1)) {
ok++;
}
else if(total >= p + 2*Math.max(0, p-2)) {
maybe++;
}
}
int ret = ok + Math.min(maybe, S);
out.write("Case #"+i+": "+ret+"\n");
}
in.close();
out.close();
}
}
| 0 | 1,189,640 |
A11759 | A12859 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class Dancing {
public static void main(String args[]){
Scanner scan = null;
try{
scan = new Scanner(new File(JOptionPane.showInputDialog("Please input filepath, e.g. C:/Documents/A-small.in")));
}
catch(FileNotFoundException e){}
String ans = "";
int T = Integer.parseInt(scan.nextLine());
for(int i=0; i<T; i++){
String[] data = scan.nextLine().split(" ");
int N = Integer.parseInt(data[0]);
int S = Integer.parseInt(data[1]);
int p = Integer.parseInt(data[2]);
int[] tots = new int[N];
for(int j=0; j<N; j++) tots[j] = Integer.parseInt(data[3+j]);
ans += "Case #" + (i+1) + ": ";
int ok = 0;
if(N==1) ok = doOne(S,p,tots);
if(N==2) ok = doTwo(S,p,tots);
if(N==3) ok = doThree(S,p,tots);
ans += ok + "\r\n";
}
PrintWriter pw = null;
try{
pw = new PrintWriter(new FileOutputStream("output.txt"));
}catch(FileNotFoundException e){}
pw.write(ans);
pw.close();
scan.close();
}
public static int doOne(int S, int p, int[] tots){
int numOverP = 0;
ArrayList<int[]> a = getPoss(tots[0]);
for(int i=0; i<2; i++){
if(a.get(i)==null) continue;
int tmpS = (isSurp(a.get(i))?1:0);
if(S!=tmpS) continue;
int tmpAns = ((best(a.get(i))>=p)?1:0);
numOverP=Math.max(numOverP, tmpAns);
}
return numOverP;
}
public static int doTwo(int S, int p, int[] tots){
int numOverP = 0;
ArrayList<int[]> a = getPoss(tots[0]);
ArrayList<int[]> b = getPoss(tots[1]);
for(int i=0; i<2; i++){
if(a.get(i)==null) continue;
for(int j=0; j<2; j++){
if(b.get(j)==null) continue;
int tmpS = (isSurp(a.get(i))?1:0) + (isSurp(b.get(j))?1:0);
if(S!=tmpS) continue;
int tmpAns = ((best(a.get(i))>=p)?1:0) + ((best(b.get(j))>=p)?1:0);
numOverP=Math.max(numOverP, tmpAns);
}
}
return numOverP;
}
public static int doThree(int S, int p, int[] tots){
int numOverP = 0;
ArrayList<int[]> a = getPoss(tots[0]);
ArrayList<int[]> b = getPoss(tots[1]);
ArrayList<int[]> c = getPoss(tots[2]);
for(int i=0; i<2; i++){
if(a.get(i)==null) continue;
for(int j=0; j<2; j++){
if(b.get(j)==null) continue;
for(int k=0; k<2; k++){
if(c.get(k)==null) continue;
int tmpS = (isSurp(a.get(i))?1:0) + (isSurp(b.get(j))?1:0) + (isSurp(c.get(k))?1:0);
if(S!=tmpS) continue;
int tmpAns = ((best(a.get(i))>=p)?1:0) + ((best(b.get(j))>=p)?1:0) + ((best(c.get(k))>=p)?1:0);
numOverP=Math.max(numOverP, tmpAns);
}
}
}
return numOverP;
}
public static ArrayList<int[]> getPoss(int tot){
int[] notSur = null;
int[] sur = null;
int maxNotSur = 0;
int maxSur = 0;
ArrayList<int[]> a = new ArrayList<int[]>();
for(int i=0; i<11; i++){
for(int j=i; j<11 && j<i+3; j++){
for(int k=j; k<11 && k<i+3; k++){
if(i+j+k==tot){
int[] um = new int[3];
um[0] = i; um[1] = j; um[2] = k;
if(isSurp(um)){
if(sur==null) sur=new int[3];
if(best(i,j,k)>=maxSur){
maxSur = best(i,j,k);
sur[0]=i;sur[1]=j;sur[2]=k;
}
} else {
if(notSur==null) notSur=new int[3];
if(best(i,j,k)>=maxNotSur){
maxNotSur = best(i,j,k);
notSur[0]=i;notSur[1]=j;notSur[2]=k;
}
}
}
}
}
}
a.add(notSur);
a.add(sur);
return a;
}
public static int best(int[] t){
return best(t[0],t[1],t[2]);
}
public static int best(int a, int b, int c){
return Math.max(Math.max(a,b), c);
}
public static boolean isSurp(int[] t){
int a = Math.abs(t[0]-t[1]);
int b = Math.abs(t[0]-t[2]);
int c = Math.abs(t[2]-t[1]);
if(a>=2 || b>=2 || c>=2) return true;
return false;
}
}
| 0 | 1,189,641 |
A11759 | A10873 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.HashMap;
import java.util.Scanner;
import java.util.regex.Pattern;
/** Parse the movie database.
*
* The format of this database is one movie per line, with movie fields
* separated by a ",". The format is:
*
* title,category
*
* Note that there is no space before or after the ",".
*/
public class Round2
{
private String[] Google;
private FileReader x;
public static void main(String[] argv)
throws FileNotFoundException
{
FileReader fr = new FileReader("test1.txt");
Round2 x = new Round2(fr);
String[] g = x.getStrings();
for (int i = 0; i < g.length; i ++){
System.out.println("Case #"+(i+1)+": "+g[i]);
}
}
/** Parse all lines from the database.
*
* @param fr The FileReader object from which to read the database.
*/
public Round2(FileReader fr)
{ try {
if (fr.ready()){
Scanner g_reader = new Scanner(fr);
int y = 0;
if (g_reader.hasNextLine()){
y = new Integer(g_reader.nextLine());
}
Google = new String[y];
parseAll(g_reader);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** Return a copy of the array of movies
*/
public String[] getStrings()
{ return Arrays.copyOf(Google, Google.length);
}
/** Parse all lines from the database.
*
* @param scn The Scanner object from which to read the database.
*/
private void parseAll(Scanner scn)
{ int i = 0;
while (scn.hasNextLine()){
Google[i] = parseOne(scn.nextLine());
i++;
}
}
/** Parse one line from the database.
*
* @param line One line from the movie database, without the newline
* character.
* @throws ParseError
*/
private String parseOne(String line)
{ String[] x = line.split(" ");
int[] y = new int[x.length];
for (int i = 0; i < x.length; i++){
y[i] = Integer.parseInt(x[i]);
}
return ""+Translate(y);
}
private int Translate(int[] x){
int numG = x[0];
int numS = x[1];
int P = x[2];
int w = 0;
Arrays.sort(x, 3, x.length);
for (int i = 3; i < x.length; i++){
if (P*3 -2 <= x[i] && P <= x[i]){
w++;
}
else if(P*3 -4 <= x[i] && numS > 0 && P <= x[i]){
w++;
numS --;
}
}
return w;
}
}
| 0 | 1,189,642 |
A11759 | A10568 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class DancingWithTheGooglers {
public static void main(String[] args) throws IOException {
BufferedReader f = new BufferedReader (new FileReader("B-small.in"));
PrintWriter out = new PrintWriter(new FileWriter("B-small.out"));
int t = Integer.parseInt(f.readLine());
for (int i = 0; i < t; i++){
int c = 0;
StringTokenizer st = new StringTokenizer(f.readLine());
int n = Integer.parseInt(st.nextToken());
int[] ti = new int[n];
int s = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
for (int j = 0; j < n; j ++){
ti[j] = Integer.parseInt(st.nextToken());
if (ti[j] % 3 == 0){
if (ti[j] / 3 >= p)
c++;
else if (ti[j] / 3 == (p-1) && s > 0 && ti[j] >= 2){
s--;
c++;
}
}
else if (ti[j] % 3 == 1){
if ((ti[j] / 3) + 1 >= p)
c++;
}
else{
if (ti[j] / 3 >= p-1)
c++;
else if (ti[j] / 3 == (p-2) && s > 0){
s--;
c++;
}
}
}
out.println("Case #" + (i+1) + ": " + c);
}
out.close();
System.exit(0);
}
}
| 0 | 1,189,643 |
A11759 | A11940 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
public class InputFile
{
public ArrayList<String> readFile() throws Exception
{
File file = new File("C:\\Users\\Nikhil\\Desktop\\googleCodeJam\\B-small-attempt1.in");
BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
ArrayList<String> list = new ArrayList<String>();
String line = null;
line = bufferedReader.readLine();
while ((line = bufferedReader.readLine()) != null)
{
list.add(line);
}
return list;
}
}
| 0 | 1,189,644 |
A11759 | A10956 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
public class QB2012 {
public static void main(String[] args) throws Exception {
new QB2012();
}
static final String filename = "B-small-attempt0";
int testcases;
//HashMap<int[], Integer> map;
public QB2012() throws Exception {
FileReader ifile = new FileReader(filename+".in");
Scanner scanner = new Scanner(ifile);
testcases = Integer.parseInt(scanner.nextLine());
FileWriter ofile = new FileWriter(filename+".out");
for (int i = 1; i <= testcases; i++) {
ofile.write("Case #"+i+": "+solve(scanner.nextLine())+(i != testcases ? "\n" : ""));
}
ofile.close();
System.out.println("Finished");
}
private int solve(String line) throws Exception {
Scanner scanner = new Scanner(line);
int N = scanner.nextInt();
int S = scanner.nextInt();
int p = scanner.nextInt();
int[] t = new int[N];
for (int i = 0; i < N; i++)
t[i] = (scanner.nextInt());
return solveRec(t, 0, S, p);
}
private int solveRec(int[] t, int i, int S, int p) {
if (i == t.length)
return 0;
if (S == 0)
return couldScoreP(t[i], false, p) + solveRec(t, i+1, 0, p);
else
return Math.max(couldScoreP(t[i], false, p) + solveRec(t, i+1, S, p), couldScoreP(t[i], true, p) + solveRec(t, i+1, S-1, p));
}
private int couldScoreP(int i, boolean suprised, int p) {
if (i < p)
return 0;
int a = (i-p)/2;
if (a < p-2 || a < p-1 && !suprised)
return 0;
return 1;
}
}
| 0 | 1,189,645 |
A11759 | A12292 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
public class GoogleDancers {
/**
* @param args
*/
static ArrayList<int[]> comb;
static int dancers;
static int posScores[];
static int S, p;
static int ld;
static int r1,r2;
static int points[];
static int max;
public static void main(String[] args) throws NumberFormatException, IOException {
// TODO Auto-generated method stub
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String hm="";
int n =Integer.valueOf(in.readLine()), m=1;
for(m=1;m<=n;m++){
max=0; ld=1;
String line[]=in.readLine().split(" ");
dancers=Integer.valueOf(line[0]);
posScores=new int[dancers+1];
S=Integer.valueOf(line[1]);
p=Integer.valueOf(line[2]);
points= new int[dancers];
comb=new ArrayList<int[]>();
for(int rd=0;rd<dancers;rd++)
points[rd]=Integer.valueOf(line[2+rd+1]);
for(int dancer=1;dancer<=dancers;dancer++){
r1=points[dancer-1]/3-1;r2=(int)Math.floor(points[dancer-1]/3.0+2);
//System.out.println(dancer+" "+r1+" "+r2);
if(r2>10) r2=10; if(r1<0) r1=0;
for(int i=r1;i<=r2;i++)
for(int j=i;j<=r2;j++)
for(int k=j;k<=r2;k++)
if((i+j+k)==points[dancer-1]){
int temp[]={dancer,i,j,k};
if(good(temp)){
if(ld!=dancer){
ld=dancer;
posScores[dancer]+=posScores[dancer-1];
}
posScores[dancer]++;
comb.add(temp);
}
}
}
//check possible combinations
rec(new int[0]);
hm+="Case #"+m+": "+max+"\n";
}
System.out.println(hm);
}
public static boolean good(int[] aux){
if(Math.abs(aux[1]-aux[2])>2) return false;
if(Math.abs(aux[1]-aux[3])>2) return false;
if(Math.abs(aux[2]-aux[3])>2) return false;
return true;
}
public static void rec(int[] chos){
if(chos.length==dancers){
//evaluate
String hm="";
int aux[];
int num=0, surp=0, lmax = 0;
for(int i=0;i<chos.length;i++){
num=0;
aux=comb.get(chos[i]);
if(Math.abs(aux[1]-aux[2])==2) num++;
if(Math.abs(aux[1]-aux[3])==2) num++;
if(Math.abs(aux[2]-aux[3])==2) num++;
if(num>=1)
surp++;
for(int j=1;j<=3;j++){
if(aux[j]>=p){
lmax++;
break;
}
}
hm+=chos[i]+" ";
}
// 0 1 4 6 8 9 SURP1
//System.out.print(" SURP "+surp);
if(surp==S && lmax>max){
max=lmax;
// System.out.println("asd"+hm+" "+max);
}
}else{
int[] newChos=new int[chos.length+1];
for(int j=0;j<chos.length;j++)
newChos[j]=chos[j];
for(int i=posScores[chos.length];i<posScores[chos.length+1];i++){
newChos[chos.length]=i;
rec(newChos);
}
}
}
public static void printComb(ArrayList<int[]> comb){
for(int i=0;i<comb.size();i++){
for(int j=0;j<comb.get(i).length;j++)
System.out.print(((int[])comb.get(i))[j]+",");
System.out.println();
}
}
public static int[] sort(int dancer, int i,int j, int k){
if(i>=j && i>=k){
if(j>=k){
int []r={dancer, i,j,k};
return r;
}else{
int []r={dancer, i,k,j};
return r;
}
}else if(j>=i && j>=k){
if(i>=k){
int []r={dancer, j,i,k};
return r;
}else{
int []r={dancer, j,k,i};
return r;
}
}else{
if(i>=j){
int []r={dancer, k,i,j};
return r;
}else{
int []r={dancer, k,j,i};
return r;
}
}
//return (new int[3]);
}
}
| 0 | 1,189,646 |
A11759 | A10080 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class Problem2 {
BufferedReader br ;
PrintWriter pw;
public static void main (String [] args) throws IOException{
new Problem2().startProcessing();
}
public void startProcessing () throws IOException {
br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("/tmp/codejam/A-small-practice.in"))));
pw = new PrintWriter(new File("/home/peeyushk/tmp/output.ou"));
startReading();
pw.flush();
pw.close();
br.close();
}
void startReading() throws IOException {
int numTestCase=0;
int numPeople=0;
int specialCases=0;
int p=0;
String numTestCaseLine = br.readLine().trim();
numTestCase = Integer.parseInt(numTestCaseLine.trim());
for( int i=0; i<numTestCase; i++) {
int result=0;
int specialCasesUsed=0;
String testCaseLine = br.readLine().trim();
String testCaseLineArray[] = testCaseLine.split(" ");
numPeople = Integer.parseInt(testCaseLineArray[0].trim());
specialCases = Integer.parseInt(testCaseLineArray[1].trim());
p = Integer.parseInt(testCaseLineArray[2].trim());
int lowerLimit= ((p-1)*3);
for (int j=0;j<numPeople;j++) {
int t = Integer.parseInt(testCaseLineArray[j+3].trim());
if (p<=0) {
result++;
} else if (p==1) {
if (t>=1) {
result++;
}
} else if (p>1 ) {
if ( t>lowerLimit ) {
result++;
} else if (t == lowerLimit || t==lowerLimit-1) {
if (specialCasesUsed<specialCases) {
result++;
specialCasesUsed++;
}
}
}
}
pw.println("Case #"+(i+1)+": "+result);
}
}
} | 0 | 1,189,647 |
A11759 | A10899 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package net.nixdev.gcj12.q2;
public class Solver {
public Integer solve(CaseData data) {
Integer result = 0;
Integer allowedException = data.excNumber;
for (Integer total: data.totals) {
Integer minStdScore = data.bestValue * 3 - 2;
if (minStdScore < 0) minStdScore = data.bestValue;
if (total >= minStdScore) {
result++;
} else {
if (allowedException > 0) {
Integer minExcScore = minStdScore - 2;
if (minExcScore < 0) minExcScore = data.bestValue;
if (total >= minExcScore) {
result++;
allowedException--;
}
}
}
}
return result;
}
}
| 0 | 1,189,648 |
A11759 | A12993 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.Set;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.Stack;
public class TaskB implements Runnable {
class Solver implements Runnable {
int testId;
boolean failed = false;
Solver(int testId) {
this.testId = testId;
}
int N;
int s;
int p;
int[] t;
private void readInput() {
N=nextInt();
s=nextInt();
p=nextInt();
t=new int[N];
for(int i=0;i<N;i++)
{
t[i]=nextInt();
}
//System.out.println("done");
}
long res =0;
public void run() {
//System.out.println("start");
int[] dp=new int[s+1];
//System.out.println("done");
for(int i=0;i<N;i++)
{
int[] ndp=new int[s+1];
for(int j=0;j<=s;j++)
{
ndp[j]=dp[j];
}
int temp=t[i]-p;
int mmin=Math.max(0, p-1)*2;
// int mmax=Math.min(10, p+1)*2;
if((temp>=mmin))
{
for(int j=0;j<=s;j++)
{
ndp[j]=dp[j]+1;
}
}
mmin=Math.max(0, p-2)*2;
if((temp>=mmin)&&(t[i]<=28))
{
for(int j=0;j<=s-1;j++)
{
ndp[j+1]=Math.max(dp[j]+1,ndp[j+1]);
}
}
dp=ndp;
}
res=dp[s];
return;
}
private void printOutput() {
if (failed) {
writer.println("BAD!!!");
System.out.println("BAD!!!");
} else {
writer.print("Case #");
writer.print(testId+1);
writer.print(": ");
writer.println(res);
}
}
}
private void solveSequential() {
int numTests = nextInt();
for (int testId = 0; testId < numTests; ++testId) {
Solver solver = new Solver(testId);
solver.readInput();
solver.run();
solver.printOutput();
}
}
private void solveParallel() {
int numTests = nextInt();
ExecutorService executor = Executors.newFixedThreadPool(2);
Solver[] solver = new Solver[numTests];
for (int testId = 0; testId < numTests; ++testId) {
solver[testId] = new Solver(testId);
solver[testId].readInput();
}
Future[] res = new Future[numTests];
for (int testId = 0; testId < numTests; ++testId) {
res[testId] = executor.submit(new Thread(solver[testId]));
}
for (int testId = 0; testId < numTests; ++testId) {
try {
res[testId].get();
} catch (InterruptedException e) {
solver[testId].failed = true;
} catch (ExecutionException e) {
solver[testId].failed = true;
}
}
for (int testId = 0; testId < numTests; ++testId) {
// writer.print("Case #");
// writer.print(testId+1);
// writer.print(": ");
solver[testId].printOutput();
}
executor.shutdown();
}
static final String TASK_ID = "taskB";
public static void main(String[] args) {
new TaskB().run();
}
BufferedReader reader;
StringTokenizer tokenizer = null;
PrintWriter writer;
public void run() {
try {
long now = System.currentTimeMillis();
reader = new BufferedReader(new FileReader(TASK_ID + ".txt"));
writer = new PrintWriter(TASK_ID + ".out");
solveParallel();
reader.close();
writer.close();
System.out.println(System.currentTimeMillis() - now + "ms");
} catch (Exception e) {
e.printStackTrace();
}
}
int nextInt() {
return Integer.parseInt(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
String nextLine()
{
String res;
try {
res = reader.readLine();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
return res;
}
String nextToken() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
}
| 0 | 1,189,649 |
A11759 | A11550 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 world2012.qualification;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Scanner;
public class B {
public static boolean canPass(int[] t, int p) {
if (t[0] < 0 || t[1] < 0 || t[2] < 0)
return false;
return t[0] >= p || t[1] >= p || t[2] >= p;
}
public static int maxGooglers(int[] scores, int p, int s) {
B b = new B();
Triple[] ts = new Triple[scores.length];
for (int i = 0; i < scores.length; i++) {
ts[i] = b.new Triple(scores[i]);
}
int count = 0;
int surpr = 0;
for (Triple t : ts) {
if (canPass(t.triple, p))
count++;
else if (canPass(t.sTriple, p))
surpr++;
}
return count + Math.min(surpr, s);
}
static PrintWriter out;
public static void parseInput() throws Exception {
String file = "world2012/qualification/B-small-attempt1.in";
// String file = "input.in";
Scanner scanner = new Scanner(new File(file));
out = new PrintWriter(new FileWriter((file.replaceAll(".in", ""))));
int T = Integer.parseInt(scanner.nextLine());
for (int i = 0; i < T; i++) {
String[] in = scanner.nextLine().split("\\s");
int N = Integer.parseInt(in[0]);
int S = Integer.parseInt(in[1]);
int P = Integer.parseInt(in[2]);
int[] scores = new int[N];
for (int j = 0; j < N; j++) {
scores[j] = Integer.parseInt(in[j + 3]);
}
int r = maxGooglers(scores, P, S);
out.println("Case #"+(i+1)+": "+r+"");
}
}
public static void main(String[] args) throws Exception {
parseInput();
out.close();
System.out.println("Done!");
}
class Triple {
int[] triple;
int[] sTriple;
int score;
public Triple(int score) {
this.score = score;
init();
}
private void init() {
if (score % 3 == 2) {
int l = score / 3;
int b = score / 3 + 1;
triple = new int[] {b, b, l};
sTriple = new int[] {b + 1, b - 1, l};
} else if (score % 3 == 1) {
int l = score / 3;
int b = score / 3 + 1;
triple = new int[] {b, l, l};
sTriple = new int[] {b, b, l - 1};
} else {
int l = score / 3;
triple = new int[] {l, l, l};
sTriple = new int[] {l + 1, l, l - 1};
}
}
}
}
| 0 | 1,189,650 |
A11759 | A12297 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.google.codejam;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class DancingGooglers {
public static void main(String[] args) throws FileNotFoundException {
new DancingGooglers().run();
}
private static class Data {
@Override
public String toString() {
return "Data [googlers=" + googlers + ", surprisingTriplets="
+ surprisingTriplets + ", p=" + p + ", totals="
+ Arrays.toString(totals) + "]";
}
public int googlers;
public int surprisingTriplets;
public int p;
public Integer[] totals;
}
private void run() throws FileNotFoundException {
Data[] data = parseInput("input");
Integer[] result = solve(data);
printResult(result, "output");
}
private Integer[] solve(Data[] data) {
Integer[] result = new Integer[data.length];
for (int i = 0; i < data.length; i++) {
result[i] = solve(data[i]);
// System.out.println("Max number of Googlers with p: " + result[i]);
}
return result;
}
private Integer solve(Data data) {
// System.out.println(data);
int counter = 0;
int availableSurpises = data.surprisingTriplets;
for (Integer total : data.totals) {
if (data.p == 0) {
// System.out.println("Googler with total=" + total + " has scored minimum of " + data.p);
counter++;
} else
if (total >= Math.max(1, data.p*3 - 2)) {
// System.out.println("Googler with total=" + total + " has scored minimum of " + data.p);
counter++;
} else if (availableSurpises > 0 && total >= Math.max(1, data.p*3 - 4)){
// System.out.println("Googler with total=" + total + " might scored minimum of " + data.p + " with suprising score");
counter++; availableSurpises--;
} else {
// System.out.println("Googler with total=" + total + " couldn't score minimum of " + data.p);
}
}
return counter;
}
private void printResult(Integer[] result, String path) throws FileNotFoundException {
PrintWriter p = new PrintWriter(new File(path));
try {
for (int i = 1; i < result.length+1; i++) {
p.format("Case #%d: %d\n", i, result[i-1]);
}
} finally {
p.close();
}
}
private Data[] parseInput(String path) throws FileNotFoundException {
Scanner scanner = new Scanner(new File(path));
try {
Data[] input = new Data[scanner.nextInt()];
for (int i = 0; i < input.length; i++) {
scanner.nextLine(); // skip to the next line
Data data = new Data();
data.googlers = scanner.nextInt();
data.surprisingTriplets = scanner.nextInt();
data.p = scanner.nextInt();
data.totals = new Integer[data.googlers];
for (int g = 0; g < data.googlers; g++) {
data.totals[g] = scanner.nextInt();
}
input[i] = data;
}
return input;
} finally {
scanner.close();
}
}
}
| 0 | 1,189,651 |
A11759 | A10981 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.moriraaca.codejam;
public interface TestCase {
}
| 0 | 1,189,652 |
A11759 | A11353 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.IOException;
import java.util.ArrayList;
import java.util.List;
public class DancingWithGooglers {
public String findMaxGooglers(String line) {
String[] tokens = line.split(" ");
int numGooglers = Integer.parseInt(tokens[0]);
int numSurprising = Integer.parseInt(tokens[1]);
int threshold = Integer.parseInt(tokens[2]);
int[] pointsArray = new int[numGooglers];
for (int i = 0; i < numGooglers; ++i) {
pointsArray[i] = Integer.parseInt(tokens[3 + i]);
}
int maxGooglers = 0;
int numSurprisingBetter = 0;
int numSurprisingEqual = 0;
for (int points : pointsArray) {
int avg = points / 3;
int rem = points - 3 * avg;
if (points >= 2 && points <= 28) {
if (avg >= threshold) {
maxGooglers++;
numSurprisingEqual++;
} else if (avg == threshold - 1) {
if (rem == 0) {
numSurprisingBetter++;
} else { // rem == 1 || rem == 2
maxGooglers++;
numSurprisingEqual++;
}
} else if (avg == threshold - 2) {
if (rem == 2) {
numSurprisingBetter++;
} else {
numSurprisingEqual++;
}
} else {
numSurprisingEqual++;
}
} else { // points = 0, 1, 29 or 30
numSurprisingEqual++;
if (avg >= threshold) {
maxGooglers++;
} else if (avg == threshold - 1 && rem > 0) {
maxGooglers++;
}
}
}
System.out.printf("%d, %d\n", numSurprisingBetter, numSurprisingEqual);
System.out.printf("%d\n", numSurprisingBetter + numSurprisingEqual);
System.out.printf("Num points: %d\n", pointsArray.length);
if (numSurprising > 0) {
int n = Math.min(numSurprisingBetter, numSurprising);
numSurprising -= n;
maxGooglers += n;
}
if (numSurprising > 0) {
int n = Math.min(numSurprisingEqual, numSurprising);
numSurprising -= n;
}
assert numSurprising == 0;
return String.valueOf(maxGooglers);
}
public static void main(String[] args) {
String inputFileName = null;
if (args.length > 0) {
inputFileName = args[0];
} else {
return;
}
File inputFile = new File(inputFileName);
List<String> outputStringList = new ArrayList<String>();
try {
DancingWithGooglers dwg = new DancingWithGooglers();
BufferedReader reader = new BufferedReader(
new FileReader(inputFile));
int numLines = Integer.parseInt(reader.readLine());
for (int i = 0; i < numLines; ++i) {
outputStringList.add(dwg.findMaxGooglers(reader.readLine()));
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
File outputFile = new File("dwg.out");
FileWriter writer;
try {
writer = new FileWriter(outputFile);
for (int i = 0; i < outputStringList.size(); ++i) {
String s = String.format("Case #%d: %s\n", i + 1,
outputStringList.get(i));
System.out.print(s);
writer.write(s);
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| 0 | 1,189,653 |
A11759 | A12627 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 q2;
import java.util.Scanner;
public class DWG {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for (int _t = 0; _t < t; _t++) {
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int floor, sfloor;
if (p == 0){
floor = 0;
} else {
floor = p+(2*(p-1));
}
if (p == 1){
sfloor = 1;
} else {
sfloor = p+(2*(p-2));
}
int y = 0;
for (int _n=0; _n<n; _n++){
int ti = sc.nextInt();
if (ti >= floor) {
y++;
} else if (ti >= sfloor && s > 0 && sfloor >= 0) {
y++;
s--;
}
}
System.out.printf("Case #%d: %d\n",_t+1,y);
}
}
}
| 0 | 1,189,654 |
A11759 | A10833 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 be.mokarea.gcj.common;
import java.io.PrintWriter;
public abstract class Transformation<T extends TestCase> {
private TestCaseReader<T> caseReader;
private final PrintWriter outputWriter;
public Transformation(TestCaseReader<T> caseReader, PrintWriter outputWriter) {
this.caseReader = caseReader;
this.outputWriter = outputWriter;
}
public void transformAll() throws Exception {
T testCase = caseReader.nextCase();
while (testCase != null) {
outputWriter.println(transform(testCase));
testCase = caseReader.nextCase();
};
}
protected abstract String transform(T testCase);
}
| 0 | 1,189,655 |
A11759 | A11681 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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._2012;
import java.io.File;
import java.util.Scanner;
public class DancingWithGooglers
{
int[][] maxScores;
private void setup()
{
maxScores = new int[31][2];
for(int i = 0; i <= 30; i++)
maxScores[i][1] = -1;
for(int score = 0; score <= 30; score++)
{
for(int s1 = 0; s1 <= 10; s1++)
for(int s2 = 0; s2 <= 10; s2++)
for(int s3 = 0; s3 <= 10; s3++)
{
if (s1 + s2 + s3 != score)
continue;
if (s1 > s2 || s1 > s3 || s2 > s3)
continue;
if (Math.abs(s1 - s2) > 2 || Math.abs(s1 - s3) > 2 || Math.abs(s2 - s3) > 2)
continue;
if (Math.abs(s1 - s2) == 2 || Math.abs(s1 - s3) == 2 || Math.abs(s2 - s3) == 2)
maxScores[score][1] = s3;
else
maxScores[score][0] = s3;
}
}
}
public void solveCases() throws Exception
{
setup();
Scanner s = new Scanner(new File("./input/B-small-attempt0.in"));
int t = s.nextInt();
s.nextLine();
for(int i = 0; i < t; i++)
solveProblem(s, i + 1);
}
private void solveProblem(Scanner s, int num)
{
System.out.print("Case #" + num + ": ");
int n = s.nextInt();
int sur = s.nextInt();
int p = s.nextInt();
int totSurprising = 0;
int totalBest = 0;
for(int i = 0; i < n; i++)
{
int score = s.nextInt();
if (maxScores[score][0] >= p)
{
totalBest++;
continue;
}
if (maxScores[score][1] != -1 && maxScores[score][1] >= p && totSurprising < sur)
{
totalBest++;
totSurprising++;
}
}
System.out.println(totalBest);
}
public static void main(String[] args)
{
DancingWithGooglers dwg = new DancingWithGooglers();
try
{
dwg.solveCases();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
| 0 | 1,189,656 |
A11759 | A12032 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 jp.funnything.competition.util;
import java.util.Comparator;
import com.google.common.base.Objects;
public class Pair< T1 , T2 > {
public static < T1 extends Comparable< T1 > , T2 extends Comparable< T2 > > Comparator< Pair< T1 , T2 > > getFirstComarator() {
return new Comparator< Pair< T1 , T2 > >() {
@Override
public int compare( final Pair< T1 , T2 > o1 , final Pair< T1 , T2 > o2 ) {
final int c = o1.first.compareTo( o2.first );
return c != 0 ? c : o1.second.compareTo( o2.second );
}
};
}
public static < T1 extends Comparable< T1 > , T2 extends Comparable< T2 > > Comparator< Pair< T1 , T2 > > getSecondComarator() {
return new Comparator< Pair< T1 , T2 > >() {
@Override
public int compare( final Pair< T1 , T2 > o1 , final Pair< T1 , T2 > o2 ) {
final int c = o1.second.compareTo( o2.second );
return c != 0 ? c : o1.first.compareTo( o2.first );
}
};
}
public T1 first;
public T2 second;
public Pair( final Pair< T1 , T2 > that ) {
this.first = that.first;
this.second = that.second;
}
public Pair( final T1 first , final T2 second ) {
this.first = first;
this.second = second;
}
@Override
public boolean equals( final Object obj ) {
if ( this == obj ) {
return true;
}
if ( obj == null || getClass() != obj.getClass() ) {
return false;
}
final Pair< ? , ? > that = ( Pair< ? , ? > ) obj;
return Objects.equal( this.first , that.first ) && Objects.equal( this.first , that.first );
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ( first == null ? 0 : first.hashCode() );
result = prime * result + ( second == null ? 0 : second.hashCode() );
return result;
}
@Override
public String toString() {
return "Pair [first=" + first + ", second=" + second + "]";
}
}
| 0 | 1,189,657 |
A11759 | A10209 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 gcj2 {
static int T; // tesztesetek száma
static int N[]; // Googlerek számai
static int S[]; // meglepŠtripletek száma
static int p[]; // pék
static int total[][]; // összpontszámok
static int tripletek[][];
static void beolvas (String f) throws IOException {
BufferedReader be = new BufferedReader(new FileReader(f));
String sor = be.readLine();
T = Integer.parseInt(sor);
N = new int[T];
S = new int[T];
p = new int[T];
tripletek = new int[T][3];
for (int i = 0; i < T; i++) {
sor = be.readLine();
String nums[] = sor.split(" ");
N[i] = Integer.parseInt(nums[0]);
S[i] = Integer.parseInt(nums[1]);
p[i] = Integer.parseInt(nums[2]);
}
be.close();
int Nmax = N[0];
for (int j = 0; j < T; j++){
if (N[j] > Nmax) Nmax = N[j];
}
total = new int[T][Nmax];
BufferedReader be2 = new BufferedReader(new FileReader(f));
sor = be2.readLine();
for (int i = 0; i < T; i++) {
sor = be2.readLine();
String nums[] = sor.split(" ");
for (int j = 0; j < N[i]; j++) {
total[i][j] = Integer.parseInt(nums[3+j]);
}
}
be2.close();
}
static void kiir () {
System.out.println(T);
for (int i = 0; i < T; i++) {
System.out.print(N[i]+" "+S[i]+" "+p[i]+" ");
for (int j = 0; j < N[i]; j++) {
System.out.print(total[i][j]+" ");
}
System.out.println();
}
}
static int count (int a) {
int er = 0;
int surp = S[a];
for (int i = 0; i < N[a]; i++) {
if (total[a][i] >= (3*p[a])-2) {
er++;
} else {
if (surp > 0 && total[a][i] >= (p[a]+2*(p[a]-2)) && p[a] > 1) {
er++;
surp--;
}
}
}
return er;
}
public static void main (String args[]) throws IOException {
beolvas("B-small-attempt0.in");
// kiir();
for (int a = 0; a < T; a++) {
System.out.println("Case #"+(a+1)+": "+count(a));
}
}
}
| 0 | 1,189,658 |
A11759 | A10447 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.Scanner;
public class Dancing {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] array = new int[n];
for (int i = 0; i < n; i++) {
int k = scan.nextInt();
int[] arrayInt = new int[k];
int s = scan.nextInt();
int p = scan.nextInt();
for (int j = 0; j < k; j++)
arrayInt[j] = scan.nextInt();
int a = 0;
for (int j = 0; j < k; j++) {
int div = arrayInt[j] / 3;
int rem = arrayInt[j] - div * 3;
if (rem == 0) {
if (div >= p)
a++;
else if (div == p - 1 && s >= 1 && div - 1 >= 0) {
a++;
s--;
}
} else if (rem == 1) {
if (div >= p - 1)
a++;
} else {
if (div >= p - 1)
a++;
else if (div == p - 2 && s >= 1) {
a++;
s--;
}
}
}
array[i] = a;
}
for (int i = 1; i <= n; i++)
System.out.println("Case #" + i + ": " + array[i - 1]);
}
}
| 0 | 1,189,659 |
A11759 | A10208 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.dancewithgooglers;
import java.io.*;
public class DanceWithGooglers {
private static String filename = "small";
public static void main(String[] args) throws Exception {
RandomAccessFile input = new RandomAccessFile(filename + "_in.txt", "r");
RandomAccessFile output = new RandomAccessFile(filename + "_out.txt", "rw");
int cases = Integer.valueOf(input.readLine());
for(int i = 0; i < cases; i++){
String[] line = input.readLine().split(" ");
int N = Integer.valueOf(line[0]);
int S = Integer.valueOf(line[1]);
int p = Integer.valueOf(line[2]);
int[] t = new int[N];
for(int j = 0; j < N; j++)t[j] = Integer.valueOf(line[j + 3]);
int solved = solve(t, S, p);
System.out.println("Case #" + (i + 1) + ": " + solved);
output.writeBytes("Case #" + (i + 1) + ": " + solved + "\n");
}
output.close();
input.close();
}
private static int solve(int[] scores, int S, int p){
int found = 0;
int surprising = 0;
for(int i : scores){
boolean[] result = permute(i, p);
if(!result[0])continue;
if(!result[1]){
found++;
}else{
surprising++;
}
}
if(S > surprising)return found + surprising;
return found + S;
}
private static boolean[] permute(int value, int search){
boolean found = false;
boolean surprising = false;
for(int a = 0; a <= 10; a++){
for(int b = a; b <= a + 2; b++){
if(b > 10)continue;
for(int c = a; c <= a + 2; c++){
if(c > 10)continue;
if((a + b + c) != value)continue;
if((a >= search) || (b >= search) || (c >= search)){
found = true;
if((Math.abs(a - b) == 2) || (Math.abs(a - c) == 2) || (Math.abs(b - c) == 2)){
surprising = true;
}else{
return new boolean[]{ true, false };
}
}
}
}
}
return new boolean[]{ found, surprising };
}
}
| 0 | 1,189,660 |
A11759 | A12071 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.renoux.gael.codejam.utils;
import java.io.Closeable;
import java.io.IOException;
/**
* <p>
* Cette classe comporte des méthodes utilitaires de gestion des flux d'entrée/sortie.
* </p>
*
* @author renouxg
*/
public class FluxUtils {
/**
* <p>
* Constructeur privé : cette classe utilitaire n'est pas destinée à être instanciée.
* </p>
*/
private FluxUtils() {
// classe non instanciable
}
/**
* <p>
* Cette méthode utilitaire ferme tous les objets <code>Closeable</code> qui lui sont passés en paramètre.
* Les éléments nuls sont ignorés. Si la fermeture de l'un ou plusieurs d'entre eux renvoie une erreur, on
* tâche néanmoins de fermer tous les flux ; la première erreur survenue est ensuite relancée.
* </p>
*
* @param fluxArray les objets implémentant {@link Closeable} qu'il faut fermer.
* @throws IOException toute exception qui peut se produire à la fermeture d'un {@link Closeable}.
*/
public static void closeCloseables(final Closeable... fluxArray) {
IOException relaunch = null;
for (Closeable flux : fluxArray) {
if (flux == null) {
continue;
}
try {
flux.close();
} catch (IOException lEx) {
if (relaunch == null) {
relaunch = lEx;
} else {
// Nouvelle exception, ignorée
}
}
}
if (relaunch != null) {
throw new TechnicalException(relaunch);
}
}
}
| 0 | 1,189,661 |
A11759 | A12740 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.*;
import java.util.*;
import java.math.*;
/** @author Samuel Ahn */
public class B {
public static void main(String args[]) throws Exception {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int i = 1; i <= T; i++) {
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int[] array = new int[N];
for (int j = 0; j < N; j++) {
array[j] = in.nextInt();
}
Arrays.sort(array);
int sum = 0;
for (int j = 0; j < N; j++) {
int temp = array[j];
if ((temp == 0)) {
if (temp >= p) {
sum++;
}
} else if ((temp == 1)) {
if (temp >= p) {
sum++;
}
} else {
if (S > 0) {
if (((temp + 4) / 3) >= p) {
sum++;
S--;
}
} else {
if (((temp + 2) / 3) >= p) {
sum++;
}
}
}
}
System.out.printf("Case #%d: %d\n", i, sum);
}
}
} | 0 | 1,189,662 |
A11759 | A11130 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.cj12;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
class Dancing {
public static void main(String[] args) throws IOException {
BufferedReader f = new BufferedReader(new FileReader("D:/Temp/B-small-attempt1.in"));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
"D:/Temp/B-small-attempt1.out")));
new Dancing().solve(f, out);
out.close();
}
private void solve(BufferedReader f, PrintWriter out) throws IOException {
int T = read(f);
for (int i=0; i<T; i++) {
int count = 0;
String[] s = f.readLine().split(" ");
int N = Integer.parseInt(s[0]);
int S = Integer.parseInt(s[1]);
int p = Integer.parseInt(s[2]);
for (int j=0; j<N; j++) {
int t = Integer.parseInt(s[j+3]);
int base = t/3;
int max = t%3==0? base : base+1;
if (max >= p) {
count++;
continue;
}
if (S == 0 || t<2 || t%3==1) continue;
max = t%3==0? base+1 : base+2;
if (max >= p) {
count++;
S--;
}
}
out.println("Case #" + (i+1) + ": " + count);
}
}
public int read(BufferedReader f) throws IOException {
return Integer.parseInt(f.readLine());
}
}
| 0 | 1,189,663 |
A11759 | A11122 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream(new File("in.txt"));
FileOutputStream fos = new FileOutputStream(new File("out.txt"));
Scanner sc = new Scanner(fis);
PrintWriter out = new PrintWriter(fos);
int cases = sc.nextInt();
for(int cs = 1; cs <= cases; cs++)
{
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int [] sums = new int[n];
for(int i=0; i<n; i++)
sums[i] = sc.nextInt();
int notsup = 0;
int supx = 0;
for(int i=0; i<n; i++)
{
if(getMax(sums[i],1)>=p)
notsup++;
if(getMax(sums[i],2)<p)
supx++;
}
int total = notsup+Math.min(n-notsup-supx, s);
out.println("Case #"+cs+": "+total);
}
sc.close();
out.close();
}
public static int getMax(int sum, int diff)
{
int max = Integer.MIN_VALUE;
for(int i=0; i<=10; i++)
for(int j=0; j<=10; j++)
{
int k=sum-i-j;
if(k>=0 && k<=10)
{
int d = Math.abs(i-j);
d = Math.max(d, Math.abs(k-j));
d = Math.max(d, Math.abs(k-i));
if(d<=diff)
{
max = Math.max(i, max);
max = Math.max(j, max);
max = Math.max(k, max);
}
}
}
return max;
}
}
| 0 | 1,189,664 |
A11759 | A11703 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
/**
*
* @author Student
*/
public class Score {
private int i;
private int j;
private int k;
private boolean surp;
public Score(int i, int j, int k,boolean surp) {
this.i = i;
this.j = j;
this.k = k;
this.surp = surp;
}
public boolean isValid(){
return (i<=10&&j<=10&&k<=10)&&(i>=0&&j>=0&&k>=0);
}
public boolean isSurprising(){
return surp;
}
public boolean isbetter(int x){
return i>=x||j>=x||k>=x;
}
public String toString(){
return "("+i+","+j+","+k+")";
}
}
| 0 | 1,189,665 |
A11759 | A11808 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package com.google.code.jam2012.problemB;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
/**
* Created with IntelliJ IDEA.
* User: Vahid
* Date: 4/14/12
* Time: 6:54 PM
* To change this template use File | Settings | File Templates.
*/
public class ProblemB1 {
private static final int MAX_SCORE = 30;
static int[] normalP = new int[MAX_SCORE + 1];
static int[] maxSP = new int[MAX_SCORE + 1];
static int[] list;
public static void main(String[] args) throws IOException {
setP();
Scanner scanner = new Scanner(new FileInputStream("data.in"));
FileOutputStream out = new FileOutputStream("B1.out");
int lines = scanner.nextInt();
scanner.nextLine();
int n, s, p;
for (int i = 1; i<=lines; i++){
n = scanner.nextInt();
s = scanner.nextInt();
p = scanner.nextInt();
list = new int[n];
for (int j=0; j<n; j++)
list[j] = scanner.nextInt();
out.write(("Case #"+i+": "+ max(n , s ,p , 0)).getBytes());
out.write('\r');
out.write('\n');
if (scanner.hasNextLine()) scanner.nextLine();
}
scanner.close();
out.close();
}
private static int max(int n, int s, int p, int candidate) {
if (n>0){
int current = list[n-1];
if ((current<2) || ((current>28))){
if (normalP[current]<p) return max(n-1, s , p , candidate);
else return max(n-1, s , p , candidate) + 1;
}
if (maxSP[current]<p) return max(n-1, s , p , candidate);
if (normalP[current]<p) {
if (s>0) return Math.max(max(n-1, s-1 , p , candidate)+1,max(n-1, s , p , candidate));
return max(n-1, s , p , candidate);
}
return max(n-1, s , p , candidate+1)+1;
}
return 0;
}
private static void setP() {
for (int i = 0; i <= MAX_SCORE; i++) {
normalP[i] = (int) Math.ceil(i / 3.0);
if (i % 3 == 0) {
maxSP[i] = i / 3 + 1;
} else {
maxSP[i] = i / 3 + 2;
}
}
}
}
| 0 | 1,189,666 |
A11759 | A12882 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 Sol2 {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(new File("B-small-attempt0.in"));
System.setOut(new PrintStream(new File("B-small-attempt0.out")));
int len = sc.nextInt();
for (int i = 0; i < len; i++) {
int nexlen = sc.nextInt();
int surp = sc.nextInt();
int minscore = sc.nextInt();
int numb = 0;
for (int a = 0; a < nexlen; a++) {
int[] three = separate(sc.nextInt());
if (isGood(three, minscore)) {
numb++;
} else {
if (((three[0]==three[1]&&three[1]==three[2]&&three[0]!=0)||(three[0]==three[1]&&three[1]-1==three[2]))&&surp>0) {
if (three[0]+1>=minscore) {
numb++;
surp--;
}
}
}
}
System.out.println("Case #"+(i+1)+": "+numb);
}
}
public static int[] separate(int i) {
int[] ret = new int[3];
ret[0] = (int)Math.ceil(i/3.);
ret[1] = (int)Math.ceil((i-ret[0])/2.);
ret[2] = i-ret[0]-ret[1];
return ret;
}
public static boolean isGood(int[] in,int a) {
for (int i = 0; i < 3; i++) {
if (in[i]>=a) {
return true;
}
}
return false;
}
} | 0 | 1,189,667 |
A11759 | A12899 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam2012;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
/**
*
* @author Luis Sergio Curay
*/
public class b_2 {
public b_2() {
Scanner in= new Scanner(System.in);
int t= in.nextInt();
HashMap<Integer, ArrayList<ArrayList<Integer>>> comb= new HashMap<Integer, ArrayList<ArrayList<Integer>>>();
for (int i = 0; i <= 30; i++) {
ArrayList<ArrayList<Integer>> curr= new ArrayList<ArrayList<Integer>>();
for (int j = 0; j <= 10; j++)
for (int k = 0; k <= 10; k++)
for (int l = 0; l <= 10; l++)
if((j+k+l) == i) {
ArrayList<Integer> tmp= new ArrayList<Integer>();
int arr[]= new int[]{j,k,l};
Arrays.sort(arr);
for (int m = 0; m < arr.length; m++) {
tmp.add(arr[m]);
}
curr.add(tmp);
}
comb.put(i, curr);
}
for (int i = 0; i < t; i++) {
int n= in.nextInt();
int s= in.nextInt();
int p= in.nextInt();
int res= 0;
for (int j = 0; j < n; j++) {
int c= in.nextInt();
int rank= 0;
ArrayList<ArrayList<Integer>> curr= comb.get(c);
for (ArrayList<Integer> combs : curr) {
if(combs.get(0).equals(combs.get(1)) && combs.get(0).equals(combs.get(2))) {
if(combs.get(0) >= p) {
rank=6;break;//res++;break;
}
} else if(combs.get(0).equals(combs.get(1))) {
if(combs.get(2) >= p && (combs.get(2) - combs.get(1)) == 1) {
if(rank < 5) rank= 5;//res++;break;
} else if(combs.get(2) >= p && (combs.get(2) - combs.get(1)) == 2 && s > 0) {
if(rank < 4) rank= 4;//res++;s--;break;
}
} else if(combs.get(1).equals(combs.get(2))) {
if(combs.get(1) >= p && (combs.get(1) - combs.get(0)) == 1) {
if(rank < 3) rank= 3;//res++;break;
} else if(combs.get(1) >= p && (combs.get(1) - combs.get(0)) == 2 && s > 0) {
if(rank < 2) rank= 2;//res++;s--;break;
}
} else {
if(combs.get(2) >= p)
if((combs.get(2) - combs.get(1)) == 1 && (combs.get(1) - combs.get(0)) == 1 && s > 0) {
if(rank < 1) rank= 1;//res++;s--;break;
}
}
}
if(rank == 6 || rank ==5 || rank == 3)
res++;
else if( rank > 0){
res++;s--;
}
}
System.out.println("Case #" + (i + 1) + ": " + res);
}
}
public void print(ArrayList<Integer> t) {
for (Integer integer : t) {
System.out.print(integer + " ");
}
System.out.println();
}
} | 0 | 1,189,668 |
A11759 | A10791 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class GoogleDance {
/**
* @param args
* @throws IOException
* @throws NumberFormatException
*/
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
int cases = Integer.parseInt(br.readLine().trim());
for(int t=1;t<=cases;t++){
String ln=br.readLine().trim();
String[] inp=ln.split(" ");
int n=Integer.parseInt(inp[0]);
int s=Integer.parseInt(inp[1]);
int p=Integer.parseInt(inp[2]);
int[] scores=new int[n];
int count=0, sleft=s;
for(int i=0;i<n;i++){
scores[i]=Integer.parseInt(inp[3+i]);
int avg = scores[i]/3;
int rem = scores[i]%3;
//System.out.println("i : "+i+" --> "+scores[i]+" :: "+avg+" :: "+rem+" :s"+sleft+" :c "+count);
if(avg>=p){
count++;
continue;
}
if(rem>=1 && (avg+1)>=p){
count++;
continue;
}
if(sleft>0){
switch (rem) {
case 0:
if(avg>0 && (avg+1)>=p){
sleft--;
count++;
continue;
}
break;
case 1:
break;
case 2:
if((avg+2)>=p){
sleft--;
count++;
continue;
}
break;
default:
break;
}
}
}
System.out.println("Case #"+t+": "+count);
}
}
}
| 0 | 1,189,669 |
A11759 | A10648 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.*;
public class B {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int N = scan.nextInt();
scan.nextLine();
for (int i = 1; i <= N; i++)
System.out.println("Case #"+i+": "+solve(scan));
}
public static Object solve(Scanner scan) {
int n = scan.nextInt(), s = scan.nextInt(), p = scan.nextInt();
int out = 0, t;
while (n-- > 0) {
t = scan.nextInt();
if ((t+2)/3 >= p || t > 1 && (t+4)/3 >= p && s-- > 0)
out++;
}
return out+"";
}
}
| 0 | 1,189,670 |
A11759 | A10822 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Scanner;
public class DancingGooglers {
public static void main(String[] args) throws Exception {
Scanner in = new Scanner(new File("input.in"));
BufferedWriter bfrw = new BufferedWriter(new FileWriter("output.out"));
int N = in.nextInt();
String output = "";
for(int i = 0; i < N;i++){
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int [] num = new int[n];
for(int j = 0; j < n;j++){
num[j] = in.nextInt();
}
output += "Case #"+(i+1)+": " + solve(num,s,p) + "\n";
}
bfrw.write(output);
in.close();
bfrw.close();
}
private static int solve(int [] num, int S, int P){
int ans = 0;
for(int x = 0; x < num.length;x++) {
int N = num[x];
ArrayList<String> al = new ArrayList<String>();
for(int i = 10; i >= 0; i--){
for(int j = 10; j >= 0; j--){
for(int k = 10; k >= 0; k--){
if(i+j+k == N && Math.max(Math.max(i,j), k) >= P && isValid(i, j, k)){
//System.out.println(i + " " + j +" " + k);
al.add(i+","+j+","+k);
//break here;
}
}
}
}
if(al.size() > 0 && !isSurprizeTrue(al)){
ans++;
} else if (al.size() > 0 && isSurprizeTrue(al) && S > 0) {
ans++;
S--;
}
//System.out.println();
}
return ans;
}
private static boolean isSurprizeTrue(ArrayList<String> al){
for(int i = 0; i < al.size();i++){
String[] s = al.get(i).split(",");
if(!isSurprize(Integer.parseInt(s[0]),Integer.parseInt(s[1]),Integer.parseInt(s[2]))) return false;
}
return true;
}
private static boolean isValid(int i,int j, int k){
if(Math.abs(i-j) > 2) return false;
if(Math.abs(i-k) > 2) return false;
if(Math.abs(j-k) > 2) return false;
return true;
}
private static boolean isSurprize(int i,int j, int k){
if(Math.abs(i-j) == 2) return true;
if(Math.abs(i-k) == 2) return true;
if(Math.abs(j-k) == 2) return true;
return false;
}
}
| 0 | 1,189,671 |
A11759 | A11602 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class BDanceScores {
public static void main(String[] args) throws FileNotFoundException {
Scanner in = new Scanner(new File("bsmall.in"));
//Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter("bsmall.out");
int T = in.nextInt();
for (int t = 1; t <= T; ++t) {
int N = in.nextInt(), S = in.nextInt(), p = in.nextInt();
int bigScores = 0, okScores = 0;
for (int i = 0; i < N; ++i) {
int sumScore = in.nextInt();
int bestScore = (sumScore + 2) / 3;
if (bestScore >= p) {
bigScores++;
} else if (bestScore == p-1 && sumScore >= 2 && sumScore <= 28 && (sumScore % 3 != 1)) {
okScores++;
}
}
int result = Math.min(okScores, S) + bigScores;
out.println("Case #" + t + ": " + result);
}
out.close();
}
}
| 0 | 1,189,672 |
A11759 | A11179 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.Scanner;
public class Googlers {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int cases = sc.nextInt();
for (int x = 0; x < cases; x++) {
sc.nextLine();
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int posibles = 0;
for (int i = 0; i < n; i++) {
int ti = sc.nextInt();
if (ti < p)
continue;
//if (ti == 3 * p || ti == 3 * p - 1 || ti == 3 * p - 2)
if (ti >= 3 * p - 2)
posibles++;
else if (s > 0 && (ti >= 3 * p - 4)) {
posibles++;
s--;
}
}
System.out.println("Case #" + (x+1) + ": " + posibles);
}
}
}
| 0 | 1,189,673 |
A11759 | A12568 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.IOException;
import java.util.*;
public class AlienLanguage extends JamProblem {
private int wordsC;
private int wordsL;
List<String> words = new ArrayList<String>();
TreeNode startNode;
public static void main(String[] args) throws IOException {
AlienLanguage p = new AlienLanguage();
p.go();
}
@Override
void parseFirstLine(List<String> file) {
int[] firstLine = JamUtil.parseIntList(file.get(0), 3);
caseCount = firstLine[2];
wordsC = firstLine[1];
wordsL = firstLine[0];
startNode = new TreeNode(null);
for (int i=0; i<wordsC; i++) {
String word = file.get(i + 1);
words.add(word);
buildTree(word, startNode);
}
lastLine = wordsC + 1;
}
@Override
String solveCase(JamCase jamCase) {
ALCase cas = (ALCase) jamCase;
Set<TreeNode> curr = new HashSet<>();
curr.add(startNode);
List<Set<Character>> pattern = cas.pattern;
for (int i = 0; i < pattern.size(); i++) {
Set<Character> characters = pattern.get(i);
Set<TreeNode> next = new HashSet<>();
for (Character ch : characters) {
for (TreeNode node : curr) {
if (node.childred.containsKey(ch)) {
next.add(node.childred.get(ch));
}
}
}
curr = next;
}
return "" + curr.size();
}
@Override
JamCase parseCase(List<String> file, int lineI) {
ALCase cas = new ALCase();
cas.lineCount = 1;
String line = file.get(lineI);
boolean inGroup = false;
char[] chars = line.toCharArray();
Set<Character> current = new HashSet<>();
for (int i = 0; i < chars.length; i++) {
char ch = chars[i];
switch (ch) {
case '(':
inGroup = true;
current = new HashSet<>();
cas.pattern.add(current);
break;
case ')':
inGroup = false;
break;
default:
if (inGroup) {
current.add(ch);
} else {
current = new HashSet<>();
cas.pattern.add(current);
current.add(ch);
}
}
}
return cas;
}
void buildTree(String str, TreeNode node) {
char c = str.charAt(0);
String remain = str.substring(1);
if (node.childred.get(c) == null) {
TreeNode newNode = new TreeNode(c);
node.childred.put(c,newNode);
}
if (!remain.isEmpty()) {
buildTree(remain,node.childred.get(c));
}
}
}
class ALCase extends JamCase {
TreeNode startNode = new TreeNode(null);
List<Set<Character>> pattern = new ArrayList<Set<Character>>();
}
class TreeNode {
TreeNode(Character ch) {
this.ch = ch;
}
Character ch;
Map<Character,TreeNode> childred = new HashMap<Character, TreeNode>();
}
| 0 | 1,189,674 |
A11759 | A10153 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.io.IOException;
import java.util.Scanner;
public class DancingGooglers {
public static void main(String[] args) throws FileNotFoundException, IOException {
Scanner sc = new Scanner(new File("C:/B-small-attempt4.in"));
BufferedWriter bf = new BufferedWriter(new FileWriter("C:/B-small.txt", false));
int T = sc.nextInt();
for (int i = 1; i <= T; i++) {
int n, s, p;
n = sc.nextInt();
s = sc.nextInt();
p = sc.nextInt();
int highScore = 0;
int medScore = 0;
for (int j = 0; j < n; j++) {
int score = sc.nextInt();
if (score > 3 * (p - 1)) {
highScore++;
} else if (p > 1 && score > 3 * (p - 2) + 1) {
medScore++;
}
}
int maxval = highScore + Math.min(s, medScore);
System.out.println("Case #" + i + ": " + maxval);
bf.write("Case #" + i + ": " + maxval + "\n");
}
bf.close();
}
}
| 0 | 1,189,675 |
A11759 | A10477 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 Q2
{
private static int max (int a, int b, int c)
{
return Math.max (a, Math.max (b, c));
}
public static void main (String[] args) throws IOException
{
BufferedReader reader = new BufferedReader (new FileReader ("input-q2.txt"));
PrintWriter writer = new PrintWriter ("output-q2.txt");
String line = reader.readLine();
int nb = Integer.parseInt (line);
for (int i = 0; i < nb; i++)
{
line = reader.readLine();
String[] tokens = line.split (" ");
int[] googlers = new int[Integer.parseInt (tokens[0])];
int s = Integer.parseInt (tokens[1]);
int p = Integer.parseInt (tokens[2]);
for (int j = 0; j < googlers.length; j++)
{
googlers[j] = Integer.parseInt (tokens[3 + j]);
}
System.out.printf ("\ns : %d, p : %d, googlers : %s\n", s, p, Arrays.toString (googlers));
// For each googler
int counter = 0;
for (int j = 0; j < googlers.length; j++)
{
System.out.print ("Googler " + googlers[j] + " :");
int a = 0, b = 0, c = 0;
if ((googlers[j] - 2) % 3 == 0)
{
a = b = (googlers[j] - 2) / 3;
c = (googlers[j] - 2) / 3 + 2;
if (max (a, b + 1, c - 1) >= p || c <= 1 || max (a, b, c) < p)
{
System.out.printf (" (%d %d %d)\n", a, b + 1, c - 1);
if (max (a, b + 1, c - 1) >= p)
{
counter++;
}
continue;
}
else if (s > 0)
{
s--;
if (max (a, b, c) >= p)
{
counter++;
}
System.out.printf (" (%d %d %d) *\n", a, b, c);
continue;
}
else
{
System.out.println ("ERROR");
}
}
if ((googlers[j] - 1) % 3 == 0)
{
a = b = (googlers[j] - 1) / 3;
c = (googlers[j] - 1) / 3 + 1;
if (max (a, b, c) >= p)
{
counter++;
}
System.out.printf (" (%d %d %d)\n", a, b, c);
continue;
}
if (googlers[j] % 3 == 0)
{
a = b = c = googlers[j] / 3;
if (max (a, b, c) >= p || b <= 1 || max (a, b - 1, c + 1) < p || s == 0)
{
System.out.printf (" (%d %d %d)\n", a, b, c);
if (max (a, b, c) >= p)
{
counter++;
}
continue;
}
else if (s > 0)
{
s--;
if (max (a, b - 1, c + 1) >= p)
{
counter++;
}
System.out.printf (" (%d %d %d) *\n", a, b - 1, c + 1);
continue;
}
else
{
System.out.println ("ERROR");
}
}
}
System.out.println ("Counter : " + counter);
writer.println ("Case #" + (i + 1) + ": " + counter);
}
writer.close();
reader.close();
}
} | 0 | 1,189,676 |
A11759 | A10500 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class B {
int N = 0;
int S = 0;
int P = 0;
ArrayList<Integer> nrs;
public B(BufferedReader reader) throws IOException {
String line = reader.readLine();
StringTokenizer token = new StringTokenizer(line, " ");
N = Integer.parseInt(token.nextToken());
S = Integer.parseInt(token.nextToken());
P = Integer.parseInt(token.nextToken());
nrs = new ArrayList<Integer>();
for (int i = 0; i<N; i++) {
int nr = Integer.parseInt(token.nextToken());
nrs.add(nr);
}
}
public int solve() {
int result = 0;
int P3 = P * 3;
for( Integer nr : nrs) {
// impossible case;
if (nr < P ) {
continue;
}
// is not surprising?
if ((nr + 2) >= P3) {
result++;
continue;
}
if (((nr + 4) >= P3) && (S > 0)) {
result++;
S--;
continue;
}
}
return result;
}
public static void main(String[] args) throws IOException {
String inputFile = args[0];
BufferedReader reader = new BufferedReader(new FileReader(inputFile
+ ".in"));
FileWriter outFile = new FileWriter(inputFile + ".out");
PrintWriter out = new PrintWriter(outFile);
String strNrLines = reader.readLine();
int nrLines = Integer.parseInt(strNrLines);
for (int i = 1; i <= nrLines; i++) {
B b = new B(reader);
out.println("Case #" + i + ": " + b.solve());
}
reader.close();
out.close();
}
}
| 0 | 1,189,677 |
A11759 | A11608 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.StringTokenizer;
public class DancingWithGooglers extends BaseSolution {
public String solveTestCase() throws Exception {
String inp = readLine();
StringTokenizer st = new StringTokenizer(inp);
int N = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
int ans=0;
for(int i=0;i<N;i++){
int t = Integer.parseInt(st.nextToken());
int maxNormal=t,maxSurprise=t;
if(t>0){
maxNormal = ((t-1)/3) + 1;
}
if(t>1){
maxSurprise = ((t-2)/3) + 2;
if(maxSurprise>10){
maxSurprise = 10;
}
}
if(maxNormal>=p){
ans++;
} else if(S>0&&maxSurprise>=p){
S--;
ans++;
}
}
return ans+"";
}
}
| 0 | 1,189,678 |
A11759 | A12466 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;
import java.util.StringTokenizer;
public class Test {
static BufferedReader reader;
static StringTokenizer tokenizer;
static PrintWriter writer;
static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
static long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
static double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
static String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
public static void main(String[] args) throws IOException {
reader = new BufferedReader(new FileReader("txt.in"));
tokenizer = null;
writer = new PrintWriter("System.out");
solve();
reader.close();
writer.close();
}
private static void solve() throws IOException {
int T=nextInt();
for (int j=0;j<T;j++)
{
int N=nextInt();
int S=nextInt();
int p=nextInt();
int k=0;
String ans="Case #"+Integer.toString(j+1)+": ";
int an=0;
if (p>1)
k=3*p-4;
else
{
for (int i=0;i<N;i++)
{
int tt=nextInt();
if (tt>=p)
an++;
}
ans+=Integer.toString(an);
if(j!=T-1)
writer.println(ans);
else
writer.print(ans);
continue;
}
for (int i=0;i<N;i++)
{
int tt=nextInt();
if (tt==k||tt==k+1)
if (S>0)
{
an++;
S--;
}
if (tt>k+1)
an++;
}
ans+=Integer.toString(an);
if(j!=T-1)
writer.println(ans);
else
writer.print(ans);
}
}
} | 0 | 1,189,679 |
A11759 | A10429 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 NOD {
public static int gcd (int a, int b)
{
if (b == 0)
return a;
else
return gcd (b, a % b);
}
public static long gcd (long a, long b)
{
if (b == 0)
return a;
else
return gcd (b, a % b);
}
public static double gcd (double a, double b)
{
if (b == 0)
return a;
else
return gcd (b, a % b);
}
}
| 0 | 1,189,680 |
A11759 | A12258 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package cj2012.qual;
import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;
public class B {
static boolean[][] NW = new boolean[11][31];
static boolean[][] SW = new boolean[11][31];
static {
for (int a = 0; a < 11; a++) {
for (int b = 0; b < 11; b++) {
for (int c = 0; c < 11; c++) {
int max = Math.max(Math.max(a, b), c);
int min = Math.min(Math.min(a, b), c);
if (max - min <= 1) NW[max][a+b+c] = true;
if (max - min == 2) SW[max][a+b+c] = true;
}
}
}
}
public static void main(String[] args) throws Exception {
Scanner scan = new Scanner(new File("in/B-small-attempt0.in"));
int T = scan.nextInt();
PrintWriter out = new PrintWriter(new File("out/B-small-attempt0.txt"));
for (int z = 1; z <= T; z++) {
int N = scan.nextInt();
int S = scan.nextInt();
int p = scan.nextInt();
int[] a = new int[N];
for (int i = 0; i < N; i++)
a[i] = scan.nextInt();
boolean[][] m = new boolean[N][2];
// False/True: no-win/win
// 0/1: not-surprising/surprising
int[] cc = new int[4];
int alwaysLose = 0;
int surpriseLose = 1;
int surpriseWin = 2;
int alwaysWin = 3;
for (int i = 0; i < N; i++) {
for (int j = p; j <= 10; j++) {
m[i][0] = m[i][0] || NW[j][a[i]];
m[i][1] = m[i][1] || SW[j][a[i]];
}
int k = 0;
if (m[i][0]) k += 1;
if (m[i][1]) k += 2;
cc[k]++;
}
int ret = 0;
while (S > 0 && cc[surpriseWin] > 0) {S--; cc[surpriseWin]--; ret++;}
while (S > 0 && cc[alwaysLose] > 0) {S--; cc[alwaysLose]--;}
while (S > 0 && cc[alwaysWin] > 0) {S--; cc[alwaysWin]--; ret++;}
while (S > 0 && cc[surpriseLose] > 0) {S--; cc[surpriseLose]--;}
ret += cc[alwaysWin] + cc[surpriseLose];
out.println("Case #" + z + ": " + ret);
}
out.close();
}
}
| 0 | 1,189,681 |
A11759 | A12370 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.*;
public class Main {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
// TODO Auto-generated method stub
Scanner scan = new Scanner(new File("in"));
scan.nextLine();// removes int at start
int counter = 0;
while (scan.hasNextInt()) {
counter++;
// initialize
int numDancers = scan.nextInt();
int numSurp = scan.nextInt();
int best = scan.nextInt();
int[] dancers = new int[numDancers];
for (int i = 0; i < numDancers; i++) {
dancers[i] = scan.nextInt();
}
// do the checks
if (best==0) {
System.out.println("Case #"+counter+": "+numDancers);
}
else if (best==1){
int cnt = 0;
for (int i = 0; i < numDancers; i++){
if (dancers[i]!=0) {
cnt++;
}
}
System.out.println("Case #"+counter+": "+cnt);
}
else{
int count1 = 0, count2 = 0;
for (int i = 0; i < numDancers; i++) {
int score = dancers[i];
if (score >= 3 * best - 2 && 3*best - 2>=0) {
count1++;
} else if (score >= 3 * best - 4 && 3*best-4>=0) {
count2++;
}
}
if (count2 <= numSurp) {
System.out.println("Case #"+counter+": "+ (int)(count1 +count2));
}
else{
System.out.println("Case #"+counter+": "+ (int)(count1+numSurp));
}
}
}
}
}
| 0 | 1,189,682 |
A11759 | A12855 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
*
*/
/**
* @author Shweta
*
*/
public class DancingGoogler {
/**
* @param list
* @param minimumScore
* @param numberOfSurprisingResults
*/
private List<Googler> list;
private int numberOfSurprisingResults, minimumScore;
private int maxNumberOfGooglersForBestResult;
public DancingGoogler(List<Googler> list, int numberOfSurprisingResults,
int minimumScore) {
this.list = list;
Collections.sort(this.list);
this.numberOfSurprisingResults = numberOfSurprisingResults;
this.minimumScore = minimumScore;
putScores(this.list);
calculateAnswer();
}
/**
*
*/
private void calculateAnswer() {
for (Googler googler : this.list) {
boolean minScoreGiven = false;
for (int i = 0; i < 3; i++) {
int score = googler.getScores()[i];
if (score >= minimumScore) {
minScoreGiven = true;
break;
}
}
if (minScoreGiven) {
maxNumberOfGooglersForBestResult++;
} else if (numberOfSurprisingResults > 0) {
if (googler.getMaxScore() > 0) {
googler.getScores()[1] = googler.getScores()[1] - 1;
googler.getScores()[2] = googler.getScores()[2] + 1;
if (googler.getScores()[2] >= minimumScore) {
maxNumberOfGooglersForBestResult++;
numberOfSurprisingResults--;
}
}
}
}
}
/**
* @param list2
*/
private void putScores(List<Googler> googlers) {
for (Googler googler : googlers) {
int maxScore = googler.getMaxScore();
int[] scores = new int[3];
int base = maxScore / 3;
scores[0] = base;
scores[1] = base;
scores[2] = base;
if (maxScore % 3 == 1) {
scores[1] = base + 1;
} else if (maxScore % 3 == 2) {
scores[1] = base + 1;
scores[2] = base + 1;
}
googler.setScores(scores);
}
}
/**
* @return
*/
public int answer() {
return maxNumberOfGooglersForBestResult;
}
public static void main(String args[]) throws Exception {
BufferedReader bufferedReader = new BufferedReader(
new FileReader(
new File(
"C:\\Documents and Settings\\Kamlesh\\Desktop\\codejam\\B-small-attempt0.in")));
int numberOfTest = Integer.valueOf(bufferedReader.readLine());
for (int i = 1; i <= numberOfTest; i++) {
String line = bufferedReader.readLine();
String tokens[] = line.split("\\ ");
int n = Integer.valueOf(tokens[0]);
int surprizingTriplets = Integer.valueOf(tokens[1]);
int minimumScore = Integer.valueOf(tokens[2]);
List<Googler> list = new ArrayList<Googler>();
for (int j = 1; j <= n; j++) {
int maxScore = Integer.valueOf(tokens[2 + j]);
Googler googler = new Googler(maxScore);
list.add(googler);
}
DancingGoogler dc = new DancingGoogler(list, surprizingTriplets,
minimumScore);
System.out.println("Case #" + i + ": " + dc.answer());
}
}
}
| 0 | 1,189,683 |
A11759 | A10371 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.feasoft.jam;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* User: Homer
* Date: 4/13/12
* Time: 9:15 PM
*/
public class Dance {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
int numberOfCases = scanner.nextInt();
for (int i = 0; i < numberOfCases; i++) {
int numberOfGooglers = scanner.nextInt();
int surprisingScore = scanner.nextInt();
int floorScore = scanner.nextInt();
List<Integer> scores = new ArrayList<Integer>();
for (int j = 0; j < numberOfGooglers; j++) {
scores.add(scanner.nextInt());
}
int answer = solve(surprisingScore, floorScore, scores);
System.out.printf("Case #%d: %d\n", i + 1, answer);
}
}
private static int solve(int surprisingScoresMaxQuantity, int floorScore, List<Integer> scores) {
int surprisingFound = 0;
int surprisingMinScore = floorScore + 2*(floorScore-2);
int nonSurprisingMinScore = floorScore + 2*(floorScore-1);
if (surprisingMinScore < 0) {
surprisingMinScore = floorScore;
}
if (nonSurprisingMinScore < 0) {
nonSurprisingMinScore = floorScore;
}
int count = 0;
for (Integer totalScore : scores) {
if (totalScore >= nonSurprisingMinScore) {
count++;
} else if (totalScore >= surprisingMinScore && surprisingScoresMaxQuantity > surprisingFound) {
count++;
surprisingFound++;
}
}
return count;
}
}
| 0 | 1,189,684 |
A11759 | A10073 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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 Chris Dziemborowicz <chris@dziemborowicz.com>
* @version 2012.0414
*/
public class DancingWithTheGooglers
{
public static void main(String[] args)
throws Exception
{
// Get input files
File dir = new File("/Users/Chris/Documents/UniSVN/code-jam/dancing-with-the-googlers/data");
File[] inputFiles = dir.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name)
{
return name.endsWith(".in");
}
});
// Learn score mappings
learn();
// Process each input file
for (File inputFile : inputFiles) {
System.out.printf("Processing \"%s\"...\n", inputFile.getName());
String outputPath = inputFile.getPath().replaceAll("\\.in$", ".out");
BufferedWriter writer = new BufferedWriter(new FileWriter(outputPath));
Scanner scanner = new Scanner(inputFile);
System.out.printf("Number of test cases: %s\n", scanner.nextLine());
int count = 0;
while (scanner.hasNext()) {
String line = scanner.nextLine();
String output = String.format("Case #%d: %d\n", ++count, process(line));
System.out.print(output);
writer.write(output);
}
writer.close();
System.out.println("Done.\n");
}
// Compare to reference files (if any)
for (File inputFile : inputFiles) {
System.out.printf("Verifying \"%s\"...\n", inputFile.getName());
String referencePath = inputFile.getPath().replaceAll("\\.in$", ".ref");
String outputPath = inputFile.getPath().replaceAll("\\.in$", ".out");
File referenceFile = new File(referencePath);
if (referenceFile.exists()) {
InputStream referenceStream = new FileInputStream(referencePath);
InputStream outputStream = new FileInputStream(outputPath);
boolean matched = true;
int referenceRead, outputRead;
do {
byte[] referenceBuffer = new byte[4096];
byte[] outputBuffer = new byte[4096];
referenceRead = referenceStream.read(referenceBuffer);
outputRead = outputStream.read(outputBuffer);
matched = referenceRead == outputRead
&& Arrays.equals(referenceBuffer, outputBuffer);
} while (matched && referenceRead != -1);
if (matched) {
System.out.println("Verified.\n");
} else {
System.out.println("*** NOT VERIFIED ***\n");
}
} else {
System.out.println("No reference file found.\n");
}
}
}
private static int[] highestOrdinary = new int[31];
private static int[] highestSurprising = new int[31];
public static void learn()
{
Arrays.fill(highestOrdinary, -1);
Arrays.fill(highestSurprising, -1);
for (int i = 0; i <= 10; i++) {
for (int j = i; j <= i + 2 && j <= 10; j++) {
for (int k = j; k <= i + 2 && k <= 10; k++) {
int score = i + j + k;
if (k == i + 2) {
if (k > highestSurprising[score]) {
highestSurprising[score] = k;
}
} else {
if (k > highestOrdinary[score]) {
highestOrdinary[score] = k;
}
}
}
}
}
}
public static int process(String line)
{
// Parse input
Scanner scanner = new Scanner(line);
int num = scanner.nextInt();
int numSurprising = scanner.nextInt();
int p = scanner.nextInt();
int[] scores = new int[num];
for (int i = 0; i < num; i++) {
scores[i] = scanner.nextInt();
}
// Find surprising scores
int count = 0;
for (int score : scores) {
if (highestOrdinary[score] >= p) {
count++;
} else if (numSurprising > 0 && highestSurprising[score] >= p) {
numSurprising--;
count++;
}
}
return count;
}
} | 0 | 1,189,685 |
A11759 | A10934 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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;
import java.io.File;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;
public class B {
static String BASEPATH = "x:\\gcj\\";
static boolean LARGE = false;
static String INPATH = BASEPATH + B.class.getSimpleName().charAt(0) + (LARGE ? "-large.in" : "-small-attempt0.in");
static String OUTPATH = INPATH.substring(0, INPATH.length()-3) + new SimpleDateFormat("-HHmmss").format(new Date()) + ".out";
static String INPUT = "";
static int[][] best = new int[31][2];
public static void prepare()
{
for(int i = 0;i <= 30;i++){
best[i][0] = -1;
best[i][1] = -1;
}
for(int i = 0;i <= 10;i++){
for(int j = i;j <= 10;j++){
for(int k = j;k <= 10;k++){
int s = i+j+k;
if(k-i <= 1){
best[s][0] = Math.max(best[s][0], k);
}else if(k-i == 2){
best[s][1] = Math.max(best[s][1], k);
}
}
}
}
}
public void call()
{
int n = ni(), s = ni(), p = ni();
int[] a = new int[n];
for(int i = 0;i < n;i++){
a[i] = ni();
}
int[][] dp = new int[n+1][s+1];
for(int i = 1;i <= n;i++){
for(int j = 0;j <= s;j++){
dp[i][j] = dp[i-1][j] + (best[a[i-1]][0] >= p ? 1 : 0);
if(j-1 >= 0){
dp[i][j] = Math.max(dp[i][j], dp[i-1][j-1] + (best[a[i-1]][1] >= p ? 1 : 0));
}
}
}
out.println(dp[n][s]);
}
Scanner in;
PrintWriter out;
int cas;
public B(int cas, Scanner in, PrintWriter out)
{
this.cas = cas;
this.in = in;
this.out = out;
}
int ni() { return Integer.parseInt(in.next()); }
long nl() { return Long.parseLong(in.next()); }
double nd() { return Double.parseDouble(in.next()); }
void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }
static void tr_(Object... o) { System.out.println(Arrays.deepToString(o)); }
public static void main(String[] args) throws Exception
{
long start = System.currentTimeMillis();
boolean real = INPUT.isEmpty();
prepare();
if(real){
System.out.println("INPATH : " + INPATH);
System.out.println("OUTPATH : " + OUTPATH);
}
Scanner in = real ? new Scanner(new File(INPATH)) : new Scanner(INPUT);
PrintWriter out = real ? new PrintWriter(new File(OUTPATH)) : new PrintWriter(System.out);
int n = in.nextInt();
in.nextLine();
for(int i = 0;i < n;i++){
out.printf("Case #%d: ", i+1);
new B(i+1, in, out).call();
out.flush();
if(real)System.err.println("case " + (i + 1) + " solved.\t");
}
long end = System.currentTimeMillis();
System.out.println((end - start) + "ms");
if(real){
System.out.println("INPATH : " + INPATH);
System.out.println("OUTPATH : " + OUTPATH);
}
}
}
| 0 | 1,189,686 |
A11759 | A11580 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class Googlers {
public static void main(String args[]) {
try {
File file = new File("input.txt");
FileReader filereader = new FileReader(file);
BufferedReader br = new BufferedReader(filereader);
File out = new File("output.txt");
FileWriter filewriter = new FileWriter(out);
BufferedWriter bw = new BufferedWriter(filewriter);
PrintWriter pw = new PrintWriter(bw);
String str = br.readLine();
int line = Integer.valueOf(str);
for (int i = 0; i < line; i++) {
int x = i + 1;
pw.print("Case #" + x + ": ");
str = br.readLine();
int ans = solve(str);
pw.println(ans);
}
pw.close();
bw.close();
} catch (IOException ie) {
ie.printStackTrace();
}
}
private static int solve(String s) {
int count = 0;
String[] elems = s.split(" ");
int N = Integer.valueOf(elems[0]);
int S = Integer.valueOf(elems[1]);
int p = Integer.valueOf(elems[2]);
for (int i = 3; i < N + 3; i++) {
int score = Integer.valueOf(elems[i]);
int q = score / 3;
int mod = score % 3;
if (q >= p) {
count++;
} else if ((mod == 0 && q + 1 >= p) && (S > 0 && score >= q + 1)) {
count++;
S--;
} else if ((mod == 1 && q + 1 >= p) && (score >= q + 1)) {
count++;
} else if ((mod == 2 && q + 1 >= p) && (score >= q + 1)) {
count++;
} else if ((mod == 2 && q + 2 >= p) && (S > 0 && score >= q + 2)) {
count++;
S--;
}
}
return count;
}
}
| 0 | 1,189,687 |
A11759 | A10847 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 rounds.qualification;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class B_dancing_with_the_googlers {
public static void main(String[] args) throws IOException {
BufferedReader reader = null;
BufferedWriter writer = null;
try {
reader = new BufferedReader(new FileReader("./input"));
writer = new BufferedWriter(new FileWriter("output"));
int numberOfCases = Integer.valueOf(reader.readLine());
for (int i = 1; i <= numberOfCases; i++) {
String line = reader.readLine();
StringBuilder sb = new StringBuilder("Case #" + i + ": ");
Scanner scanner = new Scanner(line);
int result = 0;
while(scanner.hasNextInt()) {
int numberOfGooglers = scanner.nextInt();
int numberOfSurprisings = scanner.nextInt();
int scoreToReach = scanner.nextInt();
while(numberOfGooglers>0) {
int googlerScore = scanner.nextInt();
int div = googlerScore/3;
int mod =( googlerScore % 3 == 0) ? 0 : 1;
int highest = div + mod;
if(highest>=scoreToReach) {
result++;
}
else if(googlerScore > 0 && highest+1 == scoreToReach && numberOfSurprisings > 0) {
result++;
numberOfSurprisings--;
}
numberOfGooglers--;
}
sb.append(result);
}
sb.append("\n");
writer.write(sb.toString());
}
} finally {
if (reader != null) {
reader.close();
}
if(writer!=null) {
writer.flush();
writer.close();
}
}
}
}
| 0 | 1,189,688 |
A11759 | A12832 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.Scanner;
import java.io.File;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.FileNotFoundException;
public class Dance {
public static void main(String[] args)
{
File f = new File("B-small-attempt0.in");
try
{
Scanner scan = new Scanner(f);
int lines = Integer.parseInt(scan.nextLine());
FileWriter fstream = new FileWriter("output.txt");
BufferedWriter out = new BufferedWriter(fstream);
for(int i=0; i<lines; i++)
{
String line = scan.nextLine();
String[] parts = line.split(" ");
int N = Integer.parseInt(parts[0]);
int S = Integer.parseInt(parts[1]);
int p = Integer.parseInt(parts[2]);
int[] totals = new int[N];
for(int j=3;j<3+N;j++)
totals[j-3] = Integer.parseInt(parts[j]);
int num = solve(N,S,p,totals);
out.write("Case #"+(i+1)+": "+num);
out.newLine();
}
out.close();
}
catch(FileNotFoundException e)
{
e.printStackTrace();
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
private static int solve(int n, int s, int p, int[] totals)
{
int count = 0;
int countS = 0;
for(int i: totals)
{
if(i>3*(p-1))
count++;
else if(countS < s && i>0 && (i==3*(p-1) || i==3*(p-1)-1))
{
count++;
countS++;
}
}
return count;
}
}
| 0 | 1,189,689 |
A11759 | A12850 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 cj2012;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
/**
*
* @author agraa1
*/
public class Dance {
public static void main(String[] args) throws Exception {
Dance puzzle = new Dance();
puzzle.solve();
}
private void solve() throws Exception {
BufferedReader br = new BufferedReader(new FileReader("E:\\B-small-attempt0.in"));
String line = br.readLine();
for (int count=0; count<Integer.valueOf(line); count++) {
showResult(count+1, br.readLine());
}
br.close();
}
private void showResult(int caseNum, String input) {
StringTokenizer tokenizer = new StringTokenizer(input, " ");
int numOfGooglers = Integer.valueOf(tokenizer.nextToken());
int surprises = Integer.valueOf(tokenizer.nextToken());
int maxScore = Integer.valueOf(tokenizer.nextToken());
int answer = 0;
int runningScore = 0;
while (tokenizer.hasMoreTokens()) {
runningScore = Integer.valueOf(tokenizer.nextToken());
int quot = (int) (runningScore / 3);
if (runningScore < maxScore) {
continue;
}
if (runningScore % 3 == 2) {
if (quot + 1 >= maxScore) {
answer++;
} else if ((quot + 2 >= maxScore) && (surprises > 0) && (quot + 2 <= 10)) {
answer++;
surprises--;
}
} else if (runningScore % 3 == 1) {
if (quot + 1 >= maxScore) {
answer++;
}
} else {
if (quot >= maxScore) {
answer++;
} else if ((quot + 1 >= maxScore) && (surprises > 0) && (quot + 1 <= 10)) {
answer++;
surprises--;
}
}
}
StringBuilder builder = new StringBuilder("Case #");
builder.append(caseNum);
builder.append(": ");
builder.append(answer);
System.out.println(builder.toString());
}
} | 0 | 1,189,690 |
A11759 | A10298 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | package ProblemB;
import java.io.*;
import java.util.StringTokenizer;
public class Dancing {
public Dancing() {
// TODO Auto-generated constructor stub
}
public static void dancing()throws IOException{
BufferedReader rdr = new BufferedReader(new FileReader("B-small-attempt0.in"));
PrintWriter pw = new PrintWriter(new FileWriter("B.out"));
int cases = Integer.parseInt(rdr.readLine());
for (int i = 0; i < cases; i++) {
String line = rdr.readLine();
StringTokenizer st = new StringTokenizer(line);
int n = Integer.parseInt(st.nextToken());
int s = Integer.parseInt(st.nextToken());
int p = Integer.parseInt(st.nextToken());
int result = 0;
for(int j=0; j<n; j++){
int x = Integer.parseInt(st.nextToken());
if(!(x==0 && p!=0)){
if(x >= p*3 || x == p*2 + (p-1) || x == p + (p-1)*2){
result++;
}
else{
if((s>0) && (x == p*2 + (p-2) || x == p + (p-1) +(p-2) || x == p + (p-2)*2 )){
result++;
s--;
}
}
}
}
pw.println("Case #"+(i+1)+": "+result);
}
pw.close();
rdr.close();
}
/**
* @param args
*/
public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
dancing();
}
}
| 0 | 1,189,691 |
A11759 | A13090 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 y2012.quals;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class B {
public static void main(String[] args) throws FileNotFoundException {
Scanner in = new Scanner(new File("B.in"));
PrintWriter out = new PrintWriter(new File("B.out"));
int nTestCase = in.nextInt();
for (int testCase = 0; testCase < nTestCase; testCase++) {
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = in.nextInt();
int res = 0;
int rl = p + p - 1 + p - 1, sl = p + p - 2 + p - 2;
if (p == 0) {
rl = 0;
sl = 0;
} else if (p == 1)
sl = 1;
for (int i = 0; i < n; i++)
if (a[i] >= rl)
res++;
else if (a[i] >= sl && s > 0) {
res++;
s--;
}
out.println("Case #" + (testCase + 1) + ": " + res);
}
in.close();
out.close();
}
}
| 0 | 1,189,692 |
A11759 | A11930 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.util.Scanner;
import java.util.StringTokenizer;
/**
*
* @author rama
*/
public class Codejam1 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n=Integer.parseInt(in.nextLine());
for(int i=1;i<=n;++i)
//trans(in.nextLine());
System.out.println("Case #"+i+": "+trans(in.nextLine()));
//String input = reader.readLine();
}
public static int trans(String ss){
int ans=0;
int temp;
int ok=0,srp=0;
StringTokenizer tok=new StringTokenizer(ss," ");
int n=Integer.parseInt(tok.nextToken());
int s=Integer.parseInt(tok.nextToken());
int p=Integer.parseInt(tok.nextToken());
for(int i=1;i<=n;++i){
temp=Integer.parseInt(tok.nextToken());
int l=temp-(3*p);
if(l>=-2)
++ok;
if(l<-2&&l>=-4&&temp>=2)
++srp;
}
ans=ok+Math.min(srp,s);
return ans;
}
}
| 0 | 1,189,693 |
A11759 | A12583 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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 abstract class JamCase {
int lineCount;
}
| 0 | 1,189,694 |
A11759 | A12392 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
public class DancingGooglers
{
String line="Code Jam";
static int noOfTCs;
public static void main(String[] args)
{
//initialize();
new DancingGooglers().calculate();
//generateOPFile();
}
private void calculate()
{
try
{
BufferedReader br = new BufferedReader(new FileReader("C:/CodeJam/B-small-attempt1.in"));
FileWriter fw = new FileWriter("C:/CodeJam/B-small-output.txt");
BufferedWriter bw = new BufferedWriter(fw);
line = br.readLine().trim();
noOfTCs = Integer.parseInt(line);
int dancers,surprises,maxScore;
for(int testCase=0;testCase<noOfTCs;testCase++)
{
line = br.readLine().trim();
String[] input = line.split(" ");
dancers = Integer.parseInt(input[0]);
surprises = Integer.parseInt(input[1]);
maxScore = Integer.parseInt(input[2]);
int sum,maxDancers=0;
for(int i=3; i<input.length;i++)
{
sum = Integer.parseInt(input[i]);
int rem = sum%3;
int result = sum/3;
if(rem <= 1)
{
if((result+rem)>=maxScore)
maxDancers++;
else if(rem == 0 && result > 0 && (result+1)>=maxScore && surprises > 0)
{
maxDancers++;
surprises--;
}
}
else
{
if((1+result) >= maxScore)
{
maxDancers++;
}
else
{
if(surprises > 0 && (rem+result) >= maxScore)
{
maxDancers++;
surprises--;
}
}
}
}
line = "Case #"+(testCase+1)+": "+maxDancers;
System.out.println(line);
bw.write(line);
bw.newLine();
}
br.close();
bw.close();
System.out.println("Done !");
}
catch(Exception e)
{
e.printStackTrace();
}
}
/*static void generateOPFile()
{
try
{
FileWriter fw = new FileWriter("C:/CodeJam/output.txt");
BufferedWriter bw = new BufferedWriter(fw);
for(int i=1;i<=noOfTCs;i++)
{
line = "Case #"+i+": "+1;
bw.write(line);
bw.newLine();
}
bw.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}*/
/*static void initialize()
{
try
{
BufferedReader br = new BufferedReader(new FileReader("C:/CodeJam/C-small.in"));
line = br.readLine().trim();
noOfTCs = Integer.parseInt(line);
br.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}*/
}
| 0 | 1,189,695 |
A11759 | A11788 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | import javax.swing.*;
import java.util.Scanner;
import java.io.*;
class ProblemB
{
public static void main (String []sdvv) throws IOException
{
int cases=0, N, S, p, normal, surprise, number, total;
String palabra="";
Scanner sc;
PrintWriter es;
try
{
sc = new Scanner(new File("Bsmall.IN"));
es = new PrintWriter(new BufferedWriter(new FileWriter("solutionBsmall.txt")));
cases=Integer.parseInt(sc.nextLine());
for(int j=1;j<=cases;j++)
{
surprise=0;
normal=0;
es.print("Case #"+j+": ");
N=sc.nextInt();
S=sc.nextInt();
p=sc.nextInt();
for(int x=0; x<N; x++)
{
number=sc.nextInt();
if(number==0&&p==0)
normal++;
else
if(p*3-2<=number)
normal++;
else
if(p*3-4<=number&&p>1)
surprise++;
}
if(surprise>=S)
if(normal+S>N)
total=N;
else
total=normal+S;
else
total=normal+surprise;
es.println(total);
}
es.close();
}
catch(FileNotFoundException error)
{
System.out.println("no se encuentra el archivo");
}
catch (EOFException e)
{
System.out.println("Final de Stream");
}
}
} | 0 | 1,189,696 |
A11759 | A11004 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new 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.clausewitz.codejam.qr2012;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import com.clausewitz.codejam.Solver;
public class Dancing extends Solver {
private int N = -1;
private int S = -1;
private int p = -1;
private int totalPoints[] = null;
@Override
public void readProblem() throws IOException {
String line = fileIn.readLine();
StringTokenizer st = new StringTokenizer(line);
N = Integer.parseInt(st.nextToken());
S = Integer.parseInt(st.nextToken());
p = Integer.parseInt(st.nextToken());
totalPoints = new int[N];
for(int i=0;i<N;++i) totalPoints[i] = Integer.parseInt(st.nextToken());
}
private List<Object> comb = null;
public void Combination(int[] list, int startIdx, int[] selected, int numOfRemain) {
if(numOfRemain==0) {
ArrayList<Integer> l = new ArrayList<Integer>();
for(int i=0;i<selected.length;++i) l.add(new Integer(selected[i]));
comb.add(l);
} else if(list.length==startIdx) {
} else {
selected[selected.length-numOfRemain] = startIdx;
Combination(list, startIdx+1, selected, numOfRemain-1);
selected[selected.length-numOfRemain] = -1;
Combination(list, startIdx+1, selected, numOfRemain);
}
}
@Override
public void algorithm(int idx) {
int maximum = 0;
int[] list = new int[N];
for(int i=0;i<N;++i) list[i] = i;
if(idx==46) {
System.out.print("");
}
if(S>0) {
int[] selected = new int[S];
comb = new ArrayList<Object>();
Combination(list, 0, selected, S);
for(int i=0;i<comb.size();++i) {
int countOfThisCombination = 0;
ArrayList<Integer> listOfSurprising = (ArrayList<Integer>) comb.get(i);
boolean isValidCombination = true;
for(int j=0;j<N;++j) {
boolean isSurprising = checkSurprisingNumber(listOfSurprising, j);
int maxPoints = getMaxPoints(j, isSurprising);
if(maxPoints>=p) ++countOfThisCombination;
if(isSurprising && totalPoints[j]<2) {
isValidCombination=false;
}
}
if(isValidCombination && countOfThisCombination>maximum) maximum = countOfThisCombination;
}
} else {
for(int j=0;j<N;++j) {
int maxPoints = getMaxPoints(j, false);
if(maxPoints>=p) ++maximum;
}
}
answer[idx] = "" + maximum;
if(idx==46) {
System.out.println(maximum);
}
}
private int getMaxPoints(int j, boolean isSurprising) {
int maxPoints = 0;
if(totalPoints[j]%3==0) {
if(isSurprising) maxPoints = totalPoints[j]/3+1;
else maxPoints = totalPoints[j]/3;
} else if(totalPoints[j]%3==1) {
maxPoints = totalPoints[j]/3+1;
} else {
if(isSurprising) maxPoints = totalPoints[j]/3+2;
else maxPoints = totalPoints[j]/3+1;
}
return maxPoints;
}
private boolean checkSurprisingNumber(ArrayList<Integer> listOfSurprising, int j) {
boolean isSurprising = false;
for(int k=0;k<listOfSurprising.size();++k) {
if(listOfSurprising.get(k).intValue()==j) {
isSurprising = true;
break;
}
}
return isSurprising;
}
}
| 0 | 1,189,697 |
A11759 | A12612 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new 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;
public class DancingGooglers extends FileReaderWriter {
/*//int[] GOOG = {29, 20, 8, 18, 18, 21};
int[] GOOG = {23, 22, 21};*/
DancingGooglers(String inPath, String outPath) throws IOException {
super(inPath, outPath);
reader();
}
@Override
public void reader() throws IOException {
super.writer();
strLine = br.readLine();
nTestCases = Integer.valueOf(strLine);
int N, S, p;
int nthCase = 0;
int googlerCount = 0;
String toWrite = new String();
//While LOOP
while( (strLine = br.readLine()) != null ) {
googlerCount = 0;
++nthCase;
toWrite = toWrite + "Case #" + nthCase + ": ";
String[] handler = strLine.split(" ");
int[] GOOG = new int[handler.length];
for(int i=0; i<handler.length; ++i) {
GOOG[i] = Integer.valueOf(handler[i]);
}
N = GOOG[0];
S = GOOG[1];
p = GOOG[2];
for(int i=3; i<GOOG.length; ++i) {
int base = (int) GOOG[i] / 3;
switch (GOOG[i] % 3)
{
case 0:
{
if(base >= p)
++googlerCount;
else {
if(S>0 && base>0 && base+1>=p) {
++googlerCount;
--S;
}
}
break;
}
case 1:
{
if(base >= p || base+1 >= p) {
++googlerCount;
}
else {
if(S > 0 && base + 1 >= p) {
++googlerCount;
S--;
}
}
break;
}
case 2:
{
if(base + 1 >= p || base >= p) {
++googlerCount;
}
else {
if(S > 0 && base + 2 >= p) {
++googlerCount;
--S;
}
}
break;
}
}
}
toWrite = toWrite + googlerCount + "\n";
}
System.out.println(toWrite);
bw.write(toWrite);
bw.close();
}
}
| 0 | 1,189,698 |
A11759 | A12494 | import java.io.*;
import java.util.*;
public class Problem2
{
static ArrayList<Integer> scores;
public static void main(String args[])
{
try
{
FileInputStream fstream = new FileInputStream("B-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line;
int total;
int i = 0, cases;
Scanner sc;
int number, surprising, minpoints;
while ((line = br.readLine()) != null)
{
if(i == 0)
{
total = Integer.parseInt(line);
i = 1;
continue;
}
sc = new Scanner(line);
scores = new ArrayList<Integer>();
number = sc.nextInt();
surprising = sc.nextInt();
minpoints = sc.nextInt();
cases = 0;
for(int j = 0; j < number; j++)
{
scores.add(sc.nextInt());
}
for(int score : scores)
{
int base = (int)(score/3);
switch(score%3)
{
case 0:
{
if(base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 1:
{
if(base>=minpoints | base + 1 >= minpoints)
{
cases++;
}
else if(surprising > 0 && base + 1 >= minpoints)
{
cases++;
surprising--;
}
break;
}
case 2:
{
if(base + 1>= minpoints | base>=minpoints)
{
cases++;
}
else if(surprising > 0 && base + 2 >= minpoints)
{
cases++;
surprising--;
}
break;
}
}
}
System.out.println("Case #"+i+": "+cases);
write("Case #"+i+": "+cases);
i++;
}
in.close();
}catch (Exception e){
System.err.println("Error: " + e.getMessage());
}
}
public static void write(String text)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("Problem2Output.out"), true));
bw.write(text);
bw.newLine();
bw.close();
}catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
} | /*
* Main.java
*
* Created on 14.04.2012, 10:03:46
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam12;
import qualification.CodeJamQuali;
/**
*
* @author Besitzer
*/
public class Main {
/**
* @param args the command line arguments
*/
/*public static void main(String[] args) {
char[] C = new char[26];
CodeJamQuali CJQ =new CodeJamQuali();
CJQ.fillDict("our language is impossible to understand","ejp mysljylc kd kxveddknmc re jsicpdrysi",C);
CJQ.fillDict("there are twenty six factorial possibilities","rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd",C);
CJQ.fillDict("so it is okay if you want to just give up","de kr kd eoya kw aej tysr re ujdr lkgc jv",C);
C['z'-'a']='q';
C['q'-'a']='z';
System.out.println("abcdefghijklmnopqrstuvwxyz");
System.out.println(C);
for(int i =0;i<26;i++)if(C[i]=='z')System.out.println("found");
}*/
public static void main(String[] args) {
CodeJamQuali CJQ =new CodeJamQuali();
//CJQ.go("src/qualification/A-small-attempt0.in", 1);
CJQ.go("src/qualification/B-small-attempt0.in", 2);
}
}
| 0 | 1,189,699 |