华为机试day2

最新推荐文章于 2024-08-15 08:18:49 发布

mhl119

最新推荐文章于 2024-08-15 08:18:49 发布

阅读量545

点赞数

CC 4.0 BY-SA版权

分类专栏：华为机试

本文链接：https://blog.youkuaiyun.com/mhl119/article/details/50405629

华为机试专栏收录该内容

3 篇文章

订阅专栏

这篇博客主要介绍了华为机试中的一些编程题目，包括质数因子的分解、浮点数取整、合并表记录、统计字符串中不同字符个数的算法。还探讨了Math类的取整方法，Comparator和Comparable接口的比较，以及Collections类在排序算法中的应用。通过示例代码展示了如何实现这些功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、题目
1、质数因子

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

详细描述：

函数接口说明：

public String getResult(long ulDataInput)

输入参数：

long ulDataInput：输入的正整数

返回值：

String

import java.util.ArrayList;
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            long uldataInput = in.nextLong();
            String str = getResult(uldataInput);
            System.out.println(str);
        }
    }
 
    public static String getResult(long ulDataInput) {
        ArrayList<Long> list = new ArrayList<Long>();
        String str = "";
        long tempInput = ulDataInput;
        for (long i = 2; i * i < ulDataInput; i++) {
            while (tempInput % i == 0 && tempInput != 1) {
                list.add(i);
                tempInput = tempInput / i;
            }
        }
        if (tempInput != 1 || tempInput == ulDataInput) {
            list.add(tempInput);
        }
        for (int j = 0; j < list.size(); j++) {
            str += list.get(j) + " ";
        }
        return str;
    }
 
}

2、取近似值

写出一个程序，接受一个浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

`importjava.util.Scanner;`

`publicclassMain {`

    `publicstaticvoid` `main(String[] args) {`

        `// TODO Auto-generated method stub`

        `Scanner in =` `newScanner(System.in);`

        `while(in.hasNext()) {`

            `doubleval = in.nextDouble();`

            `System.out.println(Math.round(val));`

        `}`

        `in.close();`

    `}`

`}`

添加笔记

3、合并表记录

数据表记录包含表索引和数值。请对表索引相同的记录进行合并，合并后表记录为相同索引表的数值求和

函数说明：

public int mergeRecord(List oriList, List rstList)

数据表记录包含表索引和数值。请对表索引相同的记录进行合并，合并后表记录为相同索引表的数值求和。

@param oriList 原始表记录。以List方式存放，TableRecord定义见TableRecord.java，

调用者无需对leRecord.java做任何修改
@param rstList 合并后的表记录 , 以List方式存放
@return 返回合并后表的个数

import java.util.SortedMap;
import java.util.Scanner;
import java.util.TreeMap;
 
public class Main {
     
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        SortedMap<Integer, Integer> hashMap = new TreeMap<Integer, Integer>();     
         
        while (in.hasNext()) {
            int num = in.nextInt();
            for (int i = 0; i < num; i++) {
                int key = in.nextInt();
                int val = in.nextInt();
                if (hashMap.containsKey(key)) {
                    int myval = hashMap.get(key) + val;
                    hashMap.put(key, myval);
                }else {
                    hashMap.put(key, val);
                }
            }  
             
            for (Integer key: hashMap.keySet()) {
                System.out.println(key+" "+hashMap.get(key));
            }          
        }      
        in.close();
    }      
}

4、提取不重复整数

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

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String newStr="";
        while (in.hasNext()) {
            int num = in.nextInt();
            String str = num+"";
            for(int i=str.length()-1;i>=0;i--){
                char ch = str.charAt(i);
                String tempStr=ch+"";
                if(!newStr.contains(tempStr)){
                    newStr +=tempStr;
                }
            }
            System.out.println(newStr);
        }
        in.close();
    }
 
}

5、字符个数统计

编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String str = in.nextLine();
            System.out.println(CountCharNum(str)+"");      
        }
    }
     
    public static int CountCharNum(String str){
        int cnt=0;
        int[] arrs = new int[128];
        for(int i=0;i<str.length();i++){
            char ch = str.charAt(i);
            if(arrs[ch] == 0){
                cnt++;
                arrs[ch]=1;
            }                      
        }
        return cnt;
    }
 
}

二、总结
1、常用类

Math类

三角函数方法
指数函数方法
取整方法
ceil（）向上接近整数
floor（）向下接近整数
rint（）最近的整数
round（）返回为int或long
random方法

集合

java集合框架支持两种容器

1、Collection：一种是为了存储一个元素集合，简称集合

2、Map：另一种是为了存储键/值对，简称为图

集合（Collection）有三种类型的集合

1、规则集Set：存储一组不重复的元素

（1）HashSet散列集：不可预知的顺序存储元素

（2）LinkedHashSet链式散列集：以元素被插入的顺序存储元素

（3）TreeSet树形集：存储以排好序的元素。（例如升序降序）

2、线性表List：有元素构造的有序集合

（1）ArrayList数组线性表：查找比较方便，但插入删除的复制度为O（N）

（2）LinkedList链表：可以在任意位置插入数据O（1）

3、队列Queue：存储先进先出方式处理对象

4、Vector接口实现了List接口，在java2 中，Vector和ArrayList是一样的，所不同的是它所包含的访问和就向量的方法是同步的，

Stack类扩张了Vector类，并且提供了几种对栈进行操作的方法

java集合框架所有类都实现了java.lang.cloneable和java.io.serializable接口，都是可复制和可序列化的

java集合框架所有类都包含两个构造函数，一个空的参数，一个Collection参数

图（Map）

1、HashMap散列图：不需要保持图中元素的顺序，就使用HashMap

2、LinkedHaspMap链式散列图：需要保持图中元素的插入顺序或访问顺序，就使用LinkedHashMap

3、TreeMap树形散列图:需要使图按照键值排序，就使用TreeMap

SortedMap类

2、算法

统计字符个数函数中，用到了
int[] arrs = new int[124]
if(arrs[chvalue] == 0)
cnt++;
arrs[chvalue] = 1;

3、Comparor接口和Comparable接口的比较

当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。下面通过两个例子分别用Comparable和Comparator实现对User对象中年龄排序。

1.通过实现Comparable接口，根据User的年龄进行排序。

Java代码  

import java.util.Arrays;  

/** 

 * @author pengcqu 

 *  

 */  

public class ComparableUser implements Comparable {  

    private String id;  

    private int age;  

    public ComparableUser(String id, int age) {  

        this.id = id;  

        this.age = age;  

    }  

    public int getAge() {  

        return age;  

    }  

    public void setAge(int age) {  

        this.age = age;  

    }  

    public String getId() {  

        return id;  

    }  

    public void setId(String id) {  

        this.id = id;  

    }  

    public int compareTo(Object o) {  

        return this.age - ((ComparableUser) o).getAge();  

    }  

    /** 

     * 测试方法 

     */  

    public static void main(String[] args) {  

        ComparableUser[] users = new ComparableUser[] {  

                new ComparableUser("u1001", 25),  

                new ComparableUser("u1002", 20),  

                new ComparableUser("u1003", 21) };  

        Arrays.sort(users);  

        for (int i = 0; i < users.length; i++) {  

            ComparableUser user = users[i];  

            System.out.println(user.getId() + " " + user.getAge());  

        }  

    }  

}

2. 通过实现Comparator接口，根据User的年龄进行排序。

Java代码  

public class User {  

    private String id;  

    private int age;  

    public User(String id, int age) {  

        this.id = id;  

        this.age = age;  

    }  

    public int getAge() {  

        return age;  

    }  

    public void setAge(int age) {  

        this.age = age;  

    }  

    public String getId() {  

        return id;  

    }  

    public void setId(String id) {  

        this.id = id;  

    }  

}

Java代码  

import java.util.Arrays;  

import java.util.Comparator;  

/** 

 * @author pengcqu 

 *  

 */  

public class UserComparator implements Comparator {  

    public int compare(Object arg0, Object arg1) {  

        return ((User) arg0).getAge() - ((User) arg1).getAge();  

    }  

    /** 

     * 测试方法 

     */  

    public static void main(String[] args) {  

        User[] users = new User[] { new User("u1001", 25),  

                new User("u1002", 20), new User("u1003", 21) };  

        Arrays.sort(users, new UserComparator());  

        for (int i = 0; i < users.length; i++) {  

            User user = users[i];  

            System.out.println(user.getId() + " " + user.getAge());  

        }  

    }  

}