华为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)


相关推荐

  • 高通linux-串口笔记「建议收藏」

    高通linux-串口笔记「建议收藏」概述驱动:drivers/tty/serial/msm_serial_hs_lite.c:低速版本,设备树内容配置为compatible="qcom,msm-lsuart-v14";msm_serial_hs.c:高速版本, 设备树内容配置为compatible="qcom,msm-hsuart-v14"; 2.分析设备树内容 uart_cons…

  • a算法求解八数码问题_a*算法解决八数码问题python

    a算法求解八数码问题_a*算法解决八数码问题python前面见过宽度优先搜索和深度优先搜索求解八数码问题。那两个方法都是盲目搜索。今天看启发式搜索。A算法:利用评价函数来选择下一个节点。图引用自-北京联合大学彭涛老师在中国慕课的《人工智能概论》。估价函数没有定论,可以有不同方法。这里采用处在错误位置的数字的数量。代码在:github一组测试数据的执行搜索的过程如下:A*算法(宽度优先)求解八数码问题==========宽度优先求解八数码问题,搜索过程是==========[[203..

    2022年10月26日
  • 将Matplotlib绘制的图显示到Tkinter中(详细教程)

    将Matplotlib绘制的图显示到Tkinter中(详细教程)

  • 振动与频谱分析_10频震动什么意思

    振动与频谱分析_10频震动什么意思

    2022年10月15日
  • 农林业遥感图像分类研究[通俗易懂]

    农林业遥感图像分类研究[通俗易懂]遥感图像处理是数字图像处理技术中的一个重要组成部分,长期以来被广泛应用于农林业的遥感测绘,防灾减灾等领域。本文旨在通过深度学习技术从遥感影像中分类出农田和林业地块。手工从遥感图像中分类出农田和林业区域分类虽然准确但是效率低下,并且很多采用传统图像分割技术的方法泛化性能差,不适合场景复杂的遥感图像。经实践证明,使用深度学习技术在各种计算机视觉任务中都取得了良好的效果,因此本文首先使用先进的深度学习框…

  • android空格字符串_v1d空格复制

    android空格字符串_v1d空格复制&amp;#32;==普通的英文半角空格&amp;#160;==&amp;nbsp;==&amp;#xA0;==no-breakspace(普通的英文半角空格但不换行)&amp;#12288;==中文全角空格(一个中文宽度)&amp;#8194;==&amp;ensp;==en空格(半个中文宽度)&amp;#8195;==&amp;emsp;…

发表回复

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

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