魔王语言

问题描述有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话，没有人能听懂。但他的语言是可以逐步解释成人能懂的语言的，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：
(1)α→β1β2 …… βm
(2)(θδ1δ2 …… δn)→ θδnθδn-1 …… θδ1 θ
在这两种形式中，从左到右均表示解释；从右到左均表示抽象。试写一个魔王语言的解释系统，把他的话解释成人能听得懂的话。

该算法描述如下，

1、将字符串反序放入到一个栈中，

2、然后逐个取出来，当字符串为“（”的时候进行括号匹配，括号匹配是一个递归的过程，支持嵌套括号的解释，对于括号的解释如下：当遇到“（”的时候递归进行匹配，否则将拿出来的值放入一个新的栈中，最后将栈中的值按照规则进行解释，返回字符串。

3、然后将值与常量进行迭代匹配，将关键字匹配出来，如:B->tAdA

4、最后将对应的字符串与中文进行映射

PrjConstance.java：

import java.util.HashMap;
import java.util.Map;

public final class PrjConstance {
	public final static Map<String, String> KEY_TO_HUMAN_LANGUAGE = new HashMap<String, String>();
	public final static Map<String, String> EVAIL_LANGAUGE_COVERTOR = new HashMap<String, String>();

	static {
		KEY_TO_HUMAN_LANGUAGE.put("t", "天");
		KEY_TO_HUMAN_LANGUAGE.put("d", "地");
		KEY_TO_HUMAN_LANGUAGE.put("s", "上");
		KEY_TO_HUMAN_LANGUAGE.put("a", "一只");
		KEY_TO_HUMAN_LANGUAGE.put("e", "鹅");
		KEY_TO_HUMAN_LANGUAGE.put("z", "追");
		KEY_TO_HUMAN_LANGUAGE.put("g", "赶");
		KEY_TO_HUMAN_LANGUAGE.put("x", "下");
		KEY_TO_HUMAN_LANGUAGE.put("n", "蛋");
		KEY_TO_HUMAN_LANGUAGE.put("h", "恨");

		EVAIL_LANGAUGE_COVERTOR.put("B", "tAdA");
		EVAIL_LANGAUGE_COVERTOR.put("A", "sae");
	}
}

SatanConvertor.java:

import java.util.Set;
import java.util.Stack;

public class SatanConvertor {

	private String getBracketStatckValues(Stack<String> statck) {
		String str = getStatckStr(statck);
		String result = "";
		if (!str.isEmpty()) {
			String firstChar = str.charAt(0) + "";
			for (int i = str.length() - 1; i > 0; i--) {
				result += firstChar + str.charAt(i);
			}
			result += firstChar;
		}
		return result;
	}

	private String getStatckStr(Stack<String> s) {
		StringBuffer bf = new StringBuffer();
		for (int i = 0; i < s.size(); i++) {
			bf.append(s.get(i));
		}
		return bf.toString();
	}

	private String parasBracketStatck(Stack<String> s) {
		Stack<String> result = new Stack<String>();
		String element = s.pop();

		while (!element.equals(")")) {
			if (element.equals("(")) {
				// 迭代下一次循环
				String temp = parasBracketStatck(s);
				result.push(temp);
			} else {
				if (!element.equals("(") && !element.equals(")")) {
					result.push(element);
				}
			}
			if (s.isEmpty()) {
				break;
			}
			element = s.pop();
		}
		String str = getBracketStatckValues(result);
		return str;

	}

	private Stack<String> getStack(String text) {
		Stack<String> result = new Stack<String>();
		for (int i = text.length() - 1; i >= 0; i--) {
			result.push(text.charAt(i) + "");
		}
		return result;
	}

	private String parassatanWord(Stack<String> s) {
		StringBuffer sb = new StringBuffer();
		while (!s.isEmpty()) {
			String element = s.pop();
			if (element.equals("(")) {
				String result = parasBracketStatck(s);
				sb.append(result);
			} else {
				sb.append(element);
			}
		}
		return sb.toString();
	}

	public String convertSantWordToHuman(String value) {

		Stack<String> s = getStack(value);

		value = parassatanWord(s);

		value = getHumanChar(value);

		return getHumanWorld(value);
	}

	private String getHumanChar(String satanWord) {
		while (isContainKeyWorld(satanWord)) {
			Set<String> keys = PrjConstance.EVAIL_LANGAUGE_COVERTOR.keySet();
			for (String key : keys) {
				satanWord = satanWord.replaceAll(key,
						PrjConstance.EVAIL_LANGAUGE_COVERTOR.get(key));
			}
		}
		return satanWord;
	}

	private String getHumanWorld(String satanWord) {
		Set<String> keys = PrjConstance.KEY_TO_HUMAN_LANGUAGE.keySet();
		for (String key : keys) {
			satanWord = satanWord.replaceAll(key,
					PrjConstance.KEY_TO_HUMAN_LANGUAGE.get(key));
		}
		return satanWord;
	}

	private boolean isContainKeyWorld(String satanWord) {
		for (int i = 0; i < satanWord.length(); i++) {
			if (PrjConstance.EVAIL_LANGAUGE_COVERTOR.containsKey(satanWord
					.charAt(i) + "")) {
				return true;
			}
		}
		return false;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String value = "B(ehnxgz)B";
		SatanConvertor satan = new SatanConvertor();
		System.out.println(satan.convertSantWordToHuman(value));
	}
}