F1
stringlengths 6
6
| F2
stringlengths 6
6
| label
stringclasses 2
values | text_1
stringlengths 149
20.2k
| text_2
stringlengths 48
42.7k
|
|---|---|---|---|---|
A12273 | A10558 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/*
* Dancing
* Jason Bradley Nel
* 16287398
*/
import java.io.*;
public class Dancing {
public static void main(String[] args) {
In input = new In("input.txt");
int T = Integer.parseInt(input.readLine());
for (int i = 0; i < T; i++) {
System.out.printf("Case #%d: ", i + 1);
int N = input.readInt();
int s = input.readInt();
int p = input.readInt();
int c = 0;//counter for >=p cases
//System.out.printf("N: %d, S: %d, P: %d, R: ", N, s, p);
for (int j = 0; j < N; j++) {
int score = input.readInt();
int q = score / 3;
int m = score % 3;
//System.out.printf("%2d (%d, %d) ", scores[j], q, m);
switch (m) {
case 0:
if (q >= p) {
c++;
} else if (((q + 1) == p) && (s > 0) && (q != 0)) {
c++;
s--;
}
break;
case 1:
if (q >= p) {
c++;
} else if ((q + 1) == p) {
c++;
}
break;
case 2:
if (q >= p) {
c++;
} else if ((q + 1) == p) {
c++;
} else if (((q + 2) == p) && (s > 0)) {
c++;
s--;
}
break;
}
}
//System.out.printf("Best result of %d or higher: ", p);
System.out.println(c);
}
}
}
| import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Scanner;
public class B {
public static void main(String[] args) throws FileNotFoundException {
Scanner scan = new Scanner(new File("B-small-attempt1.in"));
System.setOut(new PrintStream("B-small-attempt1.out"));
int t = scan.nextInt();
for (int c = 0; c < t; c++) {
int n = scan.nextInt(); // num
int s = scan.nextInt(); // surprising
int p = scan.nextInt(); // best result cutoff
int[] totalPoints = new int[n];
for (int i = 0; i < n; i++)
totalPoints[i] = scan.nextInt();
int sUsed = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int pts = totalPoints[i];
// can it be done normal?
if (pts >= p + (p - 1) * 2)
ans++;
// can it be done surp?
else if (pts >= p + Math.max(p - 2, 0) * 2)
if (sUsed < s) {
ans++;
sUsed++;
}
}
System.out.printf("Case #%d: %d%n", c + 1, ans);
}
}
} |
B20856 | B20108 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package Happy;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.util.*;
import java.util.Arrays.*;
import java.io.BufferedReader;
//import java.io.IOException;
//import java.io.InputStreamReader;
//import java.io.PrintWriter;
//import java.util.StringTokenizer;
/**
*
* @author ipoqi
*/
public class Happy {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Happy().haha();
}
public void haha() {
BufferedReader in = null;
BufferedWriter out = null;
try{
in = new BufferedReader(new FileReader("C-large.in"));
out = new BufferedWriter(new FileWriter("LLL.out"));
int T = Integer.parseInt(in.readLine());
System.out.println("T="+T);
//LinkedList<Integer> mm = new LinkedList<Integer>();
//mm.add(new LinkedList<Integer>());
//int[][] mm;
//for(int ii=0;ii<mm.length;ii++){
// mm[0][ii] = 1;
//}
for(int i=0;i<T;i++){
String[] line = in.readLine().split(" ");
int A = Integer.parseInt(line[0]);
int B = Integer.parseInt(line[1]);
//System.out.print(" A = "+A+"\n");
//System.out.print(" B = "+B+"\n");
int ans = 0;
for(int j=A;j<B;j++){
int n=j;
if(n>=10){
String N = Integer.toString(n);
int nlen = N.length();
List<Integer> oks = new ArrayList<Integer>();
for(int k=0;k<nlen-1;k++){
String M = "";
for(int kk=1;kk<=nlen;kk++){
M = M + N.charAt((k+kk)%nlen);
}
int m = Integer.parseInt(M);
//System.out.print(" N = "+N+"\n");
//System.out.print(" M = "+M+"\n");
if(m>n && m<=B) {
boolean isNewOne = true;
for(int kkk=0;kkk<oks.size();kkk++){
//System.out.print(" KKK = "+oks.get(kkk)+"\n");
if(m==oks.get(kkk)){
isNewOne = false;
}
}
if(isNewOne){
//System.out.print(" N = "+N+"\n");
//System.out.print(" M = "+M+"\n");
oks.add(m);
ans++;
}
}
}
}
}
out.write("Case #"+(i+1)+": "+ans+"\n");
System.out.print("Case #"+(i+1)+": "+ans+"\n");
}
in.close();
out.close();
}catch(Exception e){
e.printStackTrace();
try{
in.close();
out.close();
}catch(Exception e1){
e1.printStackTrace();
}
}
System.out.print("YES!\n");
}
} | import java.util.Scanner;
public class RecycledNumbers {
public static int Recycled(int k,int begin,int end){
int length =String.valueOf(k).length();
int inc=0;
int con=(int) Math.pow(10,length);
int div=1;
int temp;
for(int i=1;i<length;i++){
div*=10;
con/=10;
temp=(k%div)*con+(k/div);
if(temp>k){
if(temp>=begin&&temp<=end){
inc++;
}
}
}
return inc;
}
public static int testcase(int begin,int end){
int inc=0;
for(int i=begin;i<=end;i++){
inc+=Recycled(i,begin,end);
}
return inc;
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int T = scan.nextInt();
for(int i=0;i<T;i++){
System.out.println("Case #"+(i+1)+": "+testcase(scan.nextInt(),scan.nextInt()));
}
}
}
|
A20490 | A22218 | 0 | /**
*
*/
package hu.herba.codejam;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
/**
* Base functionality, helper functions for CodeJam problem solver utilities.
*
* @author csorbazoli
*/
public abstract class AbstractCodeJamBase {
private static final String EXT_OUT = ".out";
protected static final int STREAM_TYPE = 0;
protected static final int FILE_TYPE = 1;
protected static final int READER_TYPE = 2;
private static final String DEFAULT_INPUT = "test_input";
private static final String DEFAULT_OUTPUT = "test_output";
private final File inputFolder;
private final File outputFolder;
public AbstractCodeJamBase(String[] args, int type) {
String inputFolderName = AbstractCodeJamBase.DEFAULT_INPUT;
String outputFolderName = AbstractCodeJamBase.DEFAULT_OUTPUT;
if (args.length > 0) {
inputFolderName = args[0];
}
this.inputFolder = new File(inputFolderName);
if (!this.inputFolder.exists()) {
this.showUsage("Input folder '" + this.inputFolder.getAbsolutePath() + "' not exists!");
}
if (args.length > 1) {
outputFolderName = args[1];
}
this.outputFolder = new File(outputFolderName);
if (this.outputFolder.exists() && !this.outputFolder.canWrite()) {
this.showUsage("Output folder '" + this.outputFolder.getAbsolutePath() + "' not writeable!");
} else if (!this.outputFolder.exists() && !this.outputFolder.mkdirs()) {
this.showUsage("Could not create output folder '" + this.outputFolder.getAbsolutePath() + "'!");
}
File[] inputFiles = this.inputFolder.listFiles();
for (File inputFile : inputFiles) {
this.processInputFile(inputFile, type);
}
}
/**
* @return the inputFolder
*/
public File getInputFolder() {
return this.inputFolder;
}
/**
* @return the outputFolder
*/
public File getOutputFolder() {
return this.outputFolder;
}
/**
* @param input
* input reader
* @param output
* output writer
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
@SuppressWarnings("unused")
protected void process(BufferedReader reader, PrintWriter pw) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (reader/writer)!!!");
System.exit(-2);
}
/**
* @param input
* input file
* @param output
* output file (will be overwritten)
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(File input, File output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (file/file)!!!");
System.exit(-2);
}
/**
* @param input
* input stream
* @param output
* output stream
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(InputStream input, OutputStream output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (stream/stream)!!!");
System.exit(-2);
}
/**
* @param type
* @param input
* @param output
*/
private void processInputFile(File input, int type) {
long starttime = System.currentTimeMillis();
System.out.println("Processing '" + input.getAbsolutePath() + "'...");
File output = new File(this.outputFolder, input.getName() + AbstractCodeJamBase.EXT_OUT);
if (type == AbstractCodeJamBase.STREAM_TYPE) {
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(input);
os = new FileOutputStream(output);
this.process(is, os);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
System.out.println("Failed to close output: " + e.getLocalizedMessage());
}
}
}
} else if (type == AbstractCodeJamBase.READER_TYPE) {
BufferedReader reader = null;
PrintWriter pw = null;
try {
reader = new BufferedReader(new FileReader(input));
pw = new PrintWriter(output);
this.process(reader, pw);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (pw != null) {
pw.close();
}
}
} else if (type == AbstractCodeJamBase.FILE_TYPE) {
try {
this.process(input, output);
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
}
} else {
this.showUsage("Unknown type given: " + type + " (accepted values: 0,1)");
}
System.out.println(" READY (" + (System.currentTimeMillis() - starttime) + " ms)");
}
/**
* Read a single number from input
*
* @param reader
* @param purpose
* What is the purpose of given data
* @return
* @throws IOException
* @throws IllegalArgumentException
*/
protected int readInt(BufferedReader reader, String purpose) throws IOException, IllegalArgumentException {
int ret = 0;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer (" + purpose + ")!");
}
try {
ret = Integer.parseInt(line);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: the first line '" + line + "' should be an integer (" + purpose + ")!");
}
return ret;
}
/**
* Read array of integers
*
* @param reader
* @param purpose
* @return
*/
protected int[] readIntArray(BufferedReader reader, String purpose) throws IOException {
int[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer list (" + purpose + ")!");
}
String[] strArr = line.split("\\s");
int len = strArr.length;
ret = new int[len];
for (int i = 0; i < len; i++) {
try {
ret[i] = Integer.parseInt(strArr[i]);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: line '" + line + "' should be an integer list (" + purpose + ")!");
}
}
return ret;
}
/**
* Read array of strings
*
* @param reader
* @param purpose
* @return
*/
protected String[] readStringArray(BufferedReader reader, String purpose) throws IOException {
String[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be a string list (" + purpose + ")!");
}
ret = line.split("\\s");
return ret == null ? new String[0] : ret;
}
/**
* Basic usage pattern. Can be overwritten by current implementation
*
* @param message
* Short message, describing the problem with given program
* arguments
*/
protected void showUsage(String message) {
if (message != null) {
System.out.println(message);
}
System.out.println("Usage:");
System.out.println("\t" + this.getClass().getName() + " program");
System.out.println("\tArguments:");
System.out.println("\t\t<input folder>:\tpath of input folder (default: " + AbstractCodeJamBase.DEFAULT_INPUT + ").");
System.out.println("\t\t \tAll files will be processed in the folder");
System.out.println("\t\t<output folder>:\tpath of output folder (default: " + AbstractCodeJamBase.DEFAULT_OUTPUT + ")");
System.out.println("\t\t \tOutput file name will be the same as input");
System.out.println("\t\t \tinput with extension '.out'");
System.exit(-1);
}
}
| package qr2012;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;
public class DancingWithTheGooglers {
public static void main(String[] args) throws Exception {
String fileName = args[0];
DancingWithTheGooglers obj = new DancingWithTheGooglers();
obj.solve(fileName);
}
public void solve(String fileName) throws Exception {
BufferedReader br = new BufferedReader(new FileReader(fileName));
BufferedWriter bw = new BufferedWriter(
new FileWriter(fileName + ".out"));
int T = Integer.parseInt(br.readLine());
for (int i = 0; i < T; i++) {
String str = br.readLine();
StringTokenizer token = new StringTokenizer(str, " ");
int N = Integer.parseInt(token.nextToken());
int S = Integer.parseInt(token.nextToken());
int p = Integer.parseInt(token.nextToken());
int[] t = new int[N];
for (int j = 0; j < N; j++) {
t[j] = Integer.parseInt(token.nextToken());
}
// Arrays.sort(t);
int cnt = 0;
int scnt = 0;
for (int j = N - 1; j >= 0; j--) {
if (t[j] >= 3 * p - 2) {
cnt += 1;
} else if (t[j] >= 3 * p - 4 && t[j] >= 2 && scnt < S) {
cnt += 1;
scnt += 1;
}
}
bw.write("Case #" + (i + 1) + ": ");
bw.write("" + cnt);
bw.write("\r\n");
}
bw.close();
br.close();
}
}
|
A11201 | A10546 | 0 | package CodeJam.c2012.clasificacion;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* Problem
*
* You're watching a show where Googlers (employees of Google) dance, and then
* each dancer is given a triplet of scores by three judges. Each triplet of
* scores consists of three integer scores from 0 to 10 inclusive. The judges
* have very similar standards, so it's surprising if a triplet of scores
* contains two scores that are 2 apart. No triplet of scores contains scores
* that are more than 2 apart.
*
* For example: (8, 8, 8) and (7, 8, 7) are not surprising. (6, 7, 8) and (6, 8,
* 8) are surprising. (7, 6, 9) will never happen.
*
* The total points for a Googler is the sum of the three scores in that
* Googler's triplet of scores. The best result for a Googler is the maximum of
* the three scores in that Googler's triplet of scores. Given the total points
* for each Googler, as well as the number of surprising triplets of scores,
* what is the maximum number of Googlers that could have had a best result of
* at least p?
*
* For example, suppose there were 6 Googlers, and they had the following total
* points: 29, 20, 8, 18, 18, 21. You remember that there were 2 surprising
* triplets of scores, and you want to know how many Googlers could have gotten
* a best result of 8 or better.
*
* With those total points, and knowing that two of the triplets were
* surprising, the triplets of scores could have been:
*
* 10 9 10 6 6 8 (*) 2 3 3 6 6 6 6 6 6 6 7 8 (*)
*
* The cases marked with a (*) are the surprising cases. This gives us 3
* Googlers who got at least one score of 8 or better. There's no series of
* triplets of scores that would give us a higher number than 3, so the answer
* is 3.
*
* Input
*
* The first line of the input gives the number of test cases, T. T test cases
* follow. Each test case consists of a single line containing integers
* separated by single spaces. The first integer will be N, the number of
* Googlers, and the second integer will be S, the number of surprising triplets
* of scores. The third integer will be p, as described above. Next will be N
* integers ti: the total points of the Googlers.
*
* Output
*
* For each test case, output one line containing "Case #x: y", where x is the
* case number (starting from 1) and y is the maximum number of Googlers who
* could have had a best result of greater than or equal to p.
*
* Limits
*
* 1 ⤠T ⤠100. 0 ⤠S ⤠N. 0 ⤠p ⤠10. 0 ⤠ti ⤠30. At least S of the ti values
* will be between 2 and 28, inclusive.
*
* Small dataset
*
* 1 ⤠N ⤠3.
*
* Large dataset
*
* 1 ⤠N ⤠100.
*
* Sample
*
* Input Output 4 Case #1: 3 3 1 5 15 13 11 Case #2: 2 3 0 8 23 22 21 Case #3: 1
* 2 1 1 8 0 Case #4: 3 6 2 8 29 20 8 18 18 21
*
* @author Leandro Baena Torres
*/
public class B {
public static void main(String[] args) throws FileNotFoundException, IOException {
BufferedReader br = new BufferedReader(new FileReader("B.in"));
String linea;
int numCasos, N, S, p, t[], y, minSurprise, minNoSurprise;
linea = br.readLine();
numCasos = Integer.parseInt(linea);
for (int i = 0; i < numCasos; i++) {
linea = br.readLine();
String[] aux = linea.split(" ");
N = Integer.parseInt(aux[0]);
S = Integer.parseInt(aux[1]);
p = Integer.parseInt(aux[2]);
t = new int[N];
y = 0;
minSurprise = p + ((p - 2) >= 0 ? (p - 2) : 0) + ((p - 2) >= 0 ? (p - 2) : 0);
minNoSurprise = p + ((p - 1) >= 0 ? (p - 1) : 0) + ((p - 1) >= 0 ? (p - 1) : 0);
for (int j = 0; j < N; j++) {
t[j] = Integer.parseInt(aux[3 + j]);
if (t[j] >= minNoSurprise) {
y++;
} else {
if (t[j] >= minSurprise) {
if (S > 0) {
y++;
S--;
}
}
}
}
System.out.println("Case #" + (i + 1) + ": " + y);
}
}
}
| package practice;
import java.util.*;
public class GoogleDance {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int cases = Integer.parseInt(sc.nextLine());
for(int i = 0; i<cases; i++){
//Case starts here
int caseCounter = i+1;
String caseLine = sc.nextLine();
String[] caseArray = caseLine.split(" ");
int googlers = Integer.parseInt(caseArray[0]);
int surprising = Integer.parseInt(caseArray[1]);
int passing = Integer.parseInt(caseArray[2]);
List<Integer> scores = new ArrayList<Integer>();
for(int j = 3; j<caseArray.length;j++){
scores.add(Integer.parseInt(caseArray[j]));
}
//Finding individual scores
int result = 0;
for(Integer score:scores){
if(score%3==0){
int individual = score/3;
if(individual==0){
if(individual>=passing){
result++;
}
}else{
if(individual>=passing){
result++;
}else if(surprising>0){
individual++;
if(individual>=passing){
result++;
surprising--;
}
}
}
}
if(score%3==1){
int individual = score/3+1;
if(individual>=passing){
result++;
}
}
if(score%3==2){
int individual = score/3+1;
if(individual>=passing){
result++;
}else if(surprising>0){
individual++;
if(individual>=passing){
result++;
surprising--;
}
}
}
}
System.out.println("Case #"+caseCounter+": " + result);
//Case ends here
}
}
}
|
A10699 | A11846 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Dancing {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// read input file
File file = new File("B-small-attempt4.in");
//File file = new File("input.txt");
BufferedReader br = new BufferedReader(new FileReader(file));
String ln = "";
int count = Integer.parseInt(br.readLine());
// write output file
File out = new File("outB.txt");
BufferedWriter bw = new BufferedWriter(new FileWriter(out));
int y = 0;
for (int i=0; i < count; i++){
ln = br.readLine();
y = getY(ln);
bw.write("Case #" + (i+1) + ": " + y);
bw.newLine();
}
bw.close();
}
private static int getY(String str) {
String[] data = str.split(" ");
int n = Integer.parseInt(data[0]);
int s = Integer.parseInt(data[1]);
int p = Integer.parseInt(data[2]);
int[] t = new int[n];
for (int i=0; i < n; i++){
t[i] = Integer.parseInt(data[i+3]);
}
int y = 0;
int base = 0;
for(int j=0; j < t.length; j++){
base = t[j] / 3;
if(base >= p) { y++; }
else if(base == p-1){
if(t[j] - (base+p) > base-1 && t[j] > 0){
y++;
} else if(s>0 && t[j] - (base+p) > base-2 && t[j] > 0){
s -= 1;
y++;
}
} else if(base == p-2){
if(s > 0 && t[j] - (base+p) > base-1 && t[j] > 0){
s -= 1;
y++;
}
}
}
return y;
}
}
|
import java.io.FileNotFoundException;
import java.util.List;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Amya
*/
public class Dancing {
public static void main(String args[]) throws FileNotFoundException{
List<String> lines = FileUtil.readFileByLine("input1");
int records = Integer.parseInt(lines.get(0));
int numOfGooglers = 0;
int numOfSurprises = 0;
int bestScore = 0;
String[] nums = null;
int eligiblesWithSurprise = 0;
int eligiblesWithoutSurprise = 0;
int onBorder = 0;
int finalEligibles = 0;
for(int i = 1; i<=records; i++){
nums = lines.get(i).split(" ");
numOfGooglers = Integer.parseInt(nums[0]);
numOfSurprises = Integer.parseInt(nums[1]);
bestScore = Integer.parseInt(nums[2]);
for(int j=3 ; j<nums.length; j++){
if(Integer.parseInt(nums[j])>=bestScore){
if(Integer.parseInt(nums[j])>=(bestScore*3 - 4)){
eligiblesWithSurprise ++;
}
if(Integer.parseInt(nums[j])>=(bestScore*3 - 2)){
eligiblesWithoutSurprise ++;
}
}
}
finalEligibles = eligiblesWithoutSurprise;
onBorder = eligiblesWithSurprise - eligiblesWithoutSurprise;
if(onBorder > numOfSurprises){
finalEligibles += numOfSurprises;
}else{
finalEligibles += onBorder;
}
if(i == records)
FileUtil.writeOutput("Case #"+i+": "+finalEligibles, true);
else
FileUtil.writeOutput("Case #"+i+": "+finalEligibles, false);
eligiblesWithSurprise = 0;
eligiblesWithoutSurprise = 0;
}
}
}
|
B12762 | B10815 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.File;
import java.io.FileInputStream;
import java.util.Scanner;
/**
*
* @author imgps
*/
public class C {
public static void main(String args[]) throws Exception{
int A,B;
int ctr = 0;
int testCases;
Scanner sc = new Scanner(new FileInputStream("C-small-attempt0.in "));
testCases = sc.nextInt();
int input[][] = new int[testCases][2];
for(int i=0;i<testCases;i++)
{
// System.out.print("Enter input A B: ");
input[i][0] = sc.nextInt();
input[i][1] = sc.nextInt();
}
for(int k=0;k<testCases;k++){
ctr = 0;
A = input[k][0];
B = input[k][1];
for(int i = A;i<=B;i++){
int num = i;
int nMul = 1;
int mul = 1;
int tnum = num/10;
while(tnum > 0){
mul = mul *10;
tnum= tnum/10;
}
tnum = num;
int n = 0;
while(tnum > 0 && mul >= 10){
nMul = nMul * 10;
n = (num % nMul) * mul + (num / nMul);
mul = mul / 10;
tnum = tnum / 10;
for(int m=num;m<=B;m++){
if(n == m && m > num){
ctr++;
}
}
}
}
System.out.println("Case #"+(k+1)+": "+ctr);
}
}
}
| import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class RecycledNumbers {
/**
* @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[] inp=br.readLine().trim().split(" ");
int start=Integer.parseInt(inp[0]);
int end=Integer.parseInt(inp[1]);
System.out.println("Case #"+t+": "+getAns(start, end));
}
}
public static long getAns(int start, int end){
boolean[] visited=new boolean[end+1];
long total=0;
int max=0;
int digitCount=1;
int mult=10;
while(start/(mult) !=0){
digitCount++;
mult*=10;
}
for(int n=start;n<=end;n++){
int count=1;
if(visited[n])
continue;
visited[n]=true;
for(int s=1;s<digitCount;s++){
int o=n;
int fst=(int) Math.pow(10, s), oth=(int) Math.pow(10, digitCount-s);
int rem=o%fst;
o/=fst;
o+=(rem*oth);
if(o>=start && o<=end && !visited[o]){
if(rem/(Math.pow(10,digitCount-s-1))>0){
if(o!=n){
count++;
visited[o]=true;
}
}
}
}
total+=count*(count-1)/2;
}
return total;
}
}
|
B10149 | B11415 | 0 | import java.io.FileInputStream;
import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeSet;
// Recycled Numbers
// https://code.google.com/codejam/contest/1460488/dashboard#s=p2
public class C {
private static String process(Scanner in) {
int A = in.nextInt();
int B = in.nextInt();
int res = 0;
int len = Integer.toString(A).length();
for(int n = A; n < B; n++) {
String str = Integer.toString(n);
TreeSet<Integer> set = new TreeSet<Integer>();
for(int i = 1; i < len; i++) {
int m = Integer.parseInt(str.substring(i, len) + str.substring(0, i));
if ( m > n && m <= B && ! set.contains(m) ) {
set.add(m);
res++;
}
}
}
return Integer.toString(res);
}
public static void main(String[] args) throws Exception {
Scanner in = new Scanner(System.in.available() > 0 ? System.in :
new FileInputStream(Thread.currentThread().getStackTrace()[1].getClassName() + ".practice.in"));
int T = in.nextInt();
for(int i = 1; i <= T; i++)
System.out.format("Case #%d: %s\n", i, process(in));
}
}
| import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
/**
* @author Jelle Prins
*/
public class RecycledNumbers {
public static void main(String[] args) {
String input = "input.txt";
String output = "output.txt";
if (args.length >= 1) {
input = args[0];
if (args.length >= 2) {
output = args[1];
}
}
new RecycledNumbers(input, output);
}
public RecycledNumbers(String inputString, String outputString) {
init();
File input = new File(inputString);
File output = new File(outputString);
if (!input.isFile()) {
System.err.println("input file not found");
System.exit(1);
}
if (output.exists()) {
output.delete();
}
try {
String[] cases = readInput(input);
String[] results = executeCases(cases);
writeOutput(output, results);
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
private String[] readInput(File file) throws Exception {
Scanner scanner = new Scanner(file);
int lines = scanner.nextInt();
scanner.nextLine();
String[] cases = new String[lines];
for (int i = 0; i < lines; i++) {
cases[i] = scanner.nextLine().trim();
if (cases[i] == null) {
throw new Exception("not enough input lines");
}
}
scanner.close();
return cases;
}
private String[] executeCases(String[] cases) {
String[] output = new String[cases.length];
for (int i = 0; i < cases.length; i++) {
output[i] = executeCase(i + 1, cases[i]);
}
return output;
}
private String parseOutput(int caseID, String answer) {
String output = "Case #" + caseID + ": " + answer;
System.out.println(output);
return output;
}
private void writeOutput(File output, String[] results) throws Exception {
PrintWriter pw = new PrintWriter(new FileWriter(output));
for (int i = 0; i < results.length; i++) {
pw.println(results[i]);
}
pw.close();
}
private void init() {
}
private String executeCase(int caseID, String input) {
String[] split = input.split(" ");
int start = Integer.parseInt(split[0]);
int end = Integer.parseInt(split[1]);
int answer = 0;
char[] chars;
for (int n = start; n < end; n++) {
chars = getNumberChars(n);
if (chars == null) {
continue;
}
answer += recycle(n, chars, end);
}
return parseOutput(caseID, "" + answer);
}
/**
* Returns null if the number can't be recycled
*/
private char[] getNumberChars(int n) {
if (n < 10) {
return null;
}
char[] chars = Integer.toString(n).toCharArray();
int validChars = 0;
for (char c : chars) {
if (c != '0') {
validChars++;
}
}
if (validChars < 2) {
return null;
}
return chars;
}
private int recycle(int n, char[] chars, int end) {
char[] recycle = new char[chars.length];
Set<String> found = new HashSet<String>();
String str;
int answer;
int recycleTimes = 0;
for (int i = 1; i < chars.length; i++) {
System.arraycopy(chars, i, recycle, 0, chars.length - i);
System.arraycopy(chars, 0, recycle, chars.length - i, i);
str = new String(recycle);
answer = Integer.parseInt(str);
if (answer > n && answer <= end) {
if (found.add(str)) {
recycleTimes++;
}
}
}
return recycleTimes;
}
}
|
B10485 | B12210 | 0 |
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
import java.io.File;
import java.io.IOException;
import java.io.FileWriter;
import java.io.BufferedWriter;
public class Recycle
{
public static void main(String[] args)
{
/* Set<Integer> perms = getPermutations(123456);
for(Integer i: perms)
System.out.println(i);*/
try
{
Scanner s = new Scanner(new File("recycle.in"));
BufferedWriter w = new BufferedWriter(new FileWriter(new File("recycle.out")));
int numCases = s.nextInt();
s.nextLine();
for(int n = 1;n <= numCases; n++)
{
int A = s.nextInt();
int B = s.nextInt();
int count = 0;
for(int k = A; k <= B; k++)
{
count += getNumPairs(k, B);
}
w.write("Case #" + n + ": " + count + "\n");
}
w.flush();
w.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static int getNumPairs(int n, int B)
{
Set<Integer> possibles = getPermutations(n);
int count = 0;
for(Integer i : possibles)
if(i > n && i <= B)
count++;
return count;
}
public static Set<Integer> getPermutations(int n)
{
Set<Integer> perms = new TreeSet<Integer>();
char[] digits = String.valueOf(n).toCharArray();
for(int firstPos = 1; firstPos < digits.length; firstPos++)
{
String toBuild = "";
for(int k = 0; k < digits.length; k++)
toBuild += digits[(firstPos + k) % digits.length];
perms.add(Integer.parseInt(toBuild));
}
return perms;
}
} | package hk.polyu.cslhu.codejam.solution.impl;
import hk.polyu.cslhu.codejam.solution.Solution;
import java.util.ArrayList;
import java.util.List;
public class StoreCredit extends Solution {
private int amountOfCredits, numOfItems;
private List<Integer> priceList;
@Override
public void setProblem(List<String> testCase) {
this.initial(testCase);
}
private void initial(List<String> testCase) {
// TODO Auto-generated method stub
this.amountOfCredits = Integer.valueOf(testCase.get(0));
this.numOfItems = Integer.valueOf(testCase.get(1));
this.setPriceList(testCase.get(2));
}
private void setPriceList(String string) {
// TODO Auto-generated method stub
String[] splitArray = string.split(" ");
if (splitArray.length != numOfItems)
logger.error("The price list does not include all items ("
+ splitArray.length
+ "/" + this.numOfItems + ")");
this.priceList = new ArrayList<Integer>();
for (String price : splitArray) {
this.priceList.add(Integer.valueOf(price));
}
}
@Override
public void solve() {
for (int itemIndex = 0; itemIndex < this.priceList.size() - 1; itemIndex++) {
for (int anotherItemIndex = itemIndex + 1; anotherItemIndex < this.priceList.size(); anotherItemIndex++) {
if (this.priceList.get(itemIndex) + this.priceList.get(anotherItemIndex) == this.amountOfCredits) {
this.result = (itemIndex + 1) + " " + (anotherItemIndex + 1);
break;
}
}
}
}
@Override
public String getResult() {
return this.result;
}
}
|
A12273 | A11301 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/*
* Dancing
* Jason Bradley Nel
* 16287398
*/
import java.io.*;
public class Dancing {
public static void main(String[] args) {
In input = new In("input.txt");
int T = Integer.parseInt(input.readLine());
for (int i = 0; i < T; i++) {
System.out.printf("Case #%d: ", i + 1);
int N = input.readInt();
int s = input.readInt();
int p = input.readInt();
int c = 0;//counter for >=p cases
//System.out.printf("N: %d, S: %d, P: %d, R: ", N, s, p);
for (int j = 0; j < N; j++) {
int score = input.readInt();
int q = score / 3;
int m = score % 3;
//System.out.printf("%2d (%d, %d) ", scores[j], q, m);
switch (m) {
case 0:
if (q >= p) {
c++;
} else if (((q + 1) == p) && (s > 0) && (q != 0)) {
c++;
s--;
}
break;
case 1:
if (q >= p) {
c++;
} else if ((q + 1) == p) {
c++;
}
break;
case 2:
if (q >= p) {
c++;
} else if ((q + 1) == p) {
c++;
} else if (((q + 2) == p) && (s > 0)) {
c++;
s--;
}
break;
}
}
//System.out.printf("Best result of %d or higher: ", p);
System.out.println(c);
}
}
}
| import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class B{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int caze, T;
int n, s, p;
int[] ts;
void run(){
T=sc.nextInt();
for(caze=1; caze<=T; caze++){
n=sc.nextInt();
s=sc.nextInt();
p=sc.nextInt();
ts=new int[n];
for(int i=0; i<n; i++){
ts[i]=sc.nextInt();
}
solve();
}
}
void solve(){
int count1=0, count2=0, count3=0;
for(int i=0; i<n; i++){
int t=ts[i];
int max1, max2;
if(t%3==0){
max1=t/3;
if(t>=3){
max2=t/3+1;
}else{
max2=t/3;
}
}else if(t%3==1){
max1=max2=t/3+1;
}else{
max1=t/3+1;
max2=t/3+2;
}
max2=min(max2, 10);
if(max1<p&&max2<p){
count1++;
}else if(max1<p&&max2>=p){
count2++;
}else{
count3++;
}
// debug(t, max1, max2, p);
}
int ans=count3+min(count2, s);
answer(ans+"");
}
void answer(String s){
println("Case #"+caze+": "+s);
}
void println(String s){
System.out.println(s);
}
void print(String s){
System.out.print(s);
}
void debug(Object... os){
System.err.println(deepToString(os));
}
public static void main(String[] args){
try{
System.setIn(new FileInputStream("dat/B-small.in"));
System.setOut(new PrintStream(new FileOutputStream(
"dat/B-small.out")));
}catch(Exception e){}
new B().run();
System.out.flush();
System.out.close();
}
}
|
A11917 | A12916 | 0 | package com.silverduner.codejam;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.HashMap;
public class Dancing {
public static void main(String[] args) throws Exception {
File input = new File("B-small-attempt0.in");
BufferedReader in = new BufferedReader(new FileReader(input));
File output = new File("1.out");
BufferedWriter out = new BufferedWriter(new FileWriter(output));
// parse input
int N = Integer.parseInt(in.readLine());
for(int i=0;i<N;i++) {
String str = in.readLine();
out.write("Case #"+(i+1)+": ");
System.out.println("-------");
String[] words = str.split(" ");
int n = Integer.parseInt(words[0]);
int suprise = Integer.parseInt(words[1]);
int threshold = Integer.parseInt(words[2]);
int[] scores = new int[n];
for(int j=0;j<n;j++) {
scores[j] = Integer.parseInt(words[3+j]);
}
int count = 0;
for(int score : scores) {
int a,b,c;
boolean find = false;
boolean sfind = false;
for(a = 10; a>=0 && !find; a--) {
if(3*a-4>score)
continue;
for(b = a; b>=0 && b >=a-2 && !find; b--) {
for(c = b; c>=0 && c >=b-2 && c >=a-2 && !find; c--) {
System.out.println(a+","+b+","+c);
if(a+b+c==score) {
if(a >= threshold) {
if(a-c <= 1){
count++;
find = true;
System.out.println("find!");
}
else if(a-c == 2){
sfind = true;
System.out.println("suprise!");
}
}
}
}
}
}
if(!find && sfind && suprise > 0)
{
count++;
suprise --;
}
}
int maxCount = count;
out.write(maxCount+"\n");
}
out.flush();
out.close();
in.close();
}
}
| package lt.kasrud.gcj.common.io;
import java.io.*;
import java.util.List;
public class Writer {
private static String formatCase(int caseNr, String output){
return String.format("Case #%d: %s", caseNr, output);
}
public static void writeFile(String filename, List<String> data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(filename));
for (int i = 0; i < data.size(); i++) {
String output = formatCase(i+1, data.get(i));
writer.write(output + "\n");
}
writer.close();
}
}
|
B11696 | B10003 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package recycled;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.TreeSet;
/**
*
* @author Alfred
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
try {
FileInputStream fstream = new FileInputStream("C-small-attempt0.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
FileWriter outFile = new FileWriter("out.txt");
PrintWriter out = new PrintWriter(outFile);
String line;
line = br.readLine();
int cases = Integer.parseInt(line);
for (int i=1; i<=cases;i++){
line = br.readLine();
String[] values = line.split(" ");
int A = Integer.parseInt(values[0]);
int B = Integer.parseInt(values[1]);
int total=0;
for (int n=A; n<=B;n++){
TreeSet<String> solutions = new TreeSet<String>();
for (int k=1;k<values[1].length();k++){
String m = circshift(n,k);
int mVal = Integer.parseInt(m);
if(mVal<=B && mVal!=n && mVal> n && !m.startsWith("0") && m.length()==Integer.toString(n).length() )
{
solutions.add(m);
}
}
total+=solutions.size();
}
out.println("Case #"+i+": "+total);
}
in.close();
out.close();
} catch (Exception e) {//Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
private static String circshift(int n, int k) {
String nString=Integer.toString(n);
int len=nString.length();
String m = nString.substring(len-k)+nString.subSequence(0, len-k);
//System.out.println(n+" "+m);
return m;
}
}
| package qualification;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.Vector;
public class ProblemC {
static Scanner scan = new Scanner(System.in);
public static void main(String[] args) {
int cases = scan.nextInt();
for ( int i = 1; i <= cases; i++ ) {
System.out.println("Case #" + i + ": " + solveCase());
}
}
public static int solveCase() {
int A = scan.nextInt();
int B = scan.nextInt();
Map<Integer, Long> map = new HashMap<Integer, Long>();
Integer[] digits;
for ( int i = A; i <= B; i++ ) {
digits = getDigits(i);
addToMap(digits, map);
}
int result = 0;
for ( Long l : map.values() ) {
result += (l * (l-1)) / 2;
}
return result;
}
public static void addToMap(Integer[] n, Map<Integer, Long> map) {
Vector<Integer> rots = getRotationSymmetricValues(n);
// Remember to handle leading 0! All must have same length
for ( Integer num : rots) {
if ( map.containsKey(num) ) {
map.put(num, map.get(num)+1);
return;
}
}
map.put(digitsToNum(n), 1L);
}
public static Vector<Integer> getRotationSymmetricValues(Integer[] n) {
Vector<Integer> result = new Vector<Integer>();
int origNum = digitsToNum(n);
Queue<Integer> v = new LinkedList<Integer>();
for ( int i = 0; i < n.length; i++ ) {
v.add(n[i]);
}
while (true) {
Integer first = v.poll();
v.add(first);
if ( v.peek() == 0 )
continue;
int num = 0;
for ( Integer i : v) {
num *= 10;
num += i;
}
if ( num == origNum )
break;
result.add(num);
}
return result;
}
public static int digitsToNum(Integer[] digits) {
int num = 0;
for ( int i = 0; i < digits.length; i++ ) {
num *= 10;
num += digits[i];
}
return num;
}
static Comparator<Integer> comp = new Comparator<Integer>() {
@Override
public int compare(Integer arg0, Integer arg1) {
if ( arg0 == 0 )
return 1;
else if ( arg1 == 0)
return -1;
else
return arg0.compareTo(arg1);
}
};
public static Integer[] getDigits(int n) {
int numDigits = (int)Math.log10(n) + 1;
Integer[] digits = new Integer[numDigits];
for ( int i = 0; i < numDigits; i++ ) {
digits[numDigits-1-i] = n % 10;
n /= 10;
}
return digits;
}
}
|
B13196 | B12897 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Q3M {
public static void main(String[] args) throws Exception {
compute();
}
private static void compute() throws Exception {
BufferedReader br = new BufferedReader(new FileReader(new File(
"C:\\work\\Q3\\C-small-attempt0.in")));
String line = null;
int i = Integer.parseInt(br.readLine());
List l = new ArrayList();
for (int j = 0; j < i; j++) {
line = br.readLine();
String[] nums = line.split(" ");
l.add(calculate(nums));
}
writeOutput(l);
}
private static int calculate(String[] nums) {
int min = Integer.parseInt(nums[0]);
int max = Integer.parseInt(nums[1]);
int count = 0;
List l = new ArrayList();
for (int i = min; i <= max; i++) {
for (int times = 1; times < countDigits(i); times++) {
int res = shiftNum(i, times);
if (res <= max && i < res) {
if ((!l.contains((i + ":" + res)))) {
l.add(i + ":" + res);
l.add(res + ":" + i);
count++;
}
}
}
}
return count;
}
private static boolean checkZeros(int temp, int res) {
if (temp % 10 == 0 || res % 10 == 0)
return false;
return true;
}
private static int shiftNum(int n, int times) {
int base = (int) Math.pow(10, times);
int temp2 = n / base;
int placeHolder = (int) Math.pow((double) 10,
(double) countDigits(temp2));
int res = placeHolder * (n % base) + temp2;
if (countDigits(res) == countDigits(n)) {
return res;
} else {
return 2000001;
}
}
public static int countDigits(int x) {
if (x < 10)
return 1;
else {
return 1 + countDigits(x / 10);
}
}
private static void writeOutput(List l) throws Exception {
StringBuffer b = new StringBuffer();
int i = 1;
BufferedWriter br = new BufferedWriter(new FileWriter(new File(
"C:\\work\\Q3\\ans.txt")));
for (Iterator iterator = l.iterator(); iterator.hasNext();) {
br.write("Case #" + i++ + ": " + iterator.next());
br.newLine();
}
br.close();
}
} | package exercise;
public class Solver {
private static int[][] MATCHES;
public static Integer[] solve(Integer[][] input) {
Integer[] result = new Integer[input.length];
for (int cnt = 0; cnt < input.length; ++cnt)
result[cnt] = solve(input[cnt]);
return result;
}
public static int solve(Integer[] input) {
if (input == null || input.length < 2)
return 0;
Integer min = input[0];
Integer max = input[1];
int result = 0;
MATCHES = new int[max][4];
for (int cnt = min; cnt < max; ++cnt) {
result += countMatches(cnt, min, max);
}
for (int i = 0; i < MATCHES.length; ++i)
for (int j = 0; j < MATCHES[i].length; ++j)
if (MATCHES[i][j] != 0)
++result;
else
break;
return result;
}
private static int countMatches(int value, int min, int max) {
String string = String.valueOf(value);
int result = 0;
for (int idx = string.length() - 1; idx > 0; --idx) {
String candidateString = string.substring(idx, string.length()) + string.substring(0, idx);
Integer candidate = Integer.parseInt(candidateString);
if (candidate.compareTo(value) > 0
&& candidate.compareTo(min) >= 0
&& candidate.compareTo(max) <= 0) {
addToMatches(value, candidate);
}
}
return result;
}
private static void addToMatches(int value, int match) {
boolean inserted = false;
for (int cnt = 0; cnt < MATCHES[value].length; ++cnt) {
if (MATCHES[value][cnt] == 0) {
MATCHES[value][cnt] = match;
inserted = true;
break;
} else if (MATCHES[value][cnt] == match)
return;
}
if (!inserted) {
int[] save = MATCHES[value];
MATCHES[value] = new int[save.length * 2];
int cnt;
for (cnt = 0; cnt < save.length; ++cnt) {
MATCHES[value][cnt] = save[cnt];
}
MATCHES[value][cnt] = match;
}
}
}
|
B20006 | B20731 | 0 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
import org.jfree.data.function.PowerFunction2D;
public class r2a
{
Map numMap = new HashMap();
int output = 0;
/**
* @param args
*/
public static void main(String[] args)
{
r2a mk = new r2a();
try {
FileInputStream fstream = new FileInputStream("d:/cjinput.txt");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String str;
int i = 0;
while ((str = br.readLine()) != null) {
int begin=0,end = 0;
i++;
if (i == 1)
continue;
mk.numMap = new HashMap();
StringTokenizer strTok = new StringTokenizer(str, " ");
while (strTok.hasMoreTokens()) {
begin = Integer.parseInt(((String) strTok.nextToken()));
end = Integer.parseInt(((String) strTok.nextToken()));
}
mk.evaluate(i, begin, end);
}
in.close();
}
catch (Exception e) {
System.err.println(e);
}
}
private void evaluate(int rowNum, int begin, int end)
{
output=0;
for (int i = begin; i<= end; i++) {
if(numMap.containsKey(Integer.valueOf(i)))
continue;
List l = getPairElems(i);
if (l.size() > 0) {
Iterator itr = l.iterator();
int ctr = 0;
ArrayList tempList = new ArrayList();
while (itr.hasNext()) {
int next = ((Integer)itr.next()).intValue();
if (next <= end && next > i) {
numMap.put(Integer.valueOf(next), i);
tempList.add(next);
ctr++;
}
}
ctr = getCounter(ctr+1,2);
/* if (tempList.size() > 0 || ctr > 0)
System.out.println("DD: " + i + ": " + tempList +" ; ctr = " + ctr);*/
output = output + ctr;
}
}
String outputStr = "Case #" + (rowNum -1) + ": " + output;
System.out.println(outputStr);
}
private int getCounter(int n, int r) {
int ret = 1;
int nfactorial =1;
for (int i = 2; i<=n; i++) {
nfactorial = i*nfactorial;
}
int nrfact =1;
for (int i = 2; i<=n-r; i++) {
nrfact = i*nrfact;
}
return nfactorial/(2*nrfact);
}
private ArrayList getPairElems(int num) {
ArrayList retList = new ArrayList();
int temp = num;
if (num/10 == 0)
return retList;
String str = String.valueOf(num);
int arr[] = new int[str.length()];
int x = str.length();
while (temp/10 > 0) {
arr[x-1] = temp%10;
temp=temp/10;
x--;
}
arr[0]=temp;
int size = arr.length;
for (int pos = size -1; pos >0; pos--) {
if(arr[pos] == 0)
continue;
int pairNum = 0;
int multiplier =1;
for (int c=0; c < size-1; c++) {
multiplier = multiplier*10;
}
pairNum = pairNum + (arr[pos]*multiplier);
for(int ctr = pos+1, i=1; i < size; i++,ctr++) {
if (ctr == size)
ctr=0;
if (multiplier!=1)
multiplier=multiplier/10;
pairNum = pairNum + (arr[ctr]*multiplier);
}
if (pairNum != num)
retList.add(Integer.valueOf(pairNum));
}
return retList;
}
}
| package fixjava;
/**
* Convenience class for declaring a method inside a method, so as to avoid code duplication without having to declare a new method
* in the class. This also keeps functions closer to where they are applied. It's butt-ugly but it's about the best you can do in
* Java.
*/
public interface Lambda2<P, Q, V> {
public V apply(P param1, Q param2);
}
|
B11318 | B11942 | 0 | import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t=sc.nextInt();
int casos=1, a, b, n, m, cont;
while(t!=0){
a=sc.nextInt();
b=sc.nextInt();
if(a>b){
int aux=a;
a=b;
b=aux;
}
System.out.printf("Case #%d: ",casos++);
if(a==b){
System.out.printf("%d\n",0);
}else{
cont=0;
for(n=a;n<b;n++){
for(m=n+1;m<=b;m++){
if(isRecycled(n,m)) cont++;
}
}
System.out.printf("%d\n",cont);
}
t--;
}
}
public static boolean isRecycled(int n1, int n2){
String s1, s2, aux;
s1 = String.valueOf( n1 );
s2 = String.valueOf( n2 );
boolean r = false;
for(int i=0;i<s1.length();i++){
aux="";
aux=s1.substring(i,s1.length())+s1.substring(0,i);
// System.out.println(aux);
if(aux.equals(s2)){
r=true;
break;
}
}
return r;
}
}
| import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
FileInputStream fstream = null;
try {
fstream = new FileInputStream("input.txt");
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
ArrayList<String> plik = new ArrayList<String>();
try {
while ((strLine = br.readLine()) != null) {
// Print the content on the console
System.out.println(strLine);
plik.add(strLine);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
plik.remove(0); // counter nie jest potrzebny
int count = 1;
FileWriter writer = null;
try {
writer = new FileWriter("output.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for (String s : plik) {
StringBuilder outputString = new StringBuilder("Case #" + count++
+ ": ");
int recycledPairsCount = 0;
String[] splitted = s.split(" ");
Integer A = Integer.parseInt(splitted[0]);
Integer B = Integer.parseInt(splitted[1]);
int a = A;
int b = B;
for (int n = a; n < b; n++) {
for (int m = n + 1; m <= B; m++) {
if (Integer.toString(m).length() != Integer.toString(n)
.length()) {
continue;
}
if (isRecycledPair(n, m)) {
recycledPairsCount += 1;
}
}
}
outputString.append(recycledPairsCount);
System.out.println(outputString);
try {
writer.write(outputString.toString());
writer.write("\r\n");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static boolean isRecycledPair(int n, int m) {
String N = Integer.toString(n);
String M = Integer.toString(m);
int digitNumber = N.length();
if (digitNumber == 1) {
return false;
}
for (int i = 1; i <= digitNumber; i++) {
String temp = N.substring(i, digitNumber);
temp += N.substring(0, i);
if (temp.equals(M)) {
return true;
}
}
return false;
}
}
|
A10793 | A12635 | 0 | import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;
public class b {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int T = sc.nextInt();
for (int casenumber = 1; casenumber <= T; ++casenumber) {
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int[] ts = new int[n];
for (int i = 0; i < n; ++i)
ts[i] = sc.nextInt();
int thresh1 = (p == 1 ? 1 : (3 * p - 4));
int thresh2 = (3 * p - 2);
int count1 = 0, count2 = 0;
for (int i = 0; i < n; ++i) {
if (ts[i] >= thresh2) {
++count2;
continue;
}
if (ts[i] >= thresh1) {
++count1;
}
}
if (count1 > s) {
count1 = s;
}
System.out.format("Case #%d: %d%n", casenumber, count1 + count2);
}
}
}
| import java.util.*;
public class dancing_googlers {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int T = scanner.nextInt();
int[] answers = new int[T];
for (int c = 0; c < T; c++) {
int N = scanner.nextInt();
int S = scanner.nextInt();
int p = scanner.nextInt();
answers[c] = 0;
for (int i = 0; i < N; i++) {
int t = scanner.nextInt();
if (t >= (p + (p - 1) + (p - 1))) {
answers[c]++;
}
else if ((t >= (p + (p - 1) + (p - 1)) - 2) && (S > 0) && (t > 1) && (t < 29)) {
answers[c]++;
S--;
}
}
}
for (int c = 0; c < T; c++) {
int j = c+1;
System.out.println("Case #"+j+": "+answers[c]);
}
}
}
|
B12762 | B12534 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.File;
import java.io.FileInputStream;
import java.util.Scanner;
/**
*
* @author imgps
*/
public class C {
public static void main(String args[]) throws Exception{
int A,B;
int ctr = 0;
int testCases;
Scanner sc = new Scanner(new FileInputStream("C-small-attempt0.in "));
testCases = sc.nextInt();
int input[][] = new int[testCases][2];
for(int i=0;i<testCases;i++)
{
// System.out.print("Enter input A B: ");
input[i][0] = sc.nextInt();
input[i][1] = sc.nextInt();
}
for(int k=0;k<testCases;k++){
ctr = 0;
A = input[k][0];
B = input[k][1];
for(int i = A;i<=B;i++){
int num = i;
int nMul = 1;
int mul = 1;
int tnum = num/10;
while(tnum > 0){
mul = mul *10;
tnum= tnum/10;
}
tnum = num;
int n = 0;
while(tnum > 0 && mul >= 10){
nMul = nMul * 10;
n = (num % nMul) * mul + (num / nMul);
mul = mul / 10;
tnum = tnum / 10;
for(int m=num;m<=B;m++){
if(n == m && m > num){
ctr++;
}
}
}
}
System.out.println("Case #"+(k+1)+": "+ctr);
}
}
}
| package com.google.codejam;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class RecycledNumbers {
public static void main(String argsp[]) throws NumberFormatException, IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/ashwinjain/Desktop/SmsLogger/InterviewStreet/src/com/google/codejam/in3.txt")));
int cases = Integer.parseInt(br.readLine());
for(int x=0;x<cases;x++){
String temp[] = br.readLine().split(" ");
long a = Long.parseLong(temp[0]);
long b = Long.parseLong(temp[1]);
long c=a;
long count=0;
while(c<=b){
String str= c+"";
HashMap<Long, Boolean> added = new HashMap<Long, Boolean>();
for(int i=1;i<str.length();i++){
long d=Long.parseLong(str.substring(i)+str.substring(0, i));
if(d!=c && d>=a && d<=b && !added.containsKey(d)){
added.put(d, true);
count++;
}
}
c++;
}
System.out.println("Case #"+(x+1)+": "+count/2);
}
}
}
|
B10858 | B10499 | 0 | package be.mokarea.gcj.common;
public abstract class TestCaseReader<T extends TestCase> {
public abstract T nextCase() throws Exception;
public abstract int getMaxCaseNumber();
}
| import java.util.Hashtable;
import java.util.Scanner;
class RecycleResult{
private int lowerBound, upperBound, numberOfDigits;
public RecycleResult(int a, int b, int d){
lowerBound = a;
upperBound = b;
numberOfDigits = d;
}
public int solve(){
int count = 0;
for (int i = lowerBound; i < upperBound; i++){
int p = i;
Hashtable<Integer, Integer> hash = new Hashtable<Integer, Integer>();
for (int j = 1; j < numberOfDigits; j++){
p = moveToFront(p);
if ((p <= upperBound) && (p > i) && (!(p == i)) && (!(hash.containsValue(p)))){
count++;
hash.put(count, p);
}
}
}
return count;
}
public int moveToFront(int z){
int lastDigit = z % 10;
int otherDigits = (z / 10);
for (int i = 0; i < numberOfDigits - 1; i++){
lastDigit = lastDigit * 10;
}
return otherDigits + lastDigit;
}
}
public class Recycle {
public static void main(String[] args) {
int numberOfCases;
Scanner myScanner = new Scanner(System.in);
int a, b;
numberOfCases = myScanner.nextInt();
RecycleResult myResult;
for (int i = 0; i < numberOfCases; i++){
a = myScanner.nextInt();
b = myScanner.nextInt();
int length = String.valueOf(a).length();
myResult = new RecycleResult(a, b, length);
int count = myResult.solve();
System.out.println("Case #" + (i+1) + ": " + count);
}
}
}
|
B10361 | B12861 | 0 | package codejam;
import java.util.*;
import java.io.*;
public class RecycledNumbers {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("in.txt"));
PrintWriter out = new PrintWriter(new File("out.txt"));
int T = Integer.parseInt(in.readLine());
for (int t = 1; t <= T; ++t) {
String[] parts = in.readLine().split("[ ]+");
int A = Integer.parseInt(parts[0]);
int B = Integer.parseInt(parts[1]);
int cnt = 0;
for (int i = A; i < B; ++i) {
String str = String.valueOf(i);
int n = str.length();
String res = "";
Set<Integer> seen = new HashSet<Integer>();
for (int j = n - 1; j > 0; --j) {
res = str.substring(j) + str.substring(0, j);
int k = Integer.parseInt(res);
if (k > i && k <= B) {
//System.out.println("(" + i + ", " + k + ")");
if (!seen.contains(k)) {
++cnt;
seen.add(k);
}
}
}
}
out.println("Case #" + t + ": " + cnt);
}
in.close();
out.close();
System.exit(0);
}
}
| package google.codejam;
import java.util.HashMap;
public class RecycledNumberSolver implements GoogleSolver {
@Override
public String solve(String str) {
String [] numbers = str.split(" ");
int min = Integer.parseInt(numbers[0]);
int max = Integer.parseInt(numbers[1]);
int digits = numbers[0].length();
System.out.println("min:"+min + " max:"+ max);
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int count = 0;
for(int i=min; i<=max ; i++){
for(int move=1 ; move<digits ; move++){
String temp = i+"";
String test = temp.substring(temp.length()-move) + temp.substring(0, temp.length()-move);
int testNum = Integer.parseInt(test);
if(testNum>i && testNum>=min && testNum<=max){
//System.out.println("("+temp + " , " + testNum+ ")");
if(map.get(i)==null || map.get(i)!=testNum){
map.put(i, testNum);
count++;
}
}
}
map.clear();
}
return count+"";
}
}
|
B11327 | B10600 | 0 | package recycledNumbers;
public class OutputData {
private int[] Steps;
public int[] getSteps() {
return Steps;
}
public OutputData(int [] Steps){
this.Steps = Steps;
for(int i=0;i<this.Steps.length;i++){
System.out.println("Test "+(i+1)+": "+Steps[i]);
}
}
}
| import java.io.*;
import java.util.*;
class recycled
{
public static void main(String[] args) throws Exception
{
BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
String inp;
int i,j;
int T=Integer.valueOf(r.readLine());
for(int a=0;a<T;a++)
{
/*consists of a single line containing the integers A and B. */
String[] tmp =r.readLine().split("\\s");
int A = Integer.valueOf(tmp[0]);
int B = Integer.valueOf(tmp[1]);
int y=0;
HashSet<String> stv = new HashSet<String>();
for(i=A;i<=B;i++) {
String s = ""+i;
for(j=1;j<s.length();j++) {
String sj = s.substring(j) + s.substring(0,j);
int k = Integer.valueOf(sj);
String str="("+s+","+sj+")";
if (k>i && k<=B && !stv.contains(str)) {
y++;
stv.add(str);
}
}
}
System.out.println("Case #"+(a+1)+": "+y);
}
}
}
|
A20934 | A20629 | 0 | import java.util.*;
public class B {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
B th = new B();
for (int i = 0; i < T; i++) {
int n = sc.nextInt();
int s = sc.nextInt();
int p = sc.nextInt();
int[] t = new int[n];
for (int j = 0; j < n; j++) {
t[j] = sc.nextInt();
}
int c = th.getAnswer(s,p,t);
System.out.println("Case #" + (i+1) + ": " + c);
}
}
public int getAnswer(int s, int p, int[] t) {
int A1 = p + p-1+p-1;
int A2 = p + p-2+p-2;
if (A1 < 0)
A1 = 0;
if (A2 < 0)
A2 = 1;
int remain = s;
int count = 0;
int n = t.length;
for (int i = 0; i < n; i++) {
if (t[i] >= A1) {
count++;
} else if (t[i] < A1 && t[i] >= A2) {
if (remain > 0) {
remain--;
count++;
}
}
}
return count;
}
}
| import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.PrintWriter;
public class bsp2 {
/**
* @param args
* @throws IOException
* @throws NumberFormatException
*/
public static void main(String[] args) throws NumberFormatException, IOException {
// TODO Auto-generated method stub
String inFile = "B-large.in";
String outFile = inFile + ".out";
LineNumberReader lin = new LineNumberReader(new InputStreamReader(new FileInputStream(inFile)));
PrintWriter out = new PrintWriter(new File(outFile));
int NCASE = Integer.parseInt(lin.readLine());
String line="";
int erg=0;
for(int CASE = 1; CASE <= NCASE; CASE++) {
String [] ch=lin.readLine().split(" ");
int googlers=Integer.parseInt(ch[0]);
int sTriplets=Integer.parseInt(ch[1]);
int bResult=Integer.parseInt(ch[2]);
//System.out.println("Case #"+CASE);
//System.out.println(googlers);
//System.out.println(sTriplets);
//System.out.println(bResult);
for(int SCORE=3;SCORE<ch.length;SCORE++){
//System.out.print(ch[SCORE]);
int base=Integer.parseInt(ch[SCORE])/3;
switch(Integer.parseInt(ch[SCORE])%3){
case 0:
if(base >=bResult) erg++;
else{
if(sTriplets>0 && base>0 && base+1 >=bResult){
erg++;
sTriplets--;
}
}
break;
case 1:
if(base>=bResult||base+1>=bResult) erg++;
else{
if(sTriplets>0 && base>0 && base+1 >=bResult){
erg++;
sTriplets--;
}
}
break;
case 2:
if(base+1>=bResult||base>=bResult) erg++;
else{
if(sTriplets>0 && base>0 && base+2 >=bResult){
erg++;
sTriplets--;
}
}
break;
}
}
out.println("Case #" + CASE + ": "+erg);
erg=0;
}
lin.close();
out.close();
}
}
|
B21227 | B20115 | 0 | import java.util.HashSet;
import java.util.Scanner;
public class C {
static HashSet p = new HashSet();
static int low;
static int high;
int count = 0;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int no = sc.nextInt();
for (int i = 1; i <= no; i++) {
p.clear();
low = sc.nextInt();
high = sc.nextInt();
for (int l = low; l <= high; l++) {
recycle(l);
}
System.out.println("Case #" + i + ": " + p.size());
}
}
public static void recycle(int no) {
String s = Integer.toString(no);
for (int i = 0; i < s.length(); i++) {
String rec = s.substring(i) + s.substring(0, i);
int r = Integer.parseInt(rec);
if (r != no && r >= low && r <= high) {
int min = Math.min(r, no);
int max = Math.max(r, no);
String a = Integer.toString(min) + "" + Integer.toString(max);
p.add(a);
}
}
}
}
| 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.HashSet;
public class CodeJam
{
private static BufferedReader reader;
private static BufferedWriter writer;
public static void main(String args[]) throws Exception
{
prepareFiles("C-large");
int T = Integer.parseInt(reader.readLine());
for(int i = 0; i < T; i++)
{
String[] line = reader.readLine().split(" ");
int A = Integer.parseInt(line[0]);
int B = Integer.parseInt(line[1]);
int l = String.valueOf(A).length();
int recycled = 0;
for(int n = A; n <= B; n++)
{
HashSet<Integer> checkedCycles = new HashSet<>();
String recycledSequence = String.valueOf(n);
for(int j = 1; j < l; j++)
{
recycledSequence = recycle(recycledSequence);
int recycledInt = Integer.valueOf(recycledSequence);
if(checkedCycles.contains(recycledInt))
{
continue;
}
else
{
checkedCycles.add(recycledInt);
}
if(n < recycledInt && recycledInt <= B)
{
recycled ++;
}
}
}
print(getCase(i + 1));
print(recycled);
print("\n");
}
putAwayFiles();
}
private static String recycle(String sequence)
{
String newSequence = new String();
newSequence += sequence.charAt(sequence.length() - 1);
for(int i = 0; i < sequence.length() - 1; i++)
{
newSequence += sequence.charAt(i);
}
return newSequence;
}
private static void prepareFiles(String fileName) throws IOException
{
reader = new BufferedReader(new FileReader(new File(fileName + ".in")));
writer = new BufferedWriter(new FileWriter(new File(fileName + ".out")));
}
private static void putAwayFiles() throws IOException
{
reader.close();
writer.flush();
writer.close();
}
private static String getCase(int i)
{
return "Case #" + i + ": ";
}
private static void print(Object object) throws IOException
{
System.out.print(object.toString());
writer.write(object.toString());
}
}
|
A10699 | A10965 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Dancing {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// read input file
File file = new File("B-small-attempt4.in");
//File file = new File("input.txt");
BufferedReader br = new BufferedReader(new FileReader(file));
String ln = "";
int count = Integer.parseInt(br.readLine());
// write output file
File out = new File("outB.txt");
BufferedWriter bw = new BufferedWriter(new FileWriter(out));
int y = 0;
for (int i=0; i < count; i++){
ln = br.readLine();
y = getY(ln);
bw.write("Case #" + (i+1) + ": " + y);
bw.newLine();
}
bw.close();
}
private static int getY(String str) {
String[] data = str.split(" ");
int n = Integer.parseInt(data[0]);
int s = Integer.parseInt(data[1]);
int p = Integer.parseInt(data[2]);
int[] t = new int[n];
for (int i=0; i < n; i++){
t[i] = Integer.parseInt(data[i+3]);
}
int y = 0;
int base = 0;
for(int j=0; j < t.length; j++){
base = t[j] / 3;
if(base >= p) { y++; }
else if(base == p-1){
if(t[j] - (base+p) > base-1 && t[j] > 0){
y++;
} else if(s>0 && t[j] - (base+p) > base-2 && t[j] > 0){
s -= 1;
y++;
}
} else if(base == p-2){
if(s > 0 && t[j] - (base+p) > base-1 && t[j] > 0){
s -= 1;
y++;
}
}
}
return y;
}
}
| package org.tritree_tritree;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class ProblemBSmall {
static private Map<Integer, Integer> MAP_1 = new HashMap<Integer, Integer>();
static private Map<Integer, Integer> MAP_2 = new HashMap<Integer, Integer>();
static {
MAP_1.put(10, 28);
MAP_1.put(9, 25);
MAP_1.put(8, 22);
MAP_1.put(7, 19);
MAP_1.put(6, 16);
MAP_1.put(5, 13);
MAP_1.put(4, 10);
MAP_1.put(3, 7);
MAP_1.put(2, 4);
}
static {
MAP_2.put(10, 26);
MAP_2.put(9, 23);
MAP_2.put(8, 20);
MAP_2.put(7, 17);
MAP_2.put(6, 14);
MAP_2.put(5, 11);
MAP_2.put(4, 8);
MAP_2.put(3, 5);
MAP_2.put(2, 2);
}
public static void main(String[] args) throws IOException {
File source = new File("B-small-attempt0.in");
Scanner scan = new Scanner(source);
int t = scan.nextInt();
scan.nextLine();
List<String> resultList = new ArrayList<String>();
for (int i = 1; i < t + 1; i++) {
int n = scan.nextInt();
int s = scan.nextInt();
int p = scan.nextInt();
int[] pointArray = new int[n];
for (int j = 0; j < n; j++) {
pointArray[j] = scan.nextInt();
}
String result = "Case #" + i + ": " + resolve(s, p, pointArray);
resultList.add(result);
}
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd_hhmmss");
File resultFile = new File("B-small-" + dateFormat.format(new Date()) + ".out");
FileOutputStream fileOutputStream = new FileOutputStream(resultFile);
for (String result: resultList) {
result = result + "\n";
fileOutputStream.write(result.getBytes());
}
fileOutputStream.flush();
fileOutputStream.close();
}
private static int resolve(int s, int p, int[] pointArray) {
int cnt = 0;
int remainScnt = s;
for (int i = 0; i < pointArray.length; i++) {
int target = pointArray[i];
if (p*3 -2 <= target) {
cnt++;
} else if (target == 0) {
continue;
} else if (0 < remainScnt) {
if (p*3 -4 <= target) {
cnt++;
remainScnt--;
}
}
}
return cnt;
}
}
|
A22191 | A21491 | 0 | package com.example;
import java.io.IOException;
import java.util.List;
public class ProblemB {
enum Result {
INSUFFICIENT,
SUFFICIENT,
SUFFICIENT_WHEN_SURPRISING
}
public static void main(String[] a) throws IOException {
List<String> lines = FileUtil.getLines("/B-large.in");
int cases = Integer.valueOf(lines.get(0));
for(int c=0; c<cases; c++) {
String[] tokens = lines.get(c+1).split(" ");
int n = Integer.valueOf(tokens[0]); // N = number of Googlers
int s = Integer.valueOf(tokens[1]); // S = number of surprising triplets
int p = Integer.valueOf(tokens[2]); // P = __at least__ a score of P
int sumSufficient = 0;
int sumSufficientSurprising = 0;
for(int i=0; i<n; i++) {
int points = Integer.valueOf(tokens[3+i]);
switch(test(points, p)) {
case SUFFICIENT:
sumSufficient++;
break;
case SUFFICIENT_WHEN_SURPRISING:
sumSufficientSurprising++;
break;
}
// uSystem.out.println("points "+ points +" ? "+ p +" => "+ result);
}
System.out.println("Case #"+ (c+1) +": "+ (sumSufficient + Math.min(s, sumSufficientSurprising)));
// System.out.println();
// System.out.println("N="+ n +", S="+ s +", P="+ p);
// System.out.println();
}
}
private static Result test(int n, int p) {
int fac = n / 3;
int rem = n % 3;
if(rem == 0) {
// int triplet0[] = { fac, fac, fac };
// print(n, triplet0);
if(fac >= p) {
return Result.SUFFICIENT;
}
if(fac > 0 && fac < 10) {
if(fac+1 >= p) {
return Result.SUFFICIENT_WHEN_SURPRISING;
}
// int triplet1[] = { fac+1, fac, fac-1 }; // surprising
// print(n, triplet1);
}
} else if(rem == 1) {
// int triplet0[] = { fac+1, fac, fac };
// print(n, triplet0);
if(fac+1 >= p) {
return Result.SUFFICIENT;
}
// if(fac > 0 && fac < 10) {
// int triplet1[] = { fac+1, fac+1, fac-1 };
// print(n, triplet1);
// }
} else if(rem == 2) {
// int triplet0[] = { fac+1, fac+1, fac };
// print(n, triplet0);
if(fac+1 >= p) {
return Result.SUFFICIENT;
}
if(fac < 9) {
// int triplet1[] = { fac+2, fac, fac }; // surprising
// print(n, triplet1);
if(fac+2 >= p) {
return Result.SUFFICIENT_WHEN_SURPRISING;
}
}
} else {
throw new RuntimeException("error");
}
return Result.INSUFFICIENT;
// System.out.println();
// System.out.println(n +" => "+ div3 +" ("+ rem +")");
}
// private static void print(int n, int[] triplet) {
// System.out.println("n="+ n +" ("+ (n/3) +","+ (n%3) +") => ["+ triplet[0] +","+ triplet[1] +","+ triplet[2] +"]" + (triplet[0]-triplet[2] > 1 ? " *" : ""));
// }
}
| import java.io.*;
import java.util.*;
public class B {
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Scanner sc = new Scanner(br.readLine());
int T = sc.nextInt();
int caseNumber = 1;
for(int i=0; i<T; i++){
sc = new Scanner(br.readLine());
int N = sc.nextInt();
int S = sc.nextInt();
int p = sc.nextInt();
int count = 0;
//int countS = 0;
//int countCanBeS = 0;
//ArrayList<Integer> ta = new ArrayList<Integer>();
//ArrayList<Integer> tb = new ArrayList<Integer>();
for(int j=0; j<N; j++){
int tr = sc.nextInt();
if(tr>0){
if(tr/3 >= p){
count++;
}else if((tr + 2)/3 >= p){
count++;
//countCanBeS++;
}else if(tr/3<p){
if(S>0){
if((tr+3)/3 >= p){
count++;
S--;
}else if((tr+4)/3 >= p){
//System.out.println("Hello" + count);
count++;
S--;
}
}
}
}else if(tr==0 && p==0){
count++;
}
}
System.out.println("Case #"+ caseNumber +": "+count);
caseNumber++;
}
}
} |
B20006 | B21343 | 0 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
import org.jfree.data.function.PowerFunction2D;
public class r2a
{
Map numMap = new HashMap();
int output = 0;
/**
* @param args
*/
public static void main(String[] args)
{
r2a mk = new r2a();
try {
FileInputStream fstream = new FileInputStream("d:/cjinput.txt");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String str;
int i = 0;
while ((str = br.readLine()) != null) {
int begin=0,end = 0;
i++;
if (i == 1)
continue;
mk.numMap = new HashMap();
StringTokenizer strTok = new StringTokenizer(str, " ");
while (strTok.hasMoreTokens()) {
begin = Integer.parseInt(((String) strTok.nextToken()));
end = Integer.parseInt(((String) strTok.nextToken()));
}
mk.evaluate(i, begin, end);
}
in.close();
}
catch (Exception e) {
System.err.println(e);
}
}
private void evaluate(int rowNum, int begin, int end)
{
output=0;
for (int i = begin; i<= end; i++) {
if(numMap.containsKey(Integer.valueOf(i)))
continue;
List l = getPairElems(i);
if (l.size() > 0) {
Iterator itr = l.iterator();
int ctr = 0;
ArrayList tempList = new ArrayList();
while (itr.hasNext()) {
int next = ((Integer)itr.next()).intValue();
if (next <= end && next > i) {
numMap.put(Integer.valueOf(next), i);
tempList.add(next);
ctr++;
}
}
ctr = getCounter(ctr+1,2);
/* if (tempList.size() > 0 || ctr > 0)
System.out.println("DD: " + i + ": " + tempList +" ; ctr = " + ctr);*/
output = output + ctr;
}
}
String outputStr = "Case #" + (rowNum -1) + ": " + output;
System.out.println(outputStr);
}
private int getCounter(int n, int r) {
int ret = 1;
int nfactorial =1;
for (int i = 2; i<=n; i++) {
nfactorial = i*nfactorial;
}
int nrfact =1;
for (int i = 2; i<=n-r; i++) {
nrfact = i*nrfact;
}
return nfactorial/(2*nrfact);
}
private ArrayList getPairElems(int num) {
ArrayList retList = new ArrayList();
int temp = num;
if (num/10 == 0)
return retList;
String str = String.valueOf(num);
int arr[] = new int[str.length()];
int x = str.length();
while (temp/10 > 0) {
arr[x-1] = temp%10;
temp=temp/10;
x--;
}
arr[0]=temp;
int size = arr.length;
for (int pos = size -1; pos >0; pos--) {
if(arr[pos] == 0)
continue;
int pairNum = 0;
int multiplier =1;
for (int c=0; c < size-1; c++) {
multiplier = multiplier*10;
}
pairNum = pairNum + (arr[pos]*multiplier);
for(int ctr = pos+1, i=1; i < size; i++,ctr++) {
if (ctr == size)
ctr=0;
if (multiplier!=1)
multiplier=multiplier/10;
pairNum = pairNum + (arr[ctr]*multiplier);
}
if (pairNum != num)
retList.add(Integer.valueOf(pairNum));
}
return retList;
}
}
| import java.io.*;
import java.util.*;
public class C {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
enum InputType {
SAMPLE, SMALL, LARGE;
}
static final InputType currentInputType = InputType.LARGE;
static final int attemptNumber = 0; // for small inputs only
int pow10;
void solve() throws IOException {
int a = nextInt();
int b = nextInt();
pow10 = 1;
int cnt = Integer.toString(a).length();
for (int i = 0; i < cnt - 1; i++)
pow10 *= 10;
long ans = 0;
for (int i = a; i <= b; i++) {
for (int j = (i % 10) * pow10 + (i / 10); j != i; j = (j % 10) * pow10 + j / 10)
if (a <= j && j <= b && j > i)
ans++;
}
out.println(ans);
}
void inp() throws IOException {
switch (currentInputType) {
case SAMPLE:
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
break;
case SMALL:
String fileName = "C-small-attempt" + attemptNumber;
br = new BufferedReader(new FileReader(fileName + ".in"));
out = new PrintWriter(fileName + ".out");
break;
case LARGE:
fileName = "C-large";
br = new BufferedReader(new FileReader(fileName + ".in"));
out = new PrintWriter(fileName + ".out");
break;
}
int test = nextInt();
for (int i = 1; i <= test; i++) {
System.err.println("Running test " + i);
out.print("Case #" + i + ": ");
solve();
}
out.close();
}
public static void main(String[] args) throws IOException {
new C().inp();
}
String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return null;
}
}
return st.nextToken();
}
String nextString() {
try {
return br.readLine();
} catch (Exception e) {
eof = true;
return null;
}
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
|
B13196 | B10427 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Q3M {
public static void main(String[] args) throws Exception {
compute();
}
private static void compute() throws Exception {
BufferedReader br = new BufferedReader(new FileReader(new File(
"C:\\work\\Q3\\C-small-attempt0.in")));
String line = null;
int i = Integer.parseInt(br.readLine());
List l = new ArrayList();
for (int j = 0; j < i; j++) {
line = br.readLine();
String[] nums = line.split(" ");
l.add(calculate(nums));
}
writeOutput(l);
}
private static int calculate(String[] nums) {
int min = Integer.parseInt(nums[0]);
int max = Integer.parseInt(nums[1]);
int count = 0;
List l = new ArrayList();
for (int i = min; i <= max; i++) {
for (int times = 1; times < countDigits(i); times++) {
int res = shiftNum(i, times);
if (res <= max && i < res) {
if ((!l.contains((i + ":" + res)))) {
l.add(i + ":" + res);
l.add(res + ":" + i);
count++;
}
}
}
}
return count;
}
private static boolean checkZeros(int temp, int res) {
if (temp % 10 == 0 || res % 10 == 0)
return false;
return true;
}
private static int shiftNum(int n, int times) {
int base = (int) Math.pow(10, times);
int temp2 = n / base;
int placeHolder = (int) Math.pow((double) 10,
(double) countDigits(temp2));
int res = placeHolder * (n % base) + temp2;
if (countDigits(res) == countDigits(n)) {
return res;
} else {
return 2000001;
}
}
public static int countDigits(int x) {
if (x < 10)
return 1;
else {
return 1 + countDigits(x / 10);
}
}
private static void writeOutput(List l) throws Exception {
StringBuffer b = new StringBuffer();
int i = 1;
BufferedWriter br = new BufferedWriter(new FileWriter(new File(
"C:\\work\\Q3\\ans.txt")));
for (Iterator iterator = l.iterator(); iterator.hasNext();) {
br.write("Case #" + i++ + ": " + iterator.next());
br.newLine();
}
br.close();
}
} | import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
ArrayList<String> answer = read("/home/zehortigoza/Downloads/codejam/c/input.txt");
int tt = 0;
int amount = 1;
for (int i = 0; i < answer.size(); i++) {
String line = answer.get(i);
if (i == 0) {
tt = Integer.parseInt(line);
} else {
if (tt >= amount) {
HashMap<String, Boolean> count = new HashMap<String, Boolean>();
String[] splited = line.split(" ");
String a = splited[0];
String b = splited[1];
int aInt = Integer.parseInt(a);
int bInt = Integer.parseInt(b);
if (! (a.length() == 1 && b.length() == 1)) {
ArrayList<Integer> range = range(aInt, bInt);
for (int z = 0; z < range.size(); z++) {
String currentN = range.get(z)+"";
String currentM = range.get(z)+"";
int length = currentM.length();
for (int j = 0; j < length; j++) {
currentM = currentM.charAt(length-1) + currentM.substring(0, length - 1);
int currentNInt = Integer.parseInt(currentN);
int currentMInt = Integer.parseInt(currentM);
if (currentMInt <= bInt && currentMInt > currentNInt && currentMInt >= aInt) {
if(count.get(currentN+currentM) == null) {
count.put(currentN+currentM, true);
}
}
}
}
}
System.out.println("Case #" + amount + ": " + count.size());
amount++;
}
}
}
}
private static ArrayList<Integer> range(int start, int end) {
ArrayList<Integer> list = new ArrayList<Integer>();
if (start > end) {
System.out.println("error to build range");
return null;
}
for (int i = start; i <= end; i++) {
list.add(i);
}
return list;
}
private static ArrayList<String> read(String url) {
ArrayList<String> lines = new ArrayList<String>();
Scanner scanner = null;
try {
scanner = new Scanner(new FileInputStream(url));
while (scanner.hasNextLine()) {
lines.add(scanner.nextLine());
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (scanner != null) {
scanner.close();
}
}
return lines;
}
}
|
A11201 | A12869 | 0 | package CodeJam.c2012.clasificacion;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* Problem
*
* You're watching a show where Googlers (employees of Google) dance, and then
* each dancer is given a triplet of scores by three judges. Each triplet of
* scores consists of three integer scores from 0 to 10 inclusive. The judges
* have very similar standards, so it's surprising if a triplet of scores
* contains two scores that are 2 apart. No triplet of scores contains scores
* that are more than 2 apart.
*
* For example: (8, 8, 8) and (7, 8, 7) are not surprising. (6, 7, 8) and (6, 8,
* 8) are surprising. (7, 6, 9) will never happen.
*
* The total points for a Googler is the sum of the three scores in that
* Googler's triplet of scores. The best result for a Googler is the maximum of
* the three scores in that Googler's triplet of scores. Given the total points
* for each Googler, as well as the number of surprising triplets of scores,
* what is the maximum number of Googlers that could have had a best result of
* at least p?
*
* For example, suppose there were 6 Googlers, and they had the following total
* points: 29, 20, 8, 18, 18, 21. You remember that there were 2 surprising
* triplets of scores, and you want to know how many Googlers could have gotten
* a best result of 8 or better.
*
* With those total points, and knowing that two of the triplets were
* surprising, the triplets of scores could have been:
*
* 10 9 10 6 6 8 (*) 2 3 3 6 6 6 6 6 6 6 7 8 (*)
*
* The cases marked with a (*) are the surprising cases. This gives us 3
* Googlers who got at least one score of 8 or better. There's no series of
* triplets of scores that would give us a higher number than 3, so the answer
* is 3.
*
* Input
*
* The first line of the input gives the number of test cases, T. T test cases
* follow. Each test case consists of a single line containing integers
* separated by single spaces. The first integer will be N, the number of
* Googlers, and the second integer will be S, the number of surprising triplets
* of scores. The third integer will be p, as described above. Next will be N
* integers ti: the total points of the Googlers.
*
* Output
*
* For each test case, output one line containing "Case #x: y", where x is the
* case number (starting from 1) and y is the maximum number of Googlers who
* could have had a best result of greater than or equal to p.
*
* Limits
*
* 1 ⤠T ⤠100. 0 ⤠S ⤠N. 0 ⤠p ⤠10. 0 ⤠ti ⤠30. At least S of the ti values
* will be between 2 and 28, inclusive.
*
* Small dataset
*
* 1 ⤠N ⤠3.
*
* Large dataset
*
* 1 ⤠N ⤠100.
*
* Sample
*
* Input Output 4 Case #1: 3 3 1 5 15 13 11 Case #2: 2 3 0 8 23 22 21 Case #3: 1
* 2 1 1 8 0 Case #4: 3 6 2 8 29 20 8 18 18 21
*
* @author Leandro Baena Torres
*/
public class B {
public static void main(String[] args) throws FileNotFoundException, IOException {
BufferedReader br = new BufferedReader(new FileReader("B.in"));
String linea;
int numCasos, N, S, p, t[], y, minSurprise, minNoSurprise;
linea = br.readLine();
numCasos = Integer.parseInt(linea);
for (int i = 0; i < numCasos; i++) {
linea = br.readLine();
String[] aux = linea.split(" ");
N = Integer.parseInt(aux[0]);
S = Integer.parseInt(aux[1]);
p = Integer.parseInt(aux[2]);
t = new int[N];
y = 0;
minSurprise = p + ((p - 2) >= 0 ? (p - 2) : 0) + ((p - 2) >= 0 ? (p - 2) : 0);
minNoSurprise = p + ((p - 1) >= 0 ? (p - 1) : 0) + ((p - 1) >= 0 ? (p - 1) : 0);
for (int j = 0; j < N; j++) {
t[j] = Integer.parseInt(aux[3 + j]);
if (t[j] >= minNoSurprise) {
y++;
} else {
if (t[j] >= minSurprise) {
if (S > 0) {
y++;
S--;
}
}
}
}
System.out.println("Case #" + (i + 1) + ": " + y);
}
}
}
|
import java.util.Scanner;
public class CodeJam12B {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int zz = 1; zz <= T; zz++) {
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int[] t = new int[N];
int out = 0;
for (int i = 0; i < N; i++) {
t[i] = in.nextInt();
t[i] = t[i] - p;
if (t[i] >= 0) {
if (t[i] >= 2 * (p - 1)) {
out++;
} else if (t[i] >= 2 * (p - 2) && S > 0) {
S--;
out++;
}
}
}
System.out.format("Case #%d: %d\n", zz, out);
}
}
}
|
A22642 | A22764 | 0 | import java.util.*;
import java.io.*;
public class DancingWithTheGooglers
{
public DancingWithTheGooglers()
{
Scanner inFile = null;
try
{
inFile = new Scanner(new File("inputB.txt"));
}
catch(Exception e)
{
System.out.println("Problem opening input file. Exiting...");
System.exit(0);
}
int t = inFile.nextInt();
int [] results = new int [t];
DancingWithTheGooglersMax [] rnc = new DancingWithTheGooglersMax[t];
int i, j;
int [] scores;
int s, p;
for(i = 0; i < t; i++)
{
scores = new int [inFile.nextInt()];
s = inFile.nextInt();
p = inFile.nextInt();
for(j = 0; j < scores.length; j++)
scores[j] = inFile.nextInt();
rnc[i] = new DancingWithTheGooglersMax(i, scores, s, p, results);
rnc[i].start();
}
inFile.close();
boolean done = false;
while(!done)
{
done = true;
for(i = 0; i < t; i++)
if(rnc[i].isAlive())
{
done = false;
break;
}
}
PrintWriter outFile = null;
try
{
outFile = new PrintWriter(new File("outputB.txt"));
}
catch(Exception e)
{
System.out.println("Problem opening output file. Exiting...");
System.exit(0);
}
for(i = 0; i < results.length; i++)
outFile.printf("Case #%d: %d\n", i+1, results[i]);
outFile.close();
}
public static void main(String [] args)
{
new DancingWithTheGooglers();
}
private class DancingWithTheGooglersMax extends Thread
{
int id;
int s, p;
int [] results, scores;
public DancingWithTheGooglersMax(int i, int [] aScores, int aS, int aP,int [] res)
{
id = i;
s = aS;
p = aP;
results = res;
scores = aScores;
}
public void run()
{
int a = 0, b = 0;
if(p == 0)
results[id] = scores.length;
else if(p == 1)
{
int y;
y = 3*p - 3;
for(int i = 0; i < scores.length; i++)
if(scores[i] > y)
a++;
else if(scores[i] > 0)
b++;
b = Math.min(b, s);
results[id] = a+b;
}
else
{
int y, z;
y = 3*p - 3;
z = 3*p - 5;
for(int i = 0; i < scores.length; i++)
if(scores[i] > y)
a++;
else if(scores[i] > z)
b++;
b = Math.min(b, s);
results[id] = a+b;
}
}
}
} | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package google_code_jam;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
/**
*
* @author lenovo
*/
public class B {
public static void main(String[] args) throws IOException {
// TODO code application logic here
BufferedReader br = new BufferedReader(new FileReader("B-large.in"));
PrintWriter pw = new PrintWriter("B.out" );
StringTokenizer st=new StringTokenizer(br.readLine());
// System.out.println(st);
int x = Integer.parseInt(st.nextToken());
a1:for (int i = 0; i < x; i++) {
st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());// number of players
int s = Integer.parseInt(st.nextToken());//number of surprising
int p = Integer.parseInt(st.nextToken());// best degree required
int count=0;//
for (int j = 0; j < n; j++) {
int temp=Integer.parseInt(st.nextToken());
int rem=temp%3;
int div=temp/3;
if(temp==0 && p!=0)continue;
else if(temp==0 && p==0){
count++;
continue;
}
if(rem==0){
if(div>=p){
count++;
continue;
}
else if(div+1>=p && s>0){
count++;
s--;
continue;
}
}// end of this condition
else{
if(rem==1){
if(div+1 >=p)count++;
}
else if(rem==2){
if(div+1 >= p)count++;
else if (div+2 >=p && s>0){
count++;
s--;
continue;
}
}
}
}// End of converting
pw.append("Case #"+(i+1)+": "+count+"\n");
}
pw.close();
}
}
|
A21557 | A21489 | 0 | import java.io.*;
import java.util.*;
public class DancingWithGooglers {
public static class Googlers {
public int T;
public int surp;
public boolean surprising;
public boolean pSurprising;
public boolean antiSurprising;
public boolean pAntiSurprising;
public Googlers(int T, int surp) {
this.T = T;
this.surp = surp;
}
public void set(int a, int b, int c) {
if (c >= 0 && (a + b + c) == T) {
int diff = (Math.max(a, Math.max(b, c)) - Math.min(a, Math.min(b, c)));
if (diff <= 2) {
if (diff == 2) {
if (a >= surp || b >= surp || c >= surp) {
pSurprising = true;
} else {
surprising = true;
}
} else {
if (a >= surp || b >= surp || c >= surp) {
pAntiSurprising = true;
} else {
antiSurprising = true;
}
}
}
}
}
}
public static void main(String... args) throws IOException {
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedReader reader = new BufferedReader(new FileReader("B-large.in"));
// PrintWriter writer = new PrintWriter(System.out);
PrintWriter writer = new PrintWriter("B-large.out");
int len, cases = Integer.parseInt(reader.readLine());
List<Googlers> satisfied = new ArrayList<Googlers>();
List<Googlers> unsatisfied = new ArrayList<Googlers>();
String[] inputs;
int N, S, p;
for (int i = 1; i <= cases; i++) {
inputs = reader.readLine().split(" ");
p = Integer.parseInt(inputs[1]);
S = Integer.parseInt(inputs[2]);
satisfied.clear();
unsatisfied.clear();
for (int j = 3; j < inputs.length; j++) {
int t = Integer.parseInt(inputs[j]);
Googlers googlers = new Googlers(t, S);
for (int k = 0; k <= 10; k++) {
int till = k + 2 > 10 ? 10 : k + 2;
for (int l = k; l <= till; l++) {
googlers.set(k, l, (t - (k + l)));
}
}
if (googlers.pAntiSurprising) {
satisfied.add(googlers);
} else {
unsatisfied.add(googlers);
}
}
int pSurprising = 0;
if (p > 0) {
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
pSurprising++;
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
iter.remove();
pSurprising++;
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
writer.print("Case #" + i + ": 0");
}else {
writer.print("Case #" + i + ": " + (satisfied.size() + pSurprising));
}
writer.println();
}
writer.flush();
}
}
| 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-large-attempt0.in";
String file = "world2012/qualification/B-large.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};
}
}
}
}
|
B10858 | B10094 | 0 | package be.mokarea.gcj.common;
public abstract class TestCaseReader<T extends TestCase> {
public abstract T nextCase() throws Exception;
public abstract int getMaxCaseNumber();
}
| import java.io.*;
import java.util.*;
public class C implements Runnable{
public void run(){
try{
Scanner in = new Scanner(new File("C-small.in"));
PrintWriter out = new PrintWriter("C-small.out");
int a, b, t = in.nextInt(), ans, x, l;
String min, buf, max;
Set<String> set = new HashSet<String>();
for (int k = 1; k <= t; k++){
ans = 0;
a = in.nextInt();
b = in.nextInt();
max = Integer.toString(b);
for (int i = a; i < b; i++){
set.clear();
x = i;
min = buf = Integer.toString(x);
l = min.length();
for (int j = 0; j < l-1; j++){
buf = min.substring(l - j - 1) + min.substring(0, Math.max(0, l - j - 1));
if ((buf.length() == l) && (min.compareTo(buf) < 0) && (buf.compareTo(max) <= 0)) {
if (!set.contains(buf)){
set.add(buf);
ans++;
}
}
}
}
out.println("Case #" + k + ": " + ans);
}
out.close();
}
catch(Exception e){
}
}
public static void main(String[] args){
(new Thread(new C())).start();
}
} |
B21968 | B20136 | 0 | import java.util.*;
import java.io.*;
public class recycled_numbers {
public static void main(String[]a) throws Exception{
Scanner f = new Scanner(new File(a[0]));
int result=0;
int A,B;
String n,m;
HashSet<String> s=new HashSet<String>();
int T=f.nextInt(); //T total case count
for (int t=1; t<=T;t++){//for each case t
s.clear();
result=0; //reset
A=f.nextInt();B=f.nextInt(); //get values for next case
if (A==B)result=0;//remove case not meeting problem limits
else{
for(int i=A;i<=B;i++){//for each int in range
n=Integer.toString(i);
m=new String(n);
//System.out.println(n);
for (int j=1;j<n.length();j++){//move each digit to the front & test
m = m.substring(m.length()-1)+m.substring(0,m.length()-1);
if(m.matches("^0+[\\d]+")!=true &&
Integer.parseInt(m)<=B &&
Integer.parseInt(n)<Integer.parseInt(m)){
s.add(new String(n+","+m));
//result++;
//System.out.println(" matched: "+m);
}
}
}
result = s.size();
}
//display output
System.out.println("Case #" + t + ": " + result);
}
}
} | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class GoogleNumbers {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
int numberOfTestCases = Integer.parseInt(s);
StringBuffer output = new StringBuffer();
for (int i = 1; i <= numberOfTestCases; i++) {
String testCase = br.readLine().trim();
String[] inputparams = testCase.split(" ");
long A, B;
A = Long.parseLong(inputparams[0]);
B = Long.parseLong(inputparams[1]);
String outputString = solveTestCase(A, B);
if (i != 1) {
output.append("\n");
}
output.append("Case #" + i + ": ");
output.append(outputString);
}
System.out.println(output);
}
private static String solveTestCase(long A, long B) {
long pairCount = 0;
int d = String.valueOf(A).length();
for (long n = A; n <= B; n++) {
String currentNumber = String.valueOf(n);
HashMap<String, String> pairedNumbers = new HashMap<String, String>();
for (int i = 1; i < d; i++) {
int subIndex = d - i;
if (currentNumber.charAt(subIndex) == '0') {
continue;
}
String newNumber = currentNumber.substring(subIndex) + currentNumber.substring(0, subIndex);
if (pairedNumbers.containsKey(newNumber)) {
continue;
}
long m = Long.valueOf(newNumber);
if (m <= n || m > B) {
continue;
}
pairedNumbers.put(newNumber, "Y");
pairCount++;
}
}
return String.valueOf(pairCount);
}
}
|
B21752 | B20274 | 0 | package Main;
import com.sun.deploy.util.ArrayUtil;
import org.apache.commons.lang3.ArrayUtils;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
/**
* Created with IntelliJ IDEA.
* User: arran
* Date: 14/04/12
* Time: 3:12 PM
* To change this template use File | Settings | File Templates.
*/
public class Round {
public StringBuilder parse(BufferedReader in) throws IOException {
StringBuilder out = new StringBuilder();
String lineCount = in.readLine();
for (int i = 1; i <= Integer.parseInt(lineCount); i++)
{
out.append("Case #"+i+": ");
System.err.println("Case #"+i+": ");
String line = in.readLine();
String[] splits = line.split(" ");
int p1 = Integer.valueOf(splits[0]);
int p2 = Integer.valueOf(splits[1]);
int r = pairRecyclable(p1, p2);
out.append(r);
// if (i < Integer.parseInt(lineCount))
out.append("\n");
}
return out;
}
public static int pairRecyclable(int i1, int i2) {
HashSet<String> hash = new HashSet<String>();
for (int i = i1; i < i2; i++)
{
String istr = String.valueOf(i);
if (istr.length() < 2) continue;
for (int p = 0; p < istr.length() ; p++)
{
String nistr = istr.substring(p,istr.length()).concat(istr.substring(0,p));
if (Integer.valueOf(nistr) < i1) continue;
if (Integer.valueOf(nistr) > i2) continue;
if (nistr.equals(istr)) continue;
String cnistr = (Integer.valueOf(nistr) > Integer.valueOf(istr)) ? istr + "," + nistr : nistr + "," + istr;
hash.add(cnistr);
}
}
return hash.size();
}
public static void main(String[] args) {
InputStreamReader converter = null;
try {
int attempt = 0;
String quest = "C";
// String size = "small-attempt";
String size = "large";
converter = new InputStreamReader(new FileInputStream("src/resource/"+quest+"-"+size+".in"));
BufferedReader in = new BufferedReader(converter);
Round r = new Round();
String str = r.parse(in).toString();
System.out.print(str);
FileOutputStream fos = new FileOutputStream(quest+"-"+size+".out");
OutputStreamWriter osw = new OutputStreamWriter(fos);
BufferedWriter bw = new BufferedWriter(osw);
bw.write(str);
bw.flush();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| import java.io.*;
import java.util.*;
class Recycle {
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++){
int ans = 0;
StringTokenizer st = new StringTokenizer(in.readLine());
int A = Integer.parseInt(st.nextToken());
int B = Integer.parseInt(st.nextToken());
for(int j = A; j <= B; j++){
String s = "" + j;
HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();
for(int k = 0; k < s.length(); k++){
String rot = s.substring(k,s.length()) + s.substring(0,k);
hm.put(Integer.parseInt(rot),0);
}
for(int k : hm.keySet()){
if(j<k&&k<=B)
ans++;
}
}
System.out.println("Case #"+(i+1)+": " + ans);
}
}
} |
A21396 | A20695 | 0 | import java.util.*;
public class Test {
public static void main(String[] args){
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 result = 0;
for(int j = 0; j<n; j++){
int x = canAddUp(in.nextInt(), p);
if(x == 0) {
result++;
} else if (x==1 && s > 0) {
result++;
s--;
}
}
System.out.println("Case #"+i+": "+result);
}
}
public static int canAddUp(int sum, int limit) {
boolean flag = false;
for(int i = 0; i<=sum; i++) {
for(int j = 0; i+j <= sum; j++) {
int k = sum-(i+j);
int a = Math.abs(i-j);
int b = Math.abs(i-k);
int c = Math.abs(j-k);
if(a > 2 || b > 2 || c> 2){
continue;
}
if (i>=limit || j>=limit || k>=limit) {
if(a < 2 && b < 2 && c < 2) {
return 0;
}else{
flag = true;
}
}
}
}
return (flag) ? 1 : 2;
}
}
| package quiz.number05;
import java.io.*;
import java.util.Arrays;
/**
* @author Keesun Baik
*/
public class KeesunDancingTest {
public static void main(String[] args) throws IOException {
KeesunDancingTest dancing = new KeesunDancingTest();
BufferedReader in = new BufferedReader(new FileReader("/workspace/telepathy/test/quiz/number05/B-large.in"));
String s;
int lineNum = 0;
int problemNum = 0;
String answer = "";
while ((s = in.readLine()) != null) {
if (s.isEmpty()) {
return;
}
if (lineNum == 0) {
problemNum = Integer.parseInt(s);
} else {
answer += "Case #" + lineNum + ": " + dancing.figureP(s) + "\n";
}
lineNum++;
}
in.close();
System.out.println(answer);
BufferedWriter out = new BufferedWriter(new FileWriter("/workspace/telepathy/test/quiz/number05/B-large.out"));
out.write(answer);
out.close();
}
private int figureP(String s) {
String[] inputs = s.split(" ");
int people = Integer.parseInt(inputs[0]);
int surprise = Integer.parseInt(inputs[1]);
int minScore = Integer.parseInt(inputs[2]);
String[] scoreStrings = Arrays.copyOfRange(inputs, 3, inputs.length);
int[] scores = new int[scoreStrings.length];
for (int i = 0; i < scoreStrings.length; i++) {
scores[i] = Integer.parseInt(scoreStrings[i]);
}
int cases = 0;
for (int score : scores) {
int base = score / 3;
switch (score % 3) {
case 0: {
System.out.println("0");
if (base >= minScore) {
cases++;
} else if (surprise > 0 && base > 0 && base + 1 >= minScore) {
cases++;
surprise--;
}
break;
}
case 1: {
System.out.println("1");
if (base >= minScore || base + 1 >= minScore) {
cases++;
} else if (surprise > 0 && base + 1 >= minScore) {
cases++;
surprise--;
}
break;
}
case 2: {
System.out.println("2");
if (base + 1 >= minScore || base >= minScore) {
cases++;
} else if (surprise > 0 && base + 2 >= minScore) {
cases++;
surprise--;
}
break;
}
}
}
return cases;
}
}
|
A22992 | A22568 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package IO;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/**
*
* @author dannocz
*/
public class InputReader {
public static Input readFile(String filename){
try {
/* Sets up a file reader to read the file passed on the command
77 line one character at a time */
FileReader input = new FileReader(filename);
/* Filter FileReader through a Buffered read to read a line at a
time */
BufferedReader bufRead = new BufferedReader(input);
String line; // String that holds current file line
int count = 0; // Line number of count
ArrayList<String> cases= new ArrayList<String>();
// Read first line
line = bufRead.readLine();
int noTestCases=Integer.parseInt(line);
count++;
// Read through file one line at time. Print line # and line
while (count<=noTestCases){
//System.out.println("Reading. "+count+": "+line);
line = bufRead.readLine();
cases.add(line);
count++;
}
bufRead.close();
return new Input(noTestCases,cases);
}catch (ArrayIndexOutOfBoundsException e){
/* If no file was passed on the command line, this expception is
generated. A message indicating how to the class should be
called is displayed */
e.printStackTrace();
}catch (IOException e){
// If another exception is generated, print a stack trace
e.printStackTrace();
}
return null;
}// end main
}
| package googlecodejam2012.qualification.dancinggooglers;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
public class DancingGooglers {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// System.out.println(hasWithoutSurprise(6, 2));
// System.out.println(hasWithoutSurprise(5, 2));
// System.out.println(hasWithoutSurprise(4, 2));
// System.out.println(hasWithoutSurprise(7, 2));
// System.out.println(hasWithoutSurprise(8, 2));
// System.out.println(hasWithoutSurprise(3, 2));
// System.out.println(hasWithoutSurprise(1, 1));
// System.out.println(hasWithoutSurprise(0, 1));
// System.out.println();
// System.out.println(hasWithSurprise(6, 2));
// System.out.println(hasWithSurprise(5, 2));
// System.out.println(hasWithSurprise(4, 2));
// System.out.println(hasWithSurprise(7, 2));
// System.out.println(hasWithSurprise(8, 2));
// System.out.println(hasWithSurprise(3, 2));
// System.out.println("Should be false: " + hasWithSurprise(2, 3));
// System.out.println("Should be false: " + hasWithSurprise(3, 3));
// System.out.println("Should be false: " + hasWithSurprise(4, 3));
// System.out.println("Should be true: " + hasWithSurprise(5, 3));
// System.out.println("Should be true: " + hasWithSurprise(6, 3));
// System.out.println("Should be true: " + hasWithSurprise(7, 3));
// System.out.println("Should be false: " + hasWithSurprise(0, 1));
String lineSep = System.getProperty("line.separator");
BufferedReader br = new BufferedReader(
args.length > 0 ? new FileReader(args[0])
: new InputStreamReader(System.in));
try {
Writer out = new BufferedWriter(args.length > 1 ? new FileWriter(args[1]): new OutputStreamWriter(System.out));
try {
int numLines = Integer.parseInt(br.readLine().trim());
for (int i = 1; i <= numLines;++i) {
String line = br.readLine();
out.write("Case #" + i + ": "+count(line) + lineSep);
}
} finally {
out.close();
}
} finally {
br.close();
}
}
private static int count(String line) {
String[] parts = line.split(" ");
int n = Integer.parseInt(parts[0]);
int s = Integer.parseInt(parts[1]);
int p = Integer.parseInt(parts[2]);
int[] sumScores = new int[parts.length - 3];
for (int i = parts.length; i -->3;) {
sumScores[i - 3] = Integer.parseInt(parts[i]);
}
return count(n, s, p, sumScores);
}
private static int count(int n, int s, int p, int[] sumScores) {
int countWithoutSurprise = 0;
int countWithPossibleSurprise = 0;
for (int sumScore : sumScores) {
if(hasWithoutSurprise(sumScore, p)) {
countWithoutSurprise++;
} else if (hasWithSurprise(sumScore, p)) {
countWithPossibleSurprise++;
}
}
return countWithoutSurprise + Math.min(s, countWithPossibleSurprise);
}
private static boolean hasWithSurprise(int sumScore, int p) {
return sumScore >= p && (sumScore + 4) /3 >= p;
}
private static boolean hasWithoutSurprise(int sumScore, int p) {
return (sumScore + 2) / 3 >= p;
}
}
|
B10899 | B12786 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
public class ReadFile {
public static void main(String[] args) throws Exception {
String srcFile = "C:" + File.separator + "Documents and Settings"
+ File.separator + "rohit" + File.separator + "My Documents"
+ File.separator + "Downloads" + File.separator
+ "C-small-attempt1.in.txt";
String destFile = "C:" + File.separator + "Documents and Settings"
+ File.separator + "rohit" + File.separator + "My Documents"
+ File.separator + "Downloads" + File.separator
+ "C-small-attempt0.out";
File file = new File(srcFile);
List<String> readData = new ArrayList<String>();
FileReader fileInputStream = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileInputStream);
StringBuilder stringBuilder = new StringBuilder();
String line = null;
while ((line = bufferedReader.readLine()) != null) {
readData.add(line);
}
stringBuilder.append(generateOutput(readData));
File writeFile = new File(destFile);
if (!writeFile.exists()) {
writeFile.createNewFile();
}
FileWriter fileWriter = new FileWriter(writeFile);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write(stringBuilder.toString());
bufferedWriter.close();
System.out.println("output" + stringBuilder);
}
/**
* @param number
* @return
*/
private static String generateOutput(List<String> number) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < number.size(); i++) {
if (i == 0) {
continue;
} else {
String tempString = number.get(i);
String[] temArr = tempString.split(" ");
stringBuilder.append("Case #" + i + ": ");
stringBuilder.append(getRecNumbers(temArr[0], temArr[1]));
stringBuilder.append("\n");
}
}
if (stringBuilder.length() > 0) {
stringBuilder.deleteCharAt(stringBuilder.length() - 1);
}
return stringBuilder.toString();
}
// /* This method accepts method for google code jam */
// private static String method(String value) {
// int intValue = Integer.valueOf(value);
// double givenExpr = 3 + Math.sqrt(5);
// double num = Math.pow(givenExpr, intValue);
// String valArr[] = (num + "").split("\\.");
// int finalVal = Integer.valueOf(valArr[0]) % 1000;
//
// return String.format("%1$03d", finalVal);
//
// }
//
// /* This method accepts method for google code jam */
// private static String method2(String value) {
// StringTokenizer st = new StringTokenizer(value, " ");
// String test[] = value.split(" ");
// StringBuffer str = new StringBuffer();
//
// for (int i = 0; i < test.length; i++) {
// // test[i]=test[test.length-i-1];
// str.append(test[test.length - i - 1]);
// str.append(" ");
// }
// str.deleteCharAt(str.length() - 1);
// String strReversedLine = "";
//
// while (st.hasMoreTokens()) {
// strReversedLine = st.nextToken() + " " + strReversedLine;
// }
//
// return str.toString();
// }
private static int getRecNumbers(String no1, String no2) {
int a = Integer.valueOf(no1);
int b = Integer.valueOf(no2);
Set<String> dupC = new HashSet<String>();
for (int i = a; i <= b; i++) {
int n = i;
List<String> value = findPerm(n);
for (String val : value) {
if (Integer.valueOf(val) <= b && Integer.valueOf(val) >= a
&& n < Integer.valueOf(val)) {
dupC.add(n + "-" + val);
}
}
}
return dupC.size();
}
private static List<String> findPerm(int num) {
String numString = String.valueOf(num);
List<String> value = new ArrayList<String>();
for (int i = 0; i < numString.length(); i++) {
String temp = charIns(numString, i);
if (!temp.equalsIgnoreCase(numString)) {
value.add(charIns(numString, i));
}
}
return value;
}
public static String charIns(String str, int j) {
String begin = str.substring(0, j);
String end = str.substring(j);
return end + begin;
}
} | import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Parser {
File instance;
Scanner sc;
public Parser(String f){
instance = new File(f);
}
public List<List<List<String>>> parse(int nbLinePerCase) throws FileNotFoundException{
sc = new Scanner(instance);
int nbCase = sc.nextInt();
List<List<List<String>>> input = new ArrayList<List<List<String>>>(nbCase);
String line;
sc.nextLine();
for(int i = 0; i < nbCase; i++){
List<List<String>> ll = new ArrayList<List<String>>(nbLinePerCase);
for(int j = 0; j < nbLinePerCase; j++){
List<String> l = new ArrayList<String>();
line = sc.nextLine();
Scanner sc2 = new Scanner(line);
while(sc2.hasNext()){
l.add(sc2.next());
}
ll.add(l);
}
input.add(ll);
}
return input;
}
}
|
B20291 | B21398 | 0 | import java.io.*;
import java.util.*;
class B
{
public static void main(String[] args)
{
try
{
BufferedReader br = new BufferedReader(new FileReader("B.in"));
PrintWriter pw = new PrintWriter(new FileWriter("B.out"));
int X = Integer.parseInt(br.readLine());
for(int i=0; i<X; i++)
{
String[] S = br.readLine().split(" ");
int A = Integer.parseInt(S[0]);
int B = Integer.parseInt(S[1]);
int R = 0;
int x = 1;
int n = 0;
while(A/x > 0) {
n++;
x *= 10;
}
for(int j=A; j<B; j++) {
Set<Integer> seen = new HashSet<Integer>();
for(int k=1; k<n; k++) {
int p1 = j % (int)Math.pow(10, k);
int p2 = (int) Math.pow(10, n-k);
int p3 = j / (int)Math.pow(10, k);
int y = p1*p2 + p3;
if(j < y && !seen.contains(y) && y <= B) {
seen.add(y);
R++;
}
}
}
pw.printf("Case #%d: %d\n", i+1, R);
pw.flush();
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
|
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class RecycledNumbers {
private Scanner in;
private PrintWriter out;
public long output;
public int A;
public int B;
/**
* main method
*/
public static void main(String args[]){
new RecycledNumbers("C-large.in");
}
/**
* constructor
*/
public RecycledNumbers(String filename){
initIO(filename);
int n = in.nextInt();
// long tmStart = System.currentTimeMillis();
for(int i=1;i<=n;i++){
A = in.nextInt();
B = in.nextInt();
output = 0;
output=solve();
out.println("Case #"+i+": "+output);
}
// System.out.println(System.currentTimeMillis() - tmStart);
closeIO();
}
public long solve(){
long op=0;
Set<Integer> s = new HashSet<Integer>();
for(int i=A;i<=B;i++){
String stringI = Integer.toString(i);
s.clear();
for(int ind=stringI.length()-1;ind>0;ind--){
if(stringI.substring(ind).charAt(0)!= '0'){
String stringTemp = stringI.substring(ind) + stringI.substring(0, ind);
if(Integer.parseInt(stringTemp) > i && Integer.parseInt(stringTemp)<=B){
// System.out.println(stringI + " "+Integer.parseInt(stringTemp));
s.add(Integer.parseInt(stringTemp));
// op++;
}
}
}
op+=s.size();
}
return op;
}
/**
* Set up devices to do I/O
*/
public void initIO(String filename){
try {
in = new Scanner(new FileReader(filename));
out = new PrintWriter(new FileWriter(filename+".out"));
}catch (IOException except) {
System.err.println("File is missing!");
}
}
/**
* Free memory used for I/O
*/
public void closeIO(){
in.close();
out.close();
}
}
|
B20856 | B21892 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package Happy;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.util.*;
import java.util.Arrays.*;
import java.io.BufferedReader;
//import java.io.IOException;
//import java.io.InputStreamReader;
//import java.io.PrintWriter;
//import java.util.StringTokenizer;
/**
*
* @author ipoqi
*/
public class Happy {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Happy().haha();
}
public void haha() {
BufferedReader in = null;
BufferedWriter out = null;
try{
in = new BufferedReader(new FileReader("C-large.in"));
out = new BufferedWriter(new FileWriter("LLL.out"));
int T = Integer.parseInt(in.readLine());
System.out.println("T="+T);
//LinkedList<Integer> mm = new LinkedList<Integer>();
//mm.add(new LinkedList<Integer>());
//int[][] mm;
//for(int ii=0;ii<mm.length;ii++){
// mm[0][ii] = 1;
//}
for(int i=0;i<T;i++){
String[] line = in.readLine().split(" ");
int A = Integer.parseInt(line[0]);
int B = Integer.parseInt(line[1]);
//System.out.print(" A = "+A+"\n");
//System.out.print(" B = "+B+"\n");
int ans = 0;
for(int j=A;j<B;j++){
int n=j;
if(n>=10){
String N = Integer.toString(n);
int nlen = N.length();
List<Integer> oks = new ArrayList<Integer>();
for(int k=0;k<nlen-1;k++){
String M = "";
for(int kk=1;kk<=nlen;kk++){
M = M + N.charAt((k+kk)%nlen);
}
int m = Integer.parseInt(M);
//System.out.print(" N = "+N+"\n");
//System.out.print(" M = "+M+"\n");
if(m>n && m<=B) {
boolean isNewOne = true;
for(int kkk=0;kkk<oks.size();kkk++){
//System.out.print(" KKK = "+oks.get(kkk)+"\n");
if(m==oks.get(kkk)){
isNewOne = false;
}
}
if(isNewOne){
//System.out.print(" N = "+N+"\n");
//System.out.print(" M = "+M+"\n");
oks.add(m);
ans++;
}
}
}
}
}
out.write("Case #"+(i+1)+": "+ans+"\n");
System.out.print("Case #"+(i+1)+": "+ans+"\n");
}
in.close();
out.close();
}catch(Exception e){
e.printStackTrace();
try{
in.close();
out.close();
}catch(Exception e1){
e1.printStackTrace();
}
}
System.out.print("YES!\n");
}
} | import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class CodeJamC
{
public static void main(String args[]) throws Exception
{
Scanner in = new Scanner(new File("in.txt"));
BufferedWriter out = new BufferedWriter(new FileWriter("out.txt"));
int cases = in.nextInt();
for(int casenum = 1;casenum <= cases;casenum++)
{
int a = in.nextInt();
int b = in.nextInt();
int count = 0;
HashMap<Integer,ArrayList<Integer>> map = new HashMap<Integer,ArrayList<Integer>>();
int len = ("" + a).length();
for(int n = a;n <= b;n++)
{
int t = n;
for(int i = 0;i<len-1;i++)
{
t = (t%10)*(int)(Math.pow(10,len-1)) + t/10;
if(t > n && t <= b)
{
if(map.containsKey(n))
{
if(!map.get(n).contains(t))
{
count++;
map.get(n).add(t);
}
}
else
{
ArrayList<Integer> arr = new ArrayList<Integer>();
arr.add(t);
map.put(n,arr);
count++;
}
}
}
}
out.write("Case #" + casenum + ": " + count + "\n");
}
in.close();
out.close();
}
} |
A10996 | A10073 | 0 | import java.util.Scanner;
import java.io.*;
class dance
{
public static void main (String[] args) throws IOException
{
File inputData = new File("B-small-attempt0.in");
File outputData= new File("Boutput.txt");
Scanner scan = new Scanner( inputData );
PrintStream print= new PrintStream(outputData);
int t;
int n,s,p,pi;
t= scan.nextInt();
for(int i=1;i<=t;i++)
{
n=scan.nextInt(); s=scan.nextInt(); p=scan.nextInt();
int supTrip=0, notsupTrip=0;
for(int j=0;j<n;j++)
{
pi=scan.nextInt();
if(pi>(3*p-3))
notsupTrip++;
else if((pi>=(3*p-4))&&(pi<=(3*p-3))&&(pi>p))
supTrip++;
}
if(s<=supTrip)
notsupTrip=notsupTrip+s;
else if(s>supTrip)
notsupTrip= notsupTrip+supTrip;
print.println("Case #"+i+": "+notsupTrip);
}
}
} | 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;
}
} |
B10155 | B10886 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam;
/**
*
* @author eblanco
*/
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import javax.swing.JFileChooser;
public class RecycledNumbers {
public static String DatosArchivo[] = new String[10000];
public static int[] convertStringArraytoIntArray(String[] sarray) throws Exception {
if (sarray != null) {
int intarray[] = new int[sarray.length];
for (int i = 0; i < sarray.length; i++) {
intarray[i] = Integer.parseInt(sarray[i]);
}
return intarray;
}
return null;
}
public static boolean CargarArchivo(String arch) throws FileNotFoundException, IOException {
FileInputStream arch1;
DataInputStream arch2;
String linea;
int i = 0;
if (arch == null) {
//frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
JFileChooser fc = new JFileChooser(System.getProperty("user.dir"));
int rc = fc.showDialog(null, "Select a File");
if (rc == JFileChooser.APPROVE_OPTION) {
arch = fc.getSelectedFile().getAbsolutePath();
} else {
System.out.println("No hay nombre de archivo..Yo!");
return false;
}
}
arch1 = new FileInputStream(arch);
arch2 = new DataInputStream(arch1);
do {
linea = arch2.readLine();
DatosArchivo[i++] = linea;
/* if (linea != null) {
System.out.println(linea);
}*/
} while (linea != null);
arch1.close();
return true;
}
public static boolean GuardaArchivo(String arch, String[] Datos) throws FileNotFoundException, IOException {
FileOutputStream out1;
DataOutputStream out2;
int i;
out1 = new FileOutputStream(arch);
out2 = new DataOutputStream(out1);
for (i = 0; i < Datos.length; i++) {
if (Datos[i] != null) {
out2.writeBytes(Datos[i] + "\n");
}
}
out2.close();
return true;
}
public static void echo(Object msg) {
System.out.println(msg);
}
public static void main(String[] args) throws IOException, Exception {
String[] res = new String[10000], num = new String[2];
int i, j, k, ilong;
int ele = 1;
ArrayList al = new ArrayList();
String FName = "C-small-attempt0", istr, irev, linea;
if (CargarArchivo("C:\\eblanco\\Desa\\CodeJam\\Code Jam\\test\\" + FName + ".in")) {
for (j = 1; j <= Integer.parseInt(DatosArchivo[0]); j++) {
linea = DatosArchivo[ele++];
num = linea.split(" ");
al.clear();
// echo("A: "+num[0]+" B: "+num[1]);
for (i = Integer.parseInt(num[0]); i <= Integer.parseInt(num[1]); i++) {
istr = Integer.toString(i);
ilong = istr.length();
for (k = 1; k < ilong; k++) {
if (ilong > k) {
irev = istr.substring(istr.length() - k, istr.length()) + istr.substring(0, istr.length() - k);
//echo("caso: " + j + ": isrt: " + istr + " irev: " + irev);
if ((Integer.parseInt(irev) > Integer.parseInt(num[0])) && (Integer.parseInt(irev) > Integer.parseInt(istr)) && (Integer.parseInt(irev) <= Integer.parseInt(num[1]))) {
al.add("(" + istr + "," + irev + ")");
}
}
}
}
HashSet hs = new HashSet();
hs.addAll(al);
al.clear();
al.addAll(hs);
res[j] = "Case #" + j + ": " + al.size();
echo(res[j]);
LeerArchivo.GuardaArchivo("C:\\eblanco\\Desa\\CodeJam\\Code Jam\\test\\" + FName + ".out", res);
}
}
}
}
| package de.at.codejam.util;
import java.io.IOException;
public interface InputFileParser<CASE> {
void initialize(TaskStatus taskStatus);
TaskStatus getTaskStatus();
boolean hasNextCase();
CASE getNextCase() throws IOException;
}
|
A12460 | A11587 | 0 | /**
*
*/
package pandit.codejam;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Scanner;
/**
* @author Manu Ram Pandit
*
*/
public class DancingWithGooglersUpload {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileInputStream fStream = new FileInputStream(
"input.txt");
Scanner scanner = new Scanner(new BufferedInputStream(fStream));
Writer out = new OutputStreamWriter(new FileOutputStream("output.txt"));
int T = scanner.nextInt();
int N,S,P,ti;
int counter = 0;
for (int count = 1; count <= T; count++) {
N=scanner.nextInt();
S = scanner.nextInt();
counter = 0;
P = scanner.nextInt();
for(int i=1;i<=N;i++){
ti=scanner.nextInt();
if(ti>=(3*P-2)){
counter++;
continue;
}
else if(S>0){
if(P>=2 && ((ti==(3*P-3)) ||(ti==(3*P-4)))) {
S--;
counter++;
continue;
}
}
}
// System.out.println("Case #" + count + ": " + counter);
out.write("Case #" + count + ": " + counter + "\n");
}
fStream.close();
out.close();
}
}
| 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 +
'}';
}
}
|
B11327 | B11395 | 0 | package recycledNumbers;
public class OutputData {
private int[] Steps;
public int[] getSteps() {
return Steps;
}
public OutputData(int [] Steps){
this.Steps = Steps;
for(int i=0;i<this.Steps.length;i++){
System.out.println("Test "+(i+1)+": "+Steps[i]);
}
}
}
| /*
Author: Gaurav Gupta
Date: 14 Apr 2012
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Recycled {
/**
* TODO Put here a description of what this method does.
*
* @param args
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub.
FileWriter fw = new FileWriter("Output3.txt");
PrintWriter pw = new PrintWriter(fw);
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
int sum = 0;
int A, B;
for (int i = 0; i < T; i++) {
A = sc.nextInt();
B = sc.nextInt();
sum = 0;
for (int j = A; j <= B; j++) {
int n = j;
int m;
String ns = String.valueOf(n);
String ms;
int count = 0;
int found = 0;
int rep[] = new int[ns.length()];
for (int k = 0; k < ns.length(); k++) {
ms = ns.substring(k, ns.length()) + ns.substring(0, k);
m = Integer.parseInt(ms);
if (m > n && m >= A && m <= B) {
found = 0;
for (int l = 0; l < count; l++)
if (rep[l] == m) {
found = 1;
}
if (found == 0) {
rep[count] = m;
count++;
sum++;
// System.out.println(n + " " + m);
}
}
}
}
pw.println("Case #" + (i + 1) + ": " + sum);
System.out.println("Case #" + (i + 1) + ": " + sum);
}
pw.close();
}
}
|
B12115 | B10638 | 0 | package qual;
import java.util.Scanner;
public class RecycledNumbers {
public static void main(String[] args) {
new RecycledNumbers().run();
}
private void run() {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for (int t = 0; t < T; t++) {
int A = sc.nextInt();
int B = sc.nextInt();
int result = solve(A, B);
System.out.printf("Case #%d: %d\n", t + 1, result);
}
}
public int solve(int A, int B) {
int result = 0;
for (int i = A; i <= B; i++) {
int dig = (int) Math.log10(A/*same as B*/) + 1;
int aa = i;
for (int d = 0; d < dig - 1; d++) {
aa = (aa % 10) * (int)Math.pow(10, dig - 1) + (aa / 10);
if (i == aa) {
break;
}
if (i < aa && aa <= B) {
// System.out.printf("(%d, %d) ", i, aa);
result++;
}
}
}
return result;
}
}
| import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class C{
public static void main(String[] args) throws FileNotFoundException
{
Scanner sc = new Scanner(new File("C.txt"));
int testCase = Integer.parseInt(sc.nextLine());
for(int Case=1; Case<=testCase; Case++)
{
int total = 0;
int st = sc.nextInt();int en = sc.nextInt();
int len = (new Integer(st)).toString().length();
for(int i=en; i>=st;i--)
{
Set s = new HashSet();
for(int j=1; j<=len-1;j++)
{
String sam = (new Integer(i).toString());
//System.out.println(i+ "Actual String:" + sam);
StringBuffer temp=new StringBuffer();
//System.out.println("temp 1:"+temp.toString());
temp.append(sam.substring(j));
//System.out.println("temp 2:"+temp.toString());
temp.append(sam.substring(0, j));
//System.out.println("temp 3:"+temp.toString());
int num = Integer.parseInt(temp.toString());
if(num>=st && num<=en && num<i){s.add(num);}
}
total += s.size();
}
System.out.println("Case #"+Case+": "+total);
}
}
} |
B11318 | B11837 | 0 | import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t=sc.nextInt();
int casos=1, a, b, n, m, cont;
while(t!=0){
a=sc.nextInt();
b=sc.nextInt();
if(a>b){
int aux=a;
a=b;
b=aux;
}
System.out.printf("Case #%d: ",casos++);
if(a==b){
System.out.printf("%d\n",0);
}else{
cont=0;
for(n=a;n<b;n++){
for(m=n+1;m<=b;m++){
if(isRecycled(n,m)) cont++;
}
}
System.out.printf("%d\n",cont);
}
t--;
}
}
public static boolean isRecycled(int n1, int n2){
String s1, s2, aux;
s1 = String.valueOf( n1 );
s2 = String.valueOf( n2 );
boolean r = false;
for(int i=0;i<s1.length();i++){
aux="";
aux=s1.substring(i,s1.length())+s1.substring(0,i);
// System.out.println(aux);
if(aux.equals(s2)){
r=true;
break;
}
}
return r;
}
}
| import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
public class Numbers {
public static FileReader fr;
public static BufferedReader br;
public static FileWriter fw;
public static BufferedWriter bw;
public void read(String path) throws Exception
{
fr = new FileReader(path);
br=new BufferedReader(fr);
}
public void write(String path) throws Exception
{
}
public void execute(BufferedReader br,String path)throws Exception
{
String s;
fw =new FileWriter(path,false);
bw=new BufferedWriter(fw);
s=br.readLine();
int i1=1;
while((s=br.readLine())!=null)
{
int count =0;
String st[]=s.split("\\s");
int a=Integer.parseInt(st[0]);
int b=Integer.parseInt(st[1]);
for(int i=a;i<=b;i++)
{
int temp=i;
String abc=Integer.toString(temp);
int length=abc.length();
int index=length-1;
String tempString=abc;
while(index>0)
{
String first=tempString.substring(0, index);
String second=tempString.substring(index,length);
abc=second+first;
int newnumber=Integer.parseInt(abc);
if((newnumber<=b && newnumber>temp )&& !abc.startsWith("0") && (Integer.toString(temp).length())==abc.length())
count++;
index--;
}
}
bw.write("Case #"+ i1++ +": " +count +"\n");
}
bw.close();
fr.close();
}
public static void main(String[] args) throws Exception
{
Numbers t=new Numbers();
t.read("E:\\codejam\\Files\\A.in");
t.execute(br,"E:\\codejam\\Files\\A.out");
}
}
|
A20382 | A20695 | 0 | package dancinggooglers;
import java.io.File;
import java.util.Scanner;
public class DanceScoreCalculator {
public static void main(String[] args) {
if(args.length <= 0 || args[0] == null) {
System.out.println("You must enter a file to read");
System.out.println("Usage: blah <filename>");
System.exit(0);
}
File argFile = new File(args[0]);
try {
Scanner googleSpeakScanner = new Scanner(argFile);
String firstLine = googleSpeakScanner.nextLine();
Integer linesToScan = new Integer(firstLine);
for(int i = 1; i <= linesToScan; i++) {
String googleDancerLine = googleSpeakScanner.nextLine();
DanceScoreCase danceCase = new DanceScoreCase(googleDancerLine);
System.out.println(String.format("Case #%d: %d", i, danceCase.maxDancersThatCouldPass()));
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
| package quiz.number05;
import java.io.*;
import java.util.Arrays;
/**
* @author Keesun Baik
*/
public class KeesunDancingTest {
public static void main(String[] args) throws IOException {
KeesunDancingTest dancing = new KeesunDancingTest();
BufferedReader in = new BufferedReader(new FileReader("/workspace/telepathy/test/quiz/number05/B-large.in"));
String s;
int lineNum = 0;
int problemNum = 0;
String answer = "";
while ((s = in.readLine()) != null) {
if (s.isEmpty()) {
return;
}
if (lineNum == 0) {
problemNum = Integer.parseInt(s);
} else {
answer += "Case #" + lineNum + ": " + dancing.figureP(s) + "\n";
}
lineNum++;
}
in.close();
System.out.println(answer);
BufferedWriter out = new BufferedWriter(new FileWriter("/workspace/telepathy/test/quiz/number05/B-large.out"));
out.write(answer);
out.close();
}
private int figureP(String s) {
String[] inputs = s.split(" ");
int people = Integer.parseInt(inputs[0]);
int surprise = Integer.parseInt(inputs[1]);
int minScore = Integer.parseInt(inputs[2]);
String[] scoreStrings = Arrays.copyOfRange(inputs, 3, inputs.length);
int[] scores = new int[scoreStrings.length];
for (int i = 0; i < scoreStrings.length; i++) {
scores[i] = Integer.parseInt(scoreStrings[i]);
}
int cases = 0;
for (int score : scores) {
int base = score / 3;
switch (score % 3) {
case 0: {
System.out.println("0");
if (base >= minScore) {
cases++;
} else if (surprise > 0 && base > 0 && base + 1 >= minScore) {
cases++;
surprise--;
}
break;
}
case 1: {
System.out.println("1");
if (base >= minScore || base + 1 >= minScore) {
cases++;
} else if (surprise > 0 && base + 1 >= minScore) {
cases++;
surprise--;
}
break;
}
case 2: {
System.out.println("2");
if (base + 1 >= minScore || base >= minScore) {
cases++;
} else if (surprise > 0 && base + 2 >= minScore) {
cases++;
surprise--;
}
break;
}
}
}
return cases;
}
}
|
B10245 | B10262 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package recyclednumbers;
import java.util.HashSet;
/**
*
* @author vandit
*/
public class RecycleNumbers {
private HashSet<String> numbers = new HashSet<String>();
private HashSet<String> initialTempNumbers = new HashSet<String>();
private HashSet<String> finalTempNumbers = new HashSet<String>();
HashSet<Pair> numberPairs = new HashSet<Pair>();
private void findRecycledNumbers(int start, int end, int places) {
for (int i = start; i <= end; i++) {
String initialNumber = Integer.toString(i);
//if (!(numbers.contains(initialNumber) || finalTempNumbers.contains(initialNumber))) {
StringBuffer tempNumber = new StringBuffer(initialNumber);
int len = tempNumber.length();
int startIndexToMove = len - places;
String tempString = tempNumber.substring(startIndexToMove);
if ((places == 1 && tempString.equals("0")) || tempString.charAt(0) == '0') {
continue;
}
tempNumber.delete(startIndexToMove, len);
String finalTempNumber = tempString + tempNumber.toString();
if (! (finalTempNumber.equals(initialNumber) || Integer.parseInt(finalTempNumber) > end || Integer.parseInt(finalTempNumber) < Integer.parseInt(initialNumber))) {
numbers.add(initialNumber);
finalTempNumbers.add(finalTempNumber);
Pair pair = new Pair(finalTempNumber,initialNumber);
numberPairs.add(pair);
}
}
}
public HashSet<Pair> findAllRecycledNumbers(int start, int end) {
int length = Integer.toString(start).length();
for (int i = 1; i < length; i++) {
findRecycledNumbers(start, end, i);
}
return numberPairs;
}
}
| package core;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public abstract class Template {
/************* TO BE IMPLEMENTED ******************************************/
public abstract void feedData(ExtendedBufferedReader iR);
public abstract StringBuffer applyMethods();
/**************************************************************************/
public void readData(File iFile){
try {
FileReader aReader = new FileReader(iFile);
ExtendedBufferedReader aBufferedReader = new ExtendedBufferedReader(aReader);
feedData(aBufferedReader);
aBufferedReader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void writeResult(File iFile,StringBuffer iResult){
System.out.println(iResult.toString());
try {
FileWriter aWriter = new FileWriter(iFile);
aWriter.write(iResult.toString());
aWriter.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void play(String[] args) {
if (args.length>1) {
File aFile = new File(args[0]);
readData(aFile);
StringBuffer result = applyMethods();
File aResultFile= new File(args[1]);
writeResult(aResultFile,result);
} else {
System.out.println("Your a bastard ! missing argument !");
}
}
}
|
B12941 | B10807 | 0 | package com.menzus.gcj._2012.qualification.c;
import com.menzus.gcj.common.InputBlockParser;
import com.menzus.gcj.common.OutputProducer;
import com.menzus.gcj.common.impl.AbstractProcessorFactory;
public class CProcessorFactory extends AbstractProcessorFactory<CInput, COutputEntry> {
public CProcessorFactory(String inputFileName) {
super(inputFileName);
}
@Override
protected InputBlockParser<CInput> createInputBlockParser() {
return new CInputBlockParser();
}
@Override
protected OutputProducer<CInput, COutputEntry> createOutputProducer() {
return new COutputProducer();
}
}
| package codejam;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class RecycledPairs {
private static String filename = "C-small-attempt0.in";
public static boolean isRecycledPair(int n, int m) {
String sn = Integer.toString(n);
String sm = Integer.toString(m);
int length = sn.length();
String shiftedString = "";
for (int i = 1; i <= length; i++) {
shiftedString = sn.substring(i, length) + sn.substring(0, i);
//System.out.println(shiftedString + " " + sn + " " + sm);
if (shiftedString.equals(sm)) return true;
}
return false;
}
public static int recycledPairs(int A, int B) {
int acc = 0;
for (int n = A, m; n < B; n++) {
m = n + 1;
for (; m <= B; m++) {
if (isRecycledPair(n, m)) acc++;
}
}
return acc;
}
public static void main(String[] args) {;
try {
BufferedReader in = new BufferedReader(new FileReader(filename));
BufferedWriter out = new BufferedWriter(new FileWriter(filename + ".out"));
String currentString = in.readLine();
int testCases = Integer.parseInt(currentString);
for (int i = 1; i <= testCases; i++) {
String[] input = in.readLine().split(" ");
int A = Integer.parseInt(input[0]);
int B = Integer.parseInt(input[1]);
int result = recycledPairs(A, B);
out.write("Case #" + i + ": " + result + '\n');
}
out.close();
in.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
|
B10858 | B12448 | 0 | package be.mokarea.gcj.common;
public abstract class TestCaseReader<T extends TestCase> {
public abstract T nextCase() throws Exception;
public abstract int getMaxCaseNumber();
}
| package qual;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public class C {
public static int[] prepare(int m, int base, int k){
int[] res = new int[m];
for (int i = 0; i < m; i++){
int rest = k % 10;
k /= 10;
k += rest * base;
res[i] = k;
}
return res;
}
public static void main(String[] args) throws Exception{
String in_file = "q/c/s_in.txt";
String out_file = in_file.replace("_in.txt", "_out.txt");
BufferedReader in = new BufferedReader(new FileReader(in_file));
BufferedWriter out = new BufferedWriter(new FileWriter(out_file));
int n = Integer.parseInt(in.readLine());
for (int i = 1; i <= n; i++){
String[] s = in.readLine().split(" ");
int a = Integer.parseInt(s[0]);
int b = Integer.parseInt(s[1]);
int count = 0;
int base = 1;
int m = 0;
while (base * 10 <= a) {
base *= 10;
m++;
}
for (int k = a; k < b; k++){
int[] prob = prepare(m, base, k);
for (int p : prob){
if (p > k && p <= b) count++;
}
}
out.write("Case #" + i + ": " + count + "\n");
}
in.close();
out.close();
}
}
|
A12570 | A12911 | 0 | package util.graph;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Set;
public class DynDjikstra {
public static State FindShortest(Node start, Node target) {
PriorityQueue<Node> openSet = new PriorityQueue<>();
Set<Node> closedSet = new HashSet<>();
openSet.add(start);
while (!openSet.isEmpty()) {
Node current = openSet.poll();
for (Edge edge : current.edges) {
Node end = edge.target;
if (closedSet.contains(end)) {
continue;
}
State newState = edge.travel(current.last);
//if (end.equals(target)) {
//return newState;
//}
if (openSet.contains(end)) {
if (end.last.compareTo(newState)>0) {
end.last = newState;
}
} else {
openSet.add(end);
end.last = newState;
}
}
closedSet.add(current);
if (closedSet.contains(target)) {
return target.last;
}
}
return target.last;
}
}
| package com.menzus.gcj._2012.qualification.b;
import com.menzus.gcj.common.OutputEntry;
public class BOutputEntry implements OutputEntry {
private int maximumGooglersNumber;
public void setMaximumGooglersNumber(int maximumGooglersNumber) {
this.maximumGooglersNumber = maximumGooglersNumber;
}
@Override
public String formatOutput() {
return Integer.toString(maximumGooglersNumber);
}
}
|
A11277 | A13003 | 0 | package googlers;
import java.util.Scanner;
import java.util.PriorityQueue;
import java.util.Comparator;
public class Googlers {
public static void main(String[] args) {
int n,s,p,count=0,t;
Scanner sin=new Scanner(System.in);
t=Integer.parseInt(sin.nextLine());
int result[]=new int[t];
int j=0;
if(t>=1 && t<=100)
{
for (int k = 0; k < t; k++) {
count=0;
String ip = sin.nextLine();
String[]tokens=ip.split(" ");
n=Integer.parseInt(tokens[0]);
s=Integer.parseInt(tokens[1]);
p=Integer.parseInt(tokens[2]);
if( (s>=0 && s<=n) && (p>=0 && p<=10) )
{
int[] total=new int[n];
for (int i = 0; i < n; i++)
{
total[i] = Integer.parseInt(tokens[i+3]);
}
Comparator comparator=new PointComparator();
PriorityQueue pq=new PriorityQueue<Point>(1, comparator);
for (int i = 0; i < n; i++)
{
int x=total[i]/3;
int r=total[i]%3;
if(x>=p)
count++;
else if(x<(p-2))
continue;
else
{
//System.out.println("enter "+x+" "+(p-2));
if(p-x==1)
{
Point temp=new Point();
temp.q=x;
temp.r=r;
pq.add(temp);
}
else // p-x=2
{
if(r==0)
continue;
else
{
Point temp=new Point();
temp.q=x;
temp.r=r;
pq.add(temp);
}
}
}
//System.out.println("hi "+pq.size());
}
while(pq.size()!=0)
{
Point temp=(Point)pq.remove();
if(p-temp.q==1 && temp.q!=0)
{
if(temp.r>=1)
count++;
else
{
if(s!=0)
{
s--;
count++;
}
}
}
else if(p-temp.q==2)
{
if(s!=0 && (temp.q+temp.r)>=p)
{
s--;
count++;
}
}
}
//System.out.println(p);
result[j++]=count;
}
}
for (int i = 0; i < t; i++)
{
System.out.println("Case #"+(i+1)+": "+result[i]);
}
}
}
/*Point x=new Point();
x.q=8;
Point y=new Point();
y.q=6;
Point z=new Point();
z.q=7;
pq.add(x);
pq.add(y);
pq.add(z);
*/
}
class PointComparator implements Comparator<Point>
{
@Override
public int compare(Point x, Point y)
{
// Assume neither string is null. Real code should
// probably be more robust
if (x.q < y.q)
{
return 1;
}
if (x.q > y.q)
{
return -1;
}
return 0;
}
}
class Point
{
int q,r;
public int getQ() {
return q;
}
public void setQ(int q) {
this.q = q;
}
public int getR() {
return r;
}
public void setR(int r) {
this.r = r;
}
}
| package codejam;
public class Dancer extends CodeJam{
public Dancer() {
super("B-small-attempt0");
}
public static void main(String[] args) {
new Dancer().run();
}
@Override
protected String solve() {
int n = scanner.nextInt();
int s = scanner.nextInt();
int p = scanner.nextInt();
if (p == 0){
scanner.nextLine();
return n + "";
}
if (p == 1){
s = 0;
}
int sum = 3*p - 2;
int sum2 = 3*p - 4;
int count = 0;
for (int i = 0 ; i < n ; i++){
int v = scanner.nextInt();
if (v >= sum){
count++;
} else if (v >= sum2 && s-- > 0){
count++;
}
}
return count + "";
}
}
|
B11318 | B12113 | 0 | import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t=sc.nextInt();
int casos=1, a, b, n, m, cont;
while(t!=0){
a=sc.nextInt();
b=sc.nextInt();
if(a>b){
int aux=a;
a=b;
b=aux;
}
System.out.printf("Case #%d: ",casos++);
if(a==b){
System.out.printf("%d\n",0);
}else{
cont=0;
for(n=a;n<b;n++){
for(m=n+1;m<=b;m++){
if(isRecycled(n,m)) cont++;
}
}
System.out.printf("%d\n",cont);
}
t--;
}
}
public static boolean isRecycled(int n1, int n2){
String s1, s2, aux;
s1 = String.valueOf( n1 );
s2 = String.valueOf( n2 );
boolean r = false;
for(int i=0;i<s1.length();i++){
aux="";
aux=s1.substring(i,s1.length())+s1.substring(0,i);
// System.out.println(aux);
if(aux.equals(s2)){
r=true;
break;
}
}
return r;
}
}
| package com.renoux.gael.codejam.fwk;
import java.io.File;
import com.renoux.gael.codejam.utils.FluxUtils;
import com.renoux.gael.codejam.utils.Input;
import com.renoux.gael.codejam.utils.Output;
import com.renoux.gael.codejam.utils.Timer;
public abstract class Solver {
public void run() {
Timer.start();
if (!disableSample())
runOnce(getSampleInput(), getSampleOutput());
System.out.println(Timer.check());
Timer.start();
if (!disableSmall())
runOnce(getSmallInput(), getSmallOutput());
System.out.println(Timer.check());
Timer.start();
if (!disableLarge())
runOnce(getLargeInput(), getLargeOutput());
System.out.println(Timer.check());
}
public void runOnce(String pathIn, String pathOut) {
Input in = null;
Output out = null;
try {
in = Input.open(getFile(pathIn));
out = Output.open(getFile(pathOut));
int countCases = Integer.parseInt(in.readLine());
for (int k = 1; k <= countCases; k++) {
out.write("Case #", k, ": ");
solveCase(in, out);
}
} catch (RuntimeException e) {
e.printStackTrace();
} finally {
FluxUtils.closeCloseables(in, out);
}
}
private File getFile(String path) {
return new File(path);
}
protected abstract void solveCase(Input in, Output out);
private String getFullPath(boolean input, String type) {
if (input)
return "D:\\Downloads\\CodeJam\\" + getProblemName() + "\\"
+ getProblemName() + "_input_" + type + ".txt";
else
return "D:\\Downloads\\CodeJam\\" + getProblemName() + "\\"
+ getProblemName() + "_output_" + type + ".txt";
}
protected String getSampleInput() {
return getFullPath(true, "sample");
}
protected String getSmallInput() {
return getFullPath(true, "small");
}
protected String getLargeInput() {
return getFullPath(true, "large");
}
protected String getSampleOutput() {
return getFullPath(false, "sample");
}
protected String getSmallOutput() {
return getFullPath(false, "small");
}
protected String getLargeOutput() {
return getFullPath(false, "large");
}
protected boolean disableSample() {
return disable()[0];
}
protected boolean disableSmall() {
return disable()[1];
}
protected boolean disableLarge() {
return disable()[2];
}
protected boolean[] disable() {
return new boolean[] { false, false, false };
}
protected abstract String getProblemName();
}
|
B20566 | B20183 | 0 | import java.util.Scanner;
import java.io.*;
import java.lang.Math;
public class C{
public static int recycle(String str){
String[] numbers = str.split(" ");
int min = Integer.parseInt(numbers[0]);
int max = Integer.parseInt(numbers[1]);
int ret = 0;
for(int i = min; i < max; i++){
String num = i + "";
int len = num.length();
int k = i;
for(int j = 1; j < len; j++){
k = (k/10) + (int)java.lang.Math.pow(10.0,(double)(len-1))*(k%10);
if (k > i && k <= max)
ret++;
else if(k == i)
break;
}
}
return ret;
}
public static void main(String[] args){
Scanner sc = null;
String next;
int out;
try{
sc = new Scanner(new File("C-large.in"));
int cases = Integer.parseInt(sc.nextLine());
int current = 0;
FileWriter fs = new FileWriter("output.txt");
BufferedWriter buff = new BufferedWriter(fs);
while(current < cases){
next = sc.nextLine();
current++;
out = recycle(next);
buff.write("Case #" + current + ": " + out + "\n");
}
buff.close();
}
catch(Exception ex){}
}
} | import java.io.*;
import java.util.*;
import java.text.*;
public class Main implements Runnable{
/**
* @param args
*/
private StringTokenizer stReader;
private BufferedReader bufReader;
private PrintWriter out;
public static void main(String[] args) {
// TODO Auto-generated method stub
(new Main()).run();
}
@Override
public void run() {
// TODO Auto-generated method stub
bufReader = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new OutputStreamWriter(System.out));
stReader = null;
Solves();
out.flush();
}
public String ReadLine() {
String result = null;
try {
result = bufReader.readLine();
} catch (IOException e) {
}
return result;
}
public String NextString(){
if (stReader == null || !stReader.hasMoreTokens()){
stReader = new StringTokenizer(ReadLine(),"\n\r ");
}
return stReader.nextToken();
}
public int NextInt(){
return Integer.parseInt(NextString());
}
public long NextLong(){
return Long.parseLong(NextString());
}
public double NextDouble(){
return Double.parseDouble(NextString());
}
void Solves(){
int n = NextInt();
for(int i =0; i < n; i++){
out.print("Case #" +(i + 1) + ": ");
Solve();
out.println();
}
out.flush();
}
void Solve(){
int A = NextInt();
int B = NextInt();
int result = 0;
TreeSet<Integer> treeSet = new TreeSet<Integer>();
for(int i = A; i <=B; i++){
if (i <= 10) continue;
StringBuilder parse = new StringBuilder(String.valueOf(i));
treeSet.clear();
for(int j =0;j < parse.length(); j++){
int val = Shift(parse);
if (val > i && val <= B && !treeSet.contains(val)) {
result++;
treeSet.add(val);
}
}
treeSet.clear();
}
out.print(result);
}
int Shift(StringBuilder parse){
char last = parse.charAt(parse.length()-1);
parse = parse.deleteCharAt(parse.length()-1);
parse = parse.insert(0, last);
return Integer.valueOf(parse.toString());
}
}
|
A21557 | A23051 | 0 | import java.io.*;
import java.util.*;
public class DancingWithGooglers {
public static class Googlers {
public int T;
public int surp;
public boolean surprising;
public boolean pSurprising;
public boolean antiSurprising;
public boolean pAntiSurprising;
public Googlers(int T, int surp) {
this.T = T;
this.surp = surp;
}
public void set(int a, int b, int c) {
if (c >= 0 && (a + b + c) == T) {
int diff = (Math.max(a, Math.max(b, c)) - Math.min(a, Math.min(b, c)));
if (diff <= 2) {
if (diff == 2) {
if (a >= surp || b >= surp || c >= surp) {
pSurprising = true;
} else {
surprising = true;
}
} else {
if (a >= surp || b >= surp || c >= surp) {
pAntiSurprising = true;
} else {
antiSurprising = true;
}
}
}
}
}
}
public static void main(String... args) throws IOException {
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedReader reader = new BufferedReader(new FileReader("B-large.in"));
// PrintWriter writer = new PrintWriter(System.out);
PrintWriter writer = new PrintWriter("B-large.out");
int len, cases = Integer.parseInt(reader.readLine());
List<Googlers> satisfied = new ArrayList<Googlers>();
List<Googlers> unsatisfied = new ArrayList<Googlers>();
String[] inputs;
int N, S, p;
for (int i = 1; i <= cases; i++) {
inputs = reader.readLine().split(" ");
p = Integer.parseInt(inputs[1]);
S = Integer.parseInt(inputs[2]);
satisfied.clear();
unsatisfied.clear();
for (int j = 3; j < inputs.length; j++) {
int t = Integer.parseInt(inputs[j]);
Googlers googlers = new Googlers(t, S);
for (int k = 0; k <= 10; k++) {
int till = k + 2 > 10 ? 10 : k + 2;
for (int l = k; l <= till; l++) {
googlers.set(k, l, (t - (k + l)));
}
}
if (googlers.pAntiSurprising) {
satisfied.add(googlers);
} else {
unsatisfied.add(googlers);
}
}
int pSurprising = 0;
if (p > 0) {
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
pSurprising++;
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
iter.remove();
pSurprising++;
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
writer.print("Case #" + i + ": 0");
}else {
writer.print("Case #" + i + ": " + (satisfied.size() + pSurprising));
}
writer.println();
}
writer.flush();
}
}
| package dancing;
import java.io.BufferedReader;
import java.io.FileReader;
public class MaxScoreDetector {
/**
* @param args
*/
public static void main(String[] args) {
String fileName = null;
if(args.length == 1){
fileName = args[0];
}else{
System.err.println("Requires a command line argument: fileName");
System.exit(1);
};
new MaxScoreDetector(fileName);
}
public MaxScoreDetector(String fileName){
try{
BufferedReader in = new BufferedReader(new FileReader(fileName));
int cases = Integer.parseInt(in.readLine());
for(int i=0; i<cases; i++){
String[] line = in.readLine().split(" ");
int numScores = Integer.parseInt(line[0]);
int specials = Integer.parseInt(line[1]);
int min = Integer.parseInt(line[2]);
int[] scores = new int[numScores];
for(int j=0; j<scores.length; j++){
scores[j] = Integer.parseInt(line[j+3]);
}
System.out.println("Case #" + (i+1) + ": " + testScores(scores, min, specials));
}
}catch(Exception e){
e.printStackTrace();
}
}
public int testScores(int[] scores, int min, int specials){
int over = specials;
int count = 0;
for(int i=0; i<scores.length; i++){
if(scores[i] < min) continue;
double avg = scores[i]/3.;
if(avg >= min || Math.ceil(avg)>=min){
count++;
continue;
}
if(Math.round(avg) == (int)avg + 1 && Math.round(avg) + 1 >= min && over > 0){
count++;
over--;
continue;
}
if(avg == (int)avg && avg + 1 >= min && over > 0){
over--;
count++;
continue;
}
}
return count;
}
}
|
A20382 | A21672 | 0 | package dancinggooglers;
import java.io.File;
import java.util.Scanner;
public class DanceScoreCalculator {
public static void main(String[] args) {
if(args.length <= 0 || args[0] == null) {
System.out.println("You must enter a file to read");
System.out.println("Usage: blah <filename>");
System.exit(0);
}
File argFile = new File(args[0]);
try {
Scanner googleSpeakScanner = new Scanner(argFile);
String firstLine = googleSpeakScanner.nextLine();
Integer linesToScan = new Integer(firstLine);
for(int i = 1; i <= linesToScan; i++) {
String googleDancerLine = googleSpeakScanner.nextLine();
DanceScoreCase danceCase = new DanceScoreCase(googleDancerLine);
System.out.println(String.format("Case #%d: %d", i, danceCase.maxDancersThatCouldPass()));
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
| package com.google.codejam.p2;
import java.util.ArrayList;
public class TestCase {
public int N,S,p;
public ArrayList<Integer> scores;
public TestCase(int N, int S, int p, ArrayList<Integer> scores) {
this.N = N;
this.S = S;
this.p = p;
this.scores = scores;
}
}
|
B12941 | B10322 | 0 | package com.menzus.gcj._2012.qualification.c;
import com.menzus.gcj.common.InputBlockParser;
import com.menzus.gcj.common.OutputProducer;
import com.menzus.gcj.common.impl.AbstractProcessorFactory;
public class CProcessorFactory extends AbstractProcessorFactory<CInput, COutputEntry> {
public CProcessorFactory(String inputFileName) {
super(inputFileName);
}
@Override
protected InputBlockParser<CInput> createInputBlockParser() {
return new CInputBlockParser();
}
@Override
protected OutputProducer<CInput, COutputEntry> createOutputProducer() {
return new COutputProducer();
}
}
| package sebastianco;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.HashSet;
import java.util.Set;
public class RecycledNumbers {
public static void main(String[] args) throws Exception {
BufferedReader reader = null;
BufferedWriter writer = null;
try {
reader = new BufferedReader(new FileReader(new File(args[0])));
writer = new BufferedWriter(new FileWriter(new File(args[1])));
final int nrOfTestCases = Integer.valueOf(reader.readLine());
String lineSepartor = "";
for (int i = 1; i <= nrOfTestCases; i++) {
writer.write(lineSepartor);
writer.write(String.format("Case #%d: %d",
i, new TestCase(reader.readLine()).computePairs()));
lineSepartor = "\n";
}
} finally {
if (writer != null) {
writer.flush();
writer.close();
}
reader.close();
}
}
public static class TestCase {
private int a;
private int b;
public TestCase(String caseLine) {
String[] tokens = caseLine.split(" ");
a = Integer.parseInt(tokens[0]);
b = Integer.parseInt(tokens[1]);
}
public int computePairs() {
Set<String> distinctPairs = new HashSet<String>();
final String strB = String.valueOf(b);
final int maxRotations = strB.length() - 1;
int recycledPairs = 0;
for (int i = a; i < b; i++) {
String strI = String.valueOf(i); // System.out.println("==" + strI);
StringBuilder number = new StringBuilder(strI);
for (int j = 1; j <= maxRotations; j++) {
rotate(number);
String strNumber = number.toString();
if (strI.compareTo(strNumber) < 0
&& strNumber.compareTo(strB) <= 0) {
if (distinctPairs.add(strI + strNumber)) {
recycledPairs++; // System.out.println(strNumber);
}
}
}
}
return recycledPairs;
}
private void rotate(StringBuilder number) {
char c = number.charAt(number.length() - 1);
for (int i = number.length() - 1; i > 0; i--) {
number.setCharAt(i, number.charAt(i-1));
}
number.setCharAt(0, c);
}
}
}
|
B10361 | B10927 | 0 | package codejam;
import java.util.*;
import java.io.*;
public class RecycledNumbers {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("in.txt"));
PrintWriter out = new PrintWriter(new File("out.txt"));
int T = Integer.parseInt(in.readLine());
for (int t = 1; t <= T; ++t) {
String[] parts = in.readLine().split("[ ]+");
int A = Integer.parseInt(parts[0]);
int B = Integer.parseInt(parts[1]);
int cnt = 0;
for (int i = A; i < B; ++i) {
String str = String.valueOf(i);
int n = str.length();
String res = "";
Set<Integer> seen = new HashSet<Integer>();
for (int j = n - 1; j > 0; --j) {
res = str.substring(j) + str.substring(0, j);
int k = Integer.parseInt(res);
if (k > i && k <= B) {
//System.out.println("(" + i + ", " + k + ")");
if (!seen.contains(k)) {
++cnt;
seen.add(k);
}
}
}
}
out.println("Case #" + t + ": " + cnt);
}
in.close();
out.close();
System.exit(0);
}
}
| /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam.y12.round0;
import utils.Jam;
import utils.JamCase;
/**
*
* @author fabien
*/
public class DancingGooglers extends Jam {
public DancingGooglers(String filename) {
super(filename);
}
@Override
public JamCase getJamCase(int number) {
return new Line(this, number, lines[number]);
}
private class Line extends JamCase {
private String line;
private int s;
private int p;
private int[] scores;
public Line(Jam parent, int number, String line) {
super(parent, number);
this.line = line;
}
@Override
public void parse() {
String[] integers = line.split(" ");
scores = new int[Integer.parseInt(integers[0])];
s = Integer.parseInt(integers[1]);
p = Integer.parseInt(integers[2]);
int j = 0;
for (int i = 3; i < integers.length; i++) {
scores[j++] = Integer.parseInt(integers[i]);
}
}
@Override
public void solve() {
int r = 0;
if (p == 0) {
r = scores.length;
} else {
float average = 0;
float pnor = p - 1;
float psus = p - 1.4f;
for (int score : scores) {
if (score > 0) {
average = score / 3.0f;
if (average > pnor) {
r++;
} else if (s > 0 && average >= psus) {
r++;
s--;
}
}
}
}
result = Integer.toString(r);
}
}
}
|
A20382 | A22806 | 0 | package dancinggooglers;
import java.io.File;
import java.util.Scanner;
public class DanceScoreCalculator {
public static void main(String[] args) {
if(args.length <= 0 || args[0] == null) {
System.out.println("You must enter a file to read");
System.out.println("Usage: blah <filename>");
System.exit(0);
}
File argFile = new File(args[0]);
try {
Scanner googleSpeakScanner = new Scanner(argFile);
String firstLine = googleSpeakScanner.nextLine();
Integer linesToScan = new Integer(firstLine);
for(int i = 1; i <= linesToScan; i++) {
String googleDancerLine = googleSpeakScanner.nextLine();
DanceScoreCase danceCase = new DanceScoreCase(googleDancerLine);
System.out.println(String.format("Case #%d: %d", i, danceCase.maxDancersThatCouldPass()));
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
| /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Madu
*/
import java.io.*;
public class Ex2 {
public static void main(String[] args) {
try{
FileInputStream fstream = new FileInputStream("C:/Users/Madu/Documents/NetBeansProjects/CodeJamR1Ex1/input/A-small-attempt0.in");
FileOutputStream fout = new FileOutputStream ("C:/Users/Madu/Documents/NetBeansProjects/CodeJamR1Ex1/output/out.txt");
PrintStream printStream = new PrintStream(fout);
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String inputIlne;
br.readLine();
//printStream.println ("Output");
//Read File Line By Line
int lineNum = 1;
while ((inputIlne = br.readLine()) != null) {
// Print the content on the console
//##########
String[] marks = inputIlne.split(" ");
int peopleCount = Integer.parseInt(marks[0].toString());
int s = Integer.parseInt(marks[1].toString());
int p = Integer.parseInt(marks[2].toString());
int ans = 0;
for (int i = 3; i < marks.length; i++) {
System.out.println(marks[i]);
int total = Integer.parseInt(marks[i].toString());
int value = total/3;
int reminder = total%3;
if(total==0){
if(p==0){ans++;}
continue;}
if(reminder==0){
if(value>=p){ans++;}
else if(value+1>=p){
if(s>=1){ans++; s--;
}
}
}
else if(reminder==1){
if(value>=p){ans++;}
else if(value+1>=p){ans++;}
}
else if(reminder==2){
if(value>=p){ans++;}
else if(value+1>=p){ans++;}
else if(value+2>=p){
if(s>=1){ans++; s--;}
}
}
}
printStream.print ("Case #"+lineNum+": "+ans);lineNum++;
//###########
printStream.println("");
}
//Close the input stream
in.close();
}catch (Exception e){//Catch exception if any
System.err.println("Error: " + e.toString());
}
}
// public static void main(String[] args) {
//
// String test = "2 1 1 8 0";
// int peopleCount = Integer.parseInt(test.substring(0, 1));
// int s = Integer.parseInt(test.substring(2, 3));
// int p = Integer.parseInt(test.substring(4, 5));
//
// int ans = 0;
//
// //System.out.println(p);
//
// String[] marks = (test.substring(6)).split(" ");
//
//
//
// for (int i = 0; i < marks.length; i++) {
//
// System.out.println(marks[i]);
// int total = Integer.parseInt(marks[i].toString());
//
// int value = total/3;
// int reminder = total%3;
//
// if(total==0){continue;}
//
// if(reminder==0){
//
// if(value>=p){ans++;}
// else if(value+1>=p){
//
// if(s>=1){ans++; s--;
// }
//
// }
//
// }
//
// else if(reminder==1){
//
// if(value>=p){ans++;}
// else if(value+1>=p){ans++;}
//
// }
//
// else if(reminder==2){
//
// if(value>=p){ans++;}
// else if(value+1>=p){ans++;}
// else if(value+2>=p){
//
// if(s>=1){ans++; s--;}
// }
//
// }
//
// }
//
//
//
// System.out.println("Answer :"+ans);
//
// }
}
|
B12669 | B11199 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package year_2012.qualification;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
/**
*
* @author paul
* @date 14 Apr 2012
*/
public class QuestionC {
private static Set<Integer> getCycle(int x) {
String s = Integer.toString(x);
Set<Integer> set = new HashSet<Integer>();
set.add(x);
for (int c = 1; c < s.length(); c++) {
String t = s.substring(c).concat(s.substring(0, c));
set.add(Integer.parseInt(t));
}
return set;
}
private static Set<Integer> mask(Set<Integer> set, int a, int b) {
Set<Integer> result = new HashSet<Integer>();
for (int x : set) {
if (x >= a && x <= b) {
result.add(x);
}
}
return result;
}
public static void main(String[] args) throws FileNotFoundException, IOException {
String question = "C";
// String name = "large";
String name = "small-attempt0";
// String name = "test";
String filename = String.format("%s-%s", question, name);
BufferedReader input = new BufferedReader(
new FileReader(String.format("/home/paul/Documents/code-jam/2012/qualification/%s.in",
filename)));
String firstLine = input.readLine();
PrintWriter pw = new PrintWriter(new File(
String.format("/home/paul/Documents/code-jam/2012/qualification/%s.out", filename)));
int T = Integer.parseInt(firstLine);
// Loop through test cases.
for (int i = 0; i < T; i++) {
// Read data.
String[] tokens = input.readLine().split(" ");
// int N = Integer.parseInt(input.readLine());
int A = Integer.parseInt(tokens[0]);
int B = Integer.parseInt(tokens[1]);
// System.out.format("%d, %d\n", A, B);
boolean[] used = new boolean[B+1];
int total = 0;
for (int n = A; n <= B; n++) {
if (!used[n]) {
Set<Integer> set = mask(getCycle(n), A, B);
int k = set.size();
total += (k * (k-1))/2;
for (int m : set) {
used[m] = true;
}
}
}
pw.format("Case #%d: %d\n", i + 1, total);
}
pw.close();
}
}
| import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class RecycledNumbers {
public static void readInput(String pFileName, List<String> pInputCases) {
File tFile = new File(pFileName);
try {
BufferedReader tBufferedReader = new BufferedReader(
new InputStreamReader(new FileInputStream(tFile)), 4096);
String tLineRead = tBufferedReader.readLine().trim();
int tCaseSize = Integer.valueOf(tLineRead);
int tLineIndex = 0;
while(tLineIndex < tCaseSize) {
tLineRead = tBufferedReader.readLine().trim();
pInputCases.add(tLineRead);
tLineIndex++;
}
} catch(FileNotFoundException pException) {
pException.printStackTrace();
} catch(IOException pException) {
pException.printStackTrace();
}
}
public static void main(String[] pArgs) {
if(pArgs.length == 0) {
System.out.println("no input");
return;
}
List<String> tInputCases = new ArrayList<String>();
readInput(pArgs[0], tInputCases);
for(int tCaseIndex = 0; tCaseIndex < tInputCases.size(); tCaseIndex++) {
String[] tInputs = tInputCases.get(tCaseIndex).split("[ ]+");
int tLower = Integer.valueOf(tInputs[0]);
int tUpper = Integer.valueOf(tInputs[1]);
int tPairs = 0;
Map<String, Integer> tMapPairs = new HashMap<String, Integer>();
for(int tNumber = tLower; tNumber < tUpper; ++tNumber) {
int tLength = String.valueOf(tNumber).length();
int tHighUnit = 1;
for(int i = 0; i < tLength - 1; ++i) {
tHighUnit *= 10;
}
int tValue = tNumber;
int[] tValues = new int[tLength];
tValues[0] = tNumber;
for(int i = 1; i < tLength; ++i) {
int tHead = tValue / tHighUnit;
int tTail = tValue - tHead * tHighUnit;
int tNewValue = tTail * 10 + tHead;
tValues[i] = tNewValue;
tValue = tNewValue;
}
for(int i = 0; i < tLength - 1; ++i) {
for(int j = i + 1; j < tLength; ++j) {
int tOldValue = tValues[i];
int tNewValue = tValues[j];
String tKey = tOldValue + "-" + tNewValue;
if((tOldValue < tNewValue) && (tLower <= tOldValue)
&& (tNewValue <= tUpper) && (tOldValue != tNewValue)) {
if(!tMapPairs.containsKey(tKey)) {
++tPairs;
tMapPairs.put(tKey, 1);
}
}
}
}
}
System.out.println("Case #" + (tCaseIndex + 1) + ": " + tPairs);
}
}
}
|
A12113 | A12454 | 0 | import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class B {
static int[][] memo;
static int[] nums;
static int p;
public static void main(String[] args)throws IOException
{
Scanner br=new Scanner(new File("B-small-attempt0.in"));
PrintWriter out=new PrintWriter(new File("b.out"));
int cases=br.nextInt();
for(int c=1;c<=cases;c++)
{
int n=br.nextInt(),s=br.nextInt();
p=br.nextInt();
nums=new int[n];
for(int i=0;i<n;i++)
nums[i]=br.nextInt();
memo=new int[n][s+1];
for(int[] a:memo)
Arrays.fill(a,-1);
out.printf("Case #%d: %d\n",c,go(0,s));
}
out.close();
}
public static int go(int index,int s)
{
if(index>=nums.length)
return 0;
if(memo[index][s]!=-1)
return memo[index][s];
int best=0;
for(int i=0;i<=10;i++)
{
int max=i;
for(int j=0;j<=10;j++)
{
if(Math.abs(i-j)>2)
continue;
max=Math.max(i,j);
thisone:
for(int k=0;k<=10;k++)
{
int ret=0;
if(Math.abs(i-k)>2||Math.abs(j-k)>2)
continue;
max=Math.max(max,k);
int count=0;
if(Math.abs(i-k)==2)
count++;
if(Math.abs(i-j)==2)
count++;
if(Math.abs(j-k)==2)
count++;
if(i+j+k==nums[index])
{
boolean surp=(count>=1);
if(surp&&s>0)
{
if(max>=p)
ret++;
ret+=go(index+1,s-1);
}
else if(!surp)
{
if(max>=p)
ret++;
ret+=go(index+1,s);
}
best=Math.max(best,ret);
}
else if(i+j+k>nums[index])
break thisone;
}
}
}
return memo[index][s]=best;
}
}
| import java.util.Scanner;
/*
4
3 1 5 15 13 11
3 0 8 23 22 21
2 1 1 8 0
6 2 8 29 20 8 18 18 21
*/
public class Problem {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int test = 1,
numberOfTests,
dancarinos,
erros,
notaCorte,
notaAtual,
resposta;
numberOfTests = scanner.nextInt();
for( int i = 0; i < numberOfTests; i++ ){
resposta = 0;
dancarinos = scanner.nextInt();
erros = scanner.nextInt();
notaCorte = scanner.nextInt();
int[] notas = new int[dancarinos];
for( int j = 0; j < dancarinos; j++){
notas[j] = scanner.nextInt();
}
int div, resto;
for( int j = 0; j < dancarinos; j++ ){
notaAtual = notas[j];
div = notaAtual / 3;
resto = notaAtual % 3;
switch( resto ){
case 0:
if( div >= notaCorte){
resposta++;
}else{
if( erros > 0 && div > 0 && div +1 >= notaCorte){
resposta++;
erros--;
}
}
break;
case 1:
if (div >= notaCorte || div + 1 >= notaCorte){
resposta++;
}else{
if (erros > 0 && div + 1 >= notaCorte){
resposta++;
erros--;
}
}
break;
case 2:
if (div + 1 >= notaCorte || div >= notaCorte){
resposta++;
}else{
if (erros > 0 && div + 2 >= notaCorte){
resposta++;
erros--;
}
}
break;
}
}
System.out.println("Case #"+test+": "+resposta);
test++;
}
}
}
|
B10245 | B12971 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package recyclednumbers;
import java.util.HashSet;
/**
*
* @author vandit
*/
public class RecycleNumbers {
private HashSet<String> numbers = new HashSet<String>();
private HashSet<String> initialTempNumbers = new HashSet<String>();
private HashSet<String> finalTempNumbers = new HashSet<String>();
HashSet<Pair> numberPairs = new HashSet<Pair>();
private void findRecycledNumbers(int start, int end, int places) {
for (int i = start; i <= end; i++) {
String initialNumber = Integer.toString(i);
//if (!(numbers.contains(initialNumber) || finalTempNumbers.contains(initialNumber))) {
StringBuffer tempNumber = new StringBuffer(initialNumber);
int len = tempNumber.length();
int startIndexToMove = len - places;
String tempString = tempNumber.substring(startIndexToMove);
if ((places == 1 && tempString.equals("0")) || tempString.charAt(0) == '0') {
continue;
}
tempNumber.delete(startIndexToMove, len);
String finalTempNumber = tempString + tempNumber.toString();
if (! (finalTempNumber.equals(initialNumber) || Integer.parseInt(finalTempNumber) > end || Integer.parseInt(finalTempNumber) < Integer.parseInt(initialNumber))) {
numbers.add(initialNumber);
finalTempNumbers.add(finalTempNumber);
Pair pair = new Pair(finalTempNumber,initialNumber);
numberPairs.add(pair);
}
}
}
public HashSet<Pair> findAllRecycledNumbers(int start, int end) {
int length = Integer.toString(start).length();
for (int i = 1; i < length; i++) {
findRecycledNumbers(start, end, i);
}
return numberPairs;
}
}
| /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package recyclednumber;
/**
*
* @author pos
*/
public class Numbers {
int A;
int B;
int n;
int m;
int Result;
public Numbers(int A, int B) {
this.A = A;
this.B = B;
this.n = A;
this.m = n + 1;
}
String sn;
String sm;
int nLength;
int mLength;
int nIndex;
int mIndex;
private boolean isValid(int n, int m) {
int[] numberN = new int[10];
int[] numberM = new int[10];
sn = n + "";
sm = m + "";
nLength = sn.length();
mLength = sm.length();
for (int i = 0; i < nLength; i++) {
nIndex = Integer.valueOf(sn.charAt(i)) - 48;
numberN[nIndex]++;
mIndex = Integer.valueOf(sm.charAt(i)) - 48;
numberM[mIndex]++;
}
for (int i = 0; i < 10; i++) {
if (numberN[i] != numberM[i]) {
return false;
}
}
//System.out.println(A + "<=" + n + "<" + m + "<=" + B);
return true;
}
public void Calculate() {
int n, m;
for (int i = this.A; i < this.B; i++) {
for (int j = i+1; j <= this.B; j++) {
n = i;
m = j;
if (isValid(n, m))
isRecycled(n, m);
}
}
}
private boolean isRecycled(int n, int m){
String sn=n+"";
nLength=sn.length();
for(int i=1;i<nLength;i++){
if (Integer.valueOf(sn.substring(i)+sn.substring(0, i))==m){
Result++;
return true;
}
}
return false;
}
}
|
A11277 | A12902 | 0 | package googlers;
import java.util.Scanner;
import java.util.PriorityQueue;
import java.util.Comparator;
public class Googlers {
public static void main(String[] args) {
int n,s,p,count=0,t;
Scanner sin=new Scanner(System.in);
t=Integer.parseInt(sin.nextLine());
int result[]=new int[t];
int j=0;
if(t>=1 && t<=100)
{
for (int k = 0; k < t; k++) {
count=0;
String ip = sin.nextLine();
String[]tokens=ip.split(" ");
n=Integer.parseInt(tokens[0]);
s=Integer.parseInt(tokens[1]);
p=Integer.parseInt(tokens[2]);
if( (s>=0 && s<=n) && (p>=0 && p<=10) )
{
int[] total=new int[n];
for (int i = 0; i < n; i++)
{
total[i] = Integer.parseInt(tokens[i+3]);
}
Comparator comparator=new PointComparator();
PriorityQueue pq=new PriorityQueue<Point>(1, comparator);
for (int i = 0; i < n; i++)
{
int x=total[i]/3;
int r=total[i]%3;
if(x>=p)
count++;
else if(x<(p-2))
continue;
else
{
//System.out.println("enter "+x+" "+(p-2));
if(p-x==1)
{
Point temp=new Point();
temp.q=x;
temp.r=r;
pq.add(temp);
}
else // p-x=2
{
if(r==0)
continue;
else
{
Point temp=new Point();
temp.q=x;
temp.r=r;
pq.add(temp);
}
}
}
//System.out.println("hi "+pq.size());
}
while(pq.size()!=0)
{
Point temp=(Point)pq.remove();
if(p-temp.q==1 && temp.q!=0)
{
if(temp.r>=1)
count++;
else
{
if(s!=0)
{
s--;
count++;
}
}
}
else if(p-temp.q==2)
{
if(s!=0 && (temp.q+temp.r)>=p)
{
s--;
count++;
}
}
}
//System.out.println(p);
result[j++]=count;
}
}
for (int i = 0; i < t; i++)
{
System.out.println("Case #"+(i+1)+": "+result[i]);
}
}
}
/*Point x=new Point();
x.q=8;
Point y=new Point();
y.q=6;
Point z=new Point();
z.q=7;
pq.add(x);
pq.add(y);
pq.add(z);
*/
}
class PointComparator implements Comparator<Point>
{
@Override
public int compare(Point x, Point y)
{
// Assume neither string is null. Real code should
// probably be more robust
if (x.q < y.q)
{
return 1;
}
if (x.q > y.q)
{
return -1;
}
return 0;
}
}
class Point
{
int q,r;
public int getQ() {
return q;
}
public void setQ(int q) {
this.q = q;
}
public int getR() {
return r;
}
public void setR(int r) {
this.r = r;
}
}
| package qual2012;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Kattio extends PrintWriter {
public Kattio(InputStream i) {
super(new BufferedOutputStream(System.out));
r = new BufferedReader(new InputStreamReader(i));
}
public Kattio(InputStream i, OutputStream o) {
super(new BufferedOutputStream(o));
r = new BufferedReader(new InputStreamReader(i));
}
public boolean hasMoreTokens() {
return peekToken() != null;
}
public int getInt() {
return Integer.parseInt(nextToken());
}
public double getDouble() {
return Double.parseDouble(nextToken());
}
public long getLong() {
return Long.parseLong(nextToken());
}
public String getWord() {
return nextToken();
}
private BufferedReader r;
private String line;
private StringTokenizer st;
private String token;
private String peekToken() {
if (token == null)
try {
while (st == null || !st.hasMoreTokens()) {
line = r.readLine();
if (line == null) return null;
st = new StringTokenizer(line);
}
token = st.nextToken();
} catch (IOException e) {
}
return token;
}
private String nextToken() {
String ans = peekToken();
token = null;
return ans;
}
} |
B20424 | B21917 | 0 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
// static int MAX = 10000;
static int MAX = 2000000;
static Object[] All = new Object[MAX+1];
static int size( int x ) {
if(x>999999) return 7;
if(x>99999) return 6;
if(x>9999) return 5;
if(x>999) return 4;
if(x>99) return 3;
if(x>9) return 2;
return 1;
}
static int[] rotate( int value ) {
List<Integer> result = new ArrayList<Integer>();
int[] V = new int[8];
int s = size(value);
int x = value;
for(int i=s-1;i>=0;i--) {
V[i] = x%10;
x /=10;
}
int rot;
for(int i=1; i<s; i++) {
if(V[i]!=0){
rot=0;
for(int j=0,ii=i;j<s; j++,ii=(ii+1)%s){
rot=rot*10+V[ii];
}
if(rot>value && !result.contains(rot))
result.add(rot);
}
}
if( result.isEmpty() )
return null;
int[] r = new int[result.size()];
for(int i=0; i<r.length; i++)
r[i]=result.get(i);
return r;
}
static void precalculate() {
for(int i=1; i<=MAX; i++){
All[i] = rotate(i);
}
}
static int solve( Scanner in ) {
int A, B, sol=0;
A = in.nextInt();
B = in.nextInt();
for( int i=A; i<=B; i++) {
// List<Integer> result = rotate(i);
if( All[i]!=null ) {
for(int value: (int[])All[i] ) {
if( value <= B )
sol++;
}
}
}
return sol;
}
public static void main ( String args[] ) {
int T;
Scanner in = new Scanner(System.in);
T = in.nextInt();
int cnt=0;
int sol;
precalculate();
for( cnt=1; cnt<=T; cnt++ ) {
sol = solve( in );
System.out.printf("Case #%d: %d\n", cnt, sol);
}
}
}
|
import java.util.Scanner;
public class RecycledNumber {
public int deal(int A, int B)
{
int ans = 0;
for (int i = A; i<= B ; i ++)
{
int left = i;
int k = 1;
int tk = 1;
UniqueList newInts = new UniqueList(10);
while (left >= 10)
{
left = left / 10;
tk = tk * 10;
}
left = i;
while (k * 10 <= left)
{
k = k * 10;
int x = (left % k) * (tk * 10 / k) + (left / k);
//System.out.println(i + ": " + x);
if (x > i && x <= B)
newInts.add(x);
}
ans += newInts.getSize();
}
return ans;
}
public void solve()
{
Scanner scan = new Scanner(System.in);
int T = scan.nextInt();scan.nextLine();
for (int i = 1; i <= T; i ++)
{
int A = scan.nextInt();
int B = scan.nextInt();
System.out.println("Case #" + i + ": " + this.deal(A, B));
}
}
public static void main(String args[])
{
RecycledNumber r = new RecycledNumber();
r.solve();
}
}
|
A21396 | A20516 | 0 | import java.util.*;
public class Test {
public static void main(String[] args){
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 result = 0;
for(int j = 0; j<n; j++){
int x = canAddUp(in.nextInt(), p);
if(x == 0) {
result++;
} else if (x==1 && s > 0) {
result++;
s--;
}
}
System.out.println("Case #"+i+": "+result);
}
}
public static int canAddUp(int sum, int limit) {
boolean flag = false;
for(int i = 0; i<=sum; i++) {
for(int j = 0; i+j <= sum; j++) {
int k = sum-(i+j);
int a = Math.abs(i-j);
int b = Math.abs(i-k);
int c = Math.abs(j-k);
if(a > 2 || b > 2 || c> 2){
continue;
}
if (i>=limit || j>=limit || k>=limit) {
if(a < 2 && b < 2 && c < 2) {
return 0;
}else{
flag = true;
}
}
}
}
return (flag) ? 1 : 2;
}
}
| package com.googlerese.file;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
public class FileRead {
private static FileRead instance = new FileRead();
private FileRead() {
}
public static FileRead getInstance() {
return instance;
}
public Map<Integer, GooglersBean> read( final String fileName ) {
FileInputStream fstream = null;
DataInputStream in = null;
BufferedReader br = null;
Map<Integer, GooglersBean> input = null;
try {
// Open the file that is the first
// command line parameter
fstream = new FileInputStream( fileName );
// Get the object of DataInputStream
in = new DataInputStream( fstream );
br = new BufferedReader( new InputStreamReader( in ) );
String strLine;
//Read File Line By Line
int count = 0;
while ( ( strLine = br.readLine() ) != null ) {
// Print the content on the console
if ( count == 0 ) {
input = new HashMap<Integer, GooglersBean>( Integer.parseInt( strLine ) );
} else {
System.out.println( count + " : " + strLine );
GooglersBean bean = new GooglersBean();
String[] arr = strLine.split( "\\s+" );
bean.setNumGooglers( Integer.parseInt( arr[0] ) );
bean.setSurprising( Integer.parseInt( arr[1] ) );
bean.setResult( Integer.parseInt( arr[2] ) );
for ( int i = 3; i < arr.length; i++ ) {
bean.addScore( ( i - 3 ), Integer.parseInt( arr[i] ) );
}
input.put( count, bean );
}
count++;
}
} catch ( Exception e ) {//Catch exception if any
System.err.println( "Error: " + e.getMessage() );
} finally {
//Close the input stream
try {
if ( br != null ) {
br.close();
}
if ( in != null ) {
in.close();
}
if ( fstream != null ) {
fstream.close();
}
} catch ( IOException e ) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return input;
}
}
|
B10155 | B13094 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam;
/**
*
* @author eblanco
*/
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import javax.swing.JFileChooser;
public class RecycledNumbers {
public static String DatosArchivo[] = new String[10000];
public static int[] convertStringArraytoIntArray(String[] sarray) throws Exception {
if (sarray != null) {
int intarray[] = new int[sarray.length];
for (int i = 0; i < sarray.length; i++) {
intarray[i] = Integer.parseInt(sarray[i]);
}
return intarray;
}
return null;
}
public static boolean CargarArchivo(String arch) throws FileNotFoundException, IOException {
FileInputStream arch1;
DataInputStream arch2;
String linea;
int i = 0;
if (arch == null) {
//frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
JFileChooser fc = new JFileChooser(System.getProperty("user.dir"));
int rc = fc.showDialog(null, "Select a File");
if (rc == JFileChooser.APPROVE_OPTION) {
arch = fc.getSelectedFile().getAbsolutePath();
} else {
System.out.println("No hay nombre de archivo..Yo!");
return false;
}
}
arch1 = new FileInputStream(arch);
arch2 = new DataInputStream(arch1);
do {
linea = arch2.readLine();
DatosArchivo[i++] = linea;
/* if (linea != null) {
System.out.println(linea);
}*/
} while (linea != null);
arch1.close();
return true;
}
public static boolean GuardaArchivo(String arch, String[] Datos) throws FileNotFoundException, IOException {
FileOutputStream out1;
DataOutputStream out2;
int i;
out1 = new FileOutputStream(arch);
out2 = new DataOutputStream(out1);
for (i = 0; i < Datos.length; i++) {
if (Datos[i] != null) {
out2.writeBytes(Datos[i] + "\n");
}
}
out2.close();
return true;
}
public static void echo(Object msg) {
System.out.println(msg);
}
public static void main(String[] args) throws IOException, Exception {
String[] res = new String[10000], num = new String[2];
int i, j, k, ilong;
int ele = 1;
ArrayList al = new ArrayList();
String FName = "C-small-attempt0", istr, irev, linea;
if (CargarArchivo("C:\\eblanco\\Desa\\CodeJam\\Code Jam\\test\\" + FName + ".in")) {
for (j = 1; j <= Integer.parseInt(DatosArchivo[0]); j++) {
linea = DatosArchivo[ele++];
num = linea.split(" ");
al.clear();
// echo("A: "+num[0]+" B: "+num[1]);
for (i = Integer.parseInt(num[0]); i <= Integer.parseInt(num[1]); i++) {
istr = Integer.toString(i);
ilong = istr.length();
for (k = 1; k < ilong; k++) {
if (ilong > k) {
irev = istr.substring(istr.length() - k, istr.length()) + istr.substring(0, istr.length() - k);
//echo("caso: " + j + ": isrt: " + istr + " irev: " + irev);
if ((Integer.parseInt(irev) > Integer.parseInt(num[0])) && (Integer.parseInt(irev) > Integer.parseInt(istr)) && (Integer.parseInt(irev) <= Integer.parseInt(num[1]))) {
al.add("(" + istr + "," + irev + ")");
}
}
}
}
HashSet hs = new HashSet();
hs.addAll(al);
al.clear();
al.addAll(hs);
res[j] = "Case #" + j + ": " + al.size();
echo(res[j]);
LeerArchivo.GuardaArchivo("C:\\eblanco\\Desa\\CodeJam\\Code Jam\\test\\" + FName + ".out", res);
}
}
}
}
| package RecycledNumbers;
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;
public class RecycledNumbers {
public static void main(String[] args) {
try {
// lets get the data in
FileInputStream fstream = new FileInputStream("E:/workspace_java/CodeJam12/src/RecycledNumbers/input.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
// open file for writing
FileWriter fwstream = new FileWriter("E:/workspace_java/CodeJam12/src/RecycledNumbers/output.out");
BufferedWriter out = new BufferedWriter(fwstream);
// declare variables
int i,j,k;
int numCases;
String[] strArr;
// get number of cases
strLine = br.readLine();
numCases = Integer.parseInt(strLine);
// declare specific vars
int low, high, n;
int cur, len;
int count;
String ts, ns, a, b;
ArrayList<String> found = new ArrayList<String>();
// loop through cases
for(i=0;i<numCases;i++){
// read case
strLine = br.readLine();
strArr = strLine.split(" ");
count = 0;
low = Integer.parseInt(strArr[0]);
high = Integer.parseInt(strArr[1]);
for(j = low; j <= high; j++){
cur = j;
ts = new Integer(cur).toString();
len = ts.length();
//System.out.print(ts + " => ");
for(k = len - 1; k >= 0; k--){
a = ts.substring(k);
b = ts.substring(0, k);
n = Integer.parseInt(a + b);
ns = new Integer(n).toString();
if(n >= low && n <= high && n > cur && !(in_array(ns+ts, found))){
count++;
//System.out.print(ns + " ");
}
}
//System.out.println();
}
/* final tests
if((one >= 0 && one <= 10) && (two >= 0 && two <= 10) && (three >= 0 && three <= 10)) { }
else { System.out.println("Out of bounds on number"); }
if(total != tempScore) { System.out.println("Score does not add up"); }
if(surprisesTaken > numSurprises) { System.out.println("Too many surprises"); }
*/
//System.out.println(one + " " + two + " " + three);
System.out.print("Case #"+(i+1)+": ");
out.write("Case #"+(i+1)+": ");
System.out.println(count);
out.write(Integer.toString(count));
out.newLine();
}
//System.out.print("Case #"+(i+1)+": ");
//out.write("Case #"+(i+1)+": ");
//System.out.println(seanP2sum);
//out.write(Integer.toString(seanP2sum));
//out.newLine();
out.close();
in.close();
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
public static boolean in_array(String needle, ArrayList<String> haystack){
boolean found = false;
int i = 0;
int len = haystack.size();
for(i=0; i<len; i++){
if(needle.equals(haystack.get(i))){
found = true;
System.out.println("found match of "+needle + " matching " + haystack.get(i) + " at index " + i);
}
}
return found;
}
}
|
A12846 | A12200 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam.common;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author Lance Chen
*/
public class CodeHelper {
private static String FILE_ROOT = "D:/workspace/googlecodejam/meta";
public static List<List<String>> loadInputsExcludes(String fileName) {
List<List<String>> result = new ArrayList<List<String>>();
List<String> lines = FileUtil.readLines(FILE_ROOT + fileName);
int index = 0;
for (String line : lines) {
if (index == 0) {
index++;
continue;
}
if (index % 2 == 1) {
index++;
continue;
}
List<String> dataList = new ArrayList<String>();
String[] dataArray = line.split("\\s+");
for (String data : dataArray) {
if (data.trim().length() > 0) {
dataList.add(data);
}
}
result.add(dataList);
index++;
}
return result;
}
public static List<List<String>> loadInputs(String fileName) {
List<List<String>> result = new ArrayList<List<String>>();
List<String> lines = FileUtil.readLines(FILE_ROOT + fileName);
for (String line : lines) {
List<String> dataList = new ArrayList<String>();
String[] dataArray = line.split("\\s+");
for (String data : dataArray) {
if (data.trim().length() > 0) {
dataList.add(data);
}
}
result.add(dataList);
}
return result;
}
public static List<String> loadInputLines(String fileName) {
return FileUtil.readLines(FILE_ROOT + fileName);
}
public static void writeOutputs(String fileName, List<String> lines) {
FileUtil.writeLines(FILE_ROOT + fileName, lines);
}
}
| import java.io.*;
import java.util.Scanner;
public class functions {
int mod(int a){
int b = 0;
if(a > 0) b = a; else b = -a;
return b;
}
int solve(int[] a, int p, int s, int n){
int result = 0;
int i = 0;
int x = 0;
int onlyS = 0;
int onlyNotS = 0;
int both = 0;
int none = 0;
for ( i = 0;i < n; i++){
x = a[i]/3;
if(a[i]%3 ==0){
if(a[i] == 30){
onlyNotS++;
}
else if(p==x+1 && a[i]!=0){
onlyS++;
}
else if ( p<=x ){
both++;
}
else{
none++;
}
}
else if(a[i]%3 ==1){
if(a[i]==1 && p<=1){
onlyNotS++;
}
else if(p <= x+1){
both++;
}
else none++;
}
else{
if(a[i] == 29){
onlyNotS++;
}
else if(p == x+2){
onlyS++;
}
else if(p <= x+1){
both++;
}
else {
none++;
}
}
}
if(onlyS <= s){
result = both+onlyNotS+onlyS;
}
else{
result = s+both+onlyNotS;
}
return result;
}
}
|
A10568 | A12784 | 0 | 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);
}
}
| /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package dancinggooglers;
import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;
/**
*
* @author administrator
*/
public class DancingGooglers {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String input = "c:\\input.in";
String output = "c:\\output.txt";
System.out.println("Hello World");
DancingGooglers code1 = new DancingGooglers();
File in = new File(input);
File out = new File(output);
code1.processOutput(in, out, "UTF-8");
}
public void processOutput(File input, File output, String charSet) {
String temp = "";
try {
Scanner scanner = new Scanner(input, charSet);
PrintWriter out = new PrintWriter(output);
int count = 0;
int test_case = 0;
while (scanner.hasNext()) {
String test = scanner.nextLine();
int noOfGooglers;
int surprising_triplets;
int P;
int t[];
int surprises_left;
int result;
if (count == 0) {
test_case = Integer.parseInt(test);
count++;
} else {
String[] line_data = test.split("\\s");
noOfGooglers = Integer.parseInt(line_data[0]);
surprising_triplets = Integer.parseInt(line_data[1]);
P = Integer.parseInt(line_data[2]);
t = new int[noOfGooglers];
result = 0;
surprises_left = surprising_triplets;
for (int i = 0; i < noOfGooglers; i++) {
t[i] = Integer.parseInt(line_data[i + 3]);
}
for (int i = 0; i < noOfGooglers; i++) {
if (isTGreaterThanP(t[i], P)) {
result++;
} else {
if (surprises_left > 0 && isTGreaterPSurprises(t[i], P)) {
result++;
surprises_left--;
}
}
}
System.out.println("Case #" + count + ": " + result);
if (count == test_case) {
out.print("Case #" + count + ": " + result);
} else {
out.println("Case #" + count + ": " + result);
}
count++;
}
temp = temp + "\n" + test;
}
out.close();
scanner.close();
} catch (Exception e) {
System.out.println("File read/write error");
return;
}
}
private boolean isTGreaterThanP(int total, int P) {
int max = (total + 2) / 3;
if (max >= P) {
return true;
}
return false;
}
private boolean isTGreaterPSurprises(int total, int P) {
int max = (total + 4) / 3;
if (max >= 10) {
max = 10;
}
if (total == 1) {
max = 1;
} else if (total == 0) {
max = 0;
}
if (max >= P) {
return true;
}
return false;
}
}
|
A12113 | A10190 | 0 | import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class B {
static int[][] memo;
static int[] nums;
static int p;
public static void main(String[] args)throws IOException
{
Scanner br=new Scanner(new File("B-small-attempt0.in"));
PrintWriter out=new PrintWriter(new File("b.out"));
int cases=br.nextInt();
for(int c=1;c<=cases;c++)
{
int n=br.nextInt(),s=br.nextInt();
p=br.nextInt();
nums=new int[n];
for(int i=0;i<n;i++)
nums[i]=br.nextInt();
memo=new int[n][s+1];
for(int[] a:memo)
Arrays.fill(a,-1);
out.printf("Case #%d: %d\n",c,go(0,s));
}
out.close();
}
public static int go(int index,int s)
{
if(index>=nums.length)
return 0;
if(memo[index][s]!=-1)
return memo[index][s];
int best=0;
for(int i=0;i<=10;i++)
{
int max=i;
for(int j=0;j<=10;j++)
{
if(Math.abs(i-j)>2)
continue;
max=Math.max(i,j);
thisone:
for(int k=0;k<=10;k++)
{
int ret=0;
if(Math.abs(i-k)>2||Math.abs(j-k)>2)
continue;
max=Math.max(max,k);
int count=0;
if(Math.abs(i-k)==2)
count++;
if(Math.abs(i-j)==2)
count++;
if(Math.abs(j-k)==2)
count++;
if(i+j+k==nums[index])
{
boolean surp=(count>=1);
if(surp&&s>0)
{
if(max>=p)
ret++;
ret+=go(index+1,s-1);
}
else if(!surp)
{
if(max>=p)
ret++;
ret+=go(index+1,s);
}
best=Math.max(best,ret);
}
else if(i+j+k>nums[index])
break thisone;
}
}
}
return memo[index][s]=best;
}
}
| package codejam;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
/*
import lib.tuple.Pair;
import lib.tuple.Tuple;
import lib.util.StringUtil;
*/
public class CodeJam2012RQB {
static final String fileIn = "/Users/jhorwitz/Documents/workspace/test/src/codejam/data/RQ-B-in.txt"; //"data/in.txt";
static final String fileOut = "/Users/jhorwitz/Documents/workspace/test/src/codejam/data/RQ-B-out.txt"; //"data/out.txt";
public static void main(String[] args) throws Exception {
BufferedReader r = new BufferedReader(new FileReader(fileIn));
BufferedWriter w = new BufferedWriter(new FileWriter(fileOut));
String line = r.readLine();
int T = Integer.parseInt(line);
for (int caseNum = 1; caseNum <= T; caseNum++) {
line = r.readLine();
String str = "Case #" + caseNum + ": " + solve(line);
w.write(str + "\n");
System.out.println(str);
}
w.close();
r.close();
}
private static int solve(String line) {
String[] inputLineAsAnArray = line.split(" ");
int N = Integer.parseInt(inputLineAsAnArray[0]);
int S = Integer.parseInt(inputLineAsAnArray[1]);
int p = Integer.parseInt(inputLineAsAnArray[2]);
int[] t = new int[N];
int numGooglersWithMaxScoreGreaterThanP = 0;
for (int i=0; i<N; ++i) { // fill t array--separate for loop from below solely for debug purposes
t[i] = Integer.parseInt(inputLineAsAnArray[3+i]);
}
for (int iGoogler=0; iGoogler<N; ++iGoogler) {
int tBy3 = t[iGoogler]/3;
switch(t[iGoogler] % 3) {
case 0:
if(tBy3 >= p && 0<=tBy3 && tBy3<=10) { // no need for a surprising triplet for this Googler to get p or more
++numGooglersWithMaxScoreGreaterThanP;
} else if(tBy3+1 == p && 0<=tBy3-1 && tBy3+1<=10) { // a surprising triplet is needed for this Googler to get a p or more -- "use" one if there's one left
if(S>0) {
++numGooglersWithMaxScoreGreaterThanP;
--S;
}
}
// if neither of those cases, then not valid triplet (surprising or otherwise) could give this Googler a p or more
break;
case 1:
if(tBy3 + 1 >= p && 0<=tBy3 && tBy3+1<=10) { // no need for a surprising triplet for this Googler to get p or more
++numGooglersWithMaxScoreGreaterThanP;
} // for this case (1 mod 3), a surprising triplet will have the same max as a non-surprising one
// so otherwise, then not valid triplet (surprising or otherwise) could give this Googler a p or more
break;
case 2:
if(tBy3 + 1 >= p && 0<=tBy3 && tBy3+1<=10) { // no need for a surprising triplet for this Googler to get p or more
++numGooglersWithMaxScoreGreaterThanP;
} else if(tBy3 + 2 == p && 0<=tBy3 && tBy3+2<=10) { // a surprising triplet is needed for this Googler to get a p or more -- "use" one if there's one left
if(S>0) {
++numGooglersWithMaxScoreGreaterThanP;
--S;
}
}
// if neither of those cases, then not valid triplet (surprising or otherwise) could give this Googler a p or more
break;
// default left out since there better only be the three listed cases!
}
}
return numGooglersWithMaxScoreGreaterThanP;
}
} |
B12082 | B11904 | 0 | package jp.funnything.competition.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.apache.commons.io.IOUtils;
public class QuestionReader {
private final BufferedReader _reader;
public QuestionReader( final File input ) {
try {
_reader = new BufferedReader( new FileReader( input ) );
} catch ( final FileNotFoundException e ) {
throw new RuntimeException( e );
}
}
public void close() {
IOUtils.closeQuietly( _reader );
}
public String read() {
try {
return _reader.readLine();
} catch ( final IOException e ) {
throw new RuntimeException( e );
}
}
public BigDecimal[] readBigDecimals() {
return readBigDecimals( " " );
}
public BigDecimal[] readBigDecimals( final String separator ) {
final String[] tokens = readTokens( separator );
final BigDecimal[] values = new BigDecimal[ tokens.length ];
for ( int index = 0 ; index < tokens.length ; index++ ) {
values[ index ] = new BigDecimal( tokens[ index ] );
}
return values;
}
public BigInteger[] readBigInts() {
return readBigInts( " " );
}
public BigInteger[] readBigInts( final String separator ) {
final String[] tokens = readTokens( separator );
final BigInteger[] values = new BigInteger[ tokens.length ];
for ( int index = 0 ; index < tokens.length ; index++ ) {
values[ index ] = new BigInteger( tokens[ index ] );
}
return values;
}
public int readInt() {
final int[] values = readInts();
if ( values.length != 1 ) {
throw new IllegalStateException( "Try to read single interger, but the line contains zero or multiple values" );
}
return values[ 0 ];
}
public int[] readInts() {
return readInts( " " );
}
public int[] readInts( final String separator ) {
final String[] tokens = readTokens( separator );
final int[] values = new int[ tokens.length ];
for ( int index = 0 ; index < tokens.length ; index++ ) {
values[ index ] = Integer.parseInt( tokens[ index ] );
}
return values;
}
public long readLong() {
final long[] values = readLongs();
if ( values.length != 1 ) {
throw new IllegalStateException( "Try to read single interger, but the line contains zero or multiple values" );
}
return values[ 0 ];
}
public long[] readLongs() {
return readLongs( " " );
}
public long[] readLongs( final String separator ) {
final String[] tokens = readTokens( separator );
final long[] values = new long[ tokens.length ];
for ( int index = 0 ; index < tokens.length ; index++ ) {
values[ index ] = Long.parseLong( tokens[ index ] );
}
return values;
}
public String[] readTokens() {
return readTokens( " " );
}
public String[] readTokens( final String separator ) {
return read().split( separator );
}
}
| package googleJam;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.Scanner;
public class RecycledNumbers
{
public static void main(String[] args)
{
Scanner scan = null;
try
{
scan = new Scanner(new File(args[0]));
}
catch (FileNotFoundException e)
{
System.err.println("File not found!");
return;
}
if (!scan.hasNext())
{
System.err.println("Nothing in File!");
return;
}
int testCases = Integer.parseInt(scan.nextLine());
int lower;
int upper;
int move;
int d;
int total;
int zeroes;
int num = 1;
int first;
HashSet<Integer> set;
while(scan.hasNext())
{
System.out.print("Case #" + num + ": ");
total = 0;
lower = scan.nextInt();
upper = scan.nextInt();
for (int x = lower; x <= (upper); x++)
{
set = new HashSet<Integer>();
zeroes = 1;
move = x;
while (move > 9)
{
move = move/10;
zeroes = zeroes * 10;
}
int limit = zeroes;
for(int n = 10; n < (limit*10); n = n * 10)
{
move = x/n;
d = x % n;
d = d * zeroes;
d = d + move;
zeroes = zeroes / 10;
if (d < x && d >= lower && !set.contains(d) && d > 9)
{
total++;
//System.out.println(d + " , " + x);
set.add(d);
}
}
}
num++;
System.out.print(total);
if (scan.hasNext())
{
System.out.println();
}
}
}
}
|
B11327 | B12864 | 0 | package recycledNumbers;
public class OutputData {
private int[] Steps;
public int[] getSteps() {
return Steps;
}
public OutputData(int [] Steps){
this.Steps = Steps;
for(int i=0;i<this.Steps.length;i++){
System.out.println("Test "+(i+1)+": "+Steps[i]);
}
}
}
| 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 Recycle {
public static void main(String[] args)
{
File f = new File("C-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[] bounds = line.split(" ");
int count = countPairs(Integer.parseInt(bounds[0]), Integer.parseInt(bounds[1]), bounds[0].length());
out.write("Case #"+(i+1)+": "+count);
out.newLine();
}
out.close();
}
catch(FileNotFoundException e)
{
e.printStackTrace();
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
public static int countPairs(int l, int u, int n)
{
if(n==1)
return 0;
int count=0;
for(int i=l+1; i<=u; i++)
{
int cycle = (i%10)*((int)Math.pow(10,n-1)) + (i/10);
while(cycle != i)
{
if(cycle >= l && cycle < i)
count++;
cycle = (cycle%10)*((int)Math.pow(10,n-1)) + (cycle/10);
}
}
return count;
}
}
|
A20382 | A20516 | 0 | package dancinggooglers;
import java.io.File;
import java.util.Scanner;
public class DanceScoreCalculator {
public static void main(String[] args) {
if(args.length <= 0 || args[0] == null) {
System.out.println("You must enter a file to read");
System.out.println("Usage: blah <filename>");
System.exit(0);
}
File argFile = new File(args[0]);
try {
Scanner googleSpeakScanner = new Scanner(argFile);
String firstLine = googleSpeakScanner.nextLine();
Integer linesToScan = new Integer(firstLine);
for(int i = 1; i <= linesToScan; i++) {
String googleDancerLine = googleSpeakScanner.nextLine();
DanceScoreCase danceCase = new DanceScoreCase(googleDancerLine);
System.out.println(String.format("Case #%d: %d", i, danceCase.maxDancersThatCouldPass()));
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
| package com.googlerese.file;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
public class FileRead {
private static FileRead instance = new FileRead();
private FileRead() {
}
public static FileRead getInstance() {
return instance;
}
public Map<Integer, GooglersBean> read( final String fileName ) {
FileInputStream fstream = null;
DataInputStream in = null;
BufferedReader br = null;
Map<Integer, GooglersBean> input = null;
try {
// Open the file that is the first
// command line parameter
fstream = new FileInputStream( fileName );
// Get the object of DataInputStream
in = new DataInputStream( fstream );
br = new BufferedReader( new InputStreamReader( in ) );
String strLine;
//Read File Line By Line
int count = 0;
while ( ( strLine = br.readLine() ) != null ) {
// Print the content on the console
if ( count == 0 ) {
input = new HashMap<Integer, GooglersBean>( Integer.parseInt( strLine ) );
} else {
System.out.println( count + " : " + strLine );
GooglersBean bean = new GooglersBean();
String[] arr = strLine.split( "\\s+" );
bean.setNumGooglers( Integer.parseInt( arr[0] ) );
bean.setSurprising( Integer.parseInt( arr[1] ) );
bean.setResult( Integer.parseInt( arr[2] ) );
for ( int i = 3; i < arr.length; i++ ) {
bean.addScore( ( i - 3 ), Integer.parseInt( arr[i] ) );
}
input.put( count, bean );
}
count++;
}
} catch ( Exception e ) {//Catch exception if any
System.err.println( "Error: " + e.getMessage() );
} finally {
//Close the input stream
try {
if ( br != null ) {
br.close();
}
if ( in != null ) {
in.close();
}
if ( fstream != null ) {
fstream.close();
}
} catch ( IOException e ) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return input;
}
}
|
B21968 | B22250 | 0 | import java.util.*;
import java.io.*;
public class recycled_numbers {
public static void main(String[]a) throws Exception{
Scanner f = new Scanner(new File(a[0]));
int result=0;
int A,B;
String n,m;
HashSet<String> s=new HashSet<String>();
int T=f.nextInt(); //T total case count
for (int t=1; t<=T;t++){//for each case t
s.clear();
result=0; //reset
A=f.nextInt();B=f.nextInt(); //get values for next case
if (A==B)result=0;//remove case not meeting problem limits
else{
for(int i=A;i<=B;i++){//for each int in range
n=Integer.toString(i);
m=new String(n);
//System.out.println(n);
for (int j=1;j<n.length();j++){//move each digit to the front & test
m = m.substring(m.length()-1)+m.substring(0,m.length()-1);
if(m.matches("^0+[\\d]+")!=true &&
Integer.parseInt(m)<=B &&
Integer.parseInt(n)<Integer.parseInt(m)){
s.add(new String(n+","+m));
//result++;
//System.out.println(" matched: "+m);
}
}
}
result = s.size();
}
//display output
System.out.println("Case #" + t + ": " + result);
}
}
} | import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.util.ArrayList;
public class ReadWriter
{
public ArrayList<String> readFile(String path){
File file = new File(path);
ArrayList<String> strings = new ArrayList<String>();
BufferedReader reader = null;
try{
reader = new BufferedReader(new FileReader(file));
String text = null;
while((text=reader.readLine())!=null){
strings.add(text);
}
return strings;
}
catch(Exception e){
e.printStackTrace();
}
finally{
try{
if(reader!=null){
reader.close();
}
}
catch(Exception e){
e.printStackTrace();
}
}
return null;
}
public void writeFile(ArrayList<String> list, String path){
BufferedWriter out=null;
try{
FileWriter fstream = new FileWriter(path);
out = new BufferedWriter(fstream);
for(String s : list){
out.write(s);
out.write("\r\n");
}
}
catch(Exception e){
e.printStackTrace();
}
finally{
try{
if(out!=null){
out.close();
}
}
catch(Exception e){
e.printStackTrace();
}
}
}
}
|
B10361 | B12471 | 0 | package codejam;
import java.util.*;
import java.io.*;
public class RecycledNumbers {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("in.txt"));
PrintWriter out = new PrintWriter(new File("out.txt"));
int T = Integer.parseInt(in.readLine());
for (int t = 1; t <= T; ++t) {
String[] parts = in.readLine().split("[ ]+");
int A = Integer.parseInt(parts[0]);
int B = Integer.parseInt(parts[1]);
int cnt = 0;
for (int i = A; i < B; ++i) {
String str = String.valueOf(i);
int n = str.length();
String res = "";
Set<Integer> seen = new HashSet<Integer>();
for (int j = n - 1; j > 0; --j) {
res = str.substring(j) + str.substring(0, j);
int k = Integer.parseInt(res);
if (k > i && k <= B) {
//System.out.println("(" + i + ", " + k + ")");
if (!seen.contains(k)) {
++cnt;
seen.add(k);
}
}
}
}
out.println("Case #" + t + ": " + cnt);
}
in.close();
out.close();
System.exit(0);
}
}
| import java.io.*;
import java.util.*;
import java.util.regex.*;
public class jam03 {
/**
* @param args
*/
public static void main1(){
// scalar product problem
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int number_test;
Scanner sc = new Scanner(System.in);
number_test = sc.nextInt();
for(int j=1;j<=number_test;j++) {
int lowerLimit = sc.nextInt();
int upperLimit = sc.nextInt();
System.out.print("Case #" + j + ": ");
action(lowerLimit,upperLimit);
// System.out.println(sum);
}
}
private static void action(int lowerLimit, int upperLimit ) {
// TODO Auto-generated method stub
// Iterating over the elements in the set
int finalGuys = 0;
int maxZeroes = 0;
int oldNum=0;
// System.out.println("lower"+ lowerLimit);
// System.out.println("uper"+upperLimit);
for(int i=lowerLimit;i<upperLimit;i++)
{
for(int k=4;k>=1;k--)
{//3422
int temp = (int) (i/Math.pow(10, k));//34
if(maxZeroes ==0 && temp > 0)
{
maxZeroes = k;
//System.out.println("maxZeroes"+maxZeroes);
}
if(maxZeroes>0)
{
int temp1 = (int) (i - (temp*Math.pow(10, k)));//3422-3400
int newNum = (int) ((temp1*Math.pow(10, maxZeroes-k+1))+temp);//4223
if(newNum <= upperLimit && newNum > i && newNum != oldNum)
{
oldNum = newNum;
finalGuys++;
}
}
}
}
System.out.println(finalGuys);
}
}
|
B11421 | B12917 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Recycled {
public static void main(String[] args) throws Exception{
String inputFile = "C-small-attempt0.in";
BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile)));
BufferedWriter output = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output")));
long num_cases = Long.parseLong(input.readLine());
int current_case = 0;
while (current_case < num_cases){
current_case++;
String[] fields = input.readLine().split(" ");
int A = Integer.parseInt(fields[0]);
int B = Integer.parseInt(fields[1]);
int total = 0;
for (int n = A; n < B; n++){
for (int m = n+1; m <= B; m++){
if (isRecycled(n,m)) total++;
}
}
System.out.println("Case #" + current_case + ": " + total);
output.write("Case #" + current_case + ": " + total + "\n");
}
output.close();
}
private static boolean isRecycled(int n, int m) {
String sn = ""+n;
String sm = ""+m;
if (sn.length() != sm.length()) return false;
int totaln = 0, totalm = 0;
for (int i = 0; i < sn.length(); i++){
totaln += sn.charAt(i);
totalm += sm.charAt(i);
}
if (totaln != totalm) return false;
for (int i = 0; i < sn.length()-1; i++){
sm = sm.charAt(sm.length() - 1) + sm.substring(0, sm.length() - 1);
if (sm.equals(sn)) return true;
}
return false;
}
}
|
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.logging.Level;
import java.util.logging.Logger;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author B4dT0bi
*/
public class RecycledNumbers
{
public static String [] input;
public static String wholeOutput="";
public static void readInput(String inputFile)
{
BufferedReader br = null;
try
{
br = new BufferedReader(new FileReader(inputFile));
String serializedSettings = "";
String line = null;
while ((line = br.readLine()) != null)
serializedSettings += line + "\n";
input=serializedSettings.split("\n");
br.close();
} catch (Exception ex)
{
ex.printStackTrace();
} finally
{
try
{
br.close();
} catch (IOException ex)
{
ex.printStackTrace();
}
}
}
public static void writeOutput(String inputFile)
{
try
{
BufferedWriter out = new BufferedWriter(new FileWriter(inputFile+".out"));
out.write(wholeOutput);
out.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
readInput(args[0]);
wholeOutput="";
for(int i=1;i<input.length;i++)
{
String [] tmp=input[i].split(" ");
int A=Integer.parseInt(tmp[0]);
int B=Integer.parseInt(tmp[1]);
int anz=0;
for(int x=A;x<B-1;x++)
{
anz+=existingPairs(x, B);
}
wholeOutput+="Case #"+i+": "+anz+"\n";
}
writeOutput(args[0]);
}
private static int existingPairs(int x, int B)
{
String sX=""+x;
int anz=0;
HashSet<String>already=new HashSet<String>();
for(int i=1;i<sX.length();i++)
{
String tmp=sX.substring(sX.length()-i)+""+sX.substring(0,sX.length()-i);
if(tmp.charAt(0)=='0')continue;
int nr=Integer.parseInt(tmp);
if(nr<=B && nr>x)
{
if(!already.contains(tmp))
{
already.add(tmp);
anz++;
}
}
}
return anz;
}
}
|
B12115 | B12348 | 0 | package qual;
import java.util.Scanner;
public class RecycledNumbers {
public static void main(String[] args) {
new RecycledNumbers().run();
}
private void run() {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for (int t = 0; t < T; t++) {
int A = sc.nextInt();
int B = sc.nextInt();
int result = solve(A, B);
System.out.printf("Case #%d: %d\n", t + 1, result);
}
}
public int solve(int A, int B) {
int result = 0;
for (int i = A; i <= B; i++) {
int dig = (int) Math.log10(A/*same as B*/) + 1;
int aa = i;
for (int d = 0; d < dig - 1; d++) {
aa = (aa % 10) * (int)Math.pow(10, dig - 1) + (aa / 10);
if (i == aa) {
break;
}
if (i < aa && aa <= B) {
// System.out.printf("(%d, %d) ", i, aa);
result++;
}
}
}
return result;
}
}
| import java.util.*;
public class b {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
String ss = sc.nextLine();
int casenum = Integer.parseInt(ss);
String answer = "";
for(int i = 1;i<=casenum;i++){
answer = answer.concat("Case #".concat(Integer.toString(i)).concat(": "));
ss = sc.nextLine();
String wer = recycledpair(ss);
answer = answer.concat(wer);
answer = answer.concat("\n");
}
System.out.print(answer);
}
public static String recycledpair(String a){
int n = Integer.parseInt(a.substring(0, a.indexOf(' ')));
int m = Integer.parseInt(a.substring(a.indexOf(' ')+1, a.length()));
int nlength = a.substring(0, a.indexOf(' ')).length();
int pairnum = 0;
String rcp ="";
for(int i=n; i<m; i++){
LinkedList<Integer> mylist = new LinkedList<Integer>();
String sn = Integer.toString(i);
//a.substring(0, a.indexOf(' '));
for(int j=1; j<sn.length(); j++){
String newnum = sn.substring(j,sn.length()).concat(sn.substring(0,j));
int newint = Integer.parseInt(newnum);
if(newint>i&&newint<=m){
if(!mylist.contains(newint)){
pairnum++;
mylist.add(newint);
}
else{
mylist.add(newint);
}
}
}
}
String snumreturn = Integer.toString(pairnum);
//System.out.print(snumreturn);
return snumreturn;
}
}
|
A20730 | A22237 | 0 | import java.util.Scanner;
public class B {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for(int zz = 1; zz <= T;zz++){
int N = in.nextInt();
int S = in.nextInt();
int p = in.nextInt();
int x = 0;
for(int i = 0; i < N;i++){
int score = in.nextInt();
int best = score/3;
int mod = score%3;
int diff = p-best;
if(diff<1){
x++;
}else if(diff<2){
if(mod==0 && score !=0){
if(S!=0){
S--;x++;
}
}else if(score!=0){
x++;
}
}else if(diff<3){
if(mod==2){
if(S!=0){
S--;x++;
}
}
}
}
System.out.format("Case #%d: %d\n", zz, x);
}
}
}
| import java.io.*;
import java.util.*;
/**
* @author: Ignat Alexeyenko
* Date: 4/14/12
*/
public class DancingWithGooglersMain {
public static final int MAX_LENGTH = 1024;
public static void main(String[] args) {
DancingWithGooglersMain main = new DancingWithGooglersMain();
main.runConsoleApp(System.in, System.out);
}
public void runConsoleApp(InputStream inputStream, OutputStream outputStream) {
final String s = readLn(inputStream, MAX_LENGTH);
Integer cases = Integer.valueOf(s);
Writer writer = new OutputStreamWriter(outputStream);
for (int i= 0; i < cases; i++) {
String rawLine = readLn(inputStream, MAX_LENGTH);
try {
writer.write("Case #" + (i + 1) + ": " + runFunction(rawLine) + "\n");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
try {
writer.flush();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private long runFunction(String rawLine) {
String[] edgesArr = rawLine.split(" ");
int numOfGooglers = Integer.valueOf(edgesArr[0]);
int surprises = Integer.valueOf(edgesArr[1]);
int minScoreP = Integer.valueOf(edgesArr[2]);
List<Integer> marksT = new ArrayList<Integer>(numOfGooglers);
for (int t = 0; t < numOfGooglers; t++) {
marksT.add(Integer.valueOf(edgesArr[t + 3]));
}
return caclulateAmountOfGooglersThatExceedScoreP(surprises, minScoreP, marksT);
}
private int caclulateAmountOfGooglersThatExceedScoreP(int surprises, int minScoreP, List<Integer> marksT) {
Map<Integer, Set<Mark>> sumToPermutations = new HashMap<Integer, Set<Mark>>(marksT.size());
for (Integer theSum : marksT) {
Set<Mark> allPossiblePermutations = getAllPossiblePermutations(theSum, minScoreP);
sumToPermutations.put(theSum, allPossiblePermutations);
}
int exceedsWithoutSurprises = 0;
int exceedsOnlyWithSurprises = 0;
for (Integer theSum : marksT) {
Set<Mark> marksPermutations = sumToPermutations.get(theSum);
boolean exceeded = false;
boolean needSurprise = true;
for (Mark marksPermutation : marksPermutations) {
if (marksPermutation.exceedsScore) {
exceeded = true;
if (!marksPermutation.surprise && needSurprise) {
needSurprise = false;
}
}
}
if (exceeded && needSurprise) {
exceedsOnlyWithSurprises++;
}
if (exceeded && !needSurprise) {
exceedsWithoutSurprises++;
}
}
return exceedsWithoutSurprises + Math.min(exceedsOnlyWithSurprises, surprises);
}
Set<Mark> getAllPossiblePermutations(int sum, int minScoreP) {
Set<Mark> markList = new LinkedHashSet<Mark>(5);
final int start = Math.max(sum / 3 - 2, 0);
final int stop = sum / 3 + 2;
for (int i = start; i <= stop; i++) {
for (int j = start; j <= stop; j++) {
for (int k = start; k <= stop; k++) {
final int divergence = Math.abs(max(i, j, k) - min(i, j, k));
if ((i + j + k == sum) && divergence <= 2) {
boolean exceedsScore = i >= minScoreP || j >= minScoreP || k >= minScoreP;
markList.add(new Mark(i, j, k, divergence == 2, exceedsScore));
}
}
}
}
return markList;
}
private static int min(int a, int b, int c) {
return Math.min(Math.min(a, b), c);
}
private static int max(int a, int b, int c) {
return Math.max(Math.max(a, b), c);
}
private String readLn(InputStream inputStream, int maxLength) { // utility function to read from stdin,
// Provided by Programming-challenges, edit for style only
byte line[] = new byte[maxLength];
int length = 0;
int input = -1;
try {
while (length < maxLength) {//Read untill maxlength
input = inputStream.read();
if ((input < 0) || (input == '\n')) break; //or untill end of line ninput
line[length++] += input;
}
if ((input < 0) && (length == 0)) return null; // eof
return new String(line, 0, length);
} catch (IOException e) {
return null;
}
}
static class Mark {
// array represents marks, always are sorted
private List<Integer> marks;
private boolean surprise;
private boolean exceedsScore;
Mark(int m0, int m1, int m2, boolean surprise, boolean exceedsScore) {
this.marks = new ArrayList<Integer>(3);
this.marks.add(m1);
this.marks.add(m0);
this.marks.add(m2);
this.surprise = surprise;
this.exceedsScore = exceedsScore;
// todo: possibly just put elements in the list in a right order
Collections.sort(this.marks);
Collections.reverse(this.marks);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Mark mark = (Mark) o;
if (exceedsScore != mark.exceedsScore) return false;
if (surprise != mark.surprise) return false;
if (marks != null ? !marks.equals(mark.marks) : mark.marks != null) return false;
return true;
}
@Override
public int hashCode() {
int result = marks != null ? marks.hashCode() : 0;
result = 31 * result + (surprise ? 1 : 0);
result = 31 * result + (exceedsScore ? 1 : 0);
return result;
}
@Override
public String toString() {
return "Mark{" +
"marks=" + marks +
", surprise=" + surprise +
", exceedsScore=" + exceedsScore +
'}';
}
}
}
|
A11201 | A11229 | 0 | package CodeJam.c2012.clasificacion;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* Problem
*
* You're watching a show where Googlers (employees of Google) dance, and then
* each dancer is given a triplet of scores by three judges. Each triplet of
* scores consists of three integer scores from 0 to 10 inclusive. The judges
* have very similar standards, so it's surprising if a triplet of scores
* contains two scores that are 2 apart. No triplet of scores contains scores
* that are more than 2 apart.
*
* For example: (8, 8, 8) and (7, 8, 7) are not surprising. (6, 7, 8) and (6, 8,
* 8) are surprising. (7, 6, 9) will never happen.
*
* The total points for a Googler is the sum of the three scores in that
* Googler's triplet of scores. The best result for a Googler is the maximum of
* the three scores in that Googler's triplet of scores. Given the total points
* for each Googler, as well as the number of surprising triplets of scores,
* what is the maximum number of Googlers that could have had a best result of
* at least p?
*
* For example, suppose there were 6 Googlers, and they had the following total
* points: 29, 20, 8, 18, 18, 21. You remember that there were 2 surprising
* triplets of scores, and you want to know how many Googlers could have gotten
* a best result of 8 or better.
*
* With those total points, and knowing that two of the triplets were
* surprising, the triplets of scores could have been:
*
* 10 9 10 6 6 8 (*) 2 3 3 6 6 6 6 6 6 6 7 8 (*)
*
* The cases marked with a (*) are the surprising cases. This gives us 3
* Googlers who got at least one score of 8 or better. There's no series of
* triplets of scores that would give us a higher number than 3, so the answer
* is 3.
*
* Input
*
* The first line of the input gives the number of test cases, T. T test cases
* follow. Each test case consists of a single line containing integers
* separated by single spaces. The first integer will be N, the number of
* Googlers, and the second integer will be S, the number of surprising triplets
* of scores. The third integer will be p, as described above. Next will be N
* integers ti: the total points of the Googlers.
*
* Output
*
* For each test case, output one line containing "Case #x: y", where x is the
* case number (starting from 1) and y is the maximum number of Googlers who
* could have had a best result of greater than or equal to p.
*
* Limits
*
* 1 ⤠T ⤠100. 0 ⤠S ⤠N. 0 ⤠p ⤠10. 0 ⤠ti ⤠30. At least S of the ti values
* will be between 2 and 28, inclusive.
*
* Small dataset
*
* 1 ⤠N ⤠3.
*
* Large dataset
*
* 1 ⤠N ⤠100.
*
* Sample
*
* Input Output 4 Case #1: 3 3 1 5 15 13 11 Case #2: 2 3 0 8 23 22 21 Case #3: 1
* 2 1 1 8 0 Case #4: 3 6 2 8 29 20 8 18 18 21
*
* @author Leandro Baena Torres
*/
public class B {
public static void main(String[] args) throws FileNotFoundException, IOException {
BufferedReader br = new BufferedReader(new FileReader("B.in"));
String linea;
int numCasos, N, S, p, t[], y, minSurprise, minNoSurprise;
linea = br.readLine();
numCasos = Integer.parseInt(linea);
for (int i = 0; i < numCasos; i++) {
linea = br.readLine();
String[] aux = linea.split(" ");
N = Integer.parseInt(aux[0]);
S = Integer.parseInt(aux[1]);
p = Integer.parseInt(aux[2]);
t = new int[N];
y = 0;
minSurprise = p + ((p - 2) >= 0 ? (p - 2) : 0) + ((p - 2) >= 0 ? (p - 2) : 0);
minNoSurprise = p + ((p - 1) >= 0 ? (p - 1) : 0) + ((p - 1) >= 0 ? (p - 1) : 0);
for (int j = 0; j < N; j++) {
t[j] = Integer.parseInt(aux[3 + j]);
if (t[j] >= minNoSurprise) {
y++;
} else {
if (t[j] >= minSurprise) {
if (S > 0) {
y++;
S--;
}
}
}
}
System.out.println("Case #" + (i + 1) + ": " + y);
}
}
}
| 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;
}
}
}
|
B10361 | B13044 | 0 | package codejam;
import java.util.*;
import java.io.*;
public class RecycledNumbers {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("in.txt"));
PrintWriter out = new PrintWriter(new File("out.txt"));
int T = Integer.parseInt(in.readLine());
for (int t = 1; t <= T; ++t) {
String[] parts = in.readLine().split("[ ]+");
int A = Integer.parseInt(parts[0]);
int B = Integer.parseInt(parts[1]);
int cnt = 0;
for (int i = A; i < B; ++i) {
String str = String.valueOf(i);
int n = str.length();
String res = "";
Set<Integer> seen = new HashSet<Integer>();
for (int j = n - 1; j > 0; --j) {
res = str.substring(j) + str.substring(0, j);
int k = Integer.parseInt(res);
if (k > i && k <= B) {
//System.out.println("(" + i + ", " + k + ")");
if (!seen.contains(k)) {
++cnt;
seen.add(k);
}
}
}
}
out.println("Case #" + t + ": " + cnt);
}
in.close();
out.close();
System.exit(0);
}
}
| import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.StringTokenizer;
public class MainC {
private static boolean esValido(Integer n,Integer A,Integer B,boolean comp)
{
int i=0;
boolean valido=false;
if (!comp || (n>=A && n<B))
{
if (n>9)
{
while((i+1)<n.toString().length() && valido==false)
{
if (n.toString().charAt(i)!=n.toString().charAt(i+1))
{
valido=true;
}
i++;
}
}
}
return valido;
}
private static String rotar(String i)
{
return (i.charAt(i.length()-1)+i.substring(0, i.length()-1));
}
private static void combValidas(Integer i,Integer A,Integer B,HashSet<Par> conj)
{
String aux=rotar(i.toString());
Integer num=Integer.parseInt(aux);
if (esValido(num,A,B,true))
{
if (!i.equals(num))
{
conj.add(new Par(i,num));
}
//System.out.println("Se encuentra el par " + i + ", "+num + " ya que esValido "+num+" en el intervalo "+ A+ "-"+B);
}
for (int j=0;j<i.toString().length()-2;j++)
{
aux=rotar(aux);
num=Integer.parseInt(aux);
if (esValido(num,A,B,true))
{
//System.out.println("Se encuentra el par " + i + ", "+num + " ya que esValido "+num+" en el intervalo "+ A+ "-"+B);
if (!i.equals(num))
{
conj.add(new Par(i,num));
}
}
}
}
private static Integer calcularResultado(Integer A, Integer B)
{
//Para cada número hay tantas combinaciones como su longitud menos 1 (podemos rotarlo n-1 veces)
HashSet<Par> conj=new HashSet<Par>();
for (int i=A;i<B;i++)
{
if (esValido(i,A,B,false))
{
combValidas(i,A,B,conj);
}
}
//Imprimimos resultados
for (Par p:conj)
{
System.out.println(p + " en "+A+"-"+B);
}
return conj.size();
}
public static void main(String[] args) {
File archivo = null;
FileReader fr = null;
FileWriter wr = null;
PrintWriter pw = null;
BufferedReader br = null;
Integer A,B;
Integer num = 0;
String linea;
String aux;
StringTokenizer st;
try {
archivo = new File("C:/Users/Pc/Desktop/input.in");
fr = new FileReader(archivo);
br = new BufferedReader(fr);
wr = new FileWriter("C:/Users/Pc/Desktop/output.out");
pw = new PrintWriter(wr);
// Lectura del fichero
while ((linea = br.readLine()) != null) {
if (num != 0) {
aux = "Case #" + num.toString() + ": "; //Inicialización del case #N:
st=new StringTokenizer(linea," ");
A=Integer.parseInt(st.nextToken());
B=Integer.parseInt(st.nextToken());
aux+=calcularResultado(A,B).toString();
pw.println(aux);
}
num++;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (null != fr) {
fr.close();
wr.close();
}
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
|
B21752 | B21951 | 0 | package Main;
import com.sun.deploy.util.ArrayUtil;
import org.apache.commons.lang3.ArrayUtils;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
/**
* Created with IntelliJ IDEA.
* User: arran
* Date: 14/04/12
* Time: 3:12 PM
* To change this template use File | Settings | File Templates.
*/
public class Round {
public StringBuilder parse(BufferedReader in) throws IOException {
StringBuilder out = new StringBuilder();
String lineCount = in.readLine();
for (int i = 1; i <= Integer.parseInt(lineCount); i++)
{
out.append("Case #"+i+": ");
System.err.println("Case #"+i+": ");
String line = in.readLine();
String[] splits = line.split(" ");
int p1 = Integer.valueOf(splits[0]);
int p2 = Integer.valueOf(splits[1]);
int r = pairRecyclable(p1, p2);
out.append(r);
// if (i < Integer.parseInt(lineCount))
out.append("\n");
}
return out;
}
public static int pairRecyclable(int i1, int i2) {
HashSet<String> hash = new HashSet<String>();
for (int i = i1; i < i2; i++)
{
String istr = String.valueOf(i);
if (istr.length() < 2) continue;
for (int p = 0; p < istr.length() ; p++)
{
String nistr = istr.substring(p,istr.length()).concat(istr.substring(0,p));
if (Integer.valueOf(nistr) < i1) continue;
if (Integer.valueOf(nistr) > i2) continue;
if (nistr.equals(istr)) continue;
String cnistr = (Integer.valueOf(nistr) > Integer.valueOf(istr)) ? istr + "," + nistr : nistr + "," + istr;
hash.add(cnistr);
}
}
return hash.size();
}
public static void main(String[] args) {
InputStreamReader converter = null;
try {
int attempt = 0;
String quest = "C";
// String size = "small-attempt";
String size = "large";
converter = new InputStreamReader(new FileInputStream("src/resource/"+quest+"-"+size+".in"));
BufferedReader in = new BufferedReader(converter);
Round r = new Round();
String str = r.parse(in).toString();
System.out.print(str);
FileOutputStream fos = new FileOutputStream(quest+"-"+size+".out");
OutputStreamWriter osw = new OutputStreamWriter(fos);
BufferedWriter bw = new BufferedWriter(osw);
bw.write(str);
bw.flush();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
public class RecycledNumbers {
private static final boolean DEBUG = false;
public static void main( final String[] args ) throws Exception {
final BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
final int t = Integer.parseInt( br.readLine() );
for ( int ii = 0; ii < t; ++ii ) {
final String parts[] = br.readLine().split( " " );
final int from = Integer.parseInt( parts[ 0 ] );
final int to = Integer.parseInt( parts[ 1 ] );
System.out.println( solve( ii + 1, from, to ) );
if ( DEBUG ) System.out.println( "=== === === === ===" );
}
}
private static String solve( final int idx, final int from, final int to ) {
final HashSet<Long> set = new HashSet<Long>();
for ( int i = from; i <= to; ++i ) {
add( set, i, from, to );
}
return String.format( "Case #%d: %d", idx, set.size() );
}
private static void add( final HashSet<Long> set, final long n, final int from, final int to ) {
final String ns = Long.toString( n );
for ( int i = 1; i < ns.length(); ++i ) {
final String f = ns.substring( 0, i );
final String t = ns.substring( i );
final long pair = getN( t, f );
final long min = Math.min( n, pair );
final long max = Math.max( n, pair );
if ( from <= pair && pair <= to && pair != n )
set.add( min * 3000000 + max );
}
}
private static long getN( final String s1, final String s2 ) {
long res = 0;
for ( int i = 0; i < s1.length(); ++i ) {
res += s1.charAt( i ) - '0';
res *= 10;
}
for ( int i = 0; i < s2.length(); ++i ) {
res += s2.charAt( i ) - '0';
res *= 10;
}
if ( DEBUG ) System.out.printf( "DEBUG: s1='%s', s2='%s', res=%d\n", s1, s2, res / 10 );
return res / 10;
}
@org.junit.Test
public void statement1() {
org.junit.Assert.assertEquals( String.format( "Case #%d: %d", 1, 0 ), solve( 1, 1, 9 ) );
}
@org.junit.Test
public void statement2() {
org.junit.Assert.assertEquals( String.format( "Case #%d: %d", 2, 3 ), solve( 2, 10, 40 ) );
}
@org.junit.Test
public void statement3() {
org.junit.Assert.assertEquals( String.format( "Case #%d: %d", 3, 156 ), solve( 3, 100, 500 ) );
}
@org.junit.Test
public void statement4() {
org.junit.Assert.assertEquals( String.format( "Case #%d: %d", 4, 287 ), solve( 4, 1111, 2222 ) );
}
@org.junit.Test(timeout = 10000)
public void my1() {
org.junit.Assert.assertEquals( String.format( "Case #%d: %d", 5, 299997 ), solve( 5, 1000000, 2000000 ) );
}
}
|
B21373 | B21042 | 0 | import java.io.*;
import java.util.*;
import java.awt.Point;
class Case{
int num0;
long num1,num2;
String result="";
public Case(File aFile) {
try{
StringBuilder contents = new StringBuilder();
BufferedReader input = new BufferedReader(new FileReader(aFile));
String line = input.readLine();
num0 = Integer.valueOf(line).intValue();
int i=1;
while (i<=num0 && ( line = input.readLine()) != null){
StringTokenizer st = new StringTokenizer(line," ");
num1=Long.valueOf(st.nextToken()).longValue();
num2=Long.valueOf(st.nextToken()).longValue();
oneCase(i,num1,num2);
i++;
}
}
catch (IOException ex){
ex.printStackTrace();
}
}
public String getResult (){
return result;
}
public void oneCase (int c,long n1,long n2){
String re="";
//*** output
System.out.println("case="+c+": "+n1+":"+n2);
//***
int y=0;
for (long i=n1; i<=n2; i++){
y+=checkRecycle(n1,n2,i);
}
re=y+"";
result+="Case #"+c+": "+re+System.getProperty("line.separator");
}
public int checkRecycle (long n1, long n2, long num){
String numSt=Long.valueOf(num).toString();
if (numSt.length()<2) return 0;
int re=0;
Vector allNum=new Vector();
for (int i=1; i<numSt.length(); i++){
String newNumSt=numSt.substring(i)+numSt.substring(0,i);
if (!newNumSt.substring(0,1).equals("0")){
if (Long.valueOf(newNumSt).longValue()>num){
if (Long.valueOf(newNumSt).longValue()>n1 && Long.valueOf(newNumSt).longValue()<=n2){
boolean found=false;
for (int j=0;!found&&j<allNum.size();j++){
if (newNumSt.equals((String)(allNum.elementAt(j))))
found=true;
}
if (!found){
allNum.addElement(newNumSt);
re++;
}
}
}
}
}
//if (re>0)System.out.println("checkRecycle "+numSt+" re="+re+" allNum="+allNum);
return re;
}
}
public class ReadWriteTextFile {
static public String getContents(File aFile) {
StringBuilder contents = new StringBuilder();
try {
BufferedReader input = new BufferedReader(new FileReader(aFile));
try {
String line = null;
while (( line = input.readLine()) != null){
contents.append(line);
contents.append(System.getProperty("line.separator"));
}
}
finally {
input.close();
}
}
catch (IOException ex){
ex.printStackTrace();
}
return contents.toString();
}
static public void setContents(File aFile, String aContents)
throws FileNotFoundException, IOException {
if (aFile == null) {
throw new IllegalArgumentException("File should not be null.");
}
if (!aFile.exists()) {
throw new FileNotFoundException ("File does not exist: " + aFile);
}
if (!aFile.isFile()) {
throw new IllegalArgumentException("Should not be a directory: " + aFile);
}
if (!aFile.canWrite()) {
throw new IllegalArgumentException("File cannot be written: " + aFile);
}
Writer output = new BufferedWriter(new FileWriter(aFile));
try {
output.write( aContents );
}
finally {
output.close();
}
}
public static void main (String... aArguments) throws IOException {
File testFile = new File("source.txt");
File testFile2 = new File("result.txt");
Case allcases = new Case(testFile);
setContents(testFile2, allcases.getResult());
}
}
| package de.hg.codejam.tasks.io;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public abstract class Writer {
public static String generateOutputPath(String inputPath) {
return inputPath.substring(0, inputPath.lastIndexOf('.') + 1) + "out";
}
public static void print(String[] output) {
for (String s : output)
System.out.println(s);
}
public static void write(String[] output) {
for (int i = 0; i < output.length; i++)
System.out.println(getCase(i + 1, output[i]));
}
public static void write(String[] output, String path) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(path,
false))) {
for (int i = 0; i < output.length; i++) {
writer.append(getCase(i + 1, output[i]));
writer.newLine();
writer.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static String getCase(int number, String caseString) {
return "Case #" + (number) + ": " + caseString;
}
}
|
B20424 | B20120 | 0 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
// static int MAX = 10000;
static int MAX = 2000000;
static Object[] All = new Object[MAX+1];
static int size( int x ) {
if(x>999999) return 7;
if(x>99999) return 6;
if(x>9999) return 5;
if(x>999) return 4;
if(x>99) return 3;
if(x>9) return 2;
return 1;
}
static int[] rotate( int value ) {
List<Integer> result = new ArrayList<Integer>();
int[] V = new int[8];
int s = size(value);
int x = value;
for(int i=s-1;i>=0;i--) {
V[i] = x%10;
x /=10;
}
int rot;
for(int i=1; i<s; i++) {
if(V[i]!=0){
rot=0;
for(int j=0,ii=i;j<s; j++,ii=(ii+1)%s){
rot=rot*10+V[ii];
}
if(rot>value && !result.contains(rot))
result.add(rot);
}
}
if( result.isEmpty() )
return null;
int[] r = new int[result.size()];
for(int i=0; i<r.length; i++)
r[i]=result.get(i);
return r;
}
static void precalculate() {
for(int i=1; i<=MAX; i++){
All[i] = rotate(i);
}
}
static int solve( Scanner in ) {
int A, B, sol=0;
A = in.nextInt();
B = in.nextInt();
for( int i=A; i<=B; i++) {
// List<Integer> result = rotate(i);
if( All[i]!=null ) {
for(int value: (int[])All[i] ) {
if( value <= B )
sol++;
}
}
}
return sol;
}
public static void main ( String args[] ) {
int T;
Scanner in = new Scanner(System.in);
T = in.nextInt();
int cnt=0;
int sol;
precalculate();
for( cnt=1; cnt<=T; cnt++ ) {
sol = solve( in );
System.out.printf("Case #%d: %d\n", cnt, sol);
}
}
}
| package taskc;
import java.util.*;
public class TaskC {
public static void main(String[] args) {
new TaskC().main();
}
int numOfDigits(int x) {
int res = 0;
while (x > 0) {
res++;
x /= 10;
}
return res;
}
int getCycle(int n, int i) {
String s = Integer.toString(n);
int leftlen = s.length() - i;
String res = s.substring(leftlen) + s.substring(0, leftlen);
return Integer.parseInt(res);
}
Set<Integer> generateCycleNumbers(int x) {
Set<Integer> res = new HashSet<Integer>();
int n = numOfDigits(x);
for (int i = 1; i < n; i++) {
int z = getCycle(x, i);
if (numOfDigits(z) == numOfDigits(x)) {
res.add(z);
}
}
return res;
}
int f(int x, int y) {
int res = 0;
for (int i = x; i <= y; i++) {
Set<Integer> cycles = generateCycleNumbers(i);
for (int q: cycles) {
if (q >= x && q <= y && q != i) {
//System.out.println(i +" -> " + q);
res++;
}
}
}
return res/2;
}
void main() {
Scanner s = new Scanner(System.in);
int T = s.nextInt();
for (int i = 1; i <= T; i++) {
int a = s.nextInt(), b = s.nextInt();
int ans = f(a, b);
System.out.println("Case #" + i + ": " + ans);
}
}
}
|
B12085 | B12240 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package gcj;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Scanner;
/**
*
* @author daniele
*/
public class GCJ_C {
public static void main(String[] args) throws Exception{
Scanner in = new Scanner(new File(args[0]));
FileWriter out = new FileWriter("/home/daniele/Scrivania/Output");
int prove=in.nextInt();
int min,max;
int cifre;
int cifreaus;
String temp;
int aus;
int count=0;
ArrayList<Integer> vals = new ArrayList<Integer>();
int jcount=0;
ArrayList<Integer> perm = new ArrayList<Integer>();
out.write("");
out.flush();
for(int i=1;i<=prove;i++){
out.append("Case #" +i+": ");out.flush();
min=in.nextInt();
max=in.nextInt();
for(int j=min;j<=max;j++){
if(!vals.contains(j)){
temp=""+j;
cifre=temp.length();
aus=j;
perm.add(j);
for(int k=1;k<cifre;k++){
aus=rotateOnce(aus);
temp=""+aus;
cifreaus=temp.length();//elusione zeri iniziali
if(aus>=min && aus<=max && aus!=j && cifreaus==cifre && nobody(vals,perm)){
perm.add(aus);
jcount ++;
}
}
while(jcount>0){count+=jcount; jcount--;}
vals.addAll(perm);
perm= new ArrayList<Integer>();
}
}
out.append(count+"\n");out.flush();
count=0;
vals= new ArrayList<Integer>();
}
}
static public int rotateOnce(int n){
String s=""+n;
if(s.length()>1){
s=s.charAt(s.length()-1) + s.substring(0,s.length()-1);
n=Integer.parseInt(s);
}
return n;
}
static public boolean nobody(ArrayList<Integer> v,ArrayList<Integer> a){;
for(int i=0;i<a.size();i++)
if(v.contains(a.get(i))) return false;
return true;
}
}
| import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashSet;
public class RecycledNumbers {
private static FileReader freader;
private static BufferedReader buffreader;
private static FileWriter fwriter;
private static BufferedWriter buffwriter;
public static void main(String[] args) throws IOException {
freader = new FileReader("C-small-attempt0.in");
buffreader = new BufferedReader(freader);
fwriter= new FileWriter("result.txt");
buffwriter = new BufferedWriter(fwriter);
String str = null;
int linenum = 0;
int i=1;
while((str=buffreader.readLine())!=null){
if(i==1)
linenum=Integer.parseInt(str);
else{
int start = Integer.parseInt(str.split(" ")[0]);
int end = Integer.parseInt(str.split(" ")[1]);
int num = calRecycleNum(start, end);
String finalStr = "Case #"+Integer.toString(i-1)+": "+Integer.toString(num)+"\n";
buffwriter.write(finalStr);
}
i++;
}
buffwriter.close();
fwriter.close();
buffreader.close();
freader.close();
}
public static int calRecycleNum(int start, int end){
int num = 0;
for(int i=start; i<=end; i++){
int len = Integer.toString(i).length();
int recycleVal = i;
HashSet<Integer> targetSet = new HashSet<Integer>();
for(int j=1; j<len; j++){
recycleVal = recycleOnce(recycleVal,len);
if(recycleVal<=i)
continue;
else if(recycleVal<=end && recycleVal>=start){
if(!targetSet.contains(recycleVal)){
num++;
//System.out.println(i+"\t"+recycleVal);
targetSet.add(recycleVal);
}
/*else{
System.out.println("Duplicate:"+recycleVal+"\t"+i);
}*/
}
}
}
//System.out.println(num);
return num;
}
public static int recycleOnce(int val, int length){
return (int) (val%Math.pow(10, length-1)*10+val/Math.pow(10, length-1));
}
}
|
A11277 | A10750 | 0 | package googlers;
import java.util.Scanner;
import java.util.PriorityQueue;
import java.util.Comparator;
public class Googlers {
public static void main(String[] args) {
int n,s,p,count=0,t;
Scanner sin=new Scanner(System.in);
t=Integer.parseInt(sin.nextLine());
int result[]=new int[t];
int j=0;
if(t>=1 && t<=100)
{
for (int k = 0; k < t; k++) {
count=0;
String ip = sin.nextLine();
String[]tokens=ip.split(" ");
n=Integer.parseInt(tokens[0]);
s=Integer.parseInt(tokens[1]);
p=Integer.parseInt(tokens[2]);
if( (s>=0 && s<=n) && (p>=0 && p<=10) )
{
int[] total=new int[n];
for (int i = 0; i < n; i++)
{
total[i] = Integer.parseInt(tokens[i+3]);
}
Comparator comparator=new PointComparator();
PriorityQueue pq=new PriorityQueue<Point>(1, comparator);
for (int i = 0; i < n; i++)
{
int x=total[i]/3;
int r=total[i]%3;
if(x>=p)
count++;
else if(x<(p-2))
continue;
else
{
//System.out.println("enter "+x+" "+(p-2));
if(p-x==1)
{
Point temp=new Point();
temp.q=x;
temp.r=r;
pq.add(temp);
}
else // p-x=2
{
if(r==0)
continue;
else
{
Point temp=new Point();
temp.q=x;
temp.r=r;
pq.add(temp);
}
}
}
//System.out.println("hi "+pq.size());
}
while(pq.size()!=0)
{
Point temp=(Point)pq.remove();
if(p-temp.q==1 && temp.q!=0)
{
if(temp.r>=1)
count++;
else
{
if(s!=0)
{
s--;
count++;
}
}
}
else if(p-temp.q==2)
{
if(s!=0 && (temp.q+temp.r)>=p)
{
s--;
count++;
}
}
}
//System.out.println(p);
result[j++]=count;
}
}
for (int i = 0; i < t; i++)
{
System.out.println("Case #"+(i+1)+": "+result[i]);
}
}
}
/*Point x=new Point();
x.q=8;
Point y=new Point();
y.q=6;
Point z=new Point();
z.q=7;
pq.add(x);
pq.add(y);
pq.add(z);
*/
}
class PointComparator implements Comparator<Point>
{
@Override
public int compare(Point x, Point y)
{
// Assume neither string is null. Real code should
// probably be more robust
if (x.q < y.q)
{
return 1;
}
if (x.q > y.q)
{
return -1;
}
return 0;
}
}
class Point
{
int q,r;
public int getQ() {
return q;
}
public void setQ(int q) {
this.q = q;
}
public int getR() {
return r;
}
public void setR(int r) {
this.r = r;
}
}
| import java.util.Scanner;
/*
* Google Code Jam 2012
* Program by Tommy Ludwig
* Problem: Dancing With the Googlers
* Date: 2012-04-13
*/
public class dancing {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T, N, S, p;
T = in.nextInt();
for (int i = 1; i <= T; i++) {
int y = 0;
N = in.nextInt();
S = in.nextInt();
p = in.nextInt();
int [] t = new int[N];
for (int j = 0; j < N; j++)
t[j] = in.nextInt();
//minimum number with surprise case
int minNumS = (3 * p) - 4;
if (minNumS < 2) minNumS = 2;
//minimum number without surprise case
int minNum = (3 * p) - 2;
//if (minNum < 0) minNum = 0;
for (int j = 0; j < N; j++) {
if (t[j] >= minNum)
y++;
else if (t[j] >= minNumS && S > 0) {
y++;
S--;
}
}
System.out.printf("Case #%d: %d\n", i, y);
}
}
}
|
B10485 | B12231 | 0 |
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
import java.io.File;
import java.io.IOException;
import java.io.FileWriter;
import java.io.BufferedWriter;
public class Recycle
{
public static void main(String[] args)
{
/* Set<Integer> perms = getPermutations(123456);
for(Integer i: perms)
System.out.println(i);*/
try
{
Scanner s = new Scanner(new File("recycle.in"));
BufferedWriter w = new BufferedWriter(new FileWriter(new File("recycle.out")));
int numCases = s.nextInt();
s.nextLine();
for(int n = 1;n <= numCases; n++)
{
int A = s.nextInt();
int B = s.nextInt();
int count = 0;
for(int k = A; k <= B; k++)
{
count += getNumPairs(k, B);
}
w.write("Case #" + n + ": " + count + "\n");
}
w.flush();
w.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static int getNumPairs(int n, int B)
{
Set<Integer> possibles = getPermutations(n);
int count = 0;
for(Integer i : possibles)
if(i > n && i <= B)
count++;
return count;
}
public static Set<Integer> getPermutations(int n)
{
Set<Integer> perms = new TreeSet<Integer>();
char[] digits = String.valueOf(n).toCharArray();
for(int firstPos = 1; firstPos < digits.length; firstPos++)
{
String toBuild = "";
for(int k = 0; k < digits.length; k++)
toBuild += digits[(firstPos + k) % digits.length];
perms.add(Integer.parseInt(toBuild));
}
return perms;
}
} | import java.io.*;
class Programa
{
public static long procesar(String linea)
{
String vals[]=linea.split(" ");
int digitos=vals[0].length();
long a,b;
a=Long.parseLong(vals[0]);
b=Long.parseLong(vals[1]);
long reciclados=0;
int indi,ind = (int)(b-a+1);
int parejas[][]=new int[ind][ind];
long t=b-a+1;
long cal;
long v,resto,pot;
String resu,resu2;
/* for (long =0;l<t;l++) {
r[(int)l]=0;
r[(int)l]=0;
}*/
for (long l=a;l<=b;l++)
{
ind=(int) (l-a);
for (int k=1;k<digitos;k++)
{
pot=(long) Math.pow(10,k);
resto=l%pot;
v=l/pot;
resu=""+resto+v;
cal=Long.parseLong(resu);
indi=(int) (l-a);
ind=(int) (cal-a);
if (cal>=a && cal<=b && cal!=l && parejas[indi][ind]==0 && parejas[ind][indi]==0 )
{
// System.out.println(""+l+" "+cal);
parejas[indi][ind]=1;
reciclados++;
}
}
}
return reciclados;
}
public static void main(String args[])
{
try{
FileInputStream fstream = new FileInputStream(args[0]);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
strLine = br.readLine();
int casos=Integer.parseInt(strLine);
int caso=1;
long respuesta=0;
while ((strLine = br.readLine()) != null) {
respuesta=procesar(strLine);
System.out.println("Case #"+caso+": "+respuesta);
caso++;
}
//Close the input stream
in.close();
}catch (IOException e){//Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
} |
B10899 | B11905 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
public class ReadFile {
public static void main(String[] args) throws Exception {
String srcFile = "C:" + File.separator + "Documents and Settings"
+ File.separator + "rohit" + File.separator + "My Documents"
+ File.separator + "Downloads" + File.separator
+ "C-small-attempt1.in.txt";
String destFile = "C:" + File.separator + "Documents and Settings"
+ File.separator + "rohit" + File.separator + "My Documents"
+ File.separator + "Downloads" + File.separator
+ "C-small-attempt0.out";
File file = new File(srcFile);
List<String> readData = new ArrayList<String>();
FileReader fileInputStream = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileInputStream);
StringBuilder stringBuilder = new StringBuilder();
String line = null;
while ((line = bufferedReader.readLine()) != null) {
readData.add(line);
}
stringBuilder.append(generateOutput(readData));
File writeFile = new File(destFile);
if (!writeFile.exists()) {
writeFile.createNewFile();
}
FileWriter fileWriter = new FileWriter(writeFile);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write(stringBuilder.toString());
bufferedWriter.close();
System.out.println("output" + stringBuilder);
}
/**
* @param number
* @return
*/
private static String generateOutput(List<String> number) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < number.size(); i++) {
if (i == 0) {
continue;
} else {
String tempString = number.get(i);
String[] temArr = tempString.split(" ");
stringBuilder.append("Case #" + i + ": ");
stringBuilder.append(getRecNumbers(temArr[0], temArr[1]));
stringBuilder.append("\n");
}
}
if (stringBuilder.length() > 0) {
stringBuilder.deleteCharAt(stringBuilder.length() - 1);
}
return stringBuilder.toString();
}
// /* This method accepts method for google code jam */
// private static String method(String value) {
// int intValue = Integer.valueOf(value);
// double givenExpr = 3 + Math.sqrt(5);
// double num = Math.pow(givenExpr, intValue);
// String valArr[] = (num + "").split("\\.");
// int finalVal = Integer.valueOf(valArr[0]) % 1000;
//
// return String.format("%1$03d", finalVal);
//
// }
//
// /* This method accepts method for google code jam */
// private static String method2(String value) {
// StringTokenizer st = new StringTokenizer(value, " ");
// String test[] = value.split(" ");
// StringBuffer str = new StringBuffer();
//
// for (int i = 0; i < test.length; i++) {
// // test[i]=test[test.length-i-1];
// str.append(test[test.length - i - 1]);
// str.append(" ");
// }
// str.deleteCharAt(str.length() - 1);
// String strReversedLine = "";
//
// while (st.hasMoreTokens()) {
// strReversedLine = st.nextToken() + " " + strReversedLine;
// }
//
// return str.toString();
// }
private static int getRecNumbers(String no1, String no2) {
int a = Integer.valueOf(no1);
int b = Integer.valueOf(no2);
Set<String> dupC = new HashSet<String>();
for (int i = a; i <= b; i++) {
int n = i;
List<String> value = findPerm(n);
for (String val : value) {
if (Integer.valueOf(val) <= b && Integer.valueOf(val) >= a
&& n < Integer.valueOf(val)) {
dupC.add(n + "-" + val);
}
}
}
return dupC.size();
}
private static List<String> findPerm(int num) {
String numString = String.valueOf(num);
List<String> value = new ArrayList<String>();
for (int i = 0; i < numString.length(); i++) {
String temp = charIns(numString, i);
if (!temp.equalsIgnoreCase(numString)) {
value.add(charIns(numString, i));
}
}
return value;
}
public static String charIns(String str, int j) {
String begin = str.substring(0, j);
String end = str.substring(j);
return end + begin;
}
} | import java.util.*;
public class C
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int test = 1, cases = sc.nextInt();
int a, b, curr, count;
String aStr, bStr, num, shift;
while(test <= cases)
{
count = 0;
a = sc.nextInt();
b = sc.nextInt();
aStr = Integer.toString(a);
bStr = Integer.toString(b);
for(curr = a; curr <= b; curr++)
{
num = Integer.toString(curr);
shift = nextShift(num);
while(!num.equals(shift))
{
if(shift.charAt(0) != '0' && aStr.compareTo(shift) <= 0 && bStr.compareTo(shift) >= 0 && num.compareTo(shift) < 0)
count++;
shift = nextShift(shift);
}
}
System.out.println("Case #" + test + ": " + count);
test++;
}
}
public static String nextShift(String s)
{
if(s.length() <= 1)
return s;
else return s.substring(1, s.length()) + s.substring(0, 1);
}
} |
B10702 | B12419 | 0 | import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
public class Recycle {
private static HashMap<Integer, HashSet<Integer>> map = new HashMap<Integer, HashSet<Integer>>();
private static HashSet<Integer> toSkip = new HashSet<Integer>();
/**
* @param args
*/
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int T = reader.nextInt();
for (int tc = 1; tc <= T; tc++) {
int a = reader.nextInt();
int b = reader.nextInt();
long before = System.currentTimeMillis();
int res = doit(a, b);
System.out.printf("Case #%d: %d\n", tc, res);
long after = System.currentTimeMillis();
// System.out.println("time taken: " + (after - before));
}
}
private static int doit(int a, int b) {
int count = 0;
HashSet<Integer> skip = new HashSet<Integer>(toSkip);
for (int i = a; i <= b; i++) {
if (skip.contains(i))
continue;
HashSet<Integer> arr = generate(i);
// if(arr.size() > 1) {
// map.put(i, arr);
// }
// System.out.println(i + " --> " +
// Arrays.deepToString(arr.toArray()));
int temp = 0;
if (arr.size() > 1) {
for (int x : arr) {
if (x >= a && x <= b) {
temp++;
skip.add(x);
}
}
count += temp * (temp - 1) / 2;
}
// System.out.println("not skipping " + i + " gen: " + arr.size()+ " " + (temp * (temp - 1) / 2));
}
return count;
}
private static HashSet<Integer> generate(int num) {
if(map.containsKey(num)) {
HashSet<Integer> list = map.get(num);
return list;
}
HashSet<Integer> list = new HashSet<Integer>();
String s = "" + num;
list.add(num);
int len = s.length();
for (int i = 1; i < len; i++) {
String temp = s.substring(i) + s.substring(0, i);
// System.out.println("temp: " + temp);
if (temp.charAt(0) == '0')
continue;
int x = Integer.parseInt(temp);
if( x <= 2000000) {
list.add(x);
}
}
if(list.size() > 1) {
map.put(num, list);
} else {
toSkip.add(num);
}
return list;
}
}
| import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
/**
* Created by IntelliJ IDEA.
* User: elbek
* Date: 4/13/12
* Time: 7:31 PM
* To change this template use File | Settings | File Templates.
*/
public class Test {
public static void main(String[] args) {
int count = 0;
Set<String> found = new TreeSet<String>();
int t = 50;
Scanner scanner = new Scanner(System.in);
for (int q = 0; q <= t; q++) {
count = 0;
String str = scanner.nextLine();
String []arg = str.split(" ");
Integer a = Integer.parseInt(arg[0]);
Integer b = Integer.parseInt(arg[1]);
for (int i = a; i <= b; i++) {
String input = String.valueOf(i);
String changed;
int len = input.length();
for (int j = 1; j < len; j++) {
changed = input.substring(j, len) + input.substring(0, j);
if (Integer.valueOf(changed) <= Integer.valueOf(input)) continue;
if (Integer.valueOf(changed) <= b && Integer.valueOf(changed) >= a) {
found.add(input + " - " + changed);
// found.add(changed);
count++;
}
}
}
System.out.println("Case #"+(q+1)+": "+count);
}
}
}
|
A22191 | A21460 | 0 | package com.example;
import java.io.IOException;
import java.util.List;
public class ProblemB {
enum Result {
INSUFFICIENT,
SUFFICIENT,
SUFFICIENT_WHEN_SURPRISING
}
public static void main(String[] a) throws IOException {
List<String> lines = FileUtil.getLines("/B-large.in");
int cases = Integer.valueOf(lines.get(0));
for(int c=0; c<cases; c++) {
String[] tokens = lines.get(c+1).split(" ");
int n = Integer.valueOf(tokens[0]); // N = number of Googlers
int s = Integer.valueOf(tokens[1]); // S = number of surprising triplets
int p = Integer.valueOf(tokens[2]); // P = __at least__ a score of P
int sumSufficient = 0;
int sumSufficientSurprising = 0;
for(int i=0; i<n; i++) {
int points = Integer.valueOf(tokens[3+i]);
switch(test(points, p)) {
case SUFFICIENT:
sumSufficient++;
break;
case SUFFICIENT_WHEN_SURPRISING:
sumSufficientSurprising++;
break;
}
// uSystem.out.println("points "+ points +" ? "+ p +" => "+ result);
}
System.out.println("Case #"+ (c+1) +": "+ (sumSufficient + Math.min(s, sumSufficientSurprising)));
// System.out.println();
// System.out.println("N="+ n +", S="+ s +", P="+ p);
// System.out.println();
}
}
private static Result test(int n, int p) {
int fac = n / 3;
int rem = n % 3;
if(rem == 0) {
// int triplet0[] = { fac, fac, fac };
// print(n, triplet0);
if(fac >= p) {
return Result.SUFFICIENT;
}
if(fac > 0 && fac < 10) {
if(fac+1 >= p) {
return Result.SUFFICIENT_WHEN_SURPRISING;
}
// int triplet1[] = { fac+1, fac, fac-1 }; // surprising
// print(n, triplet1);
}
} else if(rem == 1) {
// int triplet0[] = { fac+1, fac, fac };
// print(n, triplet0);
if(fac+1 >= p) {
return Result.SUFFICIENT;
}
// if(fac > 0 && fac < 10) {
// int triplet1[] = { fac+1, fac+1, fac-1 };
// print(n, triplet1);
// }
} else if(rem == 2) {
// int triplet0[] = { fac+1, fac+1, fac };
// print(n, triplet0);
if(fac+1 >= p) {
return Result.SUFFICIENT;
}
if(fac < 9) {
// int triplet1[] = { fac+2, fac, fac }; // surprising
// print(n, triplet1);
if(fac+2 >= p) {
return Result.SUFFICIENT_WHEN_SURPRISING;
}
}
} else {
throw new RuntimeException("error");
}
return Result.INSUFFICIENT;
// System.out.println();
// System.out.println(n +" => "+ div3 +" ("+ rem +")");
}
// private static void print(int n, int[] triplet) {
// System.out.println("n="+ n +" ("+ (n/3) +","+ (n%3) +") => ["+ triplet[0] +","+ triplet[1] +","+ triplet[2] +"]" + (triplet[0]-triplet[2] > 1 ? " *" : ""));
// }
}
| import java.io.*;
public class Dancing{
public static void main(String args []){
try{
FileInputStream fstream = new FileInputStream("Blarge.in");
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
FileWriter ostream = new FileWriter("danceOut.txt");
BufferedWriter out = new BufferedWriter(ostream);
String str = br.readLine();
int num = Integer.parseInt(str.replaceAll("\\s",""));
String [] cases = new String[num];
String temp;
int k = 0;
while((temp = br.readLine()) != null && k < num){
cases[k] = temp;
++k;
}
for(int i=1; i<= num; i++){
String scores = cases[i-1].trim();
int n = calcScores(scores);
out.write("Case #" + i + ": " + n);
out.write("\n");
out.flush();
}
out.close();
}
catch(Exception e){}
}
public static int calcScores(String input){
String [] nums = input.split(" ");
int N = Integer.parseInt(nums[0].replaceAll("\\s",""));
int s = Integer.parseInt(nums[1].replaceAll("\\s",""));
int p = Integer.parseInt(nums[2].replaceAll("\\s",""));
int scores[] = new int[N];
int max = 0;
int sLeft = s;
for (int i=0; i< N; i++)
scores[i] = Integer.parseInt(nums[3+i].replaceAll("\\s",""));
for(int i=0; i < N; i++){
int x = scores[i];
if(findMax(x) >= p)
++max;
else{
if(sLeft > 0 && findSurprise(x) >= p){
++max;
--sLeft;
}
}
}
return max;
}
// Three cases: mod 1, mod 2 or mod 0
public static int findMax(int x){
if(x % 3 == 0)
return x/3;
else
return (x/3) + 1;
}
public static int findSurprise(int x){
if(x % 3 == 2)
return (x/3) + 2;
else if(x != 0)
return (x/3) + 1;
else
return 0;
}
}
|
A22992 | A20361 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package IO;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/**
*
* @author dannocz
*/
public class InputReader {
public static Input readFile(String filename){
try {
/* Sets up a file reader to read the file passed on the command
77 line one character at a time */
FileReader input = new FileReader(filename);
/* Filter FileReader through a Buffered read to read a line at a
time */
BufferedReader bufRead = new BufferedReader(input);
String line; // String that holds current file line
int count = 0; // Line number of count
ArrayList<String> cases= new ArrayList<String>();
// Read first line
line = bufRead.readLine();
int noTestCases=Integer.parseInt(line);
count++;
// Read through file one line at time. Print line # and line
while (count<=noTestCases){
//System.out.println("Reading. "+count+": "+line);
line = bufRead.readLine();
cases.add(line);
count++;
}
bufRead.close();
return new Input(noTestCases,cases);
}catch (ArrayIndexOutOfBoundsException e){
/* If no file was passed on the command line, this expception is
generated. A message indicating how to the class should be
called is displayed */
e.printStackTrace();
}catch (IOException e){
// If another exception is generated, print a stack trace
e.printStackTrace();
}
return null;
}// end main
}
| package R0;
import java.io.*;
import java.util.*;
public class B {
private static void solve(int TC) {
int N = ni();
int S = ni();
int p = ni();
int g[] = new int[N];
for (int i = 0; i < g.length; i++)
g[i] = ni();
int ok = 3 * p - 2;
int pok = ok - 2;
if ( p == 1 )
pok = 1;
int ret = 0;
for (int i : g) {
if ( i >= ok ) {
ret++;
continue;
}
if ( S > 0 && i >= pok ) {
ret++;
S--;
}
}
out.println(String.format("Case #%d: %d", TC, ret));
}
private static final boolean STDIO = false;
private static final String TASK = "B";
private static final String ROUND = "R0";
private static final String DATA = "large";
private static Scanner sc;
private static PrintStream out;
public static void main(String[] args) throws FileNotFoundException, IOException {
Locale.setDefault(Locale.ENGLISH);
String DATA_IN = String.format("tst/%s/%s.%s.in", ROUND, TASK, DATA);
String DATA_OUT = String.format("tst/%s/%s.%s.out", ROUND, TASK, DATA);
String str = null;
if ( args.length > 0 )
str = args[0];
else if ( !STDIO )
str = DATA_IN;
sc = new Scanner((str != null) ? new FileInputStream(str) : System.in);
str = null;
if ( args.length > 1 )
str = args[1];
else if ( !STDIO )
str = DATA_OUT;
out = (str != null) ? new PrintStream(str) : System.out;
int TC = ni();
for (int i = 1; i <= TC; i++) {
solve(i);
}
}
private static int ni() {
return sc.nextInt();
}
}
|
B20424 | B21756 | 0 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
// static int MAX = 10000;
static int MAX = 2000000;
static Object[] All = new Object[MAX+1];
static int size( int x ) {
if(x>999999) return 7;
if(x>99999) return 6;
if(x>9999) return 5;
if(x>999) return 4;
if(x>99) return 3;
if(x>9) return 2;
return 1;
}
static int[] rotate( int value ) {
List<Integer> result = new ArrayList<Integer>();
int[] V = new int[8];
int s = size(value);
int x = value;
for(int i=s-1;i>=0;i--) {
V[i] = x%10;
x /=10;
}
int rot;
for(int i=1; i<s; i++) {
if(V[i]!=0){
rot=0;
for(int j=0,ii=i;j<s; j++,ii=(ii+1)%s){
rot=rot*10+V[ii];
}
if(rot>value && !result.contains(rot))
result.add(rot);
}
}
if( result.isEmpty() )
return null;
int[] r = new int[result.size()];
for(int i=0; i<r.length; i++)
r[i]=result.get(i);
return r;
}
static void precalculate() {
for(int i=1; i<=MAX; i++){
All[i] = rotate(i);
}
}
static int solve( Scanner in ) {
int A, B, sol=0;
A = in.nextInt();
B = in.nextInt();
for( int i=A; i<=B; i++) {
// List<Integer> result = rotate(i);
if( All[i]!=null ) {
for(int value: (int[])All[i] ) {
if( value <= B )
sol++;
}
}
}
return sol;
}
public static void main ( String args[] ) {
int T;
Scanner in = new Scanner(System.in);
T = in.nextInt();
int cnt=0;
int sol;
precalculate();
for( cnt=1; cnt<=T; cnt++ ) {
sol = solve( in );
System.out.printf("Case #%d: %d\n", cnt, sol);
}
}
}
| /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package recyclednumbers;
/**
*
* @author WC
*/
public class RecycledNumbers {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
(new RecycledNumbers()).findRecycledNumbers("C-large.in", "C-large.out", "\n");
}
private void findRecycledNumbers(String filename, String outputFile, String separator) {
int numberOfTestCases = CodeJamFileManager.getIntFromFirstLineOfFile(filename, separator);
String[] testCases = CodeJamFileManager.getTextLinesOfFile(filename, separator);
String output = "";
for (int i = 1; i <= numberOfTestCases; i++) {
output += "Case #" + i + ": " + getNumberOfRecycledInts(testCases[i]) + (i != numberOfTestCases ? separator : "");
}
CodeJamFileManager.saveOutputFile(output, outputFile, separator);
}
private int getNumberOfRecycledInts(String testcase) {
int[] params = getIntArrayFromString(testcase.split(" "));
int lower = params[0];
int upper = params[1];
int currentM = lower + 1;
int numberOfRecycles = 0;
while (currentM <= upper) {
int count = timesRecycled(lower, currentM++);
numberOfRecycles += count;
}
return numberOfRecycles;
}
private int timesRecycled(int lower, int currentM) {
String currentMStr = String.valueOf(currentM);
char[] individualNumbers = currentMStr.toCharArray();
int timesRecycled = 0;
for (int i = 1; i < individualNumbers.length; i++) {
int flip = flip(individualNumbers, i);
if (flip >= lower && flip < currentM) {
timesRecycled++;
}
}
return timesRecycled;
}
private int flip(char[] individualNumbers, int positionsToFlip) {
char[] flip = new char[individualNumbers.length];
int startInt = individualNumbers.length - positionsToFlip;
int flipPos = 0;
while (startInt < individualNumbers.length) {
flip[flipPos++] = individualNumbers[startInt++];
}
int i = 0;
while (i < (individualNumbers.length - positionsToFlip)) {
flip[flipPos++] = individualNumbers[i++];
}
return Integer.parseInt(String.valueOf(flip));
}
private int[] getIntArrayFromString(String[] intStrArray) {
int[] intArray = new int[intStrArray.length];
int i = 0;
for (String intStr : intStrArray) {
intArray[i++] = Integer.parseInt(intStr);
}
return intArray;
}
}
|
A20490 | A20063 | 0 | /**
*
*/
package hu.herba.codejam;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
/**
* Base functionality, helper functions for CodeJam problem solver utilities.
*
* @author csorbazoli
*/
public abstract class AbstractCodeJamBase {
private static final String EXT_OUT = ".out";
protected static final int STREAM_TYPE = 0;
protected static final int FILE_TYPE = 1;
protected static final int READER_TYPE = 2;
private static final String DEFAULT_INPUT = "test_input";
private static final String DEFAULT_OUTPUT = "test_output";
private final File inputFolder;
private final File outputFolder;
public AbstractCodeJamBase(String[] args, int type) {
String inputFolderName = AbstractCodeJamBase.DEFAULT_INPUT;
String outputFolderName = AbstractCodeJamBase.DEFAULT_OUTPUT;
if (args.length > 0) {
inputFolderName = args[0];
}
this.inputFolder = new File(inputFolderName);
if (!this.inputFolder.exists()) {
this.showUsage("Input folder '" + this.inputFolder.getAbsolutePath() + "' not exists!");
}
if (args.length > 1) {
outputFolderName = args[1];
}
this.outputFolder = new File(outputFolderName);
if (this.outputFolder.exists() && !this.outputFolder.canWrite()) {
this.showUsage("Output folder '" + this.outputFolder.getAbsolutePath() + "' not writeable!");
} else if (!this.outputFolder.exists() && !this.outputFolder.mkdirs()) {
this.showUsage("Could not create output folder '" + this.outputFolder.getAbsolutePath() + "'!");
}
File[] inputFiles = this.inputFolder.listFiles();
for (File inputFile : inputFiles) {
this.processInputFile(inputFile, type);
}
}
/**
* @return the inputFolder
*/
public File getInputFolder() {
return this.inputFolder;
}
/**
* @return the outputFolder
*/
public File getOutputFolder() {
return this.outputFolder;
}
/**
* @param input
* input reader
* @param output
* output writer
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
@SuppressWarnings("unused")
protected void process(BufferedReader reader, PrintWriter pw) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (reader/writer)!!!");
System.exit(-2);
}
/**
* @param input
* input file
* @param output
* output file (will be overwritten)
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(File input, File output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (file/file)!!!");
System.exit(-2);
}
/**
* @param input
* input stream
* @param output
* output stream
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(InputStream input, OutputStream output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (stream/stream)!!!");
System.exit(-2);
}
/**
* @param type
* @param input
* @param output
*/
private void processInputFile(File input, int type) {
long starttime = System.currentTimeMillis();
System.out.println("Processing '" + input.getAbsolutePath() + "'...");
File output = new File(this.outputFolder, input.getName() + AbstractCodeJamBase.EXT_OUT);
if (type == AbstractCodeJamBase.STREAM_TYPE) {
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(input);
os = new FileOutputStream(output);
this.process(is, os);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
System.out.println("Failed to close output: " + e.getLocalizedMessage());
}
}
}
} else if (type == AbstractCodeJamBase.READER_TYPE) {
BufferedReader reader = null;
PrintWriter pw = null;
try {
reader = new BufferedReader(new FileReader(input));
pw = new PrintWriter(output);
this.process(reader, pw);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (pw != null) {
pw.close();
}
}
} else if (type == AbstractCodeJamBase.FILE_TYPE) {
try {
this.process(input, output);
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
}
} else {
this.showUsage("Unknown type given: " + type + " (accepted values: 0,1)");
}
System.out.println(" READY (" + (System.currentTimeMillis() - starttime) + " ms)");
}
/**
* Read a single number from input
*
* @param reader
* @param purpose
* What is the purpose of given data
* @return
* @throws IOException
* @throws IllegalArgumentException
*/
protected int readInt(BufferedReader reader, String purpose) throws IOException, IllegalArgumentException {
int ret = 0;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer (" + purpose + ")!");
}
try {
ret = Integer.parseInt(line);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: the first line '" + line + "' should be an integer (" + purpose + ")!");
}
return ret;
}
/**
* Read array of integers
*
* @param reader
* @param purpose
* @return
*/
protected int[] readIntArray(BufferedReader reader, String purpose) throws IOException {
int[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer list (" + purpose + ")!");
}
String[] strArr = line.split("\\s");
int len = strArr.length;
ret = new int[len];
for (int i = 0; i < len; i++) {
try {
ret[i] = Integer.parseInt(strArr[i]);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: line '" + line + "' should be an integer list (" + purpose + ")!");
}
}
return ret;
}
/**
* Read array of strings
*
* @param reader
* @param purpose
* @return
*/
protected String[] readStringArray(BufferedReader reader, String purpose) throws IOException {
String[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be a string list (" + purpose + ")!");
}
ret = line.split("\\s");
return ret == null ? new String[0] : ret;
}
/**
* Basic usage pattern. Can be overwritten by current implementation
*
* @param message
* Short message, describing the problem with given program
* arguments
*/
protected void showUsage(String message) {
if (message != null) {
System.out.println(message);
}
System.out.println("Usage:");
System.out.println("\t" + this.getClass().getName() + " program");
System.out.println("\tArguments:");
System.out.println("\t\t<input folder>:\tpath of input folder (default: " + AbstractCodeJamBase.DEFAULT_INPUT + ").");
System.out.println("\t\t \tAll files will be processed in the folder");
System.out.println("\t\t<output folder>:\tpath of output folder (default: " + AbstractCodeJamBase.DEFAULT_OUTPUT + ")");
System.out.println("\t\t \tOutput file name will be the same as input");
System.out.println("\t\t \tinput with extension '.out'");
System.exit(-1);
}
}
| import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
public class DancingGooglers {
private final String inputFile = "D:\\input.in";
private final String outputFile = "D:\\output.out";
private static class TestCase{
int n;
int s;
int p;
int result = 0;
List<Integer> ti = new ArrayList<Integer>();
public void calculateBest(){
result = 0;
int max = p * 3;
for (int i: ti){
if (p <= 0){
result++;
continue;
}
if (i > 0 && i >= (max - 4)){
if (i >= max || (max - i) <= 2){
result++;
}else if((max - i) <= 4 && s > 0){
result++; s--;
}
}
}
}
}
List<TestCase> input = new ArrayList<DancingGooglers.TestCase>();
public void parseInput(){
try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile)));
int numTestCases = Integer.parseInt(br.readLine());
for (int i = 0; i < numTestCases; i++){
String [] lineTokens = br.readLine().split(" ");
TestCase tc = new TestCase();
tc.n = Integer.parseInt(lineTokens[0]);
tc.s = Integer.parseInt(lineTokens[1]);
tc.p = Integer.parseInt(lineTokens[2]);
for (int j = 3; j < lineTokens.length; j++){
tc.ti.add(Integer.parseInt(lineTokens[j]));
}
tc.calculateBest();
input.add(tc);
}
br.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public void doOutput(){
try {
PrintWriter pw = new PrintWriter(new FileOutputStream(outputFile));
for (int i = 0; i < input.size(); i++){
TestCase tc = input.get(i);
pw.println("Case #" + (i + 1) + ": " + tc.result);
}
pw.flush();
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void main(String [] args){
DancingGooglers dg = new DancingGooglers();
dg.parseInput();
dg.doOutput();
}
}
|
A12846 | A12385 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package codejam.common;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author Lance Chen
*/
public class CodeHelper {
private static String FILE_ROOT = "D:/workspace/googlecodejam/meta";
public static List<List<String>> loadInputsExcludes(String fileName) {
List<List<String>> result = new ArrayList<List<String>>();
List<String> lines = FileUtil.readLines(FILE_ROOT + fileName);
int index = 0;
for (String line : lines) {
if (index == 0) {
index++;
continue;
}
if (index % 2 == 1) {
index++;
continue;
}
List<String> dataList = new ArrayList<String>();
String[] dataArray = line.split("\\s+");
for (String data : dataArray) {
if (data.trim().length() > 0) {
dataList.add(data);
}
}
result.add(dataList);
index++;
}
return result;
}
public static List<List<String>> loadInputs(String fileName) {
List<List<String>> result = new ArrayList<List<String>>();
List<String> lines = FileUtil.readLines(FILE_ROOT + fileName);
for (String line : lines) {
List<String> dataList = new ArrayList<String>();
String[] dataArray = line.split("\\s+");
for (String data : dataArray) {
if (data.trim().length() > 0) {
dataList.add(data);
}
}
result.add(dataList);
}
return result;
}
public static List<String> loadInputLines(String fileName) {
return FileUtil.readLines(FILE_ROOT + fileName);
}
public static void writeOutputs(String fileName, List<String> lines) {
FileUtil.writeLines(FILE_ROOT + fileName, lines);
}
}
| import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Solution2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// System.out.println(Solution2.calculteBestNum("6 2 8 29 20 8 18 18 21"));
BufferedReader bReader = null;
FileWriter fWriter = null;
try {
bReader = new BufferedReader(new FileReader(new File("B-small-attempt0.in")));
fWriter = new FileWriter(new File("Output"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
int num = 0;
try {
num = Integer.parseInt(bReader.readLine());
} catch (NumberFormatException | IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
for(int i = 1; i < num + 1; i ++){
String ssString = "";
try {
ssString = bReader.readLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(ssString == null){
break;
}
else if(ssString.trim() == ""){
continue;
}
try {
fWriter.write("Case #"+ i +": " + Solution2.calculteBestNum(ssString));
fWriter.write("\n");
fWriter.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static int calculteBestNum(String scores){
String[] tmp = scores.split(" ");
int num = Integer.parseInt(tmp[0].trim());
int surprising = Integer.parseInt(tmp[1].trim());
int p = Integer.parseInt(tmp[2].trim());
int key = 0;
int finalnum = 0;
for(int i = 0; i < num; i ++){
int score = Integer.parseInt(tmp[i + 3].trim());
if(score > 3 * (p - 1)){
finalnum++;
}
else if(key < surprising){
if(score >= p && score>= 3*p -4){
finalnum++;
key++;
}
}
}
return finalnum;
}
}
|
A12544 | A10309 | 0 | package problem1;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Arrays;
public class Problem1 {
public static void main(String[] args) throws FileNotFoundException, IOException{
try {
TextIO.readFile("L:\\Coodejam\\Input\\Input.txt");
}
catch (IllegalArgumentException e) {
System.out.println("Can't open file ");
System.exit(0);
}
FileOutputStream fout = new FileOutputStream("L:\\Coodejam\\Output\\output.txt");
PrintStream ps=new PrintStream(fout);
int cases=TextIO.getInt();
int googlers=0,surprising=0,least=0;
for(int i=0;i<cases;i++){
int counter=0;
googlers=TextIO.getInt();
surprising=TextIO.getInt();
least=TextIO.getInt();
int score[]=new int[googlers];
for(int j=0;j<googlers;j++){
score[j]=TextIO.getInt();
}
Arrays.sort(score);
int temp=0;
int sup[]=new int[surprising];
for(int j=0;j<googlers && surprising>0;j++){
if(biggestNS(score[j])<least && biggestS(score[j])==least){
surprising--;
counter++;
}
}
for(int j=0;j<googlers;j++){
if(surprising==0)temp=biggestNS(score[j]);
else {
temp=biggestS(score[j]);
surprising--;
}
if(temp>=least)counter++;
}
ps.println("Case #"+(i+1)+": "+counter);
}
}
static int biggestNS(int x){
if(x==0)return 0;
if(x==1)return 1;
return ((x-1)/3)+1;
}
static int biggestS(int x){
if(x==0)return 0;
if(x==1)return 1;
return ((x-2)/3)+2;
}
} | package org.cb.projectb.dancingwiththegooglers;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Contest {
public static void main(String[] args) throws FileNotFoundException {
File input = new File(System.getProperty("user.dir") + "/" + "resources/projectB/B-small-attempt0.in");
Scanner sc = new Scanner(input);
List<DanceOff> contests = new ArrayList<DanceOff>();
if (sc.hasNext()) {
Integer.parseInt(sc.nextLine()); // number of cases - ignored
while (sc.hasNext()) {
String contestString = sc.nextLine();
StringTokenizer contestTokenizer = new StringTokenizer(contestString);
int contestants = Integer.parseInt(contestTokenizer.nextToken());
int surprisingTriplets = Integer.parseInt(contestTokenizer.nextToken());
int scoreWeCareAbout = Integer.parseInt(contestTokenizer.nextToken());
List<Integer> scores = new ArrayList<Integer>();
for(int i = 0; i < contestants; i ++) {
scores.add(Integer.parseInt(contestTokenizer.nextToken()));
}
contests.add(new DanceOff(contestants, surprisingTriplets, scoreWeCareAbout, scores));
}
}
for(int i = 1; i <= contests.size(); i ++) {
DanceOff danceoff = contests.get(i-1);
System.out.println("Case #" + i + ": " + danceoff.getNumberAllowedToBeImportant());
}
}
private static class DanceOff {
private final int contestants;
private final int surprisingTriplets;
private final int scoreWeCareAbout;
private final List<Integer> contestantScores;
private final int numberAllowedToBeImportant;
public DanceOff(int contestants, int surprisingTriplets, int scoreWeCareAbout, List<Integer> contestantScores) {
this.contestants = contestants;
this.surprisingTriplets = surprisingTriplets;
this.scoreWeCareAbout = scoreWeCareAbout;
this.contestantScores = contestantScores;
this.numberAllowedToBeImportant = fillInDetails();
}
private int fillInDetails() {
int importantScores = 0;
List<Integer[]> allProbableScores = new ArrayList<Integer[]>();
for(Integer score: contestantScores) {
// System.out.print(score + " - ");
int baseScore = score / 3;
int remaining = score % 3;
Integer[] scoresArray = new Integer[]{baseScore, baseScore, baseScore};
for(int i = 0; i < remaining; i++) {
scoresArray[i] = scoresArray[i] + 1;
}
// System.out.print("Probable tripplet: [");
// for(int i = 0; i < scoresArray.length; i++) {
// System.out.print(scoresArray[i] + " ");
// }
// System.out.println("]");
allProbableScores.add(scoresArray);
}
int freebeeImportantScores = 0;
int ableToBeImportantIfSurprising = 0;
for (Integer[] scoresList : allProbableScores) {
// count how many in scores array are already important
boolean isImportant = false;
boolean canBeSurprising = false;
for (Integer integer : scoresList) {
if(integer >= this.scoreWeCareAbout) {
isImportant = true;
break;
}
}
if(isImportant) {
freebeeImportantScores++;
} else {
// see how many i can make 'surprising' to then care about
if(scoresList[0] + 1 >= this.scoreWeCareAbout) {
if(scoresList[0] == scoresList[1] && scoresList[0] != 0) {
canBeSurprising = true;
}
}
if(canBeSurprising) {
ableToBeImportantIfSurprising++;
}
}
}
// take min of allowed surprising & how many could be surprised
int numToMakeSpecial = Math.min(ableToBeImportantIfSurprising, this.surprisingTriplets);
// add min to current important scores
importantScores = freebeeImportantScores + numToMakeSpecial;
// System.out.println("Freebee important: " + freebeeImportantScores);
// System.out.println("Can be Made Important with surprising Score: " + ableToBeImportantIfSurprising);
// System.out.println("Num Of Scores we are making surprising: " + numToMakeSpecial);
// System.out.println("Max Special Scores: " + importantScores);
// System.out.println();
return importantScores;
}
public int getNumberAllowedToBeImportant() {
return numberAllowedToBeImportant;
}
@Override
public String toString() {
return "DanceOff [contestants = " + contestants
+ ", surprisingTriplets = " + surprisingTriplets
+ ", scoreWeCareAbout = " + scoreWeCareAbout
+ ", contestantScores = " + contestantScores + "]";
}
}
}
|
A21557 | A21937 | 0 | import java.io.*;
import java.util.*;
public class DancingWithGooglers {
public static class Googlers {
public int T;
public int surp;
public boolean surprising;
public boolean pSurprising;
public boolean antiSurprising;
public boolean pAntiSurprising;
public Googlers(int T, int surp) {
this.T = T;
this.surp = surp;
}
public void set(int a, int b, int c) {
if (c >= 0 && (a + b + c) == T) {
int diff = (Math.max(a, Math.max(b, c)) - Math.min(a, Math.min(b, c)));
if (diff <= 2) {
if (diff == 2) {
if (a >= surp || b >= surp || c >= surp) {
pSurprising = true;
} else {
surprising = true;
}
} else {
if (a >= surp || b >= surp || c >= surp) {
pAntiSurprising = true;
} else {
antiSurprising = true;
}
}
}
}
}
}
public static void main(String... args) throws IOException {
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedReader reader = new BufferedReader(new FileReader("B-large.in"));
// PrintWriter writer = new PrintWriter(System.out);
PrintWriter writer = new PrintWriter("B-large.out");
int len, cases = Integer.parseInt(reader.readLine());
List<Googlers> satisfied = new ArrayList<Googlers>();
List<Googlers> unsatisfied = new ArrayList<Googlers>();
String[] inputs;
int N, S, p;
for (int i = 1; i <= cases; i++) {
inputs = reader.readLine().split(" ");
p = Integer.parseInt(inputs[1]);
S = Integer.parseInt(inputs[2]);
satisfied.clear();
unsatisfied.clear();
for (int j = 3; j < inputs.length; j++) {
int t = Integer.parseInt(inputs[j]);
Googlers googlers = new Googlers(t, S);
for (int k = 0; k <= 10; k++) {
int till = k + 2 > 10 ? 10 : k + 2;
for (int l = k; l <= till; l++) {
googlers.set(k, l, (t - (k + l)));
}
}
if (googlers.pAntiSurprising) {
satisfied.add(googlers);
} else {
unsatisfied.add(googlers);
}
}
int pSurprising = 0;
if (p > 0) {
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
pSurprising++;
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = unsatisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.pSurprising) {
iter.remove();
pSurprising++;
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
for (Iterator<Googlers> iter = satisfied.iterator(); iter.hasNext(); ) {
Googlers googlers = iter.next();
if (googlers.surprising) {
iter.remove();
p--;
if (p <= 0) break;
}
}
}
if(p > 0){
writer.print("Case #" + i + ": 0");
}else {
writer.print("Case #" + i + ": " + (satisfied.size() + pSurprising));
}
writer.println();
}
writer.flush();
}
}
| package jp.funnything.competition.util;
public enum Direction {
UP , DOWN , LEFT , RIGHT;
public int dx() {
switch ( this ) {
case UP:
case DOWN:
return 0;
case LEFT:
return -1;
case RIGHT:
return 1;
default:
throw new RuntimeException( "assert" );
}
}
public int dy() {
switch ( this ) {
case UP:
return -1;
case DOWN:
return 1;
case LEFT:
case RIGHT:
return 0;
default:
throw new RuntimeException( "assert" );
}
}
public Direction reverese() {
switch ( this ) {
case UP:
return DOWN;
case DOWN:
return UP;
case LEFT:
return RIGHT;
case RIGHT:
return LEFT;
default:
throw new RuntimeException( "assert" );
}
}
public Direction turnLeft() {
switch ( this ) {
case UP:
return LEFT;
case DOWN:
return RIGHT;
case LEFT:
return DOWN;
case RIGHT:
return UP;
default:
throw new RuntimeException( "assert" );
}
}
public Direction turnRight() {
switch ( this ) {
case UP:
return RIGHT;
case DOWN:
return LEFT;
case LEFT:
return UP;
case RIGHT:
return DOWN;
default:
throw new RuntimeException( "assert" );
}
}
}
|
A20490 | A20837 | 0 | /**
*
*/
package hu.herba.codejam;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
/**
* Base functionality, helper functions for CodeJam problem solver utilities.
*
* @author csorbazoli
*/
public abstract class AbstractCodeJamBase {
private static final String EXT_OUT = ".out";
protected static final int STREAM_TYPE = 0;
protected static final int FILE_TYPE = 1;
protected static final int READER_TYPE = 2;
private static final String DEFAULT_INPUT = "test_input";
private static final String DEFAULT_OUTPUT = "test_output";
private final File inputFolder;
private final File outputFolder;
public AbstractCodeJamBase(String[] args, int type) {
String inputFolderName = AbstractCodeJamBase.DEFAULT_INPUT;
String outputFolderName = AbstractCodeJamBase.DEFAULT_OUTPUT;
if (args.length > 0) {
inputFolderName = args[0];
}
this.inputFolder = new File(inputFolderName);
if (!this.inputFolder.exists()) {
this.showUsage("Input folder '" + this.inputFolder.getAbsolutePath() + "' not exists!");
}
if (args.length > 1) {
outputFolderName = args[1];
}
this.outputFolder = new File(outputFolderName);
if (this.outputFolder.exists() && !this.outputFolder.canWrite()) {
this.showUsage("Output folder '" + this.outputFolder.getAbsolutePath() + "' not writeable!");
} else if (!this.outputFolder.exists() && !this.outputFolder.mkdirs()) {
this.showUsage("Could not create output folder '" + this.outputFolder.getAbsolutePath() + "'!");
}
File[] inputFiles = this.inputFolder.listFiles();
for (File inputFile : inputFiles) {
this.processInputFile(inputFile, type);
}
}
/**
* @return the inputFolder
*/
public File getInputFolder() {
return this.inputFolder;
}
/**
* @return the outputFolder
*/
public File getOutputFolder() {
return this.outputFolder;
}
/**
* @param input
* input reader
* @param output
* output writer
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
@SuppressWarnings("unused")
protected void process(BufferedReader reader, PrintWriter pw) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (reader/writer)!!!");
System.exit(-2);
}
/**
* @param input
* input file
* @param output
* output file (will be overwritten)
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(File input, File output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (file/file)!!!");
System.exit(-2);
}
/**
* @param input
* input stream
* @param output
* output stream
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(InputStream input, OutputStream output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (stream/stream)!!!");
System.exit(-2);
}
/**
* @param type
* @param input
* @param output
*/
private void processInputFile(File input, int type) {
long starttime = System.currentTimeMillis();
System.out.println("Processing '" + input.getAbsolutePath() + "'...");
File output = new File(this.outputFolder, input.getName() + AbstractCodeJamBase.EXT_OUT);
if (type == AbstractCodeJamBase.STREAM_TYPE) {
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(input);
os = new FileOutputStream(output);
this.process(is, os);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
System.out.println("Failed to close output: " + e.getLocalizedMessage());
}
}
}
} else if (type == AbstractCodeJamBase.READER_TYPE) {
BufferedReader reader = null;
PrintWriter pw = null;
try {
reader = new BufferedReader(new FileReader(input));
pw = new PrintWriter(output);
this.process(reader, pw);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (pw != null) {
pw.close();
}
}
} else if (type == AbstractCodeJamBase.FILE_TYPE) {
try {
this.process(input, output);
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
}
} else {
this.showUsage("Unknown type given: " + type + " (accepted values: 0,1)");
}
System.out.println(" READY (" + (System.currentTimeMillis() - starttime) + " ms)");
}
/**
* Read a single number from input
*
* @param reader
* @param purpose
* What is the purpose of given data
* @return
* @throws IOException
* @throws IllegalArgumentException
*/
protected int readInt(BufferedReader reader, String purpose) throws IOException, IllegalArgumentException {
int ret = 0;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer (" + purpose + ")!");
}
try {
ret = Integer.parseInt(line);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: the first line '" + line + "' should be an integer (" + purpose + ")!");
}
return ret;
}
/**
* Read array of integers
*
* @param reader
* @param purpose
* @return
*/
protected int[] readIntArray(BufferedReader reader, String purpose) throws IOException {
int[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer list (" + purpose + ")!");
}
String[] strArr = line.split("\\s");
int len = strArr.length;
ret = new int[len];
for (int i = 0; i < len; i++) {
try {
ret[i] = Integer.parseInt(strArr[i]);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: line '" + line + "' should be an integer list (" + purpose + ")!");
}
}
return ret;
}
/**
* Read array of strings
*
* @param reader
* @param purpose
* @return
*/
protected String[] readStringArray(BufferedReader reader, String purpose) throws IOException {
String[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be a string list (" + purpose + ")!");
}
ret = line.split("\\s");
return ret == null ? new String[0] : ret;
}
/**
* Basic usage pattern. Can be overwritten by current implementation
*
* @param message
* Short message, describing the problem with given program
* arguments
*/
protected void showUsage(String message) {
if (message != null) {
System.out.println(message);
}
System.out.println("Usage:");
System.out.println("\t" + this.getClass().getName() + " program");
System.out.println("\tArguments:");
System.out.println("\t\t<input folder>:\tpath of input folder (default: " + AbstractCodeJamBase.DEFAULT_INPUT + ").");
System.out.println("\t\t \tAll files will be processed in the folder");
System.out.println("\t\t<output folder>:\tpath of output folder (default: " + AbstractCodeJamBase.DEFAULT_OUTPUT + ")");
System.out.println("\t\t \tOutput file name will be the same as input");
System.out.println("\t\t \tinput with extension '.out'");
System.exit(-1);
}
}
| import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.HashMap;
public class tongue {
static HashMap<String, String> translationMap = new HashMap<String, String>();
private static void init() {
translationMap.put("a", "y");
translationMap.put("b", "h");
translationMap.put("c", "e");
translationMap.put("d", "s");
translationMap.put("e", "o");
translationMap.put("f", "c");
translationMap.put("g", "v");
translationMap.put("h", "x");
translationMap.put("i", "d");
translationMap.put("j", "u");
translationMap.put("k", "i");
translationMap.put("l", "g");
translationMap.put("m", "l");
translationMap.put("n", "b");
translationMap.put("o", "k");
translationMap.put("p", "r");
translationMap.put("q", "z");
translationMap.put("r", "t");
translationMap.put("s", "n");
translationMap.put("t", "w");
translationMap.put("u", "j");
translationMap.put("v", "p");
translationMap.put("w", "f");
translationMap.put("x", "m");
translationMap.put("y", "a");
translationMap.put("z", "q");
translationMap.put(" ", " ");
}
/**
* @param args
*/
public static void main(String[] args) {
init();
String inputFilePath = args[0];
try {
File inputFile = new File(inputFilePath);
FileInputStream fis = new FileInputStream(inputFile);
BufferedReader br = new BufferedReader(new InputStreamReader(fis));
// translate(br);
findScore(br);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void findScore(BufferedReader br) throws NumberFormatException, IOException {
String line = null;
Integer numberOfLines = Integer.valueOf(br.readLine());
if( !(1<=numberOfLines && numberOfLines<=100)){
throw new IllegalArgumentException("Not valid number of lines");
}
for(int i=1; i<=numberOfLines; i++){
line = br.readLine();
String[] values = line.split(" ");
int res = computeResult(values); // line.substring(5).trim());
System.out.println("Case #"+i+": " +res);
}
}
private static int computeResult(String[] values) {
int peopleCount = Integer.valueOf(values[0].trim());
int surprisingCount = Integer.valueOf(values[1].trim());
int minScore = Integer.valueOf(values[2].trim());
int foundCases =0;
for (int i=3; i<values.length; i++) {
String oneScore = values[i];
Integer sc = Integer.valueOf(oneScore.trim());
int base = sc/3;
int left = sc%3;
switch(left){
case 0:
if(base>=minScore){
foundCases++;
}
else if(surprisingCount>0 && base>0 && base+1>=minScore){
surprisingCount--;
foundCases++;
}
break;
case 1:
// normal case
if(base>=minScore || (base+1)>=minScore){
foundCases++;
}
// suprise use case
else if(surprisingCount>0 && (base+1)>=minScore){
foundCases++;
surprisingCount--;
}
break;
case 2:
// normal case
if(base>=minScore || (base+1)>=minScore){
foundCases++;
}
// surprise case
else if(surprisingCount>0 && (base+2)>=minScore){
foundCases++;
surprisingCount--;
}
break;
}
}
return foundCases;
}
private static void translate(BufferedReader br) throws IOException {
String line = null;
StringBuffer result = new StringBuffer();
Integer numberOfLines = Integer.valueOf(br.readLine());
if( !(1<=numberOfLines && numberOfLines<=30)){
throw new IllegalArgumentException("Not valid number of lines");
}
for(int i=1; i<=numberOfLines; i++){
line = br.readLine();
result.append(translateLine(line));
System.out.println("Case #"+i+": " +result);
result = new StringBuffer();
}
}
private static StringBuffer translateLine(String line) {
StringBuffer translatedLine = new StringBuffer();
for (int i=0; i < line.length(); i++) {
translatedLine.append(translateChar(line.charAt(i)));
}
return translatedLine;
}
private static String translateChar(char charAt) {
return translationMap.get(new Character(charAt).toString());
}
}
|
B12762 | B10560 | 0 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.File;
import java.io.FileInputStream;
import java.util.Scanner;
/**
*
* @author imgps
*/
public class C {
public static void main(String args[]) throws Exception{
int A,B;
int ctr = 0;
int testCases;
Scanner sc = new Scanner(new FileInputStream("C-small-attempt0.in "));
testCases = sc.nextInt();
int input[][] = new int[testCases][2];
for(int i=0;i<testCases;i++)
{
// System.out.print("Enter input A B: ");
input[i][0] = sc.nextInt();
input[i][1] = sc.nextInt();
}
for(int k=0;k<testCases;k++){
ctr = 0;
A = input[k][0];
B = input[k][1];
for(int i = A;i<=B;i++){
int num = i;
int nMul = 1;
int mul = 1;
int tnum = num/10;
while(tnum > 0){
mul = mul *10;
tnum= tnum/10;
}
tnum = num;
int n = 0;
while(tnum > 0 && mul >= 10){
nMul = nMul * 10;
n = (num % nMul) * mul + (num / nMul);
mul = mul / 10;
tnum = tnum / 10;
for(int m=num;m<=B;m++){
if(n == m && m > num){
ctr++;
}
}
}
}
System.out.println("Case #"+(k+1)+": "+ctr);
}
}
}
| package com.googlerese.file;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
public class FileRead {
private static FileRead instance = new FileRead();
private FileRead() {
}
public static FileRead getInstance() {
return instance;
}
public Map<Integer, String[]> read( final String fileName ) {
FileInputStream fstream = null;
DataInputStream in = null;
BufferedReader br = null;
Map<Integer, String[]> input = null;
try {
// Open the file that is the first
// command line parameter
fstream = new FileInputStream( fileName );
// Get the object of DataInputStream
in = new DataInputStream( fstream );
br = new BufferedReader( new InputStreamReader( in ) );
String strLine;
//Read File Line By Line
int count = 0;
while ( ( strLine = br.readLine() ) != null ) {
// Print the content on the console
if ( count == 0 ) {
input = new HashMap<Integer, String[]>( Integer.parseInt( strLine ) );
} else {
System.out.println( count + " : " + strLine );
String[] arr = strLine.split( "\\s+" );
input.put( count, arr );
}
count++;
}
} catch ( Exception e ) {//Catch exception if any
System.err.println( "Error: " + e.getMessage() );
} finally {
//Close the input stream
try {
if ( br != null ) {
br.close();
}
if ( in != null ) {
in.close();
}
if ( fstream != null ) {
fstream.close();
}
} catch ( IOException e ) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return input;
}
}
|
A12460 | A12609 | 0 | /**
*
*/
package pandit.codejam;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Scanner;
/**
* @author Manu Ram Pandit
*
*/
public class DancingWithGooglersUpload {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileInputStream fStream = new FileInputStream(
"input.txt");
Scanner scanner = new Scanner(new BufferedInputStream(fStream));
Writer out = new OutputStreamWriter(new FileOutputStream("output.txt"));
int T = scanner.nextInt();
int N,S,P,ti;
int counter = 0;
for (int count = 1; count <= T; count++) {
N=scanner.nextInt();
S = scanner.nextInt();
counter = 0;
P = scanner.nextInt();
for(int i=1;i<=N;i++){
ti=scanner.nextInt();
if(ti>=(3*P-2)){
counter++;
continue;
}
else if(S>0){
if(P>=2 && ((ti==(3*P-3)) ||(ti==(3*P-4)))) {
S--;
counter++;
continue;
}
}
}
// System.out.println("Case #" + count + ": " + counter);
out.write("Case #" + count + ": " + counter + "\n");
}
fStream.close();
out.close();
}
}
| import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
class dance {
int single[][] = new int[4][3];
int doublex[][] = new int[54][3];
dance() {
single[0][0] = 0;
single[0][1] = 0;
single[0][2] = 0;
single[1][0] = 0;
single[1][1] = 0;
single[1][2] = 1;
single[2][0] = 10;
single[2][1] = 10;
single[2][2] = 9;
single[3][0] = 10;
single[3][1] = 10;
single[3][2] = 10;
}
int[][] gen_tuple(int num) {
int tup[][] = new int[2][3];
if (num % 3 == 0) {
tup[0][0] = num / 3;
tup[0][1] = num / 3;
tup[0][2] = num / 3;
tup[1][0] = num / 3 - 1;
tup[1][1] = num / 3;
tup[1][2] = num / 3 + 1;
} else if (num % 3 == 1) {
tup[0][0] = num / 3;
tup[0][1] = num / 3;
tup[0][2] = num / 3 + 1;
tup[1][0] = num / 3 + 1;
tup[1][1] = num / 3 + 1;
tup[1][2] = num / 3 - 1;
} else if (num % 3 == 2) {
tup[0][0] = num / 3;
tup[0][1] = num / 3 + 1;
tup[0][2] = num / 3 + 1;
tup[1][0] = num / 3;
tup[1][1] = num / 3;
tup[1][2] = num / 3 + 2;
}
return tup;
}
int maxx(int a, int b, int c) {
int temp = Math.max(a, b);
temp = Math.max(temp, c);
return temp;
}
public static void main(String[] args) throws IOException {
dance my = new dance();
for (int i = 2; i < 29; i++) {
int temp[][] = my.gen_tuple(i);
// System.out.println((i - 2) * 2);
my.doublex[(i - 2) * 2][0] = temp[0][0];
my.doublex[(i - 2) * 2][1] = temp[0][1];
my.doublex[(i - 2) * 2][2] = temp[0][2];
my.doublex[(i - 2) * 2 + 1][0] = temp[1][0];
my.doublex[(i - 2) * 2 + 1][1] = temp[1][1];
my.doublex[(i - 2) * 2 + 1][2] = temp[1][2];
// System.out.print(my.doublex[(i - 2) * 2][0] + " ");
// System.out.print(my.doublex[(i - 2) * 2][1] + ",");
// System.out.print(my.doublex[(i - 2) * 2][2] + ",");
// System.out.print(my.doublex[(i - 2) * 2 + 1][0] + ",");
// System.out.print(my.doublex[(i - 2) * 2 + 1][1] + ",");
// System.out.println(my.doublex[(i - 2) * 2 + 1][2] + ",");
}
String Path = "C:\\Users\\Dell\\Desktop\\B-small-attempt0.in";
Scanner read = new Scanner(new File(Path));
File file = new File("C:\\Users\\Dell\\Desktop\\out.txt");
PrintWriter Fout = new PrintWriter(new BufferedWriter(new FileWriter(
file)), true);
String line = read.nextLine();
int iter = 0;
while (read.hasNextLine()) {
iter = iter + 1;
line = read.nextLine();
String d = "[ ]+";
String[] SplitD = line.split(d);
for (int x = 0; x < SplitD.length; x++) {
// System.out.println(SplitD[x]);
}
int N = Integer.parseInt(SplitD[0]);
int S = Integer.parseInt(SplitD[1]);
int p = Integer.parseInt(SplitD[2]);
int count = 0;
int surp = 0;
for (int j = 0; j < N; j++) {
int val = Integer.parseInt(SplitD[j + 3]);
if (val < 2) {
if (my.maxx(my.single[val][0], my.single[val][1],
my.single[val][2]) >= p) {
count += 1;
}
} else if (val > 28) {
if (my.maxx(my.single[val - 27][0], my.single[val - 27][1],
my.single[val - 27][2]) >= p) {
count += 1;
}
} else {
if (my.maxx(my.doublex[(val - 2) * 2][0],
my.doublex[(val - 2) * 2][1],
my.doublex[(val - 2) * 2][2]) >= p) {
count += 1;
} else if (my.maxx(my.doublex[(val - 2) * 2 + 1][0],
my.doublex[(val - 2) * 2 + 1][1],
my.doublex[(val - 2) * 2 + 1][2]) >= p) {
surp += 1;
}
}
}
if (surp > S) {
count = count + S;
} else {
count = count + surp;
}
String output_str = "Case #" + iter + ": " + count;
Fout.println(output_str);
}
read.close();
}
} |
A10996 | A11026 | 0 | import java.util.Scanner;
import java.io.*;
class dance
{
public static void main (String[] args) throws IOException
{
File inputData = new File("B-small-attempt0.in");
File outputData= new File("Boutput.txt");
Scanner scan = new Scanner( inputData );
PrintStream print= new PrintStream(outputData);
int t;
int n,s,p,pi;
t= scan.nextInt();
for(int i=1;i<=t;i++)
{
n=scan.nextInt(); s=scan.nextInt(); p=scan.nextInt();
int supTrip=0, notsupTrip=0;
for(int j=0;j<n;j++)
{
pi=scan.nextInt();
if(pi>(3*p-3))
notsupTrip++;
else if((pi>=(3*p-4))&&(pi<=(3*p-3))&&(pi>p))
supTrip++;
}
if(s<=supTrip)
notsupTrip=notsupTrip+s;
else if(s>supTrip)
notsupTrip= notsupTrip+supTrip;
print.println("Case #"+i+": "+notsupTrip);
}
}
} | package fixjava;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import fixjava.ParallelWorkQueue.CallableFactory;
public class ArrayUtils {
// ------------------------------------------------------------------------------------------------
/** Convert a 2D float array into a 2D double array */
public static double[][] toDblArray(float[][] data) {
double[][] copy = new double[data.length][data[0].length];
for (int i = 0; i < data.length; i++)
for (int j = 0; j < data[0].length; j++)
copy[i][j] = data[i][j];
return copy;
}
/** Convert a 2D double array into a 2D float array */
public static float[][] toFltArray(double[][] data) {
float[][] copy = new float[data.length][data[0].length];
for (int i = 0; i < data.length; i++)
for (int j = 0; j < data[0].length; j++)
copy[i][j] = (float) data[i][j];
return copy;
}
/** Transpose an array */
public static double[][] transpose(double[][] data) {
double[][] copy = new double[data[0].length][data.length];
for (int i = 0; i < data.length; i++)
for (int j = 0; j < data[0].length; j++)
copy[j][i] = data[i][j];
return copy;
}
/** Transpose an array */
public static float[][] transpose(float[][] data) {
float[][] copy = new float[data[0].length][data.length];
for (int i = 0; i < data.length; i++)
for (int j = 0; j < data[0].length; j++)
copy[j][i] = data[i][j];
return copy;
}
// ------------------------------------------------------------------------------------------------
public static float[][] matMulPar(float[][] A, boolean transposeA, float[][] B, boolean transposeB, int numThreads) {
return toFltArray(matMulPar(toDblArray(A), transposeA, toDblArray(B), transposeB, numThreads));
}
public static double[][] matMulPar(double[][] A, boolean transposeA, double[][] B, boolean transposeB, int numThreads) {
final double[][] matA = transposeA ? transpose(A) : A;
// Keep B transposed so that matrix multiplication is more able to exploit cache coherence (matrix is stored row-wise)
final double[][] matBT = transposeB ? B : transpose(B);
final int p = matA.length, q = matA[0].length, q2 = matBT[0].length, r = matBT.length;
if (q != q2)
throw new IllegalArgumentException("Array size mismatch");
final double[][] result = new double[p][r];
//final DecimalFormat formatPercent1dp = new DecimalFormat("0.0%");
try {
for (Future<Void> res : new ParallelWorkQueue<Integer, Void>(numThreads, ParallelWorkQueue.makeIntRangeIterable(p),
new CallableFactory<Integer, Void>() {
//IntegerMutable counter = new IntegerMutable();
@Override
public Callable<Void> newInstance(final Integer ii) {
return new Callable<Void>() {
int i = ii.intValue();
double[][] resultLocal = result;
int rLocal = r, qLocal = q;
double[][] matALocal = matA, matBTLocal = matBT;
@Override
public Void call() {
/**
* <code>
* TODO: try blocked matrix multiplication to see if it's faster
*
* for (int ib = 0; ib < p; ib += blockSize)
* for (int jb = 0; jb < q; jb += blockSize)
* for (int kb = 0; kb < r; kb += blockSize)
* for (int i = ib, iMax = Math.min(p, ib + blockSize); i < iMax; i++)
* for (int j = jb, jMax = Math.min(q, jb + blockSize); j < jMax; j++)
* for (int k = kb, kMax = Math.min(p, kb + blockSize); k < kMax; k++)
* prod[i][j] += matALocal[i][k] * matBTLocal[j][k];
*
* N.B. the "+=" operation above needs to use TLS accumulators
*/
for (int j = 0; j < rLocal; j++) {
float tot = 0.0f;
for (int k = 0; k < qLocal; k++)
tot += matALocal[i][k] * matBTLocal[j][k];
resultLocal[i][j] = tot;
}
// int count = counter.increment();
// if (count % 10 == 0)
// System.out.println(formatPercent1dp.format((count / (float) (pLocal - 1))));
return null;
}
};
}
}))
// Barricade
res.get();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
return result;
}
// ------------------------------------------------------------------------------------------------
/** Multiply A by constant b */
public static double[][] matMulByConst(double[][] A, double b) {
int p = A.length, q = A[0].length;
double[][] result = new double[p][q];
for (int i = 0; i < p; i++)
for (int j = 0; j < q; j++)
result[i][j] = b * A[i][j];
return result;
}
/** Multiply A by constant b */
public static float[][] matMulByConst(float[][] A, float b) {
int p = A.length, q = A[0].length;
float[][] result = new float[p][q];
for (int i = 0; i < p; i++)
for (int j = 0; j < q; j++)
result[i][j] = b * A[i][j];
return result;
}
/** Multiply A by B transpose */
public static float[][] matMulABT(float[][] A, float[][] BT) {
int p = A.length, q = A[0].length, q2 = BT[0].length, r = BT.length;
if (q != q2)
throw new IllegalArgumentException("Array size mismatch");
float[][] result = new float[p][r];
for (int i = 0; i < p; i++) {
for (int j = 0; j < r; j++) {
float tot = 0.0f;
for (int k = 0; k < q; k++)
// This is the main matrix multiplication routine, because both operands here
// are in row-major order, so we get speedups of 3-8x due to cache coherence
// on large matrices. (Use the parallel version for really large matrices...)
tot += A[i][k] * BT[j][k];
result[i][j] = tot;
}
}
return result;
}
/** Multiply A by B transpose */
public static double[][] matMulABT(double[][] A, double[][] BT) {
int p = A.length, q = A[0].length, q2 = BT[0].length, r = BT.length;
if (q != q2)
throw new IllegalArgumentException("Array size mismatch");
double[][] result = new double[p][r];
for (int i = 0; i < p; i++) {
for (int j = 0; j < r; j++) {
float tot = 0.0f;
for (int k = 0; k < q; k++)
// This is the main matrix multiplication routine, because both operands here
// are in row-major order, so we get speedups of 3-8x due to cache coherence
// on large matrices. (Use the parallel version for really large matrices...)
tot += A[i][k] * BT[j][k];
result[i][j] = tot;
}
}
return result;
}
/** Multiply A by B */
public static float[][] matMulAB(float[][] A, float[][] B) {
// Transpose B so it's row-major, and multiply by BTT==B
return matMulABT(A, transpose(B));
}
/** Multiply A by B */
public static double[][] matMulAB(double[][] A, double[][] B) {
// Transpose B so it's row-major, and multiply by BTT==B
return matMulABT(A, transpose(B));
}
/** Multiply A transpose by B */
public static float[][] matMulATB(float[][] A, float[][] B) {
// Transpose B so it's row-major, and multiply by BTT==B
return matMulABT(transpose(A), transpose(B));
}
/** Multiply A transpose by B */
public static double[][] matMulATB(double[][] A, double[][] B) {
// Transpose B so it's row-major, and multiply by BTT==B
return matMulABT(transpose(A), transpose(B));
}
/** Multiply A transpose by B transpose */
public static double[][] matMulATBT(double[][] A, double[][] B) {
return matMulABT(transpose(A), B);
}
/** Multiply A transpose by B transpose */
public static float[][] matMulATBT(float[][] A, float[][] B) {
return matMulABT(transpose(A), B);
}
// ------------------------------------------------------------------------------------------------
/** Select a random subset of rows in a matrix */
public static float[][] selectRandomRowSubset(int numRows, float[][] mat) {
int n = Math.min(numRows, mat.length);
float[][] rows = new float[mat.length][];
for (int i = 0; i < mat.length; i++)
rows[i] = mat[i];
Random rand = new Random();
for (int i = 0; i < n; i++) {
int j = rand.nextInt(mat.length);
float[] tmp = rows[i];
rows[i] = rows[j];
rows[j] = tmp;
}
return Arrays.copyOf(rows, n);
}
// ------------------------------------------------------------------------------------------------
/** Write a double[][] array to a file */
public static void writeToFile(String filename, String arrayName, double[][] array) {
try {
System.out.println("Writing to " + filename);
PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
writeArray(writer, arrayName, array);
writer.close();
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
/** Write a double[][] array to a PrintWriter */
public static void writeArray(PrintWriter writer, String name, double[][] arr) {
writer.println(name + "\t" + arr.length + "\t" + arr[0].length);
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[0].length; j++)
writer.print((j == 0 ? "" : "\t") + arr[i][j]);
writer.println();
}
}
/** Write a double[] array to a PrintWriter */
public static void writeArray(PrintWriter writer, String name, double[] arr) {
writer.println(name + "\t1\t" + arr.length);
for (int i = 0; i < arr.length; i++)
writer.print((i == 0 ? "" : "\t") + arr[i]);
writer.println();
}
}
|
A20490 | A20594 | 0 | /**
*
*/
package hu.herba.codejam;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
/**
* Base functionality, helper functions for CodeJam problem solver utilities.
*
* @author csorbazoli
*/
public abstract class AbstractCodeJamBase {
private static final String EXT_OUT = ".out";
protected static final int STREAM_TYPE = 0;
protected static final int FILE_TYPE = 1;
protected static final int READER_TYPE = 2;
private static final String DEFAULT_INPUT = "test_input";
private static final String DEFAULT_OUTPUT = "test_output";
private final File inputFolder;
private final File outputFolder;
public AbstractCodeJamBase(String[] args, int type) {
String inputFolderName = AbstractCodeJamBase.DEFAULT_INPUT;
String outputFolderName = AbstractCodeJamBase.DEFAULT_OUTPUT;
if (args.length > 0) {
inputFolderName = args[0];
}
this.inputFolder = new File(inputFolderName);
if (!this.inputFolder.exists()) {
this.showUsage("Input folder '" + this.inputFolder.getAbsolutePath() + "' not exists!");
}
if (args.length > 1) {
outputFolderName = args[1];
}
this.outputFolder = new File(outputFolderName);
if (this.outputFolder.exists() && !this.outputFolder.canWrite()) {
this.showUsage("Output folder '" + this.outputFolder.getAbsolutePath() + "' not writeable!");
} else if (!this.outputFolder.exists() && !this.outputFolder.mkdirs()) {
this.showUsage("Could not create output folder '" + this.outputFolder.getAbsolutePath() + "'!");
}
File[] inputFiles = this.inputFolder.listFiles();
for (File inputFile : inputFiles) {
this.processInputFile(inputFile, type);
}
}
/**
* @return the inputFolder
*/
public File getInputFolder() {
return this.inputFolder;
}
/**
* @return the outputFolder
*/
public File getOutputFolder() {
return this.outputFolder;
}
/**
* @param input
* input reader
* @param output
* output writer
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
@SuppressWarnings("unused")
protected void process(BufferedReader reader, PrintWriter pw) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (reader/writer)!!!");
System.exit(-2);
}
/**
* @param input
* input file
* @param output
* output file (will be overwritten)
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(File input, File output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (file/file)!!!");
System.exit(-2);
}
/**
* @param input
* input stream
* @param output
* output stream
* @throws IOException
* in case input or output fails
* @throws IllegalArgumentException
* in case the given input is invalid
*/
protected void process(InputStream input, OutputStream output) throws IOException, IllegalArgumentException {
System.out.println("NEED TO IMPLEMENT (stream/stream)!!!");
System.exit(-2);
}
/**
* @param type
* @param input
* @param output
*/
private void processInputFile(File input, int type) {
long starttime = System.currentTimeMillis();
System.out.println("Processing '" + input.getAbsolutePath() + "'...");
File output = new File(this.outputFolder, input.getName() + AbstractCodeJamBase.EXT_OUT);
if (type == AbstractCodeJamBase.STREAM_TYPE) {
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(input);
os = new FileOutputStream(output);
this.process(is, os);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
System.out.println("Failed to close output: " + e.getLocalizedMessage());
}
}
}
} else if (type == AbstractCodeJamBase.READER_TYPE) {
BufferedReader reader = null;
PrintWriter pw = null;
try {
reader = new BufferedReader(new FileReader(input));
pw = new PrintWriter(output);
this.process(reader, pw);
} catch (FileNotFoundException e) {
this.showUsage("FileNotFound: " + e.getLocalizedMessage());
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
System.out.println("Failed to close input: " + e.getLocalizedMessage());
}
}
if (pw != null) {
pw.close();
}
}
} else if (type == AbstractCodeJamBase.FILE_TYPE) {
try {
this.process(input, output);
} catch (IllegalArgumentException excIA) {
this.showUsage(excIA.getLocalizedMessage());
} catch (Exception exc) {
System.out.println("Program failed: " + exc.getLocalizedMessage());
exc.printStackTrace(System.out);
}
} else {
this.showUsage("Unknown type given: " + type + " (accepted values: 0,1)");
}
System.out.println(" READY (" + (System.currentTimeMillis() - starttime) + " ms)");
}
/**
* Read a single number from input
*
* @param reader
* @param purpose
* What is the purpose of given data
* @return
* @throws IOException
* @throws IllegalArgumentException
*/
protected int readInt(BufferedReader reader, String purpose) throws IOException, IllegalArgumentException {
int ret = 0;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer (" + purpose + ")!");
}
try {
ret = Integer.parseInt(line);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: the first line '" + line + "' should be an integer (" + purpose + ")!");
}
return ret;
}
/**
* Read array of integers
*
* @param reader
* @param purpose
* @return
*/
protected int[] readIntArray(BufferedReader reader, String purpose) throws IOException {
int[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be an integer list (" + purpose + ")!");
}
String[] strArr = line.split("\\s");
int len = strArr.length;
ret = new int[len];
for (int i = 0; i < len; i++) {
try {
ret[i] = Integer.parseInt(strArr[i]);
} catch (NumberFormatException excNF) {
throw new IllegalArgumentException("Invalid input: line '" + line + "' should be an integer list (" + purpose + ")!");
}
}
return ret;
}
/**
* Read array of strings
*
* @param reader
* @param purpose
* @return
*/
protected String[] readStringArray(BufferedReader reader, String purpose) throws IOException {
String[] ret = null;
String line = reader.readLine();
if (line == null) {
throw new IllegalArgumentException("Invalid input: line is empty, it should be a string list (" + purpose + ")!");
}
ret = line.split("\\s");
return ret == null ? new String[0] : ret;
}
/**
* Basic usage pattern. Can be overwritten by current implementation
*
* @param message
* Short message, describing the problem with given program
* arguments
*/
protected void showUsage(String message) {
if (message != null) {
System.out.println(message);
}
System.out.println("Usage:");
System.out.println("\t" + this.getClass().getName() + " program");
System.out.println("\tArguments:");
System.out.println("\t\t<input folder>:\tpath of input folder (default: " + AbstractCodeJamBase.DEFAULT_INPUT + ").");
System.out.println("\t\t \tAll files will be processed in the folder");
System.out.println("\t\t<output folder>:\tpath of output folder (default: " + AbstractCodeJamBase.DEFAULT_OUTPUT + ")");
System.out.println("\t\t \tOutput file name will be the same as input");
System.out.println("\t\t \tinput with extension '.out'");
System.exit(-1);
}
}
| import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Scanner;
public class GooglerDancerMain {
public static void main(String[] args) {
try {
Scanner s=new Scanner(new BufferedReader(new FileReader("B-large.in")));
ArrayList<GooglerDancer> list=new ArrayList<GooglerDancer>();
int i=0;
int totalCases=Integer.parseInt(s.nextLine());
while(s.hasNextLine()){
list.add(new GooglerDancer(++i,s.nextLine()));
}
for (GooglerDancer googlerDancer : list) {
googlerDancer.process();
}
} catch (FileNotFoundException e) {
System.out.println("file not found");
}
}
}
|
B13196 | B12052 | 0 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Q3M {
public static void main(String[] args) throws Exception {
compute();
}
private static void compute() throws Exception {
BufferedReader br = new BufferedReader(new FileReader(new File(
"C:\\work\\Q3\\C-small-attempt0.in")));
String line = null;
int i = Integer.parseInt(br.readLine());
List l = new ArrayList();
for (int j = 0; j < i; j++) {
line = br.readLine();
String[] nums = line.split(" ");
l.add(calculate(nums));
}
writeOutput(l);
}
private static int calculate(String[] nums) {
int min = Integer.parseInt(nums[0]);
int max = Integer.parseInt(nums[1]);
int count = 0;
List l = new ArrayList();
for (int i = min; i <= max; i++) {
for (int times = 1; times < countDigits(i); times++) {
int res = shiftNum(i, times);
if (res <= max && i < res) {
if ((!l.contains((i + ":" + res)))) {
l.add(i + ":" + res);
l.add(res + ":" + i);
count++;
}
}
}
}
return count;
}
private static boolean checkZeros(int temp, int res) {
if (temp % 10 == 0 || res % 10 == 0)
return false;
return true;
}
private static int shiftNum(int n, int times) {
int base = (int) Math.pow(10, times);
int temp2 = n / base;
int placeHolder = (int) Math.pow((double) 10,
(double) countDigits(temp2));
int res = placeHolder * (n % base) + temp2;
if (countDigits(res) == countDigits(n)) {
return res;
} else {
return 2000001;
}
}
public static int countDigits(int x) {
if (x < 10)
return 1;
else {
return 1 + countDigits(x / 10);
}
}
private static void writeOutput(List l) throws Exception {
StringBuffer b = new StringBuffer();
int i = 1;
BufferedWriter br = new BufferedWriter(new FileWriter(new File(
"C:\\work\\Q3\\ans.txt")));
for (Iterator iterator = l.iterator(); iterator.hasNext();) {
br.write("Case #" + i++ + ": " + iterator.next());
br.newLine();
}
br.close();
}
} | import java.io.*;
import java.util.HashSet;
public class ProblemC
{
public static void main(String[] args) throws Exception
{
String base = "C-small-attempt0";
BufferedReader reader = new BufferedReader(new FileReader(base+".in"));
BufferedWriter writer = new BufferedWriter(new FileWriter(base+".out"));
int place = 0;
reader.readLine();
while (reader.ready())
{
String line = reader.readLine();
String[] strs = line.split(" ");
int a = Integer.parseInt(strs[0]);
int b = Integer.parseInt(strs[1]);
int num = solve(a,b);
writer.write("Case #" + (++place) + ": " + num+'\n');
}
reader.close();
writer.close();
}
public static int solve(int a, int b)
{
int number = 0;
for (int i=a;i<=b;i++)
{
HashSet<Integer> set = new HashSet<Integer>();
String str = i+"";
for (int p=str.length()-1;p>=1;p--)
{
String test = str.substring(p) + str.substring(0,p);
int j = Integer.parseInt(test);
String test2 = j+"";
if (i < j && j <= b && str.length()==test2.length() && !set.contains(j))
{
set.add(j);
number++;
}
}
}
return number;
}
}
|
B21968 | B21499 | 0 | import java.util.*;
import java.io.*;
public class recycled_numbers {
public static void main(String[]a) throws Exception{
Scanner f = new Scanner(new File(a[0]));
int result=0;
int A,B;
String n,m;
HashSet<String> s=new HashSet<String>();
int T=f.nextInt(); //T total case count
for (int t=1; t<=T;t++){//for each case t
s.clear();
result=0; //reset
A=f.nextInt();B=f.nextInt(); //get values for next case
if (A==B)result=0;//remove case not meeting problem limits
else{
for(int i=A;i<=B;i++){//for each int in range
n=Integer.toString(i);
m=new String(n);
//System.out.println(n);
for (int j=1;j<n.length();j++){//move each digit to the front & test
m = m.substring(m.length()-1)+m.substring(0,m.length()-1);
if(m.matches("^0+[\\d]+")!=true &&
Integer.parseInt(m)<=B &&
Integer.parseInt(n)<Integer.parseInt(m)){
s.add(new String(n+","+m));
//result++;
//System.out.println(" matched: "+m);
}
}
}
result = s.size();
}
//display output
System.out.println("Case #" + t + ": " + result);
}
}
} | import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
public class Recycled {
public static void main(String[] args) throws Exception {
FileInputStream fstream = new FileInputStream("text.in");
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
int count = 0;
int totalLines;
// ArrayList<List> numbers = new ArrayList<List>();
while ((strLine = br.readLine()) != null) {
if (count == 0) {
totalLines = Integer.parseInt(strLine);
} else {
int recycled = 0;
String[] nums = strLine.split(" ");
int startNum = Integer.parseInt(nums[0]);
int endNum = Integer.parseInt(nums[1]);
for (int i = startNum; i <= endNum; i++) {
recycled += testInteger(i, endNum);
}
System.out.println("Case #" + count + ": " + recycled);
}
count++;
}
in.close();
}
private static int testInteger(int i, int endNum) {
String numStr = String.valueOf(i);
int currentCount = 0;
Set<String> matches = new HashSet<String>();
for (int j = 1; j < numStr.length(); j++) {
String newNumStr = swapNumber(numStr);
if ((Integer.parseInt(newNumStr) > i) && ((Integer.parseInt(newNumStr) <= endNum))) {
// System.out.println(i+" "+newNumStr);
currentCount++;
matches.add(newNumStr);
// } else {
// return 0;
}
numStr = newNumStr;
}
return matches.size();
}
private static String swapNumber(String numStr) {
String lastDigit = numStr.substring(numStr.length()-1);
String firstDigits = numStr.substring(0, numStr.length()-1);
return lastDigit.concat(firstDigits);
}
}
|
B10149 | B11848 | 0 | import java.io.FileInputStream;
import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeSet;
// Recycled Numbers
// https://code.google.com/codejam/contest/1460488/dashboard#s=p2
public class C {
private static String process(Scanner in) {
int A = in.nextInt();
int B = in.nextInt();
int res = 0;
int len = Integer.toString(A).length();
for(int n = A; n < B; n++) {
String str = Integer.toString(n);
TreeSet<Integer> set = new TreeSet<Integer>();
for(int i = 1; i < len; i++) {
int m = Integer.parseInt(str.substring(i, len) + str.substring(0, i));
if ( m > n && m <= B && ! set.contains(m) ) {
set.add(m);
res++;
}
}
}
return Integer.toString(res);
}
public static void main(String[] args) throws Exception {
Scanner in = new Scanner(System.in.available() > 0 ? System.in :
new FileInputStream(Thread.currentThread().getStackTrace()[1].getClassName() + ".practice.in"));
int T = in.nextInt();
for(int i = 1; i <= T; i++)
System.out.format("Case #%d: %s\n", i, process(in));
}
}
| import java.io.*;
import java.util.*;
import java.math.*;
public class C implements Runnable {
private long solve(int A, int B) {
int pow = 1;
while (pow <= A/10) {
pow *= 10;
}
HashSet<Long> h = new HashSet<Long>();
for (int n = A; n <= B; ++n) {
int nn = n;
nn = (nn%pow)*10 + (nn/pow);
while (nn != n) {
if (A <= nn && nn <= B) {
if (nn < n) {
h.add(1L*nn*pow*10+n);
}
else {
h.add(1L*n*pow*10+nn);
}
}
nn = (nn%pow)*10 + (nn/pow);
}
}
return h.size();
}
public void run() {
int n = nextInt();
for (int i = 0; i < n; ++i) {
int A = nextInt();
int B = nextInt();
long ans = solve(A, B);
out.println("Case #"+(i+1)+": "+ans);
}
out.flush();
}
private static BufferedReader br = null;
private static StringTokenizer stk = null;
private static PrintWriter out = null;
public static void main(String[] args) throws IOException {
br = new BufferedReader(new FileReader(new File("D:\\C.txt")));
out = new PrintWriter("D:\\CC.txt");
(new Thread(new C())).start();
}
public void loadLine() {
try {
stk = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
public String nextLine() {
try {
return (br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
return null;
}
public int nextInt() {
while (stk==null || !stk.hasMoreTokens()) loadLine();
return Integer.parseInt(stk.nextToken());
}
public long nextLong() {
while (stk==null || !stk.hasMoreTokens()) loadLine();
return Long.parseLong(stk.nextToken());
}
public double nextDouble() {
while (stk==null || !stk.hasMoreTokens()) loadLine();
return Double.parseDouble(stk.nextToken());
}
public String nextWord() {
while (stk==null || !stk.hasMoreTokens()) loadLine();
return (stk.nextToken());
}
}
|
B12074 | B12540 | 0 | package jp.funnything.competition.util;
import java.math.BigInteger;
/**
* Utility for BigInteger
*/
public class BI {
public static BigInteger ZERO = BigInteger.ZERO;
public static BigInteger ONE = BigInteger.ONE;
public static BigInteger add( final BigInteger x , final BigInteger y ) {
return x.add( y );
}
public static BigInteger add( final BigInteger x , final long y ) {
return add( x , v( y ) );
}
public static BigInteger add( final long x , final BigInteger y ) {
return add( v( x ) , y );
}
public static int cmp( final BigInteger x , final BigInteger y ) {
return x.compareTo( y );
}
public static int cmp( final BigInteger x , final long y ) {
return cmp( x , v( y ) );
}
public static int cmp( final long x , final BigInteger y ) {
return cmp( v( x ) , y );
}
public static BigInteger div( final BigInteger x , final BigInteger y ) {
return x.divide( y );
}
public static BigInteger div( final BigInteger x , final long y ) {
return div( x , v( y ) );
}
public static BigInteger div( final long x , final BigInteger y ) {
return div( v( x ) , y );
}
public static BigInteger mod( final BigInteger x , final BigInteger y ) {
return x.mod( y );
}
public static BigInteger mod( final BigInteger x , final long y ) {
return mod( x , v( y ) );
}
public static BigInteger mod( final long x , final BigInteger y ) {
return mod( v( x ) , y );
}
public static BigInteger mul( final BigInteger x , final BigInteger y ) {
return x.multiply( y );
}
public static BigInteger mul( final BigInteger x , final long y ) {
return mul( x , v( y ) );
}
public static BigInteger mul( final long x , final BigInteger y ) {
return mul( v( x ) , y );
}
public static BigInteger sub( final BigInteger x , final BigInteger y ) {
return x.subtract( y );
}
public static BigInteger sub( final BigInteger x , final long y ) {
return sub( x , v( y ) );
}
public static BigInteger sub( final long x , final BigInteger y ) {
return sub( v( x ) , y );
}
public static BigInteger v( final long value ) {
return BigInteger.valueOf( value );
}
}
| import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashSet;
public class RecycledNumbers {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int testCaseNumber;
String input;
BufferedReader in = new BufferedReader(new FileReader("C-small-attempt0.in"));
input = in.readLine();
testCaseNumber = Integer.parseInt(input.trim());
int[] totalAccountArray = new int[testCaseNumber];
for(int i=0; i<testCaseNumber; i++){
input = in.readLine();
String[] inputArray = input.split(" ");
int A = Integer.parseInt(inputArray[0]);
int B = Integer.parseInt(inputArray[1]);
int count = 0;
HashSet<String> hashSet = new HashSet<String>();
for(int j=A;j<=B; j++){
String num = String.valueOf(j);
for(int k=1; k<num.length(); k++){
String firstHalf = num.substring(0, k);
String lastHalf = num.substring(k,num.length());
String flipped = lastHalf+firstHalf;
int flippedNum = Integer.parseInt(flipped);
if(j>=flippedNum)
continue;
if(flippedNum>=A && flippedNum<=B){
if(hashSet.contains(num+flippedNum)){
System.out.println("DUPLICATE!!: " +num+flippedNum);
continue;
}
System.out.println("counted: "+"original: "+num+" Flipped: "+flippedNum);
count++;
hashSet.add(num+flippedNum);
}
}
}
System.out.println(count);
totalAccountArray[i] = count;
}
in.close();
FileWriter fstream = new FileWriter("C-small-attempt0.out");
BufferedWriter out = new BufferedWriter(fstream);
for(int i=1; i<=testCaseNumber;i++){
String outLine = "Case #"+i+": "+totalAccountArray[i-1]+"\n";
out.write(outLine);
}
out.close();
System.out.println("File created successfully.");
}
}
|
A11502 | A12774 | 0 | package template;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
public class TestCase {
private boolean isSolved;
private Object solution;
private Map<String, Integer> intProperties;
private Map<String, ArrayList<Integer>> intArrayProperties;
private Map<String, ArrayList<ArrayList<Integer>>> intArray2DProperties;
private Map<String, Double> doubleProperties;
private Map<String, ArrayList<Double>> doubleArrayProperties;
private Map<String, ArrayList<ArrayList<Double>>> doubleArray2DProperties;
private Map<String, String> stringProperties;
private Map<String, ArrayList<String>> stringArrayProperties;
private Map<String, ArrayList<ArrayList<String>>> stringArray2DProperties;
private Map<String, Boolean> booleanProperties;
private Map<String, ArrayList<Boolean>> booleanArrayProperties;
private Map<String, ArrayList<ArrayList<Boolean>>> booleanArray2DProperties;
private Map<String, Long> longProperties;
private Map<String, ArrayList<Long>> longArrayProperties;
private Map<String, ArrayList<ArrayList<Long>>> longArray2DProperties;
private int ref;
private double time;
public TestCase() {
initialise();
}
private void initialise() {
isSolved = false;
intProperties = new HashMap<>();
intArrayProperties = new HashMap<>();
intArray2DProperties = new HashMap<>();
doubleProperties = new HashMap<>();
doubleArrayProperties = new HashMap<>();
doubleArray2DProperties = new HashMap<>();
stringProperties = new HashMap<>();
stringArrayProperties = new HashMap<>();
stringArray2DProperties = new HashMap<>();
booleanProperties = new HashMap<>();
booleanArrayProperties = new HashMap<>();
booleanArray2DProperties = new HashMap<>();
longProperties = new HashMap<>();
longArrayProperties = new HashMap<>();
longArray2DProperties = new HashMap<>();
ref = 0;
}
public void setSolution(Object o) {
solution = o;
isSolved = true;
}
public Object getSolution() {
if (!isSolved) {
Utils.die("getSolution on unsolved testcase");
}
return solution;
}
public void setRef(int i) {
ref = i;
}
public int getRef() {
return ref;
}
public void setTime(double d) {
time = d;
}
public double getTime() {
return time;
}
public void setInteger(String s, Integer i) {
intProperties.put(s, i);
}
public Integer getInteger(String s) {
return intProperties.get(s);
}
public void setIntegerList(String s, ArrayList<Integer> l) {
intArrayProperties.put(s, l);
}
public void setIntegerMatrix(String s, ArrayList<ArrayList<Integer>> l) {
intArray2DProperties.put(s, l);
}
public ArrayList<Integer> getIntegerList(String s) {
return intArrayProperties.get(s);
}
public Integer getIntegerListItem(String s, int i) {
return intArrayProperties.get(s).get(i);
}
public ArrayList<ArrayList<Integer>> getIntegerMatrix(String s) {
return intArray2DProperties.get(s);
}
public ArrayList<Integer> getIntegerMatrixRow(String s, int row) {
return intArray2DProperties.get(s).get(row);
}
public Integer getIntegerMatrixItem(String s, int row, int column) {
return intArray2DProperties.get(s).get(row).get(column);
}
public ArrayList<Integer> getIntegerMatrixColumn(String s, int column) {
ArrayList<Integer> out = new ArrayList();
for(ArrayList<Integer> row : intArray2DProperties.get(s)) {
out.add(row.get(column));
}
return out;
}
public void setDouble(String s, Double i) {
doubleProperties.put(s, i);
}
public Double getDouble(String s) {
return doubleProperties.get(s);
}
public void setDoubleList(String s, ArrayList<Double> l) {
doubleArrayProperties.put(s, l);
}
public void setDoubleMatrix(String s, ArrayList<ArrayList<Double>> l) {
doubleArray2DProperties.put(s, l);
}
public ArrayList<Double> getDoubleList(String s) {
return doubleArrayProperties.get(s);
}
public Double getDoubleListItem(String s, int i) {
return doubleArrayProperties.get(s).get(i);
}
public ArrayList<ArrayList<Double>> getDoubleMatrix(String s) {
return doubleArray2DProperties.get(s);
}
public ArrayList<Double> getDoubleMatrixRow(String s, int row) {
return doubleArray2DProperties.get(s).get(row);
}
public Double getDoubleMatrixItem(String s, int row, int column) {
return doubleArray2DProperties.get(s).get(row).get(column);
}
public ArrayList<Double> getDoubleMatrixColumn(String s, int column) {
ArrayList<Double> out = new ArrayList();
for(ArrayList<Double> row : doubleArray2DProperties.get(s)) {
out.add(row.get(column));
}
return out;
}
public void setString(String s, String t) {
stringProperties.put(s, t);
}
public String getString(String s) {
return stringProperties.get(s);
}
public void setStringList(String s, ArrayList<String> l) {
stringArrayProperties.put(s, l);
}
public void setStringMatrix(String s, ArrayList<ArrayList<String>> l) {
stringArray2DProperties.put(s, l);
}
public ArrayList<String> getStringList(String s) {
return stringArrayProperties.get(s);
}
public String getStringListItem(String s, int i) {
return stringArrayProperties.get(s).get(i);
}
public ArrayList<ArrayList<String>> getStringMatrix(String s) {
return stringArray2DProperties.get(s);
}
public ArrayList<String> getStringMatrixRow(String s, int row) {
return stringArray2DProperties.get(s).get(row);
}
public String getStringMatrixItem(String s, int row, int column) {
return stringArray2DProperties.get(s).get(row).get(column);
}
public ArrayList<String> getStringMatrixColumn(String s, int column) {
ArrayList<String> out = new ArrayList();
for(ArrayList<String> row : stringArray2DProperties.get(s)) {
out.add(row.get(column));
}
return out;
}
public void setBoolean(String s, Boolean b) {
booleanProperties.put(s, b);
}
public Boolean getBoolean(String s) {
return booleanProperties.get(s);
}
public void setBooleanList(String s, ArrayList<Boolean> l) {
booleanArrayProperties.put(s, l);
}
public void setBooleanMatrix(String s, ArrayList<ArrayList<Boolean>> l) {
booleanArray2DProperties.put(s, l);
}
public ArrayList<Boolean> getBooleanList(String s) {
return booleanArrayProperties.get(s);
}
public Boolean getBooleanListItem(String s, int i) {
return booleanArrayProperties.get(s).get(i);
}
public ArrayList<ArrayList<Boolean>> getBooleanMatrix(String s) {
return booleanArray2DProperties.get(s);
}
public ArrayList<Boolean> getBooleanMatrixRow(String s, int row) {
return booleanArray2DProperties.get(s).get(row);
}
public Boolean getBooleanMatrixItem(String s, int row, int column) {
return booleanArray2DProperties.get(s).get(row).get(column);
}
public ArrayList<Boolean> getBooleanMatrixColumn(String s, int column) {
ArrayList<Boolean> out = new ArrayList();
for(ArrayList<Boolean> row : booleanArray2DProperties.get(s)) {
out.add(row.get(column));
}
return out;
}
public void setLong(String s, Long b) {
longProperties.put(s, b);
}
public Long getLong(String s) {
return longProperties.get(s);
}
public void setLongList(String s, ArrayList<Long> l) {
longArrayProperties.put(s, l);
}
public void setLongMatrix(String s, ArrayList<ArrayList<Long>> l) {
longArray2DProperties.put(s, l);
}
public ArrayList<Long> getLongList(String s) {
return longArrayProperties.get(s);
}
public Long getLongListItem(String s, int i) {
return longArrayProperties.get(s).get(i);
}
public ArrayList<ArrayList<Long>> getLongMatrix(String s) {
return longArray2DProperties.get(s);
}
public ArrayList<Long> getLongMatrixRow(String s, int row) {
return longArray2DProperties.get(s).get(row);
}
public Long getLongMatrixItem(String s, int row, int column) {
return longArray2DProperties.get(s).get(row).get(column);
}
public ArrayList<Long> getLongMatrixColumn(String s, int column) {
ArrayList<Long> out = new ArrayList();
for(ArrayList<Long> row : longArray2DProperties.get(s)) {
out.add(row.get(column));
}
return out;
}
}
| import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class DancingGooglers {
public static void main(String[] args) throws IOException {
BufferedReader fInput = new BufferedReader(new FileReader("res/inputB.in"));
PrintWriter fOutput = new PrintWriter(new BufferedWriter(new FileWriter(
"res/outputB.out")));
new DancingGooglers().run(fInput, fOutput);
fOutput.close();
}
private void run(BufferedReader fInput, PrintWriter fOutput) throws IOException {
int T = Integer.parseInt(fInput.readLine());
for (int i=0; i<T; i++) {
int count = 0;
String[] inputS = fInput.readLine().split(" ");
int N = Integer.parseInt(inputS[0]);
int S = Integer.parseInt(inputS[1]);
int p = Integer.parseInt(inputS[2]);
for (int j=3; j<N+3; j++) {
int t = Integer.parseInt(inputS[j]);
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--;
}
}
fOutput.println("Case #" + (i+1) + ": " + count);
}
}
} |