题目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();
}
}实现“十七进制”转“十进制”算法：输入一个十七进制数字的字符串(字母一律大写)，输出这个数值对应的十进制结果，达到进制转换目的，范围：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);
}
}
状态机——
背景：状态机在计算机各个领域中使用非常广泛，最简单的状态机包含一组状态集（states）、一个起始状态（start state）、状态间转换条件（transition condition）。
要求：根据定义的脚本构造出状态机，并根据脚本进行状态迁移，或输出状态。
脚本包含如下关键字：
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 + "]";
}
}
}
原文地址：http://blog.csdn.net/linfeng24/article/details/33790565
