package org.goro.uva.m;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Brainfuck {
private static final int MEM_SIZE = 100;
private static final char PTR_INC = '>';
private static final char PTR_DEC = '<';
private static final char VAL_INC = '+';
private static final char VAL_DEC = '-';
public static void main(String[] args) throws IOException {
Reader.init(System.in);
StringBuilder sb = new StringBuilder();
int tests = Reader.nextInt();
int currTest = 0;
while (currTest < tests) {
currTest++;
String instructions = Reader.next();
sb.append("Case " + (currTest) + ":");
processInstructions(instructions, sb);
sb.append("\n");
}
System.out.print(sb);
}
private static void processInstructions(String instructions,
StringBuilder sb) {
byte[] memory = new byte[MEM_SIZE];
int pointer = 0;
for (int i = 0; i < instructions.length(); i++) {
char instruction = instructions.charAt(i);
switch (instruction) {
case PTR_DEC:
pointer = (pointer == 0) ? MEM_SIZE - 1 : pointer - 1;
break;
case PTR_INC:
pointer = (pointer == MEM_SIZE - 1) ? 0 : pointer + 1;
break;
case VAL_INC:
memory[pointer]++;
break;
case VAL_DEC:
memory[pointer]--;
break;
default:
break;
}
}
for (int i = 0; i < memory.length; i++) {
sb.append(" " + convert(memory[i]));
}
}
private static String convert(byte n) {
return String.format("%02X", n);
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
25/07/2014
11956 - Brainfuck - JAVA
11687 - Digits - JAVA
package org.goro.uva.m;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Digits {
public static void main(String[] args) throws IOException {
Reader.init(System.in);
StringBuilder sb = new StringBuilder();
String line = Reader.next();
while (!line.equals("END")) {
int lenght = line.length();
if (line.equals("1")) {
sb.append(1);
} else if (lenght < 2) {
sb.append(2);
} else if (lenght < 10) {
sb.append(3);
} else {
sb.append(4);
}
line = Reader.next();
if (!line.equals("END")) {
sb.append("\n");
}
}
System.out.println(sb);
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
11683 - Laser Sculpture - JAVA
package org.goro.uva.m;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class LaserSculpture {
public static void main(String[] args) throws IOException {
Reader.init(System.in);
StringBuilder sb = new StringBuilder();
int height = Reader.nextInt();
while (height > 0) {
int lenght = Reader.nextInt();
int lasers = cut(height, lenght);
sb.append(lasers);
height = Reader.nextInt();
if (height > 0) {
sb.append("\n");
}
}
System.out.println(sb);
}
private static int cut(int maxHeight, int lenght) throws IOException {
int cut = 0;
int last = maxHeight;
for (int j = 0; j < lenght; j++) {
int curr = Reader.nextInt();
if (curr < last) {
cut += last - curr;
}
last = curr;
}
return cut;
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
06/10/2013
11507 - Bender B. RodrÃguez Problem - Java
package org.goro.uva.m;
import java.io.*;
import java.util.*;
public class BenderTwo {
public static int[][] table = {{9, 9, 9, 9, 9, 9},
{9, 9, 9, 9, 9, 9},
{2, 3, 1, 0, 4, 5},
{3, 2, 0, 1, 4, 5},
{4, 5, 2, 3, 1, 0},
{5, 4, 2, 3, 0, 1}};
public static String[] coder = {"+x", "-x", "+y", "-y", "+z", "-z"};
public static void main(String[] args) throws Exception {
// FileWriter writer = new FileWriter("output.out");
// BufferedWriter out = new BufferedWriter(writer);
StringBuilder sb = new StringBuilder();
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
int lenght = Reader.nextInt();
while (lenght > 0) {
int pos = 0;
for (int i = 1; i < lenght; i++) {
String tmp = Reader.next();
if (tmp.charAt(0) != 'N') pos = doStuff(tmp, pos);
}
sb.append(decode(pos)).append("\n");
lenght = Reader.nextInt();
}
System.out.print(sb);
// out.write(sb.toString());
// out.close();
}
public static int encode(char sign, char axis) {
if(sign == '+') {
if(axis == 'x') return 0;
if(axis == 'y') return 2;
return 4;
}
if(axis == 'x') return 1;
if(axis == 'y') return 3;
return 5;
}
public static String decode(int num) {
return coder[num];
}
public static int doStuff(String temp, int wire) {
int val = encode(temp.charAt(0), temp.charAt(1));
return table[val][wire];
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
10919 - Prerequisites? - Java
package org.goro.uva.m;
import java.io.*;
import java.math.RoundingMode;
import java.text.NumberFormat;
import java.util.*;
public class Prerequisites {
public static char[] ch_name1 = new char[25];
public static char[] ch_name2 = new char[25];
public static void main(String[] args) throws Exception {
// Reader.init(new FileInputStream(new File("input.in")));
Reader.init(System.in);
StringBuilder sb = new StringBuilder();
int noOfCourses = Reader.nextInt();
int noOfCat;
while (noOfCourses > 0) {
noOfCat = Reader.nextInt();
int coursesTaken[] = new int[noOfCourses];
boolean isValid = true;
for(int i = 0; i < noOfCourses; i++) coursesTaken[i] = Reader.nextInt();
for(int i = 0; i < noOfCat; i++) {
int tempNoCourses = Reader.nextInt();
int mustHave = Reader.nextInt();
int validated = 0;
for(int j = 0; j < tempNoCourses; j++) {
int tempCurse = Reader.nextInt();
for (int k : coursesTaken) {
// System.out.println("Checking course: " + tempCurse + " k: " + k);
if (tempCurse == k) {
validated++;
break;
}
}
}
if(validated < mustHave) {
isValid = false;
// System.out.println("Valid: " + validated + " must have: " + mustHave);
}
}
if(isValid) sb.append("yes\n");
else sb.append("no\n");
noOfCourses = Reader.nextInt();
}
System.out.print(sb);
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
10424 - Love Calculator - Java
package org.goro.uva.m;
import java.io.*;
import java.math.RoundingMode;
import java.text.NumberFormat;
import java.util.*;
public class LoveCalculator {
public static char[] ch_name1 = new char[25];
public static char[] ch_name2 = new char[25];
public static void main(String[] args) throws Exception {
// InputStreamReader isr = new InputStreamReader(new FileInputStream(new File("input.in")));
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder("");
String name1;
String name2;
while ((name1 = br.readLine()) != null) {
name2 = br.readLine();
name1 = name1.toLowerCase();
name2 = name2.toLowerCase();
ch_name1 = name1.toCharArray();
ch_name2 = name2.toCharArray();
int val1 = calculate(ch_name1);
int val2 = calculate(ch_name2);
if(val1 < val2) {
val1 ^= val2;
val2 ^= val1;
val1 ^= val2;
}
float propo = 0;
if( val1 != 0 ) propo = (float)val2 / (float)val1;
propo *=100;
sb.append(round(propo, 2)).append(" %\n");
}
System.out.print(sb);
}
static public String round(double d, int ic) {
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(ic);
nf.setMinimumFractionDigits(ic);
double tmp = Double.parseDouble((nf.format(d)).replaceAll(",", ".").replaceAll(" ", "") );
String temp = Double.toString(tmp);
if(temp.endsWith(".0")) return temp + "0";
else return temp;
}
public static int calculate(char[] arr) {
int retVal = 0;
for(int i = 0; i < arr.length; i++) {
if(arr[i] >= 'a' && arr[i] <= 'z') retVal += arr[i] - 'a' + 1;
}
return add(retVal);
// return retVal;
}
public static int add(int val) {
// System.out.println("running: " + val);
String tmp = Integer.toString(val);
// System.out.println("String: " + tmp + "lenght:" + tmp.length());
int retVal = 0;
for(int i = 0; i < tmp.length(); i++) {
retVal += (tmp.charAt(i) - '0');
// System.out.println(tmp.charAt(i));
}
// System.out.println("got: " + retVal);
if(retVal > 9) return add(retVal);
else return retVal;
}
}
10324 - Zeros and Ones - Java
package org.goro.uva.m;
import java.io.*;
import java.util.*;
public class ZerosAndOnes {
public static void main(String[] args) throws Exception {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder("");
int testCase = 1;
String line;
while ((line = br.readLine()) != null) {
sb.append("Case ").append(testCase).append(":\n");
testCase++;
int noOfCases = Integer.parseInt(br.readLine());
for (int j = 0; j < noOfCases; j++) {
String[] str = br.readLine().split(" ");
int val1 = Integer.parseInt(str[0]);
int val2 = Integer.parseInt(str[1]);
if (val1 > val2) {
val1 ^= val2;
val2 ^= val1;
val1 ^= val2;
}
boolean isValid = true;
if (val1 != val2) {
for (int i = val1; i < val2; i++) {
if (line.charAt(i) != line.charAt(i + 1)) {
isValid = false;
break;
}
}
}
if (isValid)
sb.append("Yes\n");
else
sb.append("No\n");
}
}
System.out.print(sb);
}
}
15/08/2013
10141 - Request for Proposal - Java
import java.io.*;
import java.util.*;
public class Request {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
int noOfRequirements = Reader.nextInt();
int noOfProposals = Reader.nextInt();
double minPrice;
int maxProposals;
int bestOffer;
for(int k = 1; noOfRequirements > 0; k++) {
String[] proposalName = new String[noOfProposals];
double[] proposalPrice = new double[noOfProposals];
int[] metReqs = new int[noOfProposals];
for (int i = 0; i < noOfRequirements; i++) {
Reader.reader.readLine();
}
minPrice = 0;
maxProposals = -1;
bestOffer = 0;
for (int i = 0; i < noOfProposals; i++) {
proposalName[i] = Reader.reader.readLine();
proposalPrice[i] = Reader.nextDouble();
metReqs[i] = Reader.nextInt();
for (int j = 0; j < metReqs[i]; j++) {
Reader.reader.readLine();
}
if (metReqs[i] > maxProposals) {
maxProposals = metReqs[i];
minPrice = proposalPrice[i];
bestOffer = i;
} else if (metReqs[i] == maxProposals && minPrice > proposalPrice[i]) {
minPrice = proposalPrice[i];
bestOffer = i;
}
}
System.out.println("RFP #" + k);
System.out.println(proposalName[bestOffer]);
noOfRequirements = Reader.nextInt();
noOfProposals = Reader.nextInt();
if(noOfRequirements != 0) System.out.println("");
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
661 - Blowing Fuses - Java
import java.io.*;
import java.util.*;
public class BlowingFuses {
public static void main(String[] args) throws Exception {
// FileWriter writer = new FileWriter("output.out");
// BufferedWriter out = new BufferedWriter(writer);
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
int currentCase = 1;
int noOfDevices = Reader.nextInt();
int noOfOperations;
int capacity;
int currentConsumption;
int maxConsumption;
boolean[] devicesState;
int[] devicesConsumption;
int tempDevice;
boolean isDone;
while (noOfDevices != 0) {
System.out.println("Sequence " + currentCase);
currentConsumption = 0;
maxConsumption = 0;
noOfOperations = Reader.nextInt();
capacity = Reader.nextInt();
devicesState = new boolean[noOfDevices];
devicesConsumption = new int[noOfDevices];
isDone = false;
for(int i = 0; i < noOfDevices; i++) {
devicesConsumption[i] = Reader.nextInt();
devicesState[i] = false;
}
for(int i = 0; i < noOfOperations; i++) {
tempDevice = Reader.nextInt() - 1;
if(!devicesState[tempDevice]) {
//power on...
devicesState[tempDevice] = true;
currentConsumption += devicesConsumption[tempDevice];
if(currentConsumption > capacity) {
for(i = i + 1; i < noOfOperations; i++) Reader.nextInt();
System.out.println("Fuse was blown.\n");
isDone = true;
}
if(currentConsumption > maxConsumption) maxConsumption = currentConsumption;
} else {
//shutting down...
currentConsumption -= devicesConsumption[tempDevice];
devicesState[tempDevice] = false;
}
}
if(!isDone) {
System.out.println("Fuse was not blown.");
System.out.println("Maximal power consumption was " + maxConsumption + " amperes.\n");
}
noOfDevices = Reader.nextInt();
currentCase++;
}
// out.close();
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
11/08/2013
573 - The Snail - Java
package org.goro.uva.m;
import java.io.*;
import java.util.*;
public class TheSnail {
public static void main(String[] args) throws Exception {
// FileWriter writer = new FileWriter("output.out");
// BufferedWriter out = new BufferedWriter(writer);
try {
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
while (true) {
int height = Reader.nextInt();
if(height == 0) break;
int dayDistance = Reader.nextInt();
int slidingDistance = Reader.nextInt();
int fatigueFactor = Reader.nextInt();
int dayLoss = fatigueFactor * dayDistance;
height *= 100;
dayDistance *= 100;
slidingDistance *= 100;
// out.write("DEBUG: New test case: H:" + height + " U:" + dayDistance + " D:" + slidingDistance + " F:" + fatigueFactor + " Loss:" + dayLoss);
int currentDay = 1;
int currentHeight = 0;
boolean isRunning = true;
while(isRunning) {
if(dayDistance > 0) {
currentHeight += dayDistance;
dayDistance -= dayLoss;
}
// out.write("DEBUG: Day:" + currentDay + " currHeight:" + currentHeight + "/" + height + " daySpeed: " + dayDistance + "\n");
if (currentHeight > height) {
System.out.println("success on day " + currentDay);
// out.write("success on day " + currentDay + "\n");
isRunning = false;
}
currentHeight -= slidingDistance;
if(currentHeight < 0 && isRunning) {
System.out.println("failure on day " + currentDay);
// out.write("failure on day " + currentDay + "\n");
isRunning = false;
}
currentDay++;
}
}
} catch (Exception ex) {
// ex.printStackTrace();
}
// out.close();
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
119 - Greedy Gift Givers - Java
import java.io.*;
import java.util.*;
public class GreedyGift {
public static void main(String[] args) throws Exception {
try {
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
boolean isRunning = true;
boolean isFirst = true;
while (isRunning) {
int noOfPeoples = Reader.nextInt();
PeopleContainer cont = new PeopleContainer();
for (int i = 0; i < noOfPeoples; i++)
cont.addPeople(Reader.next());
for (int i = 0; i < noOfPeoples; i++) {
String gaverName = Reader.next();
int giftValues = Reader.nextInt();
int noOfGiven = Reader.nextInt();
if (noOfGiven == 0)
continue;
while (giftValues % noOfGiven != 0) {
giftValues--;
}
cont.addValue(gaverName, -giftValues);
if (noOfGiven != 0) {
int tempVal = giftValues / noOfGiven;
for (int j = 0; j < noOfGiven; j++) {
String getterName = Reader.next();
cont.addValue(getterName, tempVal);
}
}
}
if (!isFirst)
System.out.println("");
cont.printAll();
isFirst = false;
}
} catch (Exception ex) {
// ex.printStackTrace();
}
}
}
class People {
String name;
int val;
}
class PeopleContainer {
ArrayList<People> list;
PeopleContainer() {
list = new ArrayList<People>();
}
public void addPeople(String name) {
People pep = new People();
pep.name = name;
pep.val = 0;
list.add(pep);
}
public void addValue(String name, int value) {
Iterator it = list.iterator();
while (it.hasNext()) {
People tmp = (People) it.next();
if (tmp.name.equals(name)) {
tmp.val += value;
return;
}
}
}
public void printAll() {
Iterator it = list.iterator();
while (it.hasNext()) {
People tmp = (People) it.next();
System.out.println(tmp.name + " " + tmp.val);
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
12554 - A Special "Happy Birthday" Song!!! - Java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class HappyBirthday {
static String[] song = {"Happy", "birthday", "to", "you",
"Happy", "birthday", "to", "you",
"Happy", "birthday", "to", "Rujia",
"Happy", "birthday", "to", "you"
};
public static void main(String[] args) throws Exception {
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
int noOfPeople = Reader.nextInt();
String[] peopleNames = new String[noOfPeople];
for(int i = 0; i < noOfPeople; i++) {
peopleNames[i] = Reader.next();
}
boolean isDone = false;
int i = 0;
// System.out.println("DEBUG: song lenght: " + song.length);
// System.out.println("DEBUG: noOfpeopne: " + noOfPeople);
while(!isDone) {
System.out.println(peopleNames[i%noOfPeople] + ": " + song[i%16]);
if(i%16 == 15 && i >= noOfPeople) isDone = true;
i++;
// System.out.println("*****DEBUG: song lenght: " + song.length);
// System.out.println("*****DEBUG: noOfpeopne: " + noOfPeople);
// System.out.println("******DEBUG Current song index: " + i%song.length + " current i:" + i);
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
12503 - Robot Instructions - Java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class RobotInstructions {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
int noOfTestCases = Reader.nextInt();
while((noOfTestCases--) > 0) {
int noOfInstructions = Reader.nextInt();
int currentPos = 0;
boolean[] instructions = new boolean[noOfInstructions];
for(int i = 0; i < noOfInstructions; i++) {
String currentInstruction = Reader.next();
if(currentInstruction.startsWith("L")) {
instructions[i] = false;
currentPos--;
} else if(currentInstruction.startsWith("R")) {
instructions[i] = true;
currentPos++;
} else {
Reader.next();
int tmp = Reader.nextInt();
instructions[i] = instructions[tmp-1];
if(instructions[i] == false) currentPos--;
else currentPos++;
}
}
System.out.println(currentPos);
}
}
}
///** Class for buffered reading int and double values */
///** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
12468 - Zapping - Java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Zapping {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
// Reader.init(new FileInputStream(new File("input.in")));
int a = Reader.nextInt();
int b = Reader.nextInt();
int val;
while(a >= 0 && b >= 0) {
val = Math.abs(a - b);
if(val > 50) val = 100 - val;
System.out.println(val);
a = Reader.nextInt();
b = Reader.nextInt();
}
}
}
///** Class for buffered reading int and double values */
///** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
10/08/2013
12157 - Tariff Plan - Java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class TariffPlan {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
//Reader.init(new FileInputStream(new File("input.in")));
int noOfTestCases = Reader.nextInt();
for(int i = 1; i <= noOfTestCases; i++) {
int noOfCalls = Reader.nextInt();
int mileTarifCost = 0;
int juiceTarifCost = 0;
int tempSeconds;
for(int j = 0; j < noOfCalls; j++) {
tempSeconds = Reader.nextInt();
//System.out.println("DEBUG: seconds / 30: " + ((tempSeconds/30) + 1));
mileTarifCost += (10 * (tempSeconds/30 + 1));
juiceTarifCost += (15 * (tempSeconds/60 + 1));
}
if(mileTarifCost < juiceTarifCost) {
System.out.println("Case " + i + ": Mile " + mileTarifCost);
} else if(mileTarifCost > juiceTarifCost) {
System.out.println("Case " + i + ": Juice " + juiceTarifCost);
} else {
System.out.println("Case " + i + ": Mile Juice "+ mileTarifCost);
}
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
12015 - Google is Feeling Lucky - Java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class GoogleLucky {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
//Reader.init(new FileInputStream(new File("file.in")));
int noOfTestCases = Reader.nextInt();
GoogleEntry[] sites = new GoogleEntry[10];
for(int i = 0; i < 10; i++) {
sites[i] = new GoogleEntry();
}
for(int i = 1; i <= noOfTestCases; i++) {
int currMax = 0;
System.out.println("Case #" + i + ":");
for(int j = 0; j < 10; j++) {
sites[j].webSite = Reader.next();
sites[j].rank = Reader.nextInt();
if(sites[j].rank > currMax) currMax = sites[j].rank;
}
for(int j = 0; j < 10; j++) {
if(sites[j].rank == currMax) System.out.println(sites[j].webSite);
}
}
}
}
class GoogleEntry {
public String webSite;
public int rank;
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
11942 - Lumberjack Sequencing - Java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class LumberjackSequencing {
enum Direction {undef, up, down};
public static void main(String[] args) throws Exception {
Reader.init(System.in);
//Reader.init(new FileInputStream(new File("input.in")));
int noOfTestCases = Reader.nextInt();
System.out.println("Lumberjacks:");
for(int i = 1; i <= noOfTestCases; i++) {
Direction dir = Direction.undef;
int previousVal;
int currentVal;
int j = 0;
boolean ordered = true;
previousVal = Reader.nextInt();
while(dir == Direction.undef && j < 9) {
currentVal = Reader.nextInt();
if(previousVal > currentVal) dir = Direction.down;
else if(previousVal < currentVal) dir = Direction.up;
j++;
previousVal = currentVal;
//System.out.println("DEBUG: Testcase " + i + "Dir: " + dir.toString() );
}
for(; j < 9; j++) {
currentVal = Reader.nextInt();
if(dir == Direction.down) {
//System.out.println("DEBUG: currJack: " + j + "Dir: " + dir.toString() + " curVal:" + currentVal + " prevVal:" + previousVal);
if(previousVal < currentVal) ordered = false;
} else if (dir == Direction.up) {
if(previousVal > currentVal) ordered = false;
}
previousVal = currentVal;
}
if(ordered) System.out.println("Ordered");
else System.out.println("Unordered");
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
11799 - Horror Dash - Java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class HorrorDash {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
int noOfTestCases = Reader.nextInt();
int noOfCreatures;
int max;
int currentSpeed;
for(int i = 1; i <= noOfTestCases; i++) {
noOfCreatures = Reader.nextInt();
max = 0;
for(int j = 0; j < noOfCreatures; j++) {
currentSpeed = Reader.nextInt();
if(currentSpeed > max) max = currentSpeed;
}
System.out.println("Case " + i + ": " + max);
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
11764 - Jumping Mario - Java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
//11764 - Jumping Mario
public class JumpingMario {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
int noOfTestCases = Reader.nextInt();
for(int currentCase = 1; currentCase <= noOfTestCases; currentCase++) {
int noOfWalls = Reader.nextInt() - 1;
int currentWall = Reader.nextInt();
int smallJumps = 0;
int bigJumps = 0;
while((noOfWalls--) > 0) {
int thisWall = Reader.nextInt();
if(thisWall < currentWall) {
smallJumps++;
} else if(thisWall > currentWall) {
bigJumps++;
}
currentWall = thisWall;
}
System.out.println("Case " + currentCase +": " + bigJumps + " " + smallJumps);
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
11679 - Sub-prime - Java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class SubPrime {
public static void main(String[] args) throws Exception {
Reader.init(System.in);
int noOfBanks = Reader.nextInt();
int noOfDebetures = Reader.nextInt();
int tempDebtor;
int tempCreditor;
int tempValue;
boolean flag;
while(noOfBanks != 0 && noOfDebetures != 0) {
int[] bankAccount = new int[noOfBanks];
for(int i = 0; i < noOfBanks; i++) {
bankAccount[i] = Reader.nextInt();
}
for(int i = 0; i < noOfDebetures; i++) {
tempDebtor = Reader.nextInt();
tempCreditor = Reader.nextInt();
tempValue = Reader.nextInt();
bankAccount[tempDebtor - 1] -= tempValue;
bankAccount[tempCreditor - 1] += tempValue;
}
flag = true;
for(int i = 0; i < noOfBanks; i++) {
if(bankAccount[i] < 0) {
flag = false;
break;
}
}
if(flag) System.out.println("S");
else System.out.println("N");
noOfBanks = Reader.nextInt();
noOfDebetures = Reader.nextInt();
}
}
}
/** Class for buffered reading int and double values */
/** http://www.cpe.ku.ac.th/~jim/java-io.html */
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
}
Subscribe to:
Posts (Atom)