昨天的JAVA面试题，感觉挺难大家帮忙看看！

是吗？
会不会a*b=c*d?

第3题

设times= 26;

a 为 0*times + 0;
b 为 1*times + 1;
c 为 2*times + 2;
d 为 3*times + 3;
.
.
.
z 为 26*times + 26;

对于一个单词，如stop，它的值为s+t+o+p

根据需要调整times的大小。
当times>26的时候，冲突的情况应该很少了。

我想你是想说372大小的一维数组吧。
我认为优势不在于效率上，而在于写代码时的可读性上。
若是372大小的一维数组，则可以birthday[(month-1)*31+day-1]++ 或者birthday[month<<5-month-31 + day -1]++;
若是366大小的一维数组，则会有些麻烦，比如说有一个人于8月5日生日，那他在这个366大小的数组中对应哪一个元素呢？
也许可以定义一个数组int monthdays[12]={0,31,60,91. . . . . }, 然后birthday[monthdays[month-1]+day-1]++，但是写出来的代码不如12*31的二维数组或372的一维数组来得简洁。
若是365大小的一维数组，则存在2月29日问题。

这个方法前面有兄弟提到过类似的,不过是把字母对应承相应的2以上的质数

这么算不对的哦，比如有30个人是3月1～30号出生的
另外有20个人是2月10号出生

拿空间换时间，主意不错。

发生溢出的可能性还是很小的，毕竟很少会有很长的单词。
我觉得问题是乘积的结果会很大，最小的8个质数的乘积为9699690。

第一题应该不难吧
第二题可以用list 和 set ，然后把set的东西再遍历一下？
第三题可以用正则的话应该不难吧

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class PhoneNumber {

	private Map<Character, char[]> keymap;

	@Before
	public void setUp() throws Exception {
		keymap = new HashMap<Character, char[]>(10);
		keymap.put('0', new char[] { '0' });
		keymap.put('1', new char[] { '0' });
		keymap.put('2', new char[] { 'a', 'b', 'c' });
		keymap.put('3', new char[] { 'd', 'e', 'f' });
		keymap.put('4', new char[] { 'g', 'h', 'i' });
		keymap.put('5', new char[] { 'j', 'k', 'l' });
		keymap.put('6', new char[] { 'm', 'n', 'o' });
		keymap.put('7', new char[] { 'p', 'q', 'r', 's' });
		keymap.put('8', new char[] { 't', 'u', 'v' });
		keymap.put('9', new char[] { 'w', 'x', 'y', 'z' });
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test
	public void testCheckNumber() {
		String number = "137689563";
		try {
			checkNumber(number);
		} catch (IllegalArgumentException e) {
			Assert.fail(e.getMessage());
		}
		number = "133";
		try {
			checkNumber(number);
		} catch (IllegalArgumentException e) {
			Assert.fail("Equals 3");
		}
		number = "13312341234";
		try {
			checkNumber(number);
		} catch (IllegalArgumentException e) {
			Assert.fail("Equals 11");
		}
		number = "13";
		try {
			checkNumber(number);
			Assert.fail("Shorter then 3");
		} catch (IllegalArgumentException e) {
		}
		number = "1376118956312";
		try {
			checkNumber(number);
			Assert.fail("Longer then 11");
		} catch (IllegalArgumentException e) {
		}
		number = "13761189B5";
		try {
			checkNumber(number);
			Assert.fail("Invalid char.");
		} catch (IllegalArgumentException e) {
		}
	}

	@Test
	public void testEnumerate() {
		String number = "65967427";
		Set<String> enums = enumerate(number);
		for (String element : enums) {
			System.out.println(element);
		}
		System.out.println("Total: " + enums.size());
	}

	/**
	 * @param number
	 */
	private void checkNumber(String number) {
		if (!number.matches("[0-9]{3,11}")) {
			throw new IllegalArgumentException("Invalid phone number.");
		}
	}

	private Set<String> enumerate(Set<String> base, char[] chars) {
		Set<String> result = new TreeSet<String>();
		if (base.isEmpty()) {
			for (char element : chars) {
				String s = new String(new char[] { element });
				result.add(s);
			}
		} else {
			for (String baseString : base) {
				for (char element : chars) {
					result.add(baseString + element);
				}
			}
		}
		return result;
	}

	/**
	 * @param number
	 * @return
	 */
	private Set<String> enumerate(String number) {
		checkNumber(number);
		char[] chars = number.toCharArray();
		Set<String> result = new HashSet<String>();
		for (char element : chars) {
			result = enumerate(result, keymap.get(element));
		}
		return result;
	}

}

这个比较有趣，写一个看看我家电话号码值钱不。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * 2.3求解：在一份文本文件中，查找其中所有的anagram。
 * 例如，如果这份文件中包含了stop、tops、pots这样三个单词，
 * 这三个词就是一组 anagram，
 * 这三个单词都是由s、t、o、p这四个字母组成的。
 * 这份文件中可能存在多组anagram，大小写视为同样字符。
 * 在解答时，需要注意代码的效率、质量。当不能给出完整代码时，
 * 可以描述解题思路。
 * @author maodajun327
 *
 */
public class AnagramWords {
		Map map= new HashMap();
		String[] strArray = new String[]{  
		            "stop","tops","pots"
		         };  
		public static void main(String arg[]){
			AnagramWords D2 = new AnagramWords();
			for(int i = 0 ; i < D2.strArray.length ; i++ ){
				D2.getTheWord(D2.strArray[i]);
			}
			List list  = D2.flashMap();
			System.out.println(list);
			
		}
		public void getTheWord(String str){
			str= str.toLowerCase();
			char[] arr=str.toCharArray();
			Arrays.sort(arr);
			String key =String.valueOf(arr);
			if(arr.length<=2){//字数为2当然不用了。
				return;
			}
			if(map.get(key)==null){
				Set set = new TreeSet();
				set.add(str);
				map.put(key, set);		
			}else{
				Set set = (Set) map.get(key);
				if(!set.contains(str)){//重的不要
					set.add(str);
				}
			}
			
		}
		public List flashMap(){
			List list = new ArrayList();
			Set set= map.entrySet();
			Iterator<Map.Entry> it=set.iterator();
			while(it.hasNext()){
				Map.Entry<String, Set> tmp= it.next();
				if(tmp.getValue().size()>=3){//小于3的不要。
					list.add(tmp.getValue());
				}
			}
			return list;			
		}
	
}