亚马逊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;
}
}