CodeEval - Distinct Subsequences - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
           StringTokenizer st=new StringTokenizer(line,",");
           wholeStr=st.nextToken();
           str=st.nextToken();
           sb.append(getOccurence(0, 0, new StringBuilder()));
           sb.append('\n');
        }
        System.out.print(sb);
    }
   
    static String str;
    static String wholeStr;
   
    static int getOccurence(int j,int i,StringBuilder string){
        if(j==str.length())
            return 1;
        if(i==wholeStr.length())
            return 0;
        int counter=0;
        if(str.charAt(j)==wholeStr.charAt(i)){
            counter=getOccurence(j+1,i+1,string);
        }
        return  getOccurence(j,i+1,string)+counter;
    }

}

CodeEval - Telephone Words - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb2 = new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
           sb=new StringBuffer();
           str=line;
           getWords(new StringBuilder());
           sb2.append(sb);
           sb2.append('\n');
        }
        System.out.print(sb2);
    }
   
    static String str;
    static StringBuffer sb;
 static void getWords(StringBuilder word){
     int index=word.length();
     if(index==7){
         if(sb.length()!=0){
             sb.append(',');
         }
         sb.append(word);
         return;
     }
     char c=str.charAt(index);
     if(c=='0' || c=='1'){
        word.append(c);
        getWords(word);
        word.deleteCharAt(word.length()-1);
     }
     else{
         int valz=c-'0'-2;
         int counter=0;
         if(valz>5)
             counter=1;
         char ca=(char) ('a'+valz*3+counter);
         word.append(ca);
         getWords(word);
         word.deleteCharAt(word.length()-1);
         char cb=(char) ('b'+valz*3+counter);
         word.append(cb);
         getWords(word);
         word.deleteCharAt(word.length()-1);
         char cc=(char) ('c'+valz*3+counter);
         word.append(cc);
         getWords(word);
         word.deleteCharAt(word.length()-1);
         if(valz==5 || valz==7){
            char cd=(char) ('d'+valz*3+counter);
            word.append(cd);
            getWords(word);
            word.deleteCharAt(word.length()-1);
         }
     }
 }

}

CodeEval - Lowest Common Ancestor - Moderate

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String line;
        BinTree tree=setupTree();
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line);
            HashSet<Integer> hs=getPathHash(tree, Integer.parseInt(st.nextToken()));
            LinkedList<Integer> list=getPathList(tree, Integer.parseInt(st.nextToken()));
            boolean flag=false;
            while(!list.isEmpty()){
                int val=list.removeLast();
                if(hs.contains(val)){
                   sb.append(val);
                   flag=true;
                   break;
                }
            }
            if(flag)
                sb.append('\n');
        }
        System.out.print(sb);
    }
   
    static BinTree setupTree(){
        BinTree tree =new BinTree(30);
        BinTree temp=tree;
        temp.setLeft(8);
        temp.setRight(52);
        temp=temp.getLeft();
        temp.setLeft(3);
        temp.setRight(20);
        temp=temp.getRight();
        temp.setLeft(10);
        temp.setRight(29);
        return tree;
    }
   
    static  HashSet<Integer> getPathHash(BinTree b,int value){
         HashSet<Integer> hs=new HashSet<Integer>();
         BinTree temp=b;
         while(temp.getValue()!=value){
             hs.add(temp.getValue());
             if(temp.getValue()>value){
                 temp=temp.getLeft();
             }else{
                 temp=temp.getRight();
             }
         }
         hs.add(value);
         return hs;
    }
  
    static LinkedList<Integer> getPathList(BinTree b,int value){
         LinkedList<Integer> list=new LinkedList<Integer>();
         BinTree temp=b;
         while(temp.getValue()!=value){
             list.add(temp.getValue());
             if(temp.getValue()>value){
                 temp=temp.getLeft();
             }else{
                 temp=temp.getRight();
             }
         }
         list.add(value);
         return list;
    }
}

class BinTree{
   private BinTree right;
   private BinTree left;
   private int value;

    public BinTree(int x) {
        value=x;
        right=null;
        left=null;
    }

    public BinTree getLeft() {
        return left;
    }

    public void setLeft(int left) {
        this.left = new BinTree(left);
    }

    public BinTree getRight() {
        return right;
    }

    public void setRight(int right) {
        this.right = new BinTree(right);
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
  
}

CodeEval - Minesweeper - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main {
    public static void main (String[] args) throws FileNotFoundException, IOException {

    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuffer sb=new StringBuffer();
    String line;
    while ((line = in.readLine()) != null) {
        StringTokenizer st=new StringTokenizer(line,";");
        StringTokenizer st2=new StringTokenizer(st.nextToken(),",");
        int n=Integer.parseInt(st2.nextToken());
        int m=Integer.parseInt(st2.nextToken());
        StringBuilder str=new StringBuilder(st.nextToken());
        int[][]arr=new int[n+2][m+2];
        char[][]val=new char[n+2][m+2];
        for(int i=1;i<n+1;i++){
            for(int j=1;j<m+1;j++){
                val[i][j]=str.charAt(0);
                if(val[i][j]=='*'){
                    inc(arr, i, j);
                }
                str.deleteCharAt(0);
            }
        }
        for(int i=1;i<n+1;i++){
            for(int j=1;j<m+1;j++){
                if(val[i][j]=='*'){
                    sb.append(val[i][j]);
                }else{
                   sb.append(arr[i][j]);
                }
            }
        }
        sb.append('\n');
    }
    System.out.print(sb);
  }
   
    static void inc(int[][]arr,int x,int y){
        for(int i=x-1;i<x+2;i++){
            arr[i][y-1]++;
            if(i!=x)
                arr[i][y]++;
            arr[i][y+1]++;
        }
    }
}

CodeEval - Find a Square - Moderate

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
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 FileNotFoundException, IOException {

    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuffer sb=new StringBuffer();
    String line;
    while ((line = in.readLine()) != null) {
        Point []points=new Point[4];
        StringTokenizer st=new StringTokenizer(line," ");
        for(int i=0;i<4;i++){
            points[i]=parsePoint(st.nextToken());
        }
        Point center=new Point(0,0);
        for(int i=0;i<4;i++){
            center.x+=points[i].x;
            center.y+=points[i].y;
        }
        center.x/=4;
        center.y/=4;
        boolean flag=true;
        double dist=eculDist(center, points[0]);
        for(int i=1;i<4;i++){
            double temp=eculDist(center, points[i]);
            if(temp!=dist){
                 sb.append(false).append("\n");
                 flag=false;
                 break;
            }
        }
        if(flag){
            int counter=0;
            for(int i=1;i<4;i++){
                if(dotProd(difPoint(points[0], center), difPoint(points[i], center))==0)
                        counter++;
            }
            if(counter==2){
                sb.append(true).append("\n");
            }
            else{
                sb.append(false).append("\n");
            }
        }
       
    }
    System.out.print(sb);
  }
   
    static double eculDist(Point p1,Point p2){
        return Math.sqrt(((p1.x-p2.x)*(p1.x-p2.x))+((p1.y-p2.y)*(p1.y-p2.y)));
    }
   
    static double dotProd(Point p1,Point p2){
        return p1.x*p2.x+p1.y*p2.y;
    }
   
    static Point difPoint(Point p1,Point p2){
        return new Point(p1.x-p2.x,p1.y-p2.y);
    }
   
    static Point parsePoint(String string){
        StringBuilder str=new StringBuilder(string);
        str.deleteCharAt(0);
        if(str.charAt(str.length()-1)==',')
            str.deleteCharAt(str.length()-1);
        str.deleteCharAt(str.length()-1);
        StringTokenizer st2=new StringTokenizer(str.toString(),",");
        return new Point(Integer.parseInt(st2.nextToken()),Integer.parseInt(st2.nextToken()));
    }
}

class Point{
    double x;
    double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
   
   
}

CodeEval - Point in Circle - Moderate

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main {
    public static void main (String[] args) throws FileNotFoundException, IOException {

    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringBuffer sb=new StringBuffer();
    String line;
    while ((line = in.readLine()) != null) {
        StringTokenizer st=new StringTokenizer(line,";");
        StringBuilder str=new StringBuilder(st.nextToken());
        str.delete(0, 9);
        str.deleteCharAt(str.length()-1);
        StringTokenizer st2=new StringTokenizer(str.toString(),",");
        double centerX=Double.parseDouble(st2.nextToken());
        double centerY=Double.parseDouble(st2.nextToken().trim());
       
        str=new StringBuilder(st.nextToken());
        str.delete(0, 9);
        double radius=Double.parseDouble(str.toString());
       
        str=new StringBuilder(st.nextToken());
        str.delete(0, 9);
        str.deleteCharAt(str.length()-1);
        st2=new StringTokenizer(str.toString(),",");
        double pX=Double.parseDouble(st2.nextToken());
        double pY=Double.parseDouble(st2.nextToken().trim());
        sb.append(!(eculDist(pX, pY, centerX, centerY)>radius)).append("\n");
    }
    System.out.print(sb);
  }
   
    static double eculDist(double x1,double y1,double x2,double y2){
        return Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
    }
}