华为OJ机试训练（一）

题目1 ——

通过输入英文句子。将每一个单词反过来，标点符号顺序不变。非26个字母且非标点符号的情况就可以标识单词结束。

标点符号包含,.!?

比如输入：Hello, I need an apple.

输出：

/**
 * 华为机试训练1： 通过输入英文句子，将每一个单词反过来。标点符号顺序不变。非26个字母且非标点符号的情况就可以标识单词结束。 标点符号包含,.!?
 * Hello, I need an apple.
 *
 * @author snail
 *
 */
public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = scanner.nextLine();
		scanner.close();
		String[] ssString = string.split("\\W+");
		String[] s2 = string.split("\\w+");

	int wordsNum = ssString.length;
	for (int i = 0; i < wordsNum; i++) {

	if (s2.length >= wordsNum) {
		int j = ssString[i].length() - 1;
		for (; j > -1; j--) {
			System.out.print(ssString[i].charAt(j));
		}
		System.out.print(s2[i + s2.length - wordsNum]);
	} else {

	System.out.print(s2[i - s2.length + wordsNum]);
	int j = ssString[i].length() - 1;
	for (; j > -1; j--) {
		System.out.print(ssString[i].charAt(j));
	}
	}

	}
	System.out.println();
	}

}

题目2——

实现“十七进制”转“十进制”算法：输入一个十七进制数字的字符串(字母一律大写)，输出这个数值相应的十进制结果。达到进制转换目的，范围：0-0xFFFFFFFF。

我的程序——

/**
 * 实现“十七进制”转“十进制”算法：
 * 输入一个十七进制数字的字符串(字母一律大写)，
 * 输出这个数值相应的十进制结果，达到进制转换目的，
 * 范围：0-0xFFFFFFFF。

* @author snail
 *
 */
public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = scanner.nextLine();
		scanner.close();
		double result = 0;
		int length = string.length();
		double temp = 0;
		char tempChar = '0';
		int bitvalue = 0;
		for (int i = 0; i < length; i++) {
			tempChar = string.charAt(length -i-1);
			if (!Character.isDigit(tempChar)) {
				if (tempChar>=0x40 && tempChar <=0x46) {
					bitvalue = tempChar - 0x41 +10;
				}else {
					bitvalue = tempChar - 0x61 +10;
				}
			}else {
				bitvalue = tempChar - 0x30;
			}

			temp = bitvalue * Math.pow(17, i);
			result += temp;
		}
		System.out.println(result);
	}
}

题目3——

状态机——

背景：状态机在计算机各个领域中使用很广泛。最简单的状态机包括一组状态集（states）、一个起始状态（start state）、状态间转换条件（transition condition）。

要求：依据定义的脚本构造出状态机，并依据脚本进行状态迁移，或输出状态。

脚本包括例如以下keyword：

Insert  插入状态或迁移条件

语法是Insert 状态1,状态2,条件1

第一条Insert语句的第一个状态默觉得状态机的起始态。

假设状态1或状态2不存在，则新增状态1或状态2，假设状态1在条件1下已经存在其它迁移状态，则Insert失败。并输出Error字符串。

Delete 删除状态或迁移条件，

语法是Delete 状态1/条件1

当删除状态1时。状态1所关联的全部条件全被删除，Delete起始态将删除整个状态机，删除当前活动状态时，无效并输出Error字符串，删除的条件或状态不存在，输出Error字符串。

Input 状态机接收新条件

语法是 Input 条件1

当前状态在条件1下有正确的迁移状态时。状态机迁移到下一个状态，假设在条件1下没有正确的迁移状态时。保持在当前状态，并输出Error字符串；假设当前状态机没有状态。相同输出Error字符串。

Output 输出当前状态

语法是Output。假设当前状态机不存在。输出Error字符串，否则输出当前状态名.

End 结束命令

语法是End。收到该命令，脚本执行结束，忽略后面的脚本

说明：输入脚本命令正确，不用考虑异常情况

例子输入：

Insert Sa,Sb,C1

Insert Sb,Sc,C2

Insert Sb,Sd,C3

Insert Sc,Se,C4

Insert Sd,Se,C5

Insert Se,Sa,C6

Input C1

Delete Sc

Input C2

Output

Input C3

Output

End

输出是 ：

Error

Sb

Sd

我的程序——感觉写得非常垃圾，没有找到合适的方法来表示这个状态。懂的朋友请指点下。

package tree.test;

import java.util.ArrayList;
import java.util.Scanner;

/**
 * 状态机
 * 20:03
 * @author snail
 *
 */
public class Main {
	private static ArrayList<Status> statusList = new ArrayList<Main.Status>();
	private static String currentStatus ;
	 private static Status firstStatus ;
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = "";
		ArrayList<String> inputList = new ArrayList<String>();
		while(!(string=scanner.nextLine()).equals("End")){
			inputList.add(string);
		}
		int length = inputList.size();
		String temp = "";
		for (int i = 0; i < length; i++) {
			temp = inputList.get(i);
			if (temp.contains("Insert")) {
				insert(temp);

			}else if (temp.contains("Delete")) {
				delete(temp);
				System.out.println("debug-Delete --剩下"+statusList.size());
			}else if (temp.contains("Input")) {

				input(temp);
				System.out.println("当前状态："+currentStatus.toString());
			}else if (temp.contains("Output")) {
				output();
				//System.out.println("Output"+statusList.toString());
			}
		}

		System.out.println();
	}

	private static void insert(String string){
		String[] ss = string.split(" ");
		String dataString = ss[1];
		String[] insertStrings = dataString.split(",");
		String currentString = insertStrings[0];
		String nextString = insertStrings[1];
		String requireString = insertStrings[2];
		int size = statusList.size();
		boolean existFlag = false;
		for (int i = 0; i < size; i++) {
			if (statusList.get(i).getCurrentStatus().equals(currentString)&&
					statusList.get(i).getRequireString().equals(requireString)&&
					!statusList.get(i).getNextStatus().equals(nextString)
					 ) {
				existFlag = true;
				break;
			}
		}
		if (existFlag) {
			System.out.println("Error");
			return ;
		}else {
			Status status = new Status();
			status.setCurrentStatus(currentString);
			status.setRequireString(requireString);
			status.setNextStatus(nextString);
			if(statusList.size() == 0){
				firstStatus = status;
				currentStatus = currentString;
			}
			statusList.add(status);

		}

	}

	/**
	 * 删除
	 * @author snail
	 *
	 */
	private static void delete(String string){
		String[] ss = string.split(" ");
		String deleteString = ss[1];

		if (deleteString == currentStatus) {
			System.out.println("Error");
			return ;
		}else if(deleteString == firstStatus.getCurrentStatus()){
			statusList.clear();
			return ;
		}

		for (int i = 0; i < statusList.size(); i++) {
			Status status = statusList.get(i);
			//删除状态
			if (status.getCurrentStatus().equals(deleteString)) {
				for (int j = 0; j < statusList.size(); j++) {
					if (statusList.get(j).getNextStatus().equals(deleteString)) {
						statusList.get(j).setRequireString("");//删除有关的条件
						//statusList.remove(j);
					}
				}
				statusList.remove(i);
				return ;
			}
			//删除条件
			if (status.getRequireString().equals(deleteString)) {

				statusList.remove(i);
				return ;
			}
		}

		//不存在
		System.out.println("Error");
		return ;
	}

	private static void input(String string){
		String[] ss = string.split(" ");
		String inputString = ss[1];
		if (currentStatus == null) {
			System.out.println("debug-input -- null");
			System.out.println("Error");
			return ;
		}
		ArrayList<Status> currentList = new ArrayList<Main.Status>();
		for (int i = 0; i < statusList.size(); i++) {
			if (statusList.get(i).currentStatus.equals(currentStatus)) {
				currentList.add(statusList.get(i));
			}
		}
		boolean exist = false;
		for (int i = 0; i < currentList.size(); i++) {
			//System.out.println("debug-input --require:"+currentStatus.requireString+",input :"+inputString);
			if (currentList.get(i).requireString.equals(inputString) ) {
				String nextString = currentList.get(i).getNextStatus();
			//	System.out.println("debug-input -- 当前状态中有该条件");
				//System.out.println("debug-input -- 下一个状态是"+nextString);
				int size = statusList.size();

				//寻找下一个状态
				for (int j = 0; j < size; j++) {
					if (statusList.get(i).getCurrentStatus().equals(nextString)) {
						currentStatus = statusList.get(j).getCurrentStatus();
						exist = true;
						break;
					}
				}

		}

			if (exist) {
				return ;
			}else {

			//	System.out.println("debug-input -- 没有该迁移状态");
				System.out.println("Error");
				return ;
			}}
		{
				//System.out.println("debug-input -- 没有该迁移条件");
				System.out.println("Error");
				return ;
			}	

	}

	private static void output(){
		if (currentStatus == null) {
			System.out.println("Error");
			return ;
		}else {
			System.out.println(currentStatus);
			return ;
		}
	}

	public static class Status{
		private String currentStatus;
		private String requireString;
		private String nextStatus;
		public String getCurrentStatus() {
			return currentStatus;
		}
		public void setCurrentStatus(String currentStatus) {
			this.currentStatus = currentStatus;
		}
		public String getRequireString() {
			return requireString;
		}
		public void setRequireString(String requireString) {
			this.requireString = requireString;
		}
		public String getNextStatus() {
			return nextStatus;
		}
		public void setNextStatus(String nextStatus) {
			this.nextStatus = nextStatus;
		}
		@Override
		public String toString() {
			return "Status [currentStatus=" + currentStatus
					+ ", requireString=" + requireString + ", nextStatus="
					+ nextStatus + "]";
		}

	}
}