华为机试题Java实现(附详解)_华为java机考是考什么?

华为机试题Java实现(附详解，持续更新)

本文章是我做的华为机试题目，有些是自己写的，有些是参考解答，都做了详细备注，都能看懂，有时间陆陆续更新完。

1. 计算一个字符串最后一个单词长度，单词用空格隔开
思路：本题使用split()方法将字符串按空格切割成字符串数组保存即可，数组最后一个元素（字符串）的长度即为答案。

import java.util.Scanner;
public class Main{
 public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String strs = sc.nextLine();
            lengthOfLastString(strs);
        }

         static  void lengthOfLastString(String strs){
            String[] arr = strs.split(" ");
             System.out.println(arr[arr.length - 1].toCharArray().length);
        }

1
2
3
4
5
6
7
8
9
10
11
12
13

要注意的是：1.若String结尾是空格，可以使用split(" ",-1)解决，原生split是不识别末尾元素的；
2.特殊分割要使用转译符

2. 写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入输入字符串中含有该字符的个数。不区分大小写

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String strs = sc.nextLine();
        //将输入的字符串转成char型便于比较
        char ch1 = sc.nextLine().charAt(0);
        int count = 0;
        char[] arrs = strs.toCharArray();
        for(char ch : arrs){
            //char类型没有忽略大小写比较，但是可以直接将都转成大写或者小写比较
            if(Character.toUpperCase(ch) == Character.toUpperCase(ch1)){
                count++;
            }
        }
        System.out.println(count);
    }
   }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. 明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)

import java.util.Scanner;
import java.util.TreeSet;
public class Main{
    //要求不重复-set
    //不重复的同时还要有序-TreeSet
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        //不接收到停止符号就一直输入，默认键盘crtl+z停止，或者给终止符sc.hasNext(‘0’)
        while(sc.hasNext()){
            int n = sc.nextInt();//随机数由输入产生
            TreeSet<Integer> treeSet = new TreeSet<Integer>();//要装包装类型
            if(n > 0){
                for(int i = 0;i < n;i++){//自动装箱
                    //将由输入产生的随机数加入set,重复的加不进,默认按照自然排序
                    treeSet.add(sc.nextInt());
                }
           
            }
            for(Integer i : treeSet){
                System.out.println(i);
            }
            
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4. 连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

import java.util.Scanner;
public class Main{
  public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      while(sc.hasNext()){
          String strs = sc.nextLine();
          if(strs.length() %8 != 0){//长度不够8的整数倍补7个0
             strs = strs + "0000000"; 
          }
          while(strs.length() >= 8){
              //现在字符串长度肯定大于等于8，将其8个8个截取，最后扔的肯定是补得0，没有影响
              System.out.println(strs.substring(0,8));//大于8，肯定够截取
              //substring(begin,end),从begin位到end长度分割字符串，不够报错
              strs = strs.substring(8);
          }
         }
      }
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5. 写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入）

a.方法一
使用BigInteger
BigInteger：Java里大数值类，理论上数值不会越界（和计算机内存相关），是个String,但是不能直接赋值，必须调用构造器，里面提供了一些方法例如add等（运算用方法，不是+，-，*，/）。
//16进制转10进制
import java.math.BigInteger;
import java.util.Scanner;
public class sixteethTOten{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str16 = sc.nextLine();
            System.out.println(new BigInteger(str16,16).toString(10));

        }

    }
}

b.方法二
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
			//为什么截取2,因为十六进制数有两种表示方法，fff,0xfff，第二中显然要截取前面的标志
            String str=sc.next().substring(2);
// Integer.parseInt(str,x),将str转成x进制
            System.out.println(Integer.parseInt(str,16));

        }
        
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//自己写实现16-10
public class Main { 
    public static void main(String[] args) { 
        Scanner sc=new Scanner(System.in); 
        while (sc.hasNext()){ 
            StringBuffer sb=new StringBuffer(); 
            sb.append(sc.next()); 
            //String str=sc.next(); 
            String str=sb.reverse().substring(0,sb.length()-2); 
            char ch[]=str.toCharArray(); 
            int sum=0; 
            for(int i=0;i<ch.length;i++){ 
                if(ch[i]>='A'&&ch[i]<='F'){ 
                    sum+=(Integer.valueOf(ch[i])-55)*Math.pow(16,i); 
                }else { 
                    sum+=(Integer.valueOf(ch[i])-48)*Math.pow(16,i); 
                } 
            } 
            System.out.println(sum); 
           // System.out.println(Integer.valueOf('6')); 
        } 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

**6. 题目描述
数据表记录包含表索引和数值（int范围的整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。

输入描述: 先输入键值对的个数 然后输入成对的index和value值，以空格隔开

输出描述: 输出合并后的键值对（多行）**
1
2
3

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class mapQuChong {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

        while(sc.hasNext()){
//TreeMap按照Key的自然大小排序
            Map<Integer,Integer> map = new TreeMap<Integer,Integer>();
            int n = sc.nextInt();
            for(int i = 0;i < n;i++){
                int k = sc.nextInt();
                int value = sc.nextInt();
                //如果键已经存在则合并
                if(map.containsKey(k)){
                    map.put(k,map.get(k) + value);
                }else{
                    //不存在就说明无键重复，加入map
                    map.put(k,value);
                }
            }
            //输出map
            for(Integer key: map.keySet()){
                System.out.println(key + " " + map.get(key));
            }
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

7. 输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int result = 0;
        //构建一个十大小的数组，将反向遍历的数的下标位置标记成1，每次判断该数组下标位置是否为0，即可判断是否重复
        int[] arr = new int[10];
        while(num != 0){
            //从最后一位遍历，反向int
            if(arr[num%10] == 0){
                result = result*10 + num%10;//实现从右到左
                arr[num%10]++;//将该数字对应下标值置1
                num /= 10;
            }else{
                //该位置下标值不为0，说明有重复，直接删除
                num /= 10;
            }
        }
        System.out.println(result);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8. 编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。注意是不同的字符

import java.util.Scanner;
public class StringBuChong {
    public static  void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int count = 0;
        for(int i = 0;i < str.length();i++){
            //判断每一个字符是否在范围内，并且是否是唯一,indexOf该字符在字符串中首次出现的索引位置，lastIndexOf,最后出现位置
            if(str.charAt(i) > 0 && str.charAt(i)< 127 &&
                    str.indexOf(str.charAt(i)) == i){
                count++;
            }
        }
        System.out.println(count);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

9. 输入描述:
输入一个int整数
输出描述:
将这个整数以字符串的形式逆序输出

import java.util.Scanner;

public class intReverse {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        String str = num + "";
        char[] chars = str.toCharArray();
        char[] rechars = new char[str.length()];
        for(int i = str.length()-1;i >= 0;i--){
            rechars[str.length()-1-i] = chars[i];
        }
        //String result = rechars.toString();
        String result = new String(rechars);
        System.out.println(result);
    }
}
/**
 * int转String
 *  1.int+"";
 *  2.public String toString()
 *
 * String转int
 * public static int parseInt(String s)
 *
 * String转Integer
 * public static Interger valueOf(String s)
 *
 * String转char[]
 * String.toCharArray()
 *
 * char[]转String
 *  1.String string1 = new String(chars);
    2.String string2 = String.valueOf(chars);
 *
 */


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

10.字符串反转（也可以用8的方式）

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        StringBuffer restr = new StringBuffer(str);
        System.out.println(restr.reverse().toString());
        
    }
}

1
2
3
4
5
6
7
8
9
10
11

先更新十题，后面的题目要涉及一些算法了，整理好了再更新