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

CodeEval - Play with DNA - 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.Collections;
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;
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line);
            String pattern=st.nextToken();
            int allowedMiss=Integer.parseInt(st.nextToken());
            String str=st.nextToken();
            LinkedList<Pattern> list=new LinkedList<Pattern>();
            StringBuilder strb=new StringBuilder();
            for(int i=0;i<pattern.length()-1;i++){
                strb.append(str.charAt(i));
            }
            for(int i=pattern.length()-1;i<str.length();i++){
                 strb.append(str.charAt(i));
                 int dist=levenshteinDistance(pattern, strb.toString());
                 if(dist<=allowedMiss){
                     list.add(new Pattern(dist, strb.toString()));
                 }
                 strb.deleteCharAt(0);
            }
            Collections.sort(list);
            boolean first=true;
            while(!list.isEmpty()){
                if(!first){
                    sb.append(' ');
                }
                sb.append(list.remove().getPattern());
                first=false;
            }
            if(first){
                sb.append("No match");
            }
            sb.append('\n');
        }
       
        System.out.print(sb);
    }
   
    private static int minimum(int a, int b, int c) {
        return Math.min(Math.min(a, b), c);
    }

    public static int levenshteinDistance(String str1,String str2) {
        int[][] distance = new int[str1.length() + 1][str2.length() + 1];

        for (int i = 0; i <= str1.length(); i++)
            distance[i][0] = i;
        for (int j = 1; j <= str2.length(); j++)
            distance[0][j] = j;

        for (int i = 1; i <= str1.length(); i++)
            for (int j = 1; j <= str2.length(); j++)
                distance[i][j] = minimum(
                        distance[i - 1][j] + 1,
                        distance[i][j - 1] + 1,
                        distance[i - 1][j - 1]+ ((str1.charAt(i - 1) == str2.charAt(j - 1)) ? 0 : 1));

        return distance[str1.length()][str2.length()];   
    }

}
class Pattern implements Comparable<Pattern> {
    int score;
    String pattern;

    public Pattern(int score, String pattern) {
        this.score = score;
        this.pattern = pattern;
    }
   

    public String getPattern() {
        return pattern;
    }

    public int getScore() {
        return score;
    }

    public void setPattern(String pattern) {
        this.pattern = pattern;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(Pattern o) {
        if(this.score<o.getScore())
            return -1;
        if(this.score>o.getScore())
            return 1;
        return this.pattern.compareTo(o.getPattern());
    }
   
   
}

CodeEval - Sudoku - 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,";");
            int n=Integer.parseInt(st.nextToken());
            int arr[][]=new int[n][n];
            StringTokenizer valz=new StringTokenizer(st.nextToken(),",");
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    arr[i][j]=Integer.parseInt(valz.nextToken());
                }
            }
            if(checkSoduku(arr)){
                sb.append("True\n");
            }else{
                sb.append("False\n");
            }
        }
        System.out.print(sb);
    }
   
     static boolean checkSoduku(int[][]arr){
         int n=arr.length;
         for(int i=0;i<n;i++){
             boolean[] valz=new boolean[n+1];
             for(int j=0;j<n;j++){
                 if(arr[i][j]>n){
                     return false;
                 }
                 valz[arr[i][j]]=true;
             }
             for(int j=1;j<valz.length;j++){
                 if(!valz[j]){
                     return false;
                 }
             }
         }
         for(int i=0;i<n;i++){
             boolean[] valz=new boolean[n+1];
             for(int j=0;j<n;j++){
                 if(arr[j][i]>n){
                     return false;
                 }
                 valz[arr[j][i]]=true;
             }
             for(int j=1;j<valz.length;j++){
                 if(!valz[j]){
                     return false;
                 }
             }
         }
         int sqX=(int) Math.sqrt(n);
         for(int i=0;i<sqX*sqX;i+=sqX){
             for(int j=0;j<sqX*sqX;j+=sqX){
                 boolean[] valz=new boolean[n+1];
                 for(int z=i;z<i+sqX;z++){
                     for(int k=j;k<j+sqX;k++){
                        valz[arr[z][k]]=true;
                     }
                 }
                 for(int z=1;z<valz.length;z++){
                    if(!valz[z]){
                         return false;
                    }
                 }
             }
         }
         return true;
     }
}

CodeEval - String Searching - 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.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;
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line,",");
            String str=st.nextToken();
            String temp=st.nextToken();
            StringBuilder stb=new StringBuilder();
            LinkedList<String> list=new LinkedList<String>();
            for(int i=0;i<temp.length();i++){
                char c=temp.charAt(i);
                if(i==0){
                    if(c!='*'){
                        stb.append(c);
                    }
                    if(i<temp.length()-1){
                        if(c=='\\'&&temp.charAt(i+1)=='*'){
                            stb.deleteCharAt(stb.length()-1);
                        }
                    }
                }else if(i== temp.length()-1){
                    if(c=='*'){
                        if(temp.charAt(i-1)=='\\'){
                           stb.append(c);
                        }
                    }else{
                        stb.append(c);
                    }
                }else{
                    if(c=='*'){
                        if(temp.charAt(i-1)=='\\'){
                           stb.append(c);
                        }else{
                            list.add(stb.toString());
                            stb=new StringBuilder();
                        }
                    }else if(c=='\\'){
                        if(temp.charAt(i+1)!='*'){
                           stb.append(c);
                        }
                    }else{
                        stb.append(c);
                    }
                }
            }
            if(stb.length()!=0){
                list.add(stb.toString());
            }
            sb.append(findThesePatterns(str, list)).append('\n');
        }
        System.out.print(sb);
    }
   
    static boolean findThesePatterns(String Str,LinkedList<String> pattern){
        LinkedList<LinkedList<Integer>> list=new LinkedList<LinkedList<Integer>>();
        LinkedList<Integer> length=new LinkedList<Integer>();
        while(!pattern.isEmpty()){
            String val=pattern.remove();
            list.add(searchForPattrern(Str,val));
            length.add(val.length());
        }
        return canBeAfter(0, -1, list, length);
    }
   
    static boolean canBeAfter(int j,int index,LinkedList<LinkedList<Integer>> list,LinkedList<Integer> length){
        if(j==length.size()){
            return true;
        }
        LinkedList<Integer> less=list.get(j);
        int lengthL=length.get(j);
        for(int val:less){
            if(val>index){
               boolean res=canBeAfter(j+1,val+lengthL,list, length);
               if(res){
                   return true;
               }
            }
        }
        return false;
    }
   
     static LinkedList<Integer> searchForPattrern(String val,String pattern){
         LinkedList<Integer> index=new LinkedList<Integer>();
         for(int i=0;i<val.length()-pattern.length()+1;i++){
             int counter=0;
             for(int j=0;j<pattern.length();j++){
                 if(val.charAt(i+j)!=pattern.charAt(j)){
                     break;
                 }
                 counter++;
             }
             if(counter==pattern.length()){
                 index.add(i);
             }
         }
         return index;
     }
}

CodeEval - Text to Number - 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.HashMap;
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;
        HashMap<String,Integer> lessThan1000=getLessThan1000();
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line);
            String[]arr=new String[st.countTokens()];
            for(int i=0;i<arr.length;i++){
                arr[i]=st.nextToken();
            }
            sb.append(convToNum(arr, lessThan1000));
            sb.append('\n');
        }
        System.out.print(sb);
    }
  
    static int convToNum(String[]arr,HashMap<String,Integer> hm){
        int val=0;
        LinkedList<String> digit=new LinkedList<String>();
        LinkedList<String> thousand=new LinkedList<String>();
        LinkedList<String> million=new LinkedList<String>();
        int cases=0;
        boolean neg=false;
        for(int i=arr.length-1;i>-1;i--){
            if(arr[i].equals("thousand")){
                cases=1;
            }
            else if(arr[i].equals("million")){
                cases=2;
            }else{
                if(i==0){
                    if(arr[0].equals("negative")){
                        neg=true;
                        continue;
                    }
                }
                if(cases==0){
                    digit.add(arr[i]);
                }else if(cases==1){
                    thousand.add(arr[i]);
                }else{
                    million.add(arr[i]);
                }
            }
        }
        val=getVal(million, hm)*1000*1000+getVal(thousand, hm)*1000+getVal(digit, hm);
        if(neg){
            val=-val;
        }
        return val;
    }
  
    static int getVal(LinkedList<String> list,HashMap<String,Integer> hm){
        boolean first=true;
        StringBuilder sb=new StringBuilder();
        if(list.isEmpty()){
            return 0;
        }
        while(!list.isEmpty()){
            if(!first){
                sb.append(' ');
            }
            sb.append(list.removeLast());
            first=false;
        }
        return hm.get(sb.toString());
    }
  
    static HashMap<String, Integer> getLessThan1000(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        HashMap<String,Integer> digits0=initDigits0();
        HashMap<String,Integer> digits1=initDigits1();
        HashMap<String,Integer> digits2=initDigits2();
        for(String s:digits0.keySet()){
            hm.put(s,digits0.get(s));
        }
        for(String s:digits1.keySet()){
            hm.put(s,digits1.get(s));
        }
        digits0.remove("zero");
        for(String s:digits2.keySet()){
            hm.put(s,digits2.get(s));
            for(String s2:digits0.keySet()){
                hm.put(s+" "+s2,digits2.get(s)+digits0.get(s2));
            }
        }
        for(String s0:digits0.keySet()){
            hm.put(s0+" hundred",digits0.get(s0)*100);
            for(String s:digits0.keySet()){
                hm.put(s0+" hundred "+s,digits0.get(s0)*100+digits0.get(s));
            }
            for(String s:digits1.keySet()){
                hm.put(s0+" hundred "+s,digits0.get(s0)*100+digits1.get(s));
            }
            for(String s:digits2.keySet()){
                hm.put(s0+" hundred "+s,digits0.get(s0)*100+digits2.get(s));
                for(String s2:digits0.keySet()){
                    hm.put(s0+" hundred "+s+" "+s2,digits0.get(s0)*100+digits2.get(s)+digits0.get(s2));
                }
            }
        }
        return hm;
    }
  
    static HashMap<String, Integer> initDigits0(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        hm.put("zero",0);
        hm.put("one",1);
        hm.put("two",2);
        hm.put("three",3);
        hm.put("four",4);
        hm.put("five",5);
        hm.put("six",6);
        hm.put("seven",7);
        hm.put("eight",8);
        hm.put("nine",9);
        return hm;
    }
  
    static HashMap<String, Integer> initDigits1(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        hm.put("ten",10);
        hm.put("eleven",11);
        hm.put("twelve",12);
        hm.put("thirteen",13);
        hm.put("fourteen",14);
        hm.put("fifteen",15);
        hm.put("sixteen",16);
        hm.put("seventeen",17);
        hm.put("eighteen",18);
        hm.put("nineteen",19);
        return hm;
    }
  
    static HashMap<String, Integer> initDigits2(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        hm.put("twenty",20);
        hm.put("thirty",30);
        hm.put("forty",40);
        hm.put("fifty",50);
        hm.put("sixty",60);
        hm.put("seventy",70);
        hm.put("eighty",80);
        hm.put("ninety",90);
        return hm;
    }
  
}

Facebook Hacker Cup 2013 - Qualification - Problem A - Beautiful Strings

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 in = new BufferedReader(new InputStreamReader(System.in));
    StringBuffer sb=new StringBuffer();
    String line;
    while ((line = in.readLine()) != null) {
       String val=line.toLowerCase();
       char[]hist=new char[26];
       for(int i=0;i<val.length();i++){
           if(val.charAt(i)>='a' && val.charAt(i)<='z'){
            hist[val.charAt(i)-'a']++;
           }
       }
       Arrays.sort(hist);
       int sum=0;
       for(int i=hist.length-1;i>-1;i--){
           sum+=hist[i]*(i+1);
       }
       sb.append(sum).append('\n');
    }
    System.out.print(sb);
  }
}

Hacker Rank - Unfriendly Numbers

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    static int unfriendlyNumbers(long[] a,long k) {
        LinkedList<Long> factors=new LinkedList<Long>();
        for(long i=2;i<=Math.sqrt(k);i++){
            if(k%i==0){
                factors.add(i);
                if(k/i !=i){
                    factors.add(k/i);
                }
            }
        }
        HashSet<Long> hs=new HashSet<Long>();
        for(int i=0;i<a.length;i++){
               hs.add(gcd(a[i], k));
        }
        factors.add(k);
        int counter=0;
        while(!factors.isEmpty()){
            long div=factors.remove();
            boolean flag=true;
            for(long key: hs){
                if(key%div==0){
                    flag=false;
                }
            }
            if(flag){
                counter++;
            }
        }
        return counter;
    }
   
    public static long gcd(long x,long y){
        if(y==0)
            return x;
        return gcd(y, x%y);
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine());
        long n=Long.parseLong(st.nextToken()),k=Long.parseLong(st.nextToken());
        st=new StringTokenizer(br.readLine());
        long[]arr=new long[st.countTokens()];
        for(int i=0;i<arr.length;i++){
            arr[i]=Long.parseLong(st.nextToken());
        }
        System.out.println(unfriendlyNumbers(arr, k));
    }
}