华为机试在线训练部分题目练习和记录。
1.字符串最后一个单词的长度
题目描述
计算字符串最后一个单词的长度，单词以空格隔开。
输入描述：
一行字符串，非空，长度小于5000。
输出描述：
整数N，最后一个单词的长度。
示例：
输入：hello world
输出：5
编程
import java.lang.String;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String words = sc.nextLine();
String[] result = words.split(" ");
int len = result.length;
int len_result = result[len-1].length();
System.out.println(len_result);
}
}
讨论
该题目中值得注意的点在于：
- 在用到
Scanner/String及相关方法时别忘了import对应的包。 - 获取数组的长度可利用属性length。
- 获取字符串的长度要用到方法length()。
2.计算字符个数
题目描述
写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述：
第一行输入一个有字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述：
输出输入字符串中含有该字符的个数。
示例：
输入：ABCDEF/n A
输出：1
编程
import java.lang.String;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String aim = sc.nextLine();
String word1 = sc.nextLine();
String word2 = null;
if(word1.compareTo("Z")>0){
word2 = word1.toUpperCase();
}else{
word2 = word1.toLowerCase();
}
int count = getNum(aim,word1) + getNum(aim,word2);
System.out.println(count);
}
public static int getNum(String str,String ch){
String[] str1 = str.split(ch);
int len = str1.length-1;
return len;
}
}
讨论
该题目中值得注意的点在于：
- 大小写字符对应的ascii码值的范围及二者之间的转换（自己在做的时候考虑的是将目标字符分别转换为大小写进行判断，也可以考虑将目标字符串转换为大写或小写）。
- 对于不同的解题思路的积累。
思路1
思路2
思路3——利用正则表达式
3.明明的随机数
题目描述
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。
Input Param
n 输入随机数的个数
inputArray n个随机整数组成的数组
Return Value
OutputArray 输出处理后的随机整数
注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。
输入描述：
输入多行，先输入随机整数的个数，再输入相应个数的整数
输出描述：
返回多行，处理后的结果
示例：
输入：11 10 20 40 32 67 40 20 89 300 400 15
输出：10 15 20 32 40 67 89 300 400
编程
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){ //while循环实现对于多组输入数据的处理
int len = sc.nextInt();
int[] num = new int[len];
for(int i=0;i<len;i++){
num[i] = sc.nextInt();
}
int temp = 0;
for(int m=0; m<len; m++){ //冒泡排序
for(int n=0; n<len-m-1; n++){
if(num[n]>num[n+1]){
temp = num[n];
num[n] = num[n+1];
num[n+1] = temp;
}
}
}
for(int j=0; j<len-1; j++){ //输出时判断是否存在重复数据
if(num[j] != num[j+1]){
System.out.println(num[j]);
}
if(j == len-2){
System.out.println(num[len-1]);
}
}
}
}
}
讨论
该题目中值得注意的点在于：
- 注意对于输入数据的处理，需要进行循环处理。
- 对于不同的解题思路的积累。
思路1——利用TreeSet这一数据结构，其中的数据都是按顺序存储的，并且作为Set，其中也不会包含重复数据。
思路2——java对一个int数组进行排序、去重的思路如下
出处：https://www.cnblogs.com/daleyzou/p/9522533.html
思路：
1、使用 HashSet 进行去重
2、将 HashSet 变为 TreeSet
3、使用 TreeSet 进行排序
4、将 Set 变为 Integer 数组
5、将 Integer 数组变为 int 数组
4.字符串分隔
题目描述
- 连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
- 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：
连续输入字符串(输入2次,每个字符串长度小于100)
输出描述：
输出到长度为8的新字符串数组
示例：
输入：abc 123456789
输出：abc00000 12345678 90000000
编程
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()){
String target = sc.nextLine();
String sub = target;
int len = target.length();
if(len==0){ //空字符串的情况
continue;
}
for(int i=0; (i+8)<=len; ){
String tar = sub.substring(i,i+8);
System.out.println(tar);
target = sub.substring(i+8);
i=i+8;
}
int lengt = 8-target.length();
for(int j=0; j<lengt; j++){
target = target + "0";
}
if(!target.equals("00000000")){ //长度刚好是8的整数倍的情况
System.out.println(target);
}
}
}
}
讨论
该题目中值得注意的点在于：
- 注意对于各种特殊情况的考虑。
- 对于编程的简化。
5.进制转换
题目描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入 ）
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。
示例：
输入：0xA
输出：10
编程
import java.util.*;
import java.lang.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String tar = sc.nextLine().replace("0x","");
String str = Integer.valueOf(tar,16).toString();
System.out.println(str);
}
}
}
讨论
java进制转换——在java.lang包中的Integer类有相应的转换方法：
- toBinaryString(int)：转换为二进制
- toHexString(int i)：转换为十六进制
- toOctalString(int i)：转换为八进制
以上是十进制转化成2，8，16进制。进制之间的任意转化则需要借助十进制作为中间变量。先把其他进制转化为十进制，再把十进制转化为其他进制。
//例如十六进制转化为二进制。
//先把十六进制转化为十进制。
String str = Integer.valueOf("FFFF",16).toString();
//再把十进制转化为二进制。
Integer.toBinaryString(str);
6.质数因子
题目描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）,最后一个数后面也要有空格。
详细描述：
函数接口说明：
public String getResult(long ulDataInput)
输入参数：
long ulDataInput：输入的正整数
返回值：
String
输入描述：
输入一个long型整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
示例：
输入：180
输出：2 2 3 3 5
编程
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long data = sc.nextLong();
for (int i = 2; i < data + 1; i++) {
while (data % i == 0) {
System.out.print(i + " ");
data = data / i;
}
}
}
}
讨论
1.注意System.out.print()和System.out.printIn()的区别，后者输出之后会自动换行。
2.判断一个数是否是质数。
public static boolean isPrime(int n) {
if (n <= 3) {
return n > 1;
}
int sqrt = (int)Math.sqrt(n);
for (int i = 2; i <= sqrt; i++) {
if(n % i == 0) {
return false;
}
}
return true;
}
7.取近似值
题目描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
输入描述：
输入一个正浮点数值
输出描述：
输出该数值的近似整数值
示例：
输入：5.5
输出：6
编程
import java.util.Scanner;
import java.lang.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
Double tar = sc.nextDouble();
int res = (int)(tar + 0.5);
System.out.println(res);
}
}
}
8.合并表记录
题目描述
数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
输入描述：
先输入键值对的个数，然后输入成对的index和value值，以空格隔开
输出描述：
输出合并后的键值对（多行）
示例：
输入：4 0 1 0 2 1 2 3 4
输出：0 3 1 2 3 4
编程
关键：利用数据结构TreeMap（其中的元素默认升序排列）
import java.util.Scanner;
import java.lang.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
Double tar = sc.nextDouble();
int res = (int)(tar + 0.5);
System.out.println(res);
}
}
}
9.提取不重复的整数
题目描述
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述：
输入一个int型整数
输出描述：
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例：
输入：9876673
输出：37689
编程
关键：利用栈的先进后出特性，以及判断字符串中是否包含某个字符的str.contains()函数。
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String result = "";
while(sc.hasNext()){
String str = sc.nextLine();
char[] tar = str.toCharArray();
Stack<Character> one = new Stack<Character>();
for(int i=0; i<tar.length; i++){
one.push(tar[i]);
}
result = result + one.pop();
while(!one.isEmpty()){
char j = one.pop();
if(!result.contains(String.valueOf(j))){
result = result + j;
}
}
System.out.print(result);
}
}
}
10.句子逆序
题目描述
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
接口说明
/**
- 反转句子
- @param sentence 原句子
- @return 反转后的句子
*/
public String reverse(String sentence);
输入描述：
将一个英文语句以单词为单位逆序排放。
输出描述：
得到逆序的句子
示例：
输入：I am a boy
输出：boy a am I
编程
关键：利用字符串分割str.split()函数。
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String[] tar = str.split(" ");
int len = tar.length;
for(int i=len-1; i>=0; i--){
System.out.print(tar[i]+" ");
}
}
}
11.字串的连接最长路径查找
题目描述
给定n个字符串，请对n个字符串按照字典序排列。
输入描述：
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串。
示例：
输入：9 cap to cat card two too up boat boot
输出：boat boot cap card cat to too two up
编程
关键：两种思路，一种是利用基本排序算法，还有一种是利用Arrays.sort(str[]);方法。
//思路1
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int len = sc.nextInt();
String[] tar = new String[len];
for(int i=0; i<len; i++){
tar[i] = sc.next();
}
String[] re = sortStr(tar);
for(int j=0; j<len; j++){
System.out.println(re[j]);
}
}
public static String[] sortStr(String[] xxx){
int lenn = xxx.length;
for(int i=0; i<lenn; i++){
for(int j=0; j<lenn-i-1; j++){
if(xxx[j].compareTo(xxx[j+1])>0){
String temp = xxx[j];
xxx[j] = xxx[j+1];
xxx[j+1] = temp;
}
}
}
return xxx;
}
}
//思路2
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
String [] ss = new String[num];
for (int i = 0; i < num; i++) {
ss[i]=sc.next();
}
Arrays.sort(ss);
for (int i = 0; i < ss.length; i++) {
System.out.println(ss[i]);
}
}
}
讨论
（1）关于sc.next()和sc.nextLine()
注意sc.next()和sc.nextLine()的区别。这里用sc.nextLine()就没法读取到输入的最后一个字符串。
sc.nextLine();不能放在sc.nextInt();代码段后面，否则sc.nextLine();会读入”\n”字符，但”\n”并不会成为返回的字符，
所以看起来有一种“跳过”的假象。
（2）关于Arrays.sort()
Arrays.sort(int[] a)
这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。
Arrays.sort(int[] a, int fromIndex, int toIndex)
这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序。
public static
void sort(T[] a,int fromIndex, int toIndex, Comparator<? super T> c)
上面有一个拘束，就是排列顺序只能是从小到大，如果我们要从大到小，就要使用这种方式。具体示例如下——
package test;
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
//注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
//而要使用它们对应的类
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
//定义一个自定义类MyComparator的对象
Comparator cmp = new MyComparator();
Arrays.sort(a, cmp);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
}
}
}
//Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
//而不是extends Comparator
class MyComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
//如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
//这样颠倒一下，就可以实现反向排序了
if(o1 < o2) {
return 1;
}else if(o1 > o2) {
return -1;
}else {
return 0;
}
}
}