【华为机考刷题】2022_6_14

isaaak

已于 2022-06-14 17:37:21 修改

阅读量1.7k

点赞数 1

分类专栏：代码文章标签：华为 java

于 2022-06-14 10:59:36 首次发布

本文链接：https://blog.csdn.net/qq_43283474/article/details/125273888

版权

代码专栏收录该内容

2 篇文章 1 订阅

订阅专栏

【机考练习地址】机考练习地址（供参考）:
https://www.nowcoder.com/ta/huawei

HJ1 字符串最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        int current=0;
        char br=' ';
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)==br)//查询一个字符串某个字符是什么
            {
                current=0;
            }else{
                current++;
            }
        }
        System.out.println(current);
    }
    
}

HJ2 计算某字符出现次数

写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine().toLowerCase();
        char s=sc.nextLine().toLowerCase().charAt(0);
        int count=0;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)==s){
                count++;
            }
        }
        System.out.println(count);
    }
}

HJ3 明明的随机数

明明生成了N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。

import java.util.*;
 
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();//nextint在java中是取下一个随机的整数
        TreeSet<Integer> set = new TreeSet<>();//遍历集合时，输出的所有元素是有序的
//         for(int i=0;i<num;i++){
//             int r=new Random().nextInt(500);
//             set.add(r);
//         }
        for(int i=0;i<num;i++){
            set.add(sc.nextInt());
        }
        for(Integer i:set){
            System.out.println(i);
        }       
    }
}

HJ4 字符串分隔

输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);       
        while(sc.hasNextLine()){
            String str = sc.nextLine();
            while(str.length()>8){
                System.out.print(str.substring(0,8));
                System.out.print("\n");
                str=str.substring(8);               
            }
            str=str+"00000000";
            System.out.println(str.substring(0,8));
        }
    }
}

HJ5 进制转换

写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。

import java.util.*;
 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String s=sc.nextLine();
            System.out.println(Integer.parseInt(s.substring(2,s.length()),16));
        }
    }
}

HJ6 质数因子

功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        long num=sc.nextLong();
        long k=(long)Math.sqrt(num);
        for(long i=2;i<=k;i++){
            while(num%i==0){
                System.out.print(i+" ");
                num/=i;
            }
        }
        System.out.println(num == 1 ? "": num+" ");
}

HJ7 取近似值

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。数据范围：保证输入的数字在 32 位浮点数范围内

import java.util.*;
 
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        float s=sc.nextFloat();
        if((s-(int)s)>=0.5){
            s=(int)s+1;
            System.out.println((int)s);
        }else{
            s=(int)s;
            System.out.println((int)s);
        }
         
    }
}

HJ8 合并表记录

数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
提示:
0 <= index <= 11111111
1 <= value <= 100000

// import java.util.*;

// public class Main{
//     public static void main(String[] args){
//         Scanner sc =new Scanner(System.in);
//         TreeMap<Integer,Integer> map=new TreeMap<>();
//         int n=sc.nextInt();
//         for(int i=0;i<n;i++){
//             int key=sc.nextInt();
//             int value=sc.nextInt();

//             if(!map.containsKey(map)){
//                 map.put(key,value);
//             }else{
//                 map.put(key,map.get(key)+value);//Map.get方法——返回指定键所映射的值
//             }
//         }
        
//         for (Integer i:map.keySet()){//Map.keySet()方法：获取Map集合的所有键名
//             System.out.println(i+" "+map.get(i));
//         }
        
//     }
// }


import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        TreeMap<Integer, Integer> map = new TreeMap<>(); // 输出结果要求有序！
        while(sc.hasNextInt()){
            int n = sc.nextInt();
            for(int i = 0; i < n; i++){
                int key = sc.nextInt();
                int value = sc.nextInt();
                map.put(key,map.getOrDefault(key,0) + value);
                //getOrDefault() 方法获取指定 key 对应对 value，
                //如果找不到 key ，则返回设置的默认值
            }
        }
        for (Integer i : map.keySet()) {
            System.out.println(i + " " + map.get(i));
        }
    }
}

HJ9 提取不重复的整数

输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。

import java.util.*;
 
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
         
        //逆序排列
        //StringBuilder对象则代表一个字符序列可变的字符串，
        //当一个StringBuilder被创建以后，通过StringBuilder提供的
        //append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变
        //这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，
        //就可以调用它的toString()方法将其转换为一个String对象。
        StringBuilder sb=new StringBuilder(sc.nextLine()).reverse();
        String str=sb.toString();
         
        //结果集
        StringBuilder result=new StringBuilder();
         
        for(int i=0;i<str.length();i++){
            if(str.indexOf(str.charAt(i))==i){
                //indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置
                result.append(str.charAt(i));
                //append()向列表添加元素
            }
        }
        System.out.println(result.toString());
 
         
    }
}

HJ10 字符个数统计

编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。

import java.util.*;

public class Main{
        public static void main(String[] args){
            Scanner sc=new Scanner(System.in);
            String str=sc.next();//next() 返回迭代器的下一个项目
            HashSet<Character> hs=new HashSet<Character>();
            //将字符串转换为字符数组,获取每一个字符存储在HashSet集合中,自动去除重复
            for(int i=0;i<str.length();i++){
                hs.add(str.charAt(i));
            }
            System.out.println(hs.size());
        }
}

HJ11 数字颠倒(上一题的简单版)

输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

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

HJ12 字符串反转

接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
输入描述：
输入一行，为一个只包含小写字母的字符串。
输出描述：
输出该字符串反转后的字符串。

import java.util.*;

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

HJ13 句子逆序

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        String s[]=str.split(" ");//以空格分隔单词
        for(int i=s.length-1;i>=0;i--){
            if(i!=0)
                System.out.print(s[i]+" ");//倒序输出boy a am I
            else
                System.out.print(s[i]);
        }        
    }
}