当前位置:   article > 正文

华为机试题Java实现(附详解)_华为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

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

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/183274
推荐阅读
相关标签
  

闽ICP备14008679号