华为OJ机试训练(一)

华为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 + "]";
		}
		
		
	}
}







版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/115906.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号