面试题目

      看完楼上各位童鞋的回帖，简直要崩溃了~~~~~~~
      我估计没有几个人搞懂了面试官究竟是想考什么，楼上各位如果可以在笔试阶段画上15分钟把你们的代码用纸笔写出来，我真还服了你们了。
       哎...........

我估计你要佩服了,我看表的,6分钟用editplus写出来了.

你说的你的观点,其实代码行数是差不多的,

   特地回去看了你的代码，没有前面那些人复杂，确实可以在6分钟内写出来。不过要我让我佩服，那就真不好意思了。我是考官只能给你70分。
    对这种题目，我贴出个广大童鞋可以在3分钟内写出的代码(首先不考虑一些异常的控制，比如传空字符串等，这只是为了减少一些干扰），同时也让ww_java看看，两种代码的差别吧

<script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/themes/advanced/langs/zh.js"></script><script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/plugins/javaeye/langs/zh.js"></script>
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class ClassA {
	private Map<Character, Integer> getToken(String str) {
		Map<Character, Integer> token = new LinkedHashMap<Character, Integer>();
		for (int i = 0; i < str.length(); i++) {
			if (token.get(str.charAt(i)) != null) {
				token.put(str.charAt(i), token.get(str.charAt(i)) + 1);
			} else {
				token.put(str.charAt(i), 1);
			}
		}
		return token;
	}
	
	
	public void print(String str, boolean print) {
		Map<Character ,Integer> token = getToken(str) ; 
		Iterator<Character> iterator = token.keySet().iterator(); 
		int max = Collections.max(token.values()); 
		while(iterator.hasNext()){ 
			Character c = iterator.next(); 
			if(token.get(c).compareTo(max) == 0){
				if (print) {
					System.out.println(c +" = "+token.get(c));
				}
			}
		}
	}
	
	public void print2(String s, boolean print) {
		char[] chars = s.toCharArray();
		Arrays.sort(chars);
		int i = 0 ;
		int maxCount = 0 ;
		char maxChar = ' ';
		char last = ' ';
		for (char c : chars) {
			if (last != c) {
				if (i > maxCount) {
					maxCount = i ;
					maxChar = last ;
				}
				last = c ;
				i = 0 ;
			}
			i ++ ;
		}
		if (print) {
			System.out.println(maxChar + " = "+ maxCount);
		}
	}
	
	public static void main(String[] args) {
		String s = "jdkfjw,.oeto,.34utkgf.syf9w ,e7r23, haerhyqbkbwkhjgosu9asuf9qojekogtjalugf9qu7r13htfn";
		ClassA a = new ClassA();
		a.print(s, true);
		System.out.println("--------------------");
		a.print2(s, true);
		long start = System.currentTimeMillis() ;
		for (int i = 0; i < 10000; i++) {
			a.print(s, false);
		}
		long end = System.currentTimeMillis() ;
		System.out.println("execute print method cost: "+(end - start));

		start = System.currentTimeMillis() ;
		for (int i = 0; i < 10000; i++) {
			a.print2(s, false);
		}
		end = System.currentTimeMillis() ;
		System.out.println("execute print2 method cost: "+(end - start));
	}
}

   得到的结果是

f = 6
--------------------
f = 6
execute print method cost: 328
execute print2 method cost: 94

    采用print2的速度要比print方法快了4倍。其实如果随着字符串的长度越长，速度的差别会更加明显。当然，我也并不是说这是什么最佳不最佳，速度的差别只是考虑的一个方面，没有必要纠缠是否还可以继续优化那么一点点。 各位童鞋好好从程序本身的复杂度来看看这两个方法吧。即使说不准用Arrays.sort方法，无非也就是多加一个快速排序（不会超过十分钟），而在print方法中我们也可以看到类似的Collections.max方法。
    其实这是一个简单的笔试题，希望大家能清楚，凡事笔试的，都不会太复杂或者繁琐，它考察的点究竟在哪里。

 String str = "hello wolrd wlllkdsfhksadfls?sdfls sdf.pqyutgvAAAxzsdfs " +
                "lsdfj,ljsfd  ajfdsak sfksjdfisfsdkfj lsdfjsidf jsafdalsjfs sfskdfjs";
        int[] strCounts = new int[255];
        int biggestCount = 0;
        char biggestCh = 0;
        char ch = 0;
        int currentCount = 0;
        for (int i = str.length() - 1; i >= 0; i--) {
            ch = str.charAt(i);
            currentCount = ++strCounts[ch];
            if (currentCount > biggestCount) {
                biggestCount = currentCount;
                biggestCh = ch;
            }
        }
        System.out.println(biggestCh);
        System.out.println(biggestCount);
        /**
         * 100,000
         * 295
         * 239
         * 265
         */

笔试的话这几句不算多吧。

   楼上的想法还是不错，有新意。反正ASCII字符也就最多255个，数组每个下标对应该字符出现的值。
   p.s 不过这个biggestCount的取名有些意思~~~~

这是算法题，不是java题，当然你可以用java写
如果用到Collections类的方法，那要被面试管BS的，一般就是理解错了这个题目的意思，如果要考Collections类的方法，就会考更复杂的问题了
这种算法题要用最简单的方法实现，占空间少，执行越快越好
如果循环肯定也是要BS的
这个算法只要O(n)就行了

   楼主好像没有说这是算法题，不是考编程吧？从楼主的帖子你也可以看得出啊！理解面试中对于笔试的要求是非常重要的（如果只是考算法，用这样的题目就未免太简单了吧，呵呵）。我都不清楚楼上如何得出个这样的结论的.......
   至于说，在笔试题中使用了Collections就得BS，怕是楼上你的误区吧。如果是考编程题目，也就是考你基础应用编程的能力（一个有一些开发经验的程序员和完全没有开发经验的学生，差距就是在这里了），公司需要的更倾向的是能够应用的程序员，而不是一套套算法理论的学生的。
   最后给楼上总结下：
  1. 如果公司想考算法，想了解思维能力，绝对不会用这么简单的题目，起码也得弄个和高程（现在好像叫软件设计师吧)差不多水平的说。至少也要高过学校所学的。
  2. 这样的题目一般也会明确使用某种特定的语言的（当然我假设java），否则，程序写出来，考官未必都能够准确评分。
  3. 对于这样的笔试题，请一定从简单入手，不要整得那么复杂，也别想得那么复杂。笔试从来只是入门坎，而不是评优。
  

一个问题，当有两或两个以上的字母出现的次数都是最大的时候，你这段代码只能找到一个，其他的结果都丢了。

路过，我觉得是不是真的有必要上Map,List之类的容器
A-Z a-z就52个字符

public static void main(String[] args) {
        int max = 0;// 记录最多次数
        int count[] = new int[52];// 开个52的数组
        String input = "abbcAAAZZ.x.m .. .fdZZxxaaaaZ";
        for(int i=0;i<input.length();i++){
            int index = 0;
            char letter = input.charAt(i);
            if(letter >='A' && letter <='Z'){
                index = letter - 'A';
            }else if(letter >='a' && letter <='z'){
                index = letter - 'a' + 26;
            }else{// 其他字符
                continue;
            }
            count[index]++;
            if(count[index] > max){
                max = count[index];
            }
        }
        // 最多的可能有多个，于是循环一下
        for(int j=0;j<count.length;j++){
            if(count[j] == max)
                System.out.println("max = "+max+", maxLetter = "+ (j<26?(char)('A'+j):(char)('a'+j-26)));
        }
    }

package test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class StaticStr {

	
	public static void main(String[] args)
	{
		Map<Character,Integer> map = new TreeMap<Character,Integer>(new CharComparator());
		String str = "abbcAAAZZ.x.m .. .fdZZxxaaaaZ";
		List<Compound> result = new ArrayList<Compound>();
		char[] chararr = str.toCharArray();
		for(int i=0;i<chararr.length;i++)
		{
			if(!(chararr[i] >='A' && chararr[i] <='Z')&&!(chararr[i] >='a' && chararr[i] <='z')) continue;
			Integer num = (Integer)map.get(chararr[i]);
			if(num==null)
			{
				map.put(chararr[i], 1);
			}else
			{
				num++;
				map.put(chararr[i], num);
			}
		}
		
		Set<Map.Entry<Character,Integer>> set = map.entrySet();
		for(Map.Entry entry:set)
		{
			Compound c = new Compound();
			c.key = (Character) entry.getKey();
			c.value = (Integer) entry.getValue();
			result.add(c);
		}
		
		Collections.sort(result);
		Compound maxChar = result.get(0);
		int maxNum = maxChar.value;
		int i = 0;
		do{
			i++;
			System.out.println("Max num char:"+maxChar.key+" count:"+maxChar.value);
		}while(( maxChar = result.get(i))!=null&&maxChar.value==maxNum);
		
	}
	
	public  static final class CharComparator implements Comparator<Character>
	{

		public int compare(Character o1, Character o2) {
			char v1 = o1;
			char v2 =o2;
			if(v1==v2)
				return 0;
			else if(v1<v2)
				return 1;
			else
				return -1;
		}
		
	}
	
	public static final class Compound implements Comparable<Compound>
	{
		private char key;
		
		private int value;

		public int compareTo(Compound o) {
			if(this.value>o.value)
				return -1;
			else if(this.value==o.value)
				return 0;
			else
				return 1;
		}
		
		
	}
	
}