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;
	}

}