亚马逊2014在线面试第一题

package algorithm;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


 /**
 *  Class Name: zhipai.java
 *  Description: 规则一：

四张牌相同。自然数字大的胜出，比如3,3,3,3 < 6,6,6,6

规则二：

四张牌连续。当然序列最大的那个胜出。但是有个小trick，A在这里默认表最大牌，但是如果后接2,3,4，则A表最小牌，为了获得连续序列

比如A,2,3,4 < J,Q,K,A

规则三：

有三张相同。以每个序列相同牌较大的胜出。

比如3,3,3,2>2,2,2,A

规则四:

两个对子。当然以对子较大的胜出，最大的对子相同，则以次大的对子较大者胜出。

比如4,4,3,3 > 4,2,4,2

规则五：

一个对子。对子较大者胜出，如果对子相同，则比较剩下较大牌，如果还相同，比较次大牌

3,3,7,4 < 3,3,7,5

规则六：

如果以上皆不满足，则按照大牌>小牌比较（即从最大牌开始比较，分出高下为止）
 *  @author liuwei  DateTime 2014-10-13 上午9:42:08 
 *  @company bvit 
 *  @email liu.wei@bvit.com.cn  
 *  @version 2.0
 */
public class zhipai {
	
	
	
	
	 /**
	 *  Description:
	 *  1.判断所在级别
	 *  2.低级别大于高级别
	 *  3.级别相同
	 *  @author liuwei  DateTime 2014-10-10 下午5:25:39
	 *  @param str1
	 *  @param str2
	 *  @return
	 */
	public static int compare(String[] str1 ,String[] str2){
		
		int lev1 = getLevel(changeStr(str1));
		System.out.println(lev1);
		int lev2 = getLevel(changeStr(str2));
		System.out.println(lev2);
		
		if(lev1<lev2){
			return 1;
		}else if(lev1>lev2){
			return -1;
		}else{
			int[] array1 = changeStr(str1);
			int[] array2 = changeStr(str2);
			
			if(lev1==3||lev1==5){
				 array1 = sort(array1);
				 array2 = sort(array2);
			}
			for(int i:array1){
				System.out.print(i+" ");
			}
			System.out.println();
			for(int i:array2){
				System.out.print(i+" ");
			}
			System.out.println();
			
			for(int i=0;i<4;i++){
				if(array1[i]>array2[i]){
					return 1;
				}else if(array1[i]<array2[i]){
					return -1;
				}else if(array1[i]==array2[i] && i==3){
					return 0;
				}
			}
		}
		return 0 ;
	}
	
	
	 /**
	 *  Description:判断所属级别
	 *  1.炸弹
	 *  2.顺子
	 *  3.三张
	 *  4.双对
	 *  5.一对
	 *  6.单张
	 *  @author liuwei  DateTime 2014-10-10 下午5:39:47
	 *  @param intArray
	 *  @return
	 */
	public static int getLevel(int[] intArray){
		Map<Integer ,Integer> map = new HashMap<Integer, Integer>();
		
		for(int i:intArray){
			if(map.keySet().contains(i)){
				map.put(i, map.get(i)+1);
			}else{
				map.put(i, 1);
			}
		}
		if(map.containsValue(4))//炸弹
			return 1;
		else if(map.containsValue(3))//三张
			return 3;
		else if(map.containsValue(2)&& map.keySet().size()==2)//两对
			return 4;
		else if(map.containsValue(2)&& map.keySet().size()!=2)//两对
			return 5;
		else if(map.containsValue(1)&& 
				(intArray[0]+1==intArray[1] && intArray[1]+1==intArray[2] && intArray[2]+1==intArray[3] 
						)||(2==intArray[0] &&3==intArray[1] && 4==intArray[2] && 14==intArray[3]  ))//顺子
			return 2;
		else
			return 6;
	}
	
	
	
	 /**
	 *  Description:数字相同的排在前面,其余从大到小排列
	 *  @author liuwei  DateTime 2014-10-11 下午2:56:52
	 *  @param intArray
	 *  @return
	 */
	private static int[] sort(int[] intArray){
		Map<Integer ,Integer> map = new HashMap<Integer, Integer>();
		
		for(int i:intArray){
			if(map.keySet().contains(i)){
				map.put(i, map.get(i)+1);
			}else{
				map.put(i, 1);
			}
		} 
		map = MapUtil.sortByValue(map);  
		
		int[] newArray = new int[4];
		Set<Integer> set =map.keySet();
		int loc =0;
		for(Iterator<Integer> iter = set.iterator();iter.hasNext();){
			int key =iter.next();
			int value =map.get(key);
			if(value > 1){
				for(int i=0;i<value;i++){
					newArray[i] = key;
					loc++;
				}
			}else{
				newArray[loc] =key;
				loc++;
			}
			
			
		}
		
		//判断顺序是否正确
		for(int i=3;i>1;i--){
			if(newArray[i]>newArray[i-1] && newArray[i-1]!=newArray[i-2]){
				int temp = newArray[i];
				newArray[i] = newArray[i-1];
				newArray[i-1] = temp;
			}
		}
		
		return newArray;
	}
	
	
	
	 /**
	 *  Description:将AKQJ转化成数字
	 *  @author liuwei  DateTime 2014-10-13 上午9:35:15
	 *  @param str
	 *  @return
	 */
	public static int[] changeStr(String[] str){
		int[] intArray = new int[4];
		for(int i=0;i<str.length;i++){
			switch(str[i]){
			 	case "A":
			 		if(Arrays.asList(str).contains("A")&&Arrays.asList(str).contains("2")&&
			 				Arrays.asList(str).contains("3")&&Arrays.asList(str).contains("4")){
			 			intArray[i]=1;  
			 		}else
			 			intArray[i]=14;    
			    break;
			 	case "K":
			 	intArray[i]=13;    
			    break;
			 	case "Q":
				intArray[i]=12;    
				break;
			 	case "J":
				intArray[i]=11;    
				break;
			 	default:
				intArray[i]=Integer.parseInt(str[i]);    
				break;
			}
		}
		Arrays.sort(intArray);
		int[] newArray = new int[4];
		for(int i=0;i<4;i++){
			newArray[i] = intArray[3-i];
		}
		
		
		return newArray;
	}
	
	
	
	public static void main(String[] args) {
		String[] str1 = {"4","4","3","5"};
		String[] str2 = {"4","3","5","5"};
		switch(compare(str1,str2)){
			case 1:
			System.out.println("1大");
			break;
			case -1:
			System.out.println("2大");
			break;
			case 0:
			System.out.println("平局");
			break;
		}
	}
}

package algorithm;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class MapUtil
{
    public static <K, V extends Comparable<? super V>> Map<K, V> 
        sortByValue( Map<K, V> map )
    {
        List<Map.Entry<K, V>> list =
            new LinkedList<Map.Entry<K, V>>( map.entrySet() );
        Collections.sort( list, new Comparator<Map.Entry<K, V>>()
        {
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
            {
//                return (o1.getValue()).compareTo( o2.getValue() );//从小大大
            	return (o2.getValue()).compareTo( o1.getValue() );//从大到小
            }
        } );

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list)
        {
            result.put( entry.getKey(), entry.getValue() );
        }
        return result;
    }
}