UVA Problem ID 10924 (Prime Words)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main{
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		while((input=br.readLine())!=null) 
		{
			int sum=0;
			for (int i = 0; i < input.length(); i++) {
				if(input.charAt(i)>=97 && input.charAt(i)<=122)
					sum+=input.charAt(i)-96;
				else if(input.charAt(i)>=65 && input.charAt(i)<=90)
					sum+=input.charAt(i)-38;
			}
			if(isPrime(sum))
				sb.append("It is a prime word.\n");
			else
				sb.append("It is not a prime word.\n");
		}
		System.out.print(sb);
	}
	public static boolean isPrime(int number)
	{
		if(number!=2  && number%2==0)
			return false;
		for (int i =3; i <= Math.ceil(Math.sqrt(number)); i=i+2) {
			if(number%i==0)
				return false;
		}
		return true;
	}
}

UVA Problem ID 10946 (You want what filled?)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
	static char grid[][];
	static boolean wasVisited[][];
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int testcase=0;
		while((input=br.readLine())!=null) 
		{
			String s[]=input.split(" +");
			int row=Integer.parseInt(s[0]);
			int column=Integer.parseInt(s[1]);
			if(row==0 && column==0)
				break;
			testcase++;
			grid=new char[row][column];
			wasVisited=new boolean[row][column];
			for (int i = 0; i < row; i++) {
				input=br.readLine().trim();
				for (int j = 0; j rowlimit || column>columnlimit || row<0 || column<0 || wasVisited[row][column]==true)
			return 0;
		if(grid[row][column]==c)
		{
			count++;
			grid[row][column]='.';
			wasVisited[row][column]=true;
			count+=floodfill(row-1,column,c,rowlimit,columnlimit);
			count+=floodfill(row,column-1,c,rowlimit,columnlimit);
			count+=floodfill(row,column+1,c,rowlimit,columnlimit);
			count+=floodfill(row+1,column,c,rowlimit,columnlimit);
			return count;
		}
		return 0;
	}
}
class Hole implements Comparable
{
	char name;
	int count;
	public Hole(char n,int c)
	{
		name=n;
		count=c;
	}
	
	@Override
	public int compareTo(Hole h1) {
		if(this.count>h1.count)
			return -1;
		else if(this.count 

UVA Problem ID 10336 (Rank the Languages)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
	static char grid[][];
	static boolean wasVisited[][];
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int testcase=Integer.parseInt(br.readLine());
		for (int t1 = 0; t1 rowlimit || column>columnlimit || row<0 || column<0 || wasVisited[row][column]==true)
			return ;
		if(grid[row][column]==c)
		{
			grid[row][column]='.';
			wasVisited[row][column]=true;
		
		
		floodfill(row-1,column,c,rowlimit,columnlimit);
		floodfill(row,column-1,c,rowlimit,columnlimit);
		floodfill(row,column+1,c,rowlimit,columnlimit);
		floodfill(row+1,column,c,rowlimit,columnlimit);
		}
		
	}
}
class Token implements Comparable
{
	char name;
	int count;
	public Token(char n,int c)
	{
		name=n;
		count=c;
	}
	
	@Override
	public int compareTo(Token t1) {
		if(this.count>t1.count)
			return -1;
		else 
			return 1;
	}
}

UVA Problem ID 784 (Maze Exploration)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	static char grid[][]=new char[30][];
	static boolean wasVisited[][]=new boolean[30][];
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int testases=Integer.parseInt(br.readLine());
		for (int t1 = 0; t1 < testases; t1++) 
		{
			input=br.readLine();
			int t=0;
			do {
				grid[t]=new char[input.length()];
				wasVisited[t]=new boolean[input.length()];
				for (int j = 0; j rowlimit || column>columnlimit || row<0 || column<0 )
			return;
		if(grid[row][column]=='X' || wasVisited[row][column]==true)
			return;
			
		if(grid[row][column]==' ' || grid[row][column]=='*')
		{
			grid[row][column]='#';
			wasVisited[row][column]=true;
		}
		floodfill(row-1,column,rowlimit,grid[row-1].length-1);
		floodfill(row,column-1,rowlimit,grid[row].length-1);
		floodfill(row,column+1,rowlimit,grid[row].length-1);
		floodfill(row+1,column,rowlimit,grid[row+1].length-1);
	}
}

UVA Problem ID 871 (Counting Cells in a Blob)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	static int grid[][];
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int t = 0; t < testcases; t++) 
		{
			if(t>0)
				sb.append("\n");
			br.readLine();
			input=br.readLine();
			int dimension=input.length();
			grid=new int[dimension][dimension];
			for (int j = 0; j < dimension; j++) {
				grid[0][j]=input.charAt(j)-48;
			}
			for (int i = 1; i < dimension; i++) {
				input=br.readLine();
				for (int j = 0; j < dimension; j++) {
					grid[i][j]=input.charAt(j)-48;
				}
			}
			
			int largest=0;
			for (int i = 0; i < dimension; i++) {
				for (int j = 0; j largest)
							largest=count;
					}
				}
			}
			sb.append(largest+"\n");
		}
		System.out.print(sb);

	}
	public static int floodfill(int row,int column,int rowlimit,int columnlimit)
	{
		if(grid[row][column]!=1)
			return 0;
		int count=1;
		
		
		grid[row][column]=0;
		if(row-1>=0)
		{
			count+=floodfill(row-1, column, rowlimit, columnlimit);
			if(column-1>=0)
				count+=floodfill(row-1, column-1, rowlimit, columnlimit);
			if(column+1<=columnlimit)
				count+=floodfill(row-1, column+1, rowlimit, columnlimit);
		}
		if(row+1<=rowlimit)
		{
			count+=floodfill(row+1, column, rowlimit, columnlimit);
			if(column-1>=0)
				count+=floodfill(row+1, column-1, rowlimit, columnlimit);
			if(column+1<=columnlimit)
				count+=floodfill(row+1, column+1, rowlimit, columnlimit);
		}
		if(column-1>=0)
			count+=floodfill(row, column-1, rowlimit, columnlimit);
		if(column+1<=columnlimit)
			count+=floodfill(row, column+1, rowlimit, columnlimit);
		return count;
	}

}

UVA Problem ID 11244 (Counting Stars)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	static char image[][];
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		while((input=br.readLine())!=null)
		{
			String s[]=input.split(" +");
			int row=Integer.parseInt(s[0]);
			int column=Integer.parseInt(s[1]);
			if(row==0 && column==0)
				break;
			image=new char[row][column];
			for (int i = 0; i < row; i++) {
				input=br.readLine();
				for (int j = 0; j < column; j++) {
					image[i][j]=input.charAt(j);
				}
			}
			int no_of_stars=0;
			for (int i = 0; i < row; i++) {
				for (int j = 0; j =0)
		{
			count+=floodfill(row-1, column, rowlimit, columnlimit);
			if(column-1>=0)
				count+=floodfill(row-1, column-1, rowlimit, columnlimit);
			if(column+1<=columnlimit)
				count+=floodfill(row-1, column+1, rowlimit, columnlimit);
		}
		if(row+1<=rowlimit)
		{
			count+=floodfill(row+1, column, rowlimit, columnlimit);
			if(column-1>=0)
				count+=floodfill(row+1, column-1, rowlimit, columnlimit);
			if(column+1<=columnlimit)
				count+=floodfill(row+1, column+1, rowlimit, columnlimit);
		}
		if(column-1>=0)
			count+=floodfill(row, column-1, rowlimit, columnlimit);
		if(column+1<=columnlimit)
			count+=floodfill(row, column+1, rowlimit, columnlimit);
		return count;
	}

}

UVA Problem ID 11470 (Square Sums)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	static int square[][];
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		int testno=0;
		StringBuilder sb=new StringBuilder(10000);
		while((input=br.readLine())!=null)
		{
			
			int dimension=Integer.parseInt(input);
			if(dimension==0)
				break;
			testno++;
			square=new int[dimension][dimension];
			for (int i = 0; i < dimension; i++) {
				String s[]=br.readLine().split(" +");
				for (int j = 0; j < dimension; j++) {
					square[i][j]=Integer.parseInt(s[j]);
				}
			}
			sb.append("Case "+testno+": ");
			for (int i = 0; i < dimension/2; i++) {
				int count=0;
				count +=sumsquare(i,i+1,false,dimension-i-1);
				count +=sumsquare(i,i,true,dimension-i);
				count +=sumsquare(dimension-i-1,i+1,false,dimension-i-1);
				count +=sumsquare(i,dimension-i-1,true,dimension-i);
				if(i==0)
					sb.append(count);
				else
					sb.append(" "+count);
			}
			if(dimension % 2!=0 && dimension/2==0)
				sb.append(square[(int) Math.floor(dimension / 2.0)][(int) Math.floor(dimension / 2.0)]);
			else if(dimension % 2!=0)
				sb.append(" "+square[(int) Math.floor(dimension / 2.0)][(int) Math.floor(dimension / 2.0)]);
			sb.append("\n");
		}
		System.out.print(sb);
	}
	public static int sumsquare(int i,int j,boolean isrowchange,int dimension)
	{
		int count=0;
		
		if(isrowchange)
		{
			for (int k = i; k < dimension; k++) {
				count+=square[k][j];
			}
		}
		else
		{
			for (int k = j; k < dimension; k++) {
				count+=square[i][k];
			}
		}
		return count;
	}
}

UVA Problem ID 11078 (Open Credit System)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int t = 0; t < testcases;t++) {
			int n=Integer.parseInt(br.readLine());
			int score[]=new int[n];
			int maxdiff=-99999999,max=-99999999;
			for (int i = 0; i < n; i++) {
				score[i]=Integer.parseInt(br.readLine().trim());
			}
			for (int j =0; j max)
					max=score[j];
				if(max-score[j+1]>maxdiff)
					maxdiff=max-score[j+1];
			}
			sb.append(maxdiff+"\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 10976 (Fractions Again)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		
		StringBuilder sb1=new StringBuilder(1000);
		while((input=br.readLine())!=null)
		{
			StringBuilder sb=new StringBuilder(1000);
			int k=Integer.parseInt(input);
			int count=0;
			for (int i = k+1; i <= k*2; i++) {
				
				if((i*k)%(i-k)==0)
				{
					count++;
					sb.append("1/"+k+" = 1/"+((k*i)/(i-k))+" + 1/"+i+"\n");				
				}
			}
			sb1.append(count+"\n"+sb);
		}
		System.out.print(sb1);
	}
}

UVA Problem ID 11364 (Parking)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine().trim());
		for(int i=0;imax)
				{
					max=Integer.parseInt(s[j]);
				}
				if(Integer.parseInt(s[j])

UVA Problem ID 256 (Quirksome Squares)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		while((input=br.readLine())!=null)
		{
			int lowerbound=0;
			int upperbound=0;
			int divider=10;
			switch (Integer.parseInt(input)) {
				case 2:
				{
					lowerbound=00;
					upperbound=99;
					divider=10;
					break;
				}
				case 4:
				{
					lowerbound=0000;
					upperbound=9999;
					divider=100;
					break;
				}
				case 6:
				{
					lowerbound=000000;
					upperbound=999999;
					divider=1000;
					break;
				}
				case 8:
				{
					lowerbound=00000000;
					upperbound=99999999;
					divider=10000;
					break;
				}
			}
			for (int i = lowerbound; i <= upperbound; i++) {
				int a=i/divider;
				int b=i-a*divider;
				if((a+b)*(a+b)==i)
				{
					System.out.format("%0"+Integer.parseInt(input)+"d\n",i);
				}
			}
		}
	}
}

UVA Problem ID 12289 (One-Two-Three)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine().trim());
		for(int i=0;i

UVA Problem ID 12577 (Hajj-e-Akbar)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int testcase=0;
		while((input=br.readLine())!=null)
		{
			if(input.trim().equals("*"))
				break;
			testcase++;
			if(input.trim().equals("Hajj"))
				sb.append("Case "+testcase+": Hajj-e-Akbar\n");
			else 
				sb.append("Case "+testcase+": Hajj-e-Asghar\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 12403 (Save Setu)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int no_of_operations=Integer.parseInt(br.readLine().trim());
		int money=0;
		for(int i=0;i

UVA Problem ID 12372 (Packing for Holiday)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine().trim());
		for(int i=0;i

UVA Problem ID 12279 (Emoogle Balance)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int testcase=0;
		while((input=br.readLine())!=null)
		{
			if(Integer.parseInt(input.trim())==0)
				break;
			testcase++;
			String s[]=br.readLine().split(" +");
			int reason=0;
			int party=0;
			for (int i = 0; i < Integer.parseInt(input.trim()); i++) {
				if(Integer.parseInt(s[i])>0)
					reason++;
				else 
					party++;
			}
			sb.append("Case "+testcase+": "+(reason-party)+"\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 12250 (Language Detection)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int testcase=0;
		while((input=br.readLine())!=null)
		{
			if(input.equals("#"))
				break;
			testcase++;
			switch (input) {
				case "HELLO":
				{
					sb.append("Case "+testcase+": ENGLISH\n");
					break;
				}
				case "HOLA":
				{
					sb.append("Case "+testcase+": SPANISH\n");
					break;
				}
				case "HALLO":
				{
					sb.append("Case "+testcase+": GERMAN\n");
					break;
				}
				case "BONJOUR":
				{
					sb.append("Case "+testcase+": FRENCH\n");
					break;
				}
				case "CIAO":
				{
					sb.append("Case "+testcase+": ITALIAN\n");
					break;
				}
				case "ZDRAVSTVUJTE":
				{
					sb.append("Case "+testcase+": RUSSIAN\n");
					break;
				}
				default:
				{
					sb.append("Case "+testcase+": UNKNOWN\n");
					break;
				}
			}
		}
		System.out.print(sb);
	}
}

UVA Problem ID 11172 (Relational Operators)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine().trim());
		for(int i=0;ib)
				sb.append(">\n");
			else if(a

UVA Problem ID 1124 (Celebrity jeopardy)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		while((input=br.readLine())!=null)
		{
			sb.append(input+"\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 572 (Oil Deposits)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		while((input=br.readLine())!=null)
		{
			String s[]=input.split(" +");
			int m=Integer.parseInt(s[0]);
			int n=Integer.parseInt(s[1]);
			if(m==0)
				break;
			char grid[][]=new char[m][n];
			
			for (int i = 0; i < m; i++) {
				input=br.readLine();
				for (int j = 0; j < n; j++) {
					grid[i][j]=input.charAt(j);
				}	
			}
			int no_of_oilDeposits=0;
			for(int i=0;i=0)
		{
			if(column-1>=0 && grid[row-1][column-1]=='@')
				floodfill(grid,row-1, column-1,rowlimit,columnlimit);
			if(column+1=0 && grid[row+1][column-1]=='@')
				floodfill(grid,row+1, column-1,rowlimit,columnlimit);
			if(column+1=0 && grid[row][column-1]=='@')
			floodfill(grid,row, column-1,rowlimit,columnlimit);
		if(column+1

UVA Problem ID 352 (Seasonal War)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		int imageNo=0;
		while((input=br.readLine())!=null)
		{
			imageNo++;
			int dimention=Integer.parseInt(input.trim());
			
			char image[][]=new char[dimention][dimention];
			
			for (int i = 0; i < dimention; i++) {
				input=br.readLine();
				for (int j = 0; j < dimention; j++) {
					image[i][j]=input.charAt(j);
				}	
			}
			int no_of_eagle=0;
			for(int i=0;i=0)
		{
			if(column-1>=0 && image[row-1][column-1]=='1')
				floodfill(image,row-1, column-1,dimention);
			if(column+1=0 && image[row+1][column-1]=='1')
				floodfill(image,row+1, column-1,dimention);
			if(column+1=0 && image[row][column-1]=='1')
			floodfill(image,row, column-1,dimention);
		if(column+1

UVA Problem ID 442 (Matrix Chain Multiplication)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int no_of_matrices=Integer.parseInt(br.readLine());
		Matrix matrices[]=new Matrix[26];
		for (int i = 0; i  st=new Stack();
			int totalcost=0;
			for (int i = 0; i < input.length(); i++) {
				if(input.charAt(i)=='(')
				{
					//do nothing
				}
				else if(input.charAt(i)==')')
				{
					
					Matrix b=(Matrix) st.pop();
					Matrix a=(Matrix) st.pop();

					if(a.column!=b.row)
					{
						sb.append("error\n");
						flag=false;
						break;
					}
					else
					{
						totalcost+=a.row*a.column*b.column;
						st.push(new Matrix('t',a.row,b.column));		
					}
				}
				else
				{
					st.push(matrices[input.charAt(i)-65]);
				}
			}
			if(st.size()>2)
			{
				sb.append("error\n");
				flag=false;
			}
			else if(!st.isEmpty() && st.size()==2)
			{
				
				Matrix b=(Matrix) st.pop();
				Matrix a=(Matrix) st.pop();	
				if(a.column!=b.row)
				{
					sb.append("error\n");
					flag=false;
				}
				else
				{
					totalcost+=a.row*a.column*b.column;				
				}
			}
			if(flag)
				sb.append(totalcost+"\n");
		}
		System.out.print(sb);
	}
}
class Matrix
{
	public int row;
	public int column;
	public char name;
	
	public Matrix(char name,int row,int column)
	{
		this.name=name;
		this.row=row;
		this.column=column;
	}
}

UVA Problem ID 1237 (Halloween Treats)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int i = 0; i 0)
				sb.append("\n");
			int d=Integer.parseInt(br.readLine().trim());
			String name[]=new String[d];
			int lowestprice[]=new int[d];
			int highestprice[]=new int[d];
			for(int j=0;j=lowestprice[t] && queryvalue<=highestprice[t])
					{
						index=t;
						count++;
					}
				}
				if(count==1)
					sb.append(name[index]+"\n");
				else
					sb.append("UNDETERMINED\n");
			}
		}
		System.out.print(sb);
	}
}

UVA Problem ID 927 (Integer Sequences from Addition of Terms)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int i = 0; i =k)
				{
					for (int t = 0; t < coefficients.length; t++) {
						ans+=coefficients[t]*Math.pow(j, t);
					}
					break;
				}
			}
			sb.append(ans+"\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 294 (Divisors)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int i = 0; i 

UVA Problem ID 11130 (Billiard bounces)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		while(true)
		{
			String s1[]=br.readLine().split(" +");
			int a=Integer.parseInt(s1[0]);
			int b=Integer.parseInt(s1[1]);
			int v=Integer.parseInt(s1[2]);
			int A=Integer.parseInt(s1[3]);
			int s=Integer.parseInt(s1[4]);
			if(a==0 && b==0 && v==0 && A==0 && s==0 )
				break;
			int horizontaldistance=(int) ((a+v*Math.cos(A*Math.PI/180)*s)/(a*2));
			int verticaldistance=(int) ((b+v*Math.sin(A*Math.PI/180)*s)/(b*2));

			sb.append(horizontaldistance);
			sb.append(" "+verticaldistance+"\n");

		}
		System.out.print(sb);
	}

}

UVA Problem ID 11313 (Gourmet Games)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int i = 0; i =m)
			{
				total_shows+=left/m;
				left=left/m+left%m;
			}
			if(left==1)
				sb.append(total_shows+"\n");
			else
				sb.append("cannot do this\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 11723 (Numbering Roads)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcase=0;
		while(true)
		{
			testcase++;
			String s[]=br.readLine().split(" +");
			int R=Integer.parseInt(s[0]);
			int N=Integer.parseInt(s[1]);
			if(R==0 && N==0)
				break;
			int a=R-N;
			int ans;
			if(a%N==0 || R26)
				sb.append("Case "+testcase+": impossible\n");
			else
				sb.append("Case "+testcase+": "+ans+"\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 11805 (Bafana Bafana)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(1000);
		int testcases=Integer.parseInt(br.readLine());
		for (int i = 0; i 

UVA Problem ID 10346 (Peter's Smokes)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		
		while((input=br.readLine())!=null)
		{
			String s[]=input.split(" +");
			int n=Integer.parseInt(s[0]);
			int k=Integer.parseInt(s[1]);
			int total_cigarettes=n;
			int butts=n;
			while(butts>=k)
			{
				total_cigarettes+=butts/k;
				butts=butts/k+butts%k;
			}
			sb.append(total_cigarettes+"\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 10219 (Find the Ways! )

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder(10000);
		String input;
		while((input=br.readLine())!=null)
		{
			String numbers[]=input.split(" +");
			int n=Integer.parseInt(numbers[0]);
			int r=Integer.parseInt(numbers[1]);
			sb.append(factorial(new BigInteger(n+""),1,r).divide(factorial(new BigInteger(r+""))).toString().length()+"\n");
		}
		System.out.print(sb);
	}
	public static BigInteger factorial(BigInteger n)
	{
		if(n.intValue()==0 || n.intValue()==1)
			return BigInteger.ONE;
		else
		{
			return n.multiply(factorial(n.subtract(BigInteger.ONE)));
		}
	}
	public static BigInteger factorial(BigInteger n,int count,int limit)
	{
		if(n.intValue()==0 || n.intValue()==1)
			return BigInteger.ONE;
		else
		{
			if(count

UVA Problem ID 10303 (How Many Trees)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringBuilder sb=new StringBuilder(10000);
  String input;
  while((input=br.readLine())!=null)
  {
   int n=Integer.parseInt(input.trim());
   sb.append(factorial(new BigInteger((2*n)+"")).divide(factorial(new BigInteger(n+"")).multiply(factorial(new BigInteger((n+1)+""))))+"\n");
  }
  System.out.print(sb);
 }
 public static BigInteger factorial(BigInteger n)
 {
  if(n.intValue()==0 || n.intValue()==1)
   return BigInteger.ONE;
  else
  {
   return n.multiply(factorial(n.subtract(BigInteger.ONE)));
  }
 }
}

UVA Problem ID 10220 (I Love Big Numbers!)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringBuilder sb=new StringBuilder(10000);
  String input;
  while((input=br.readLine())!=null)
  {
   int n=Integer.parseInt(input.trim());
   String fac=factorial(new BigInteger(n+"")).toString();
   
   int sum=0;
   for (int i = 0; i < fac.length(); i++) {
    sum=sum+fac.charAt(i)-48;
   }
   sb.append(sum+"\n");
  }
  System.out.print(sb);
 }
 public static BigInteger factorial(BigInteger n)
 {
  if(n.intValue()==0 || n.intValue()==1)
   return BigInteger.ONE;
  else
  {
   return n.multiply(factorial(n.subtract(BigInteger.ONE)));
  }
 }
}

UVA Problem ID 10007 (Count the Trees)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringBuilder sb=new StringBuilder(10000);
  
  while(true)
  {
   int n=Integer.parseInt(br.readLine().trim());
   if(n==0)
    break;
   sb.append(factorial(new BigInteger((2*n)+"")).divide(factorial(new BigInteger((n+1)+"")))+"\n");
  }
  System.out.print(sb);
 }
 public static BigInteger factorial(BigInteger n)
 {
  if(n.intValue()==0 || n.intValue()==1)
   return BigInteger.ONE;
  else
  {
   return n.multiply(factorial(n.subtract(BigInteger.ONE)));
  }
 }
}

UVA Problem ID 10334 (Ray Through Glasses)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuilder sb=new StringBuilder(10000);
  
  while((input=br.readLine())!=null)
  {
   BigInteger A[][]={{new BigInteger("1"),new BigInteger("1")},{new BigInteger("1"),new BigInteger("0")}};
   
   sb.append(matrixpower(A,Integer.parseInt(input)+2)[1][0]+"\n");
  }
  System.out.print(sb);
 }
 public static BigInteger[][] matrixmultiplication(BigInteger[][] A,BigInteger[][] B)
 {
  BigInteger resultantmatrix[][]=new BigInteger[2][2];
  resultantmatrix[0][0] =  A[0][0].multiply(B[0][0]).add(A[0][1].multiply(B[1][0]));
  resultantmatrix[0][1] =  A[0][0].multiply(B[0][1]).add(A[0][1].multiply(B[1][1]));
  resultantmatrix[1][0] =  A[1][0].multiply(B[0][0]).add(A[1][1].multiply(B[1][0]));
  resultantmatrix[1][1] =  A[1][0].multiply(B[0][1]).add(A[1][1].multiply(B[1][1]));
  
  return resultantmatrix;
 }
 public static BigInteger[][] matrixpower(BigInteger[][] A,int power)
 {
  if(power==0)
  {
   BigInteger matrixA[][]={{new BigInteger("1"),new BigInteger("0")},{new BigInteger("0"),new BigInteger("1")}};
   return matrixA;
  }
  
  else if(power % 2==0)
  {
   BigInteger C[][]=matrixpower(A, power/2);
   return matrixmultiplication(C,C);
  }
  else
  {
   return matrixmultiplication(A,matrixpower(A, power-1));
  }
 }
}

UVA Problem ID 495 (Fibonacci Freeze)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuilder sb=new StringBuilder(10000);
  
  while((input=br.readLine())!=null)
  {
   BigInteger A[][]={{new BigInteger("1"),new BigInteger("1")},{new BigInteger("1"),new BigInteger("0")}};
   
   sb.append("The Fibonacci number for "+input+" is "+matrixpower(A,Integer.parseInt(input))[1][0]+"\n");
  }
  System.out.print(sb);
 }
 public static BigInteger[][] matrixmultiplication(BigInteger[][] A,BigInteger[][] B)
 {
  BigInteger resultantmatrix[][]=new BigInteger[2][2];
  resultantmatrix[0][0] =  A[0][0].multiply(B[0][0]).add(A[0][1].multiply(B[1][0]));
  resultantmatrix[0][1] =  A[0][0].multiply(B[0][1]).add(A[0][1].multiply(B[1][1]));
  resultantmatrix[1][0] =  A[1][0].multiply(B[0][0]).add(A[1][1].multiply(B[1][0]));
  resultantmatrix[1][1] =  A[1][0].multiply(B[0][1]).add(A[1][1].multiply(B[1][1]));
  
  return resultantmatrix;
 }
 public static BigInteger[][] matrixpower(BigInteger[][] A,int power)
 {
  if(power==0)
  {
   BigInteger matrixA[][]={{new BigInteger("1"),new BigInteger("0")},{new BigInteger("0"),new BigInteger("1")}};
   return matrixA;
  }
  
  else if(power % 2==0)
  {
   BigInteger C[][]=matrixpower(A, power/2);
   return matrixmultiplication(C,C);
  }
  else
  {
   return matrixmultiplication(A,matrixpower(A, power-1));
  }
 }
}

UVA Problem ID 10579 (Fibonacci Numbers)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuilder sb=new StringBuilder(10000);
  
  while((input=br.readLine())!=null)
  {
   BigInteger A[][]={{new BigInteger("1"),new BigInteger("1")},{new BigInteger("1"),new BigInteger("0")}};
   
   sb.append(matrixpower(A,Integer.parseInt(input))[1][0]+"\n");
  }
  System.out.print(sb);
 }
 public static BigInteger[][] matrixmultiplication(BigInteger[][] A,BigInteger[][] B)
 {
  BigInteger resultantmatrix[][]=new BigInteger[2][2];
  resultantmatrix[0][0] =  A[0][0].multiply(B[0][0]).add(A[0][1].multiply(B[1][0]));
  resultantmatrix[0][1] =  A[0][0].multiply(B[0][1]).add(A[0][1].multiply(B[1][1]));
  resultantmatrix[1][0] =  A[1][0].multiply(B[0][0]).add(A[1][1].multiply(B[1][0]));
  resultantmatrix[1][1] =  A[1][0].multiply(B[0][1]).add(A[1][1].multiply(B[1][1]));
  
  return resultantmatrix;
 }
 public static BigInteger[][] matrixpower(BigInteger[][] A,int power)
 {
  if(power==0)
  {
   BigInteger matrixA[][]={{new BigInteger("1"),new BigInteger("0")},{new BigInteger("0"),new BigInteger("1")}};
   return matrixA;
  }
  
  else if(power % 2==0)
  {
   BigInteger C[][]=matrixpower(A, power/2);
   return matrixmultiplication(C,C);
  }
  else
  {
   return matrixmultiplication(A,matrixpower(A, power-1));
  }
 }
}

UVA Problem ID 389 (Basically Speaking)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuilder sb=new StringBuilder(1000);
  
  while((input=br.readLine())!=null)
  {
   String numbers[]=input.trim().split(" +");
   BigInteger no=new BigInteger(numbers[0],Integer.parseInt(numbers[1]));
   String ans=no.toString(Integer.parseInt(numbers[2]));
   if(ans.length()>7)
    sb.append("  ERROR\n");
   else
   {
    while(ans.length()!=7)
     ans=" "+ans;
    sb.append(ans.toUpperCase()+"\n");
   }   
  }
  System.out.print(sb);
 }
}

UVA Problem ID 374 (Big Mod)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuilder sb=new StringBuilder(1000);
  
  while((input=br.readLine())!=null)
  {
   if(input.trim().equals(""))
    input=br.readLine();
   long B=Long.parseLong(input.trim());
   long P=Long.parseLong(br.readLine().trim());
   long M=Long.parseLong(br.readLine().trim());
   sb.append(bigmod(B,P,M)+"\n");
   
  }
  System.out.print(sb);
 }
 public static long bigmod(long b,long p,long m)
 {
  if(p==0)
   return 1;
  else if(p%2==0)
  {
   long temp=bigmod(b,p/2,m);
   return ((temp % m)*(temp % m)) % m;
  }
  else
   return ((b % m)*(bigmod(b,p-1,m) % m)) % m;
     
 }
}

UVA Problem ID 10229 (Modular Fibonacci)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {
 public static void main (String args[]) throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuilder sb=new StringBuilder(1000);
  
  while((input=br.readLine())!=null)
  {
   String numbers[]=input.trim().split(" +");
   long matrixA[][]={{1,1},{1,0}};
   long ans=matrixpowerMod(matrixA,Integer.parseInt(numbers[0]),(int) Math.pow(2,Integer.parseInt(numbers[1])))[0][1];
   sb.append(ans+"\n");
  }
  System.out.print(sb);
 }
 public static long[][] matrixmultiplication(long[][] A,long[][] B,int mod)
 {
  long resultantmatrix[][]=new long[2][2];
  resultantmatrix[0][0] =  (A[0][0]*B[0][0] + A[0][1]*B[1][0]) % mod;
  resultantmatrix[0][1] =  (A[0][0]*B[0][1] + A[0][1]*B[1][1]) % mod;
  resultantmatrix[1][0] =  (A[1][0]*B[0][0] + A[1][1]*B[1][0] )% mod;
  resultantmatrix[1][1] =  (A[1][0]*B[0][1] + A[1][1]*B[1][1] )% mod;
  
  return resultantmatrix;
 }
 public static long[][] matrixpowerMod(long[][] A,long power,int mod)
 {
  if(power==0)
  {
   long matrixA[][]={{1,0},{0,1}};
   return matrixA;
  }
  
  else if(power % 2==0)
  {
   long C[][]=matrixpowerMod(A, power/2,mod);
   return matrixmultiplication(C,C,mod);
  }
  else
  {
   return matrixmultiplication(A,matrixpowerMod(A, power-1,mod),mod);
  }
 }
}

UVA Problem ID 355 (The Bases Are Loaded)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;


public class Main {
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(1000);
		
		while((input=br.readLine())!=null)
		{
			String numbers[]=input.trim().split(" +");
			try {
				BigInteger no=new BigInteger(numbers[2],Integer.parseInt(numbers[0]));
				String ans=no.toString(Integer.parseInt(numbers[1]));
				sb.append(numbers[2]+" base "+numbers[0]+" = "+(ans.toUpperCase())+" base "+numbers[1]);
			} catch (Exception e) {
				sb.append(numbers[2]+" is an illegal base "+numbers[0]+" number");
			}	
			sb.append("\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 343 (What Base Is This?)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main{
	public static void main (String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb=new StringBuilder(10000);
		while((input=br.readLine())!=null)
		{
			boolean flag=true;
			
			String numbers[]=input.trim().split(" +");
			for (int i = 2; i < 37; i++) {
				for (int j = 2; j < 37; j++) {
					
					try {//System.out.println(numbers[0].trim()+"  "+Integer.parseInt(numbers[0].trim(),i)+" (base "+i+")"+"____"+numbers[1].trim()+"  "+Integer.parseInt(numbers[1].trim(),j)+" (base "+j+")");
						if(Integer.parseInt(numbers[0].trim(),i)==Integer.parseInt(numbers[1].trim(),j))
						{
							sb.append(numbers[0].trim()+" (base "+i+") = "+numbers[1].trim()+" (base "+j+")");
							sb.append("\n");
							i=38;j=38;flag=false;
						}
					} catch (Exception e) {
						continue;
					}
				}
			}
			if(flag)
			{
				sb.append(numbers[0].trim()+" is not equal to "+numbers[1].trim()+" in any base 2..36");
				sb.append("\n");
			}
		}
		System.out.print(sb);
	}
}

UVA Problem ID 113 (Power of Cryptography)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        String input;
        while((input=br.readLine())!=null)
        {  	
        	int n=Integer.parseInt(input);
        	double p=Double.parseDouble(br.readLine());
        	sb.append(Math.round(Math.pow(p,(double)1/n)));
        	sb.append("\n");
        }
        System.out.print(sb);
    }
}

UVA Problem ID 10931 (Parity)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        String input;
        while((input=br.readLine())!=null)
        {  	
        	int I=Integer.parseInt(input);
        	if(I==0)
        		break;
        	String s=Integer.toBinaryString(I);
        	int onbits=Integer.bitCount(I);
        	
        	sb.append("The parity of "+s+" is "+onbits+" (mod 2).");
        	sb.append("\n");
        }
        System.out.print(sb);
    }
}

UVA Problem ID 10035 (Primary Arithmetic)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        String input;
        int noofoperation=0;
        while((input=br.readLine())!=null)
        {  noofoperation=0;	
        	String s[]=input.split(" ");
        	
        	if(s[0].equals("0") && s[1].equals("0"))
        		break;
        	int maxlength=s[1].length()>s[0].length()?s[1].length():s[0].length();
        	int carry=0;
        	while(s[0].length()=0; i--)
			{
				int sum=Integer.parseInt(s[0].charAt(i)+"")+Integer.parseInt(s[1].charAt(i)+"")+carry;
				carry=0;
				if(sum>=10)
				{	
					carry=1;
					noofoperation++;
				}
			}
        	if(noofoperation==0)
        		sb.append("No carry operation.\n");
        	else if(noofoperation==1)
        		sb.append("1 carry operation.\n");
        	else
        		sb.append(noofoperation+" carry operations.\n");
        }
        System.out.print(sb);
    }
}

UVA Problem ID 725 (Division)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        String input;
        int t=0;
        while((input=br.readLine())!=null)
        {  	
        	int N=Integer.parseInt(input);
        	if(N==0)
        		break;
        	if(t!=0)
        	{
        		sb.append("\n");
        	}
        	t=1;
        	boolean flag=false;
        	for (long i =1234; i <98765; i++)
        	{
        		if(isdiffdigits(i+""))
				{
					long a=N*i;
					if(isdiffdigits(a+"") && isdiffdigits(i+"",a+""))
					{
						flag=true;
						if((i+"").length()<5)
							sb.append(a+" / 0"+i+" = "+N+"\n");
						else
							sb.append(a+" / "+i+" = "+N+"\n");
					}
				}
			}
        	if(!flag)
        		sb.append("There are no solutions for "+N+".\n");
        	
        }
        System.out.print(sb);
    }
	public static boolean isdiffdigits(String N)
	{
		if(N.length()<5)
			N=0+N;
		for (int i = 0; i < N.length()-1; i++)
		{
			for (int j = i+1; j < N.length(); j++)
			{
				if(N.charAt(i)==N.charAt(j))
					return false;
			}
		}
		return true;
	}
	public static boolean isdiffdigits(String N1,String N2)
	{
		if(N1.length()<5)
			N1=0+N1;
		if(N2.length()<5)
			N2=0+N2;
		for (int i = 0; i < N1.length(); i++)
		{
			for (int j = 0; j < N2.length(); j++)
			{
				if(N1.charAt(i)==N2.charAt(j))
					return false;
			}
		}
		return true;
	}
}

UVA Problem ID 11804 (Argentina)

//Note:-BAD ALGORITHM
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;


public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        int testcase=Integer.parseInt(br.readLine());
        String playersname[]=new String[10];
        int playersability[][]=new int[10][2];
        for (int i = 0; i < testcase; i++)
		{
        	for (int j = 0; j < 10; j++)
        	{
        		String s[]=br.readLine().split(" ");
        		playersname[j]=s[0];
        		playersability[j][0]=Integer.parseInt(s[1]);
        		playersability[j][1]=Integer.parseInt(s[2]);
        	}
        	int max=0;
        	boolean isattacker[]=new boolean[10];
        	for (int b =0; b < 10-4; b++)
    		{
    			for (int c =b+1;c<10-3; c++)
    			{
    				
    				for (int d =c+1;d<10-2; d++)
    				{
    					
    					for (int e=d+1;e<10-1; e++)
    					{
    						
    						for (int f =e+1; f<10; f++)
    						{
    							int totalattack=playersability[b][0]+playersability[c][0]+playersability[d][0]+playersability[e][0]+playersability[f][0];
    							if(totalattack>max)
    							{
    								for (int j = 0; j < isattacker.length; j++)
									{
										isattacker[j]=false;
									}
    								isattacker[b]=true;
    								isattacker[c]=true;
    								isattacker[d]=true;
    								isattacker[e]=true;
    								isattacker[f]=true;
    					
    								max=totalattack;
    							}
    							else if(totalattack==max)
    							{
    								int totaldefence=0;
    								int olddefence=0;
    								for (int j = 0; j < isattacker.length; j++)
									{
										if(!isattacker[j])
										{
											olddefence+=playersability[j][1];
										}
									}
    								for (int j = 0; j < playersability.length; j++)
									{
										if(j!=b && j!=c && j!=d && j!=e && j!=f)
											totaldefence+=playersability[j][1];
									}
    								if(olddefence0)
											{
												//ans a1
												for (int j1 = 0; j1 < isattacker.length; j1++)
												{
													isattacker[j1]=false;
												}
												isattacker[b]=true;
		        								isattacker[c]=true;
		        								isattacker[d]=true;
		        								isattacker[e]=true;
		        								isattacker[f]=true;
		        								max=totalattack;
		        								break;
											}
											
										}
										
											
    								}
    							}
       						}
    					}
    				}
    			}
    		}
        	String attackers[]=new String[5];
        	String defender[]=new String[5];
        	int t=0,q=0;
            	for (int j = 0; j < isattacker.length; j++)
				{
            		if(isattacker[j])
            		{
            				attackers[t++]=playersname[j];
            		}
            		else
            			defender[q++]=playersname[j];
				}
            	Arrays.sort(attackers);
            	Arrays.sort(defender);
            	sb.append("Case "+(i+1)+":\n");
            	sb.append("("+attackers[0]);
            	for (int j = 1; j < attackers.length; j++)
				{
            		sb.append(", "+attackers[j]);
				}
            	sb.append(")\n");
            	
            	sb.append("("+defender[0]);
            	for (int j = 1; j < defender.length; j++)
				{
            		sb.append(", "+defender[j]);
				}
            	sb.append(")\n");
		}
        System.out.print(sb);
    }
}

UVA Problem ID 10018 (Reverse and Add)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        String input;
        int testcase=Integer.parseInt(br.readLine());
       
        for (int i = 0; i < testcase; i++)
		{
        	input=br.readLine();
        	int iteations=0;
        	while(!ispalindrome(input))
        	{
        		long sum=Long.parseLong(input)+Long.parseLong(new StringBuilder(input).reverse().toString());
        		input=sum+"";
        		iteations++;
        	}
        	sb.append(iteations+" "+input+"\n");
		}
        System.out.print(sb);
    }
	public static boolean ispalindrome(String s)
	{
		StringBuilder sb1=new StringBuilder(s);
		String s1=new String(sb1.reverse());
		
		if(s.equals(s1))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

UVA Problem ID 441 (Lotto)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder("");
        String input;
        int testcase=0;
        while((input=br.readLine())!=null)
        {
        	String inputarr[]=input.split(" ");
        	int k=Integer.parseInt(inputarr[0]);
        	if(k==0)
        		break;
        	if(testcase!=0)
        	{
			sb.append("\n");
		}
		testcase=1;
        	int S[]=new int[k];
        	for (int i = 0; i < S.length; i++)
			{
				S[i]=Integer.parseInt(inputarr[i+1]);
			}
        	
        	for (int a = 0; k-a > 5; a++)
			{
        		for (int b = a+1; k-b > 4; b++)
        		{
        			for (int c = b+1; k-c >3; c++)
        			{
        				for (int d =c+1; k-d >2; d++)
        				{
        					for (int e=d+1; k-e>1; e++)
        					{
        						for (int f = e+1; k-f >0; f++)
        						{
        							sb.append(S[a]+" "+S[b]+" "+S[c]+" "+S[d]+" "+S[e]+" "+S[f]);
        							sb.append("\n");
        						}
        					}
        				}
        			}
        		}
            	
			}
        }
        System.out.print(sb);
    }
}

UVA Problem ID 12356 (Army Buddies)

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedOutputStream output = new BufferedOutputStream(System.out);
		StringBuilder sb = new StringBuilder(10000);
		int left[]=new int[100001];
		int right[]=new int[100001];
		int S,B;
		String input;
		while((input=br.readLine())!=null)
		{
			StringTokenizer s=new StringTokenizer(input);
			S=Integer.parseInt(s.nextToken());
			B=Integer.parseInt(s.nextToken());
			if(S==0 && B==0)
				break;
			
			for (int i =0; i = 10000) {

                output.write(sb.toString().getBytes());

                sb = new StringBuilder(25000);

            }

		}
		output.write(sb.toString().getBytes());

        output.flush();

        output.close();
		
	}
}

UVA Problem ID 10107 (What is the Median?)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class Main
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuilder sb = new StringBuilder("");
		TreeSet ts=new TreeSet();
		int ar[]=new int[10000];
		int k=0;
		while((input=br.readLine())!=null)
		{
			input=input.trim();
			int n=Integer.parseInt(input);
			ar[k++]=n;
			Arrays.sort(ar,0,k);
				
			if((k)%2!=0)
			{
				sb.append(ar[k/2]);
			}
			else
			{
				sb.append((ar[k/2-1]+ar[k/2])/2);

			}
			sb.append("\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 10038 (Jolly Jumpers)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuffer sb = new StringBuffer("");
		while((input=br.readLine())!=null)
		{
			String s[]=input.split(" ");
			int n=Integer.parseInt(s[0]);
			if(n>3000)
				break;
			int sequence[]=new int[n];
			boolean flag[]=new boolean[n-1];
			for (int i = 0; i < sequence.length; i++)
			{
				sequence[i]=Integer.parseInt(s[i+1]);
			}
			for (int i = 0; i < sequence.length-1; i++)
			{
				int diff=Math.abs(sequence[i]-sequence[i+1]);
				//System.out.println("diff ="+diff);
				if(diff >=1 && diff<=n-1)
				{
					flag[diff-1]=true;
				}
			}
			boolean isjolly=true;
			for (int i = 0; i < flag.length; i++)
			{
				if(!flag[i])
				{
					isjolly=false;
					break;
				}
			}
			if(isjolly)
				sb.append("Jolly\n");
			else
				sb.append("Not jolly\n");
		}
		System.out.print(sb);
	}
}

UVA Problem ID 10226 (Hardwood Species)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Main
{
	public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb=new StringBuffer("");
        String input;
        int testcases=Integer.parseInt(br.readLine());
        br.readLine();
        for (int t = 0; t < testcases; t++)
		{
        	if(t>0)
        		sb.append("\n");
        	TreeMap tm=new TreeMap<>();
        	int count=0;
			while((input=br.readLine())!=null)
			{
				if(input.trim().equals(""))
					break;
	        	count++;
	        	
	        	if(tm.containsKey(input))
	        	{
	        		tm.put(input,tm.get(input)+1);
	        	}
	        	else
	        	{
	        		tm.put(input,1);
	        	}
	        }
			Set> set=tm.entrySet();
			
			Iterator> i=set.iterator();
			
			while(i.hasNext())
			{
				Map.Entry me=(Map.Entry)i.next();
				double fraction=((double)me.getValue()/count)*100;
				DecimalFormat df=new DecimalFormat("0.0000");
				sb.append(me.getKey()+" "+df.format(fraction));
				sb.append("\n");
			}
		}
        System.out.print(sb);
    }
}

UVA Problem ID 459 (Graph Connectivity)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main
{
	static int pset[];
	 
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String input;
		StringBuffer sb = new StringBuffer("");
		int testcases = Integer.parseInt(br.readLine());
		br.readLine();
		for (int i = 0; i < testcases; i++)
		{
			if(i>0)
				sb.append("\n");
			int largest=br.readLine().charAt(0)-64;
			initSet(largest);
			while((input=br.readLine())!=null)
			{
				if(input.trim().equals(""))
					break;
				
				union(input.charAt(0)-65,input.charAt(1)-65);
//				UnionFindDisjoint1.print();
				
			}
			
//			Set set=UnionFindDisjoint1.unique();
			sb.append(numberOfSets()+"\n");
			
		}
		System.out.print(sb);
	}
	public static int findSet(int i)
	{
		return (pset[i] == i) ? i : (pset[i] = findSet(pset[i]));
	}
	public static void  union(int i,int j)
	{
		pset[findSet(i)] = findSet(j);
	}
	public static void initSet(int size)
	{
		pset=new int[size];
		for (int i = 0; i < size; i++)
		{
			pset[i]=i;
		}
	}
	public static int numberOfSets()
	{
		int numerofsets=0;
		for (int i = 0; i < pset.length; i++)
		{
			if(pset[i] == i)
				numerofsets++;
		}
		return numerofsets;
	}
}

UVA Problem ID 793 ( Network Connections)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
 public static void main(String[] args) throws IOException
 {
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  String input;
  StringBuffer sb = new StringBuffer("");
  int testcases = Integer.parseInt(br.readLine());
  br.readLine();

  for (int i = 0; i < testcases; i++)
  {
   if(i>0)
    sb.append("\n");
   int no_of_computers=Integer.parseInt(br.readLine());
   
   UnionFindDisjoint.initSet(no_of_computers);
   int N1=0;
   int N2=0;
   while((input=br.readLine())!=null)
   {
    if(input.trim().equals(""))
     break;
    String s[]=input.split(" ");
    switch (s[0])
    {
     case "c":
     {
      UnionFindDisjoint.union(Integer.parseInt(s[1])-1,Integer.parseInt(s[2])-1);
      break;
     }
     case "q":
     {
      if(UnionFindDisjoint.isSameSet(Integer.parseInt(s[1])-1,Integer.parseInt(s[2])-1))
      {
       N1++;
      }
      else
       N2++;
      break;
     }
    }
   }
   sb.append(N1+","+N2+"\n");
  }
  System.out.print(sb);
 }
}
class UnionFindDisjoint
{
 static int pset[];
 public static void initSet(int size)
 {
  pset=new int[size];
  for (int i = 0; i < size; i++)
  {
   pset[i]=i;
  }
 }
 public static int findSet(int i)
 {
  return (pset[i] == i) ? i : (pset[i] = findSet(pset[i]));
 }
 public static void  union(int i,int j)
 {
  pset[findSet(i)] = findSet(j);
 }
 public static boolean isSameSet(int i,int j)
 {
  return findSet(i) == findSet(j);
 }
}