Moderate 猜测序列hit或是pseudo-hit @CareerCup

思路不难，关键是如何写出结构清晰的代码，另外注意到的就是用到的frequencies数组来使得复杂度由暴力的O(n2)到O(n)

package Moderate;

import java.util.Random;


/**
 * The Game of Master Mind is played as follows:

The computer has four slots containing balls that are red (R ), yellow (Y), green (G) or blue (B). For example, the computer might have RGGB (e.g., Slot #1 is red, Slots #2 and #3 are green, Slot #4 is blue).

You, the user, are trying to guess the solution. You might, for example, guess YRGB.When you guess the correct color for the correct slot, you get a “hit”. If you guess a color that exists but is in the wrong slot, you get a “pseudo-hit”. For example, the guess YRGB has 2 hits and one pseudo hit.

For each guess, you are told the number of hits and pseudo-hits. Write a method that, given a guess and a solution, returns the number of hits and pseudo hits.

译文：

Master Mind游戏规则如下：

4个槽，里面放4个球，球的颜色有4种，红(R )，黄(Y)，绿(G)，蓝(B)。比如， 给出一个排列RGGB，表示第一个槽放红色球，第二和第三个槽放绿色球，第四个槽放蓝色球。

你要去猜这个排列。比如你可能猜排列是：YRGB。当你猜的颜色是正确的，位置也是正确的， 你就得到一个hit，比如上面第3和第4个槽猜的和真实排列一样(都是GB)，所以得到2个hit。 如果你猜的颜色在真实排列中是存在的，但位置没猜对，你就得到一个pseudo-hit。比如， 上面的R，猜对了颜色，但位置没对，得到一个pseudo-hit。

对于你的每次猜测，你会得到两个数：hits和pseudo-hits。写一个函数， 输入一个真实排列和一个猜测，返回hits和pseudo-hits。
 *
 */
public class S17_5 {

	public static class Result {
        public int hits;
        public int pseudoHits;
        
        public Result(int h, int p) {
            hits = h;
            pseudoHits = p;
        }
        
        public Result() {
        }
        
        public String toString() {
            return "(" + hits + ", " + pseudoHits + ")";
        }
	};

	public static int code(char c) {
        switch (c) {
        case 'B':
                return 0;
        case 'G':
                return 1;
        case 'R':
                return 2;
        case 'Y':
                return 3;
        default:
                return -1;
        }
	}

	public static int MAX_COLORS = 4;

	public static Result estimate(String guess, String solution) {
        if (guess.length() != solution.length()) return null;
        Result res = new Result();
        int[] frequencies = new int[MAX_COLORS];
            
        /* Compute hits and built frequency table */
        for (int i = 0; i < guess.length(); i++) {
            if (guess.charAt(i) == solution.charAt(i)) {
                res.hits++;
            } else {
                /* Only increment the frequency table (which will be used for pseudo-hits) if
                 * it's not a hit. If it's a hit, the slot has already been "used." */
                int code = code(solution.charAt(i));
                if (code >= 0) {
                	frequencies[code]++;		// 把答案的分布存在frequencies数组中
                }
            }
        }
        
        /* Compute pseudo-hits */
        for (int i = 0; i < guess.length(); i++) {
            int code = code(guess.charAt(i));
            if (code >= 0 && frequencies[code] > 0 && guess.charAt(i) != solution.charAt(i)) {
                res.pseudoHits++;
                frequencies[code]--;
            }
        }
        return res;
	}

/************************** TEST CODE **********************************/

	public static char letterFromCode(int k) {
        switch (k) {
        case 0:
                return 'B';
        case 1:
                return 'G';
        case 2:
                return 'R';
        case 3:
                return 'Y';
        default:
                return '0';
        }                
	}

	public static Result estimateBad(String g, String s) {
        char[] guess = g.toCharArray();
        char[] solution = s.toCharArray();
        int hits = 0;
        for (int i = 0; i < guess.length; i++) {
            if (guess[i] == solution[i]) {
                hits++;
                solution[i] = '0';
                guess[i] = '0';
            }
        }
        
        int pseudohits = 0;
        
        for (int i = 0; i < guess.length; i++) {
            if (guess[i] != '0') {
                for (int j = 0; j < solution.length; j++) {
                    if (solution[j] != '0') {
                        if (solution[j] == guess[i]) {
                            pseudohits++;
                            solution[j] = '0';
                            break;
                        }
                    }
                }
            }
        }
        
        return new Result(hits, pseudohits);
	}
	
	public static String randomString() {
        int length = 4;
        char[] str = new char[length];
        Random generator = new Random();
        
        for (int i = 0; i < length; i++) {
            int v = generator.nextInt(4);
            char c = letterFromCode(v);
            str[i] = c;
        }
        
        return String.valueOf(str);
	}
	
	public static boolean test(String guess, String solution) {
        Result res1 = estimate(guess, solution);
        Result res2 = estimateBad(guess, solution);
        if (res1.hits == res2.hits && res1.pseudoHits == res2.pseudoHits) {
            return true;
        } else {
            System.out.println("FAIL: (" + guess + ", " + solution + "): " + res1.toString() + " | " + res2.toString());
            return false;
        }
	}
	
	public static boolean testRandom() {
        String guess = randomString();
        String solution = randomString();
        return test(guess, solution);
	}
	
	public static boolean test(int count) {
        for (int i = 0; i < count; i++) {
            if (!testRandom()) {
                    return true;
            }
        }
        return false;
	}
	
	/********************** END TEST CODE ************************/
	
	
	public static void main(String[] args) {
		test(1000);
	}
}