UVA - 11608 - No Problem

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));
        StringBuilder sb = new StringBuilder();
        int cases=1;
        while (true) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            if (x <0) {
                break;
            }
            sb.append("Case ").append(cases).append(":\n");
            st = new StringTokenizer(br.readLine());
            int []month=new int[13];
            month[0]=x;
            for(int i=1;i<13;i++){
                month[i]=Integer.parseInt(st.nextToken());
            }
            int sum=x;
            st = new StringTokenizer(br.readLine());
            for(int i=1;i<13;i++){
                int temp=Integer.parseInt(st.nextToken());
                if(sum>=temp){
                    sb.append("No problem! :D\n");
                    sum-=temp;
                }else{
                    sb.append("No problem. :(\n");
                }
                sum+=month[i];
            }
            cases++;
        }
        System.out.print(sb);
    }
}

UVA - 10703 - Free spots

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));
        StringBuilder sb = new StringBuilder();
        while (true) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            int qu = Integer.parseInt(st.nextToken());
            if (x == 0 && y == 0 && qu == 0) {
                break;
            }
            boolean arr[][] = new boolean[x + 1][y + 1];
            for (int c = 0; c < qu; c++) {
                st = new StringTokenizer(br.readLine());
                int x1 = Integer.parseInt(st.nextToken());
                int y1 = Integer.parseInt(st.nextToken());
                int x2 = Integer.parseInt(st.nextToken());
                int y2 = Integer.parseInt(st.nextToken());
                for (int i = Math.min(x1, x2); i < Math.max(x1, x2) + 1; i++) {
                    for (int j = Math.min(y1, y2); j < Math.max(y1, y2) + 1; j++) {
                        arr[i][j] = true;
                    }
                }
            }
            int counter = 0;
            for (int i = 1; i < x + 1; i++) {
                for (int j = 1; j < y + 1; j++) {
                    if (!arr[i][j]) {
                        counter++;
                    }
                }
            }if(counter==0){
                sb.append("There is no empty spots.\n");
            }else if(counter==1){
                sb.append("There is one empty spot.\n");
            }else{
                sb.append("There are ").append(counter).append(" empty spots.\n");
            }
            br.readLine();
        }
        System.out.print(sb);
    }
}

UVA - 11496 - Musical Loop

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));
       StringBuilder sb = new StringBuilder();
       while(true){
           StringTokenizer st=new StringTokenizer(br.readLine());
           int n=Integer.parseInt(st.nextToken());
           if(n==0){
               break;
           }
           st=new StringTokenizer(br.readLine());
           int a0=Integer.parseInt(st.nextToken());
           boolean up=true,first=true;
           int last=Integer.parseInt(st.nextToken());
           if(last<a0){
               up=false;
               first=false;
           }
           int current=0;
           int counter=1;
           for(int i=2;i<n;i++){
               current=Integer.parseInt(st.nextToken());
               if(up){
                  if(last>current){
                      counter++;
                      up=false;
                  }
               }else{
                  if(last<current){
                      counter++;
                      up=true;
                  }
               }
               last=current;
           }
           if(up){
               if(last>a0 && first){
                      counter++;
                  }
           }else{
               if(last<a0 && !first){
                      counter++;
                  }
           }
            sb.append(counter).append("\n");
       }
       System.out.print(sb);
    }
  
}

UVA - 10391 - Compound Words

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.LinkedList;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        String m="";
        HashSet<String> hs=new HashSet<String>();
        LinkedList<String> str=new LinkedList<String>();
        while((m=br.readLine())!=null){
           hs.add(m);
           str.add(m);
        }
        while(!str.isEmpty()){
            String temp=str.remove();
            StringBuilder tempS=new StringBuilder();
            boolean flag=false;
            for(int i=0;i<temp.length()-1;i++){
                tempS.append(temp.charAt(i));
                if(hs.contains(tempS.toString())){
                   StringBuilder  tempS2=new StringBuilder();
                   for(int j=i+1;j<temp.length();j++){
                       tempS2.append(temp.charAt(j));
                   }
                    if(hs.contains(tempS2.toString())){
                        flag=true;
                        break;
                    }
                }
            }
            if(flag){
                sb.append(temp).append("\n");
            }
        }
        System.out.print(sb);
    }
}

UVA - 11588 - Image Coding

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

public class Main {


public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        int cases=Integer.parseInt(br.readLine());
        for(int l=1;l<cases+1;l++){
            StringTokenizer st=new  StringTokenizer(br.readLine());
            int x=Integer.parseInt(st.nextToken()),
                y=Integer.parseInt(st.nextToken()),
                c=Integer.parseInt(st.nextToken()),
                o=Integer.parseInt(st.nextToken());
            int []arr=new int[26];
            for(int i=0;i<x;i++){
                StringBuilder str=new StringBuilder(br.readLine());
                for(int j=0;j<y;j++){
                    arr[str.charAt(j)-65]++;
                }
            }
            Arrays.sort(arr);
            int totalCost=arr[25]*c;
            int counter=arr[25];
            for(int j=24;j>-1;j--){
                if(arr[j]!=arr[j+1]){
                    break;
                }
                totalCost+=arr[j]*c;
                counter+=arr[j];
            }
            totalCost+=((x*y)-counter)*o;
            String s=String.format("Case %d: %d\n",l,totalCost);
            sb.append(s);
        }
        System.out.print(sb);
    }

}

UVA - 232 - Crossword Answers

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        int cases=1;
        while(true){
           StringTokenizer st=new StringTokenizer(br.readLine());
           int n=Integer.parseInt(st.nextToken());
           if(n==0)
               break;
           if(cases>1){
               sb.append("\n");
           }
           sb.append(String.format("puzzle #%d:\n", cases));
           int m=Integer.parseInt(st.nextToken());
           char[][]arr=new char[n][m];
           char[][]pos=new char[n][m];
           for(int i=0;i<n;i++){
               arr[i]=br.readLine().toCharArray();
           }
           for(int i=0;i<n;i++){
               boolean flag=true;
              for(int j=0;j<m;j++){
                  if(arr[i][j]=='*'){
                      flag=true;
                  }else{
                      if(flag){
                         flag=false;
                         pos[i][j]='n';
                      }
                  }
              }
           }
           for(int i=0;i<m;i++){
               boolean flag=true;
              for(int j=0;j<n;j++){
                  if(arr[j][i]=='*'){
                      flag=true;
                  }else{
                      if(flag){
                         flag=false;
                         pos[j][i]='n';
                      }
                  }
              }
           }
           int[][]posX=new int[n][m];
           for(int i=0,p=1;i<n;i++){
              for(int j=0;j<m;j++){
                  if(pos[i][j]=='n'){
                      posX[i][j]=p++;
                  }
              }
           }
           LinkedList<String> list=new LinkedList<String>();
           sb.append("Across\n");
           for(int i=0;i<n;i++){
               boolean flag=true;
               StringBuilder temp=new StringBuilder();
              for(int j=0;j<m;j++){
                  if(arr[i][j]=='*'){
                      if(!flag){
                          list.add(temp.toString());
                          temp=new StringBuilder();
                      }
                      flag=true;
                  }else{
                      if(flag){
                         String str=String.format("%3d.", posX[i][j]) ; 
                         temp.append(str);
                         flag=false;
                      }
                      temp.append(arr[i][j]);
                  }
              }
              if(!flag){
                list.add(temp.toString());
                temp=new StringBuilder();
              }
           }
           Collections.sort(list);
           while(!list.isEmpty()){
               sb.append(list.remove()).append("\n");
           }
           sb.append("Down\n");
           LinkedList<String> list2=new  LinkedList<String>();
           for(int i=0;i<m;i++){
               boolean flag=true;
               StringBuilder temp=new StringBuilder();
              for(int j=0;j<n;j++){
                  if(arr[j][i]=='*'){
                      if(!flag){
                          list2.add(temp.toString());
                          temp=new StringBuilder();
                      }
                      flag=true;
                  }else{
                      if(flag){
                         String str=String.format("%3d.", posX[j][i]) ; 
                         temp.append(str);
                         flag=false;
                      }
                      temp.append(arr[j][i]);
                  }
              }
              if(!flag){
                list2.add(temp.toString());
                temp=new StringBuilder();
              }
           }
           Collections.sort(list2);
           while(!list2.isEmpty()){
               sb.append(list2.remove()).append("\n");
           }
           cases++;
        }
        System.out.print(sb);
    }
}

UVA - 11340 - Newspaper

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        int cases=Integer.parseInt(br.readLine());
        String m="";
        for(int i=0;i<cases;i++){
            int n=Integer.parseInt(br.readLine());
            HashMap<Character,Integer> hm=new HashMap<Character, Integer>();
            for(int j=0;j<n;j++){
                StringTokenizer str=new StringTokenizer(br.readLine());
                hm.put(str.nextToken().charAt(0), Integer.parseInt(str.nextToken()));
            }
            long sum=0;
            n=Integer.parseInt(br.readLine());
            for(int j=0;j<n;j++){
                m=br.readLine();
                for(int z=0;z<m.length();z++){
                    if(hm.containsKey(m.charAt(z))){
                        sum+=hm.get(m.charAt(z));
                    }
                }
              
            }
            String temp=sum%100+"";
            if(temp.length()<2){
                temp="0"+temp;
            }
            sb.append(sum/100).append(".").append(temp).append("$\n");
        }
        System.out.print(sb);
    }
}

UVA - 10409 - Die Game

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb=new StringBuffer();
        while(true){
            int step=Integer.parseInt(br.readLine());
            if(step==0){
                break;
            }
            LinkedList<Integer> ver=new LinkedList<Integer>();
            LinkedList<Integer> hor=new LinkedList<Integer>();
            ver.add(2);
            ver.add(1);
            ver.add(5);
            ver.add(6);
            hor.add(3);
            hor.add(1);
            hor.add(4);
            for(int i=0;i<step;i++){
                String temp=br.readLine();
                if(temp.equals("east")){
                    hor.add(0,ver.removeLast());
                    ver.add(hor.removeLast());
                    ver.remove(1);
                    ver.add(1, hor.get(1));
                }
                else if(temp.equals("west")){
                    hor.add(ver.removeLast());
                    ver.add(hor.remove());
                    ver.remove(1);
                    ver.add(1, hor.get(1));
                }else if(temp.equals("north")){
                    ver.add(ver.remove());
                    hor.remove(1);
                    hor.add(1, ver.get(1));
                }else if(temp.equals("south")){
                    ver.add(0,ver.removeLast());
                    hor.remove(1);
                    hor.add(1, ver.get(1));
                }
            }
            sb.append(ver.get(1)).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 12364 - In Braille

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));
        char[][][]arr=new char[10][3][2];
        for(int i=0;i<10;i++){
           if(i!=9 &&i!=0){
               arr[i][0][0]='*';
           }else{
               arr[i][0][0]='.';
           }
           if(i!=1 &&i!=2&&i!=5 &&i!=8){
               arr[i][0][1]='*';
           }else{
               arr[i][0][1]='.';
           }
           if(i!=1 &&i!=3&&i!=4 &&i!=5){
               arr[i][1][0]='*';
           }else{
               arr[i][1][0]='.';
           }
           if(i!=1 &&i!=2 &&i!=3&&i!=6 &&i!=9){
               arr[i][1][1]='*';
           }else{
               arr[i][1][1]='.';
           }
           arr[i][2][0]='.';
           arr[i][2][1]='.';
        }
       
        StringBuffer sb = new StringBuffer("");
        String m = "";
        while (true) {
            int n =Integer.parseInt(br.readLine());
            if (n==0) {
                break;
            }
            char tempC=br.readLine().charAt(0);
            if(tempC=='S'){
                sb.append(encode(br.readLine(),arr));
            }else{
                char[][][]mes=new char[n][3][2];
                for (int j = 0; j < 3; j++) {
                    String temp=br.readLine();
                    for(int i=0,num=0;i<temp.length();num++){
                        if(i>0)
                            i++;
                        for (int z = 0; z < 2; z++,i++) {
                            mes[num][j][z]=temp.charAt(i);
                        }
                   }
                }
                sb.append(decode(mes, arr));
            }
        }
        System.out.print(sb);
    }
   
    static String encode(String x,char[][][]arr){
        int[]arrN=new int[x.length()];
        for(int i=0;i<x.length();i++){
            arrN[i]=x.charAt(i)-48;
        }
        StringBuilder sb=new StringBuilder();
        for(int j=0;j<3;j++){
            for(int i=0;i<arrN.length;i++){
                if(i>0)
                    sb.append(" ");
                for(int z=0;z<2;z++){
                   sb.append(arr[arrN[i]][j][z]);
                }
            }
            sb.append("\n");
        }
        return sb.toString();
    }
   
    static String decode(char[][][] x, char[][][] arr) {
        StringBuilder sb = new StringBuilder();
        for (int ind = 0; ind < x.length; ind++) {
            int num = -1;
            for (int i = 0; i < 10; i++) {
                int counter = 0;
                for (int j = 0; j < 3; j++) {
                    for (int z = 0; z < 2; z++) {
                        if (arr[i][j][z] == x[ind][j][z]) {
                            counter++;
                            if (counter == 6) {
                                num = i;
                                break;
                            }
                        }
                    }
                    if (counter == 6) {
                        break;
                    }
                }
                if (counter == 6) {
                    break;
                }

            }
            sb.append(num);
        }
        sb.append("\n");
        return sb.toString();
    }
}

UVA - 10815 - Andy's First Dictionary

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        HashSet<String> hs = new HashSet<String>();
        LinkedList<String> list = new LinkedList<String>();
        String m = "";
        while ((m = br.readLine()) != null) {
           /* if (m.equals("#")) {
                break;
            }*/
            StringBuilder temp = new StringBuilder();
            for (int i = 0; i < m.length(); i++) {
                if ((m.charAt(i) >= 'a' && m.charAt(i) <= 'z')
                        || (m.charAt(i) >= 'A' && m.charAt(i) <= 'Z')) {
                    temp.append(m.charAt(i));
                } else {
                    String word = temp.toString().toLowerCase();
                    temp = new StringBuilder();
                    if (word.equals("")) {
                        continue;
                    }
                    if (!hs.contains(word)) {
                        list.add(word);
                        hs.add(word);
                    }
                }
            }
            String word = temp.toString().toLowerCase();
            if (word.equals("")) {
                continue;
            }
            if (!hs.contains(word)) {
                list.add(word);
                hs.add(word);
            }
        }

        Collections.sort(list);
        while (!list.isEmpty()) {
            sb.append(list.remove()).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 11239 - Open Source

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        boolean flag=true;
        while(true){
            HashMap <String,Integer> hm=new  HashMap<String, Integer>();
            HashMap <String,String> id=new HashMap <String,String>();
            LinkedList<String> prj=new  LinkedList<String>();
            String last="";
            while (true) {
                    String temp=br.readLine().trim();
                    if(temp.equals("1")){
                        break;
                    }
                    if(temp.equals("0")){
                        flag=false;
                        break;
                    }
                    if(temp.charAt(0)>='a' &&temp.charAt(0)<='z'){
                        if(!id.containsKey(temp)){
                            id.put(temp, last);
                            int tempC=hm.get(last)+1;
                            hm.put(last, tempC);
                        }else{
                            String projtemp=id.get(temp);
                            if(projtemp.equals(last)||projtemp.equals("Banned")){
                                continue;
                            }
                            int projDec=hm.get(projtemp)-1;
                            hm.put(projtemp, projDec);
                            id.put(temp,"Banned");
                        }
                    }
                    if(temp.charAt(0)>='A' &&temp.charAt(0)<='Z'){
                        if(!hm.containsKey(temp)){
                            hm.put(temp, 0);
                            prj.add(temp);
                        }
                        last=temp;
                    }
                }
            if(!flag){
                break;
            }
            LinkedList<Project> list=new LinkedList<Project>();
            while(!prj.isEmpty()){
                String projN=prj.remove();
                int tempC=hm.get(projN);
                list.add(new Project(projN, tempC));
            }
            Collections.sort(list);
            while(!list.isEmpty()){
                Project temp=list.removeLast();
                sb.append(temp.getName()).append(" ").append(temp.getCounter()).append("\n");
            }
        }
        System.out.print(sb);
    }
}
class Project implements Comparable<Project>{
    private String name;
    private int counter;

    public Project(String name, int counter) {
        this.name = name;
        this.counter = counter;
    }

    public int getCounter() {
        return counter;
    }

    public String getName() {
        return name;
    }
   
    @Override
    public int compareTo(Project o) {
        if(this.counter>o.getCounter()){
            return 1;
        }
        if(this.counter<o.getCounter()){
            return -1;
        }else{
            if(this.name.compareTo(o.getName())>-1){
                return -1;
            }else{
                return 1;
            }
        }
    }
}

UVA - 10226 - Hardwood Species

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int cases=Integer.parseInt(br.readLine());
        br.readLine();
        for(int i=0;i<cases;i++){
            if(i>0)
                System.out.println();
            HashMap<String,Integer> hm=new HashMap<String, Integer>();
            LinkedList<String> list=new LinkedList<String>();
            int counter=0;
            String temp;
            while((temp=br.readLine())!=null){
                temp=temp.trim();
                if(temp.equals("")){
                    break;
                }else{
                   if(hm.containsKey(temp)){
                       int ind=hm.get(temp);
                       hm.put(temp, ind+1);
                   }else{
                       hm.put(temp, 1);
                       list.add(temp);
                   }
                   counter++;
                }
            }
            Collections.sort(list);
            while(!list.isEmpty()){
                String str=list.remove();
                double val=(double)hm.get(str)*100/counter;
                System.out.printf("%s %.4f\n", str,val);
            }
        }
    }
}

UVA - 11629 - Ballot evaluation

//Avoid Using Double parsing
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
            StringTokenizer st=new StringTokenizer(br.readLine());
            int n=Integer.parseInt(st.nextToken());
            int m=Integer.parseInt(st.nextToken());
            HashMap<String,Integer> hm=new HashMap<String, Integer>();
            for(int i=0;i<n;i++){
                st=new StringTokenizer(br.readLine());
                hm.put(st.nextToken(), mult(st.nextToken()));
            }
            for(int i=1;i<m+1;i++){
                sb.append("Guess #").append(i).append(" was ");
                st=new StringTokenizer(br.readLine());
                int countofToken=st.countTokens();
                double ans=hm.get(st.nextToken());
                while(st.hasMoreTokens()){
                    String temp=st.nextToken();
                    if(temp.equals("+")){
                        ans+=hm.get(st.nextToken());
                    }
                    if(temp.equals("<")){
                        if(ans<10*Integer.parseInt(st.nextToken())){
                            sb.append("correct.\n");
                        }else{
                            sb.append("incorrect.\n");
                        }
                    }
                    else if(temp.equals(">")){
                        if(ans>10*Integer.parseInt(st.nextToken())){
                            sb.append("correct.\n");
                        }else{
                            sb.append("incorrect.\n");
                        }
                    }
                    else if(temp.equals(">=")){
                        if(ans>=10*Integer.parseInt(st.nextToken())){
                            sb.append("correct.\n");
                        }else{
                            sb.append("incorrect.\n");
                        }
                    }
                    else if(temp.equals("<=")){
                        if(ans<=10*Integer.parseInt(st.nextToken())){
                            sb.append("correct.\n");
                        }else{
                            sb.append("incorrect.\n");
                        }
                    }
                    else if(temp.equals("=")){
                        if(ans==10*Integer.parseInt(st.nextToken())){
                            sb.append("correct.\n");
                        }else{
                            sb.append("incorrect.\n");
                        }
                    }
                }
            }
        System.out.print(sb);
    }
   
    static int mult(String x){
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<x.length();i++){
            if(x.charAt(i)>='0' &&x.charAt(i)<='9'){
                sb.append(x.charAt(i));
            }
        }
        return Integer.parseInt(sb.toString());
    }
}

UVA - 11286 - Conformity

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        while(true){
            int n=Integer.parseInt(br.readLine());
            if(n==0){
                break;
            }
            HashMap<String,Integer> hm=new HashMap<String, Integer>();
            int max=Integer.MIN_VALUE;
            int counterMax=0;
            for(int i=0;i<n;i++){
                StringTokenizer st=new StringTokenizer(br.readLine());
                int[] arr=new int[5];
                for(int j=0;j<5;j++){
                    arr[j]=Integer.parseInt(st.nextToken());
                }
                Arrays.sort(arr);
                StringBuilder str=new  StringBuilder("");
                for(int j=0;j<5;j++){
                    if(j>0)
                        str.append(" ");
                    str.append(arr[j]);
                }
                String temp=str.toString();
                if(hm.containsKey(temp)){
                    int index=hm.get(temp);
                    hm.put(temp, index+1);
                    if(index+1>max){
                        max=index+1;
                        counterMax=max;
                    }
                    else if(index+1==max){
                        counterMax+=max;
                    }
                }else{
                    hm.put(temp, 1);
                    if(1>max){
                        max=1;
                        counterMax=1;
                    }
                    else if(max==1){
                        counterMax++;
                    }
                }
            }
            sb.append(counterMax).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 11849 - CD

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        while(true){
            StringTokenizer st=new StringTokenizer(br.readLine());
            int n=Integer.parseInt(st.nextToken());
            int m=Integer.parseInt(st.nextToken());
            if(n==0 &&m==0){
                break;
            }
            HashSet<Integer> hs=new HashSet<Integer>();
            for(int i=0;i<n;i++){
                hs.add(Integer.parseInt(br.readLine()));
            }
            int counter=0;
            for(int i=0;i<m;i++){
                if(hs.contains(Integer.parseInt(br.readLine()))){
                    counter++;
                }
            }
            sb.append(counter).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 12554 - A Special "Happy Birthday" Song!!!

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        String []happy={"Happy","birthday","to","you","Happy","birthday","to","you"
        ,"Happy","birthday","to","Rujia","Happy","birthday","to","you"};
        int cases=Integer.parseInt(br.readLine());
        Queue<String> qu=new LinkedList();
        for(int i=0;i<cases;i++){
           qu.add(br.readLine());
        }
        while (cases>0){
            for(int i=0;i<happy.length;i++){
                String temp=qu.remove();
                sb.append(temp).append(": ").append(happy[i]).append("\n");
                qu.add(temp);
            }
            cases-=happy.length;
        }
        System.out.print(sb);
    }
   
}

UVA - 11349 - Symmetric Matrix

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));
        StringBuffer sb = new StringBuffer("");
        int cases=Integer.parseInt(br.readLine());
        for(int i=0;i<cases;i++){
            String[]str=br.readLine().split("=");
            int n=Integer.parseInt(str[1].trim());
            long [][]arr=new long[n][n];
            for(int j=0;j<n;j++){
                String[] temp=br.readLine().split(" ");
              for(int z=0;z<n;z++){
                 arr[j][z]=Long.parseLong(temp[z]);
              } 
            }
            long[][] temp=rotate180(arr);
            sb.append("Test #").append((i+1)).append(": ");
            if(check(arr, temp)){
                sb.append("Symmetric.\n");
            }else{
                sb.append("Non-symmetric.\n");
            }
           }
        System.out.print(sb);
    }
   
   
   static public long[][] rotate180(long[][] arr){
        int x=arr.length,y=arr[0].length;
        long[][]temp=new long[x][y];
        for(int i=0;i<x;i++){
          for(int j=0;j<y;j++){
              temp[i][j]=arr[x-i-1][y-j-1];
            } 
        }
        return temp;
    }
  
   static boolean check(long[][]x,long[][]y){
       for(int i=0;i<x.length;i++){
           for(int j=0;j<y.length;j++){
               if(x[i][j]!=y[i][j] ||x[i][j]<0||y[i][j]<0){
                   return false;
               }
           }
       }
       return true;
   }
}

UVA - 10855 - Rotated square

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));
        StringBuffer sb = new StringBuffer("");
        while(true){
            String[]str=br.readLine().split(" ");
            int n=Integer.parseInt(str[0]);
            int m=Integer.parseInt(str[1]);
            if(n==0 && m==0){
                break;
            }
            char [][]arr=new char[n][n];
            for(int i=0;i<n;i++){
                String temp=br.readLine();
              for(int j=0;j<n;j++){
                 arr[i][j]=temp.charAt(j);
              } 
            }
            char [][]arr2=new char[m][m];
            for(int i=0;i<m;i++){
                String temp=br.readLine();
              for(int j=0;j<m;j++){
                 arr2[i][j]=temp.charAt(j);
              } 
            }
            int[]ans=new int[4];
            ans[0]=search(arr, arr2);
            ans[1]=search(arr, rotate90(arr2));
            ans[2]=search(arr, rotate180(arr2));
            ans[3]=search(arr, rotate270(arr2));
            sb.append(ans[0]).append(" ").append(ans[1]).append(" ").append(ans[2]).append(" ").append(ans[3]).append("\n");
        }
        System.out.print(sb);
    }
   
    static public char[][] rotate90(char[][] arr){
        int x=arr.length,y=arr[0].length;
        char[][]temp=new char[x][y];
        for(int i=0;i<x;i++){
          for(int j=0;j<y;j++){
              temp[i][j]=arr[y-j-1][i];
            } 
        }
        return temp;
    }
   
   static public char[][] rotate180(char[][] arr){
        int x=arr.length,y=arr[0].length;
        char[][]temp=new char[x][y];
        for(int i=0;i<x;i++){
          for(int j=0;j<y;j++){
              temp[i][j]=arr[x-i-1][y-j-1];
            } 
        }
        return temp;
    }
  
    static public char[][] rotate270(char[][] arr){
        int x=arr.length,y=arr[0].length;
        char[][]temp=new char[x][y];
        for(int i=0;i<x;i++){
          for(int j=0;j<y;j++){
              temp[i][j]=arr[j][x-i-1];
            } 
        }
        return temp;
    }
   
    static int search(char[][]big,char[][]small){
        int counter=0;
        for(int l=0;l<big.length-small.length+1;l++){
            for(int z=0;z<big[0].length-small[0].length+1;z++){
                boolean flag=true;
                for(int i=z, x=0;x<small.length;i++,x++){
                   for(int j=l,y=0;y<small[0].length;j++,y++){
                       if(big[i][j]!=small[x][y]){
                           flag=false;
                           break;
                       }
                    }
                   if(!flag){
                       break;
                   }
                }
                if(flag){
                    counter++;
                }
            }
        }
        return counter;
    }
}