华为机试专辑【6-10题】

最新推荐文章于 2024-04-29 23:18:05 发布

原创最新推荐文章于 2024-04-29 23:18:05 发布 · 505 阅读

0 ·

CC 4.0 BY-SA版权

牛客网专栏收录该内容

24 篇文章

订阅专栏

本文提供了一系列算法实现，包括正整数的质因数分解、浮点数四舍五入、合并重复索引记录、去除整数重复数字及计算字符串不同字符数量等，每项算法都附带了详细的代码示例。

题目描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）
最后一个数后面也要有空格
详细描述：
函数接口说明：
public String getResult(long ulDataInput)
输入参数：
long ulDataInput：输入的正整数
返回值：
String
输入描述:
输入一个long型整数
输出描述:
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
输入例子:
180
输出例子:
2 2 3 3 5

思考：刚开始由于思维定式，我以为必须先求出long范围以内的质数，然后用给出的数ulDataInput 不断的去除求出的质数，最后排序！其实从2到ulDataInput 按照顺序去除就可以，而且可以被其整除的一定是质数，而且是有序的。

#include<iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
using namespace std;
string getResult(long ulDataInput);
string long_to_string(long n);
int main()
{
    long input;
    while(cin >> input) {
        cout << getResult(input) << endl;
    }
    return 0;
}

string getResult(long ulDataInput) {
    long bound = ulDataInput;
    long input = ulDataInput;
    string res = "";
    for(long  i = 2; i <= bound; i++) {
        while(input%i == 0) {
            res += long_to_string(i);
            res += " ";
            input /= i;
        }
    }
    return res;
}
//long 转 string
string long_to_string(long n)
{
    ostringstream stream;
    stream << n;  //n为long类型
    return stream.str();
}

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()) {
            long num = scanner.nextLong();
            System.out.println(getResult(num));
        }
    }
    public static String getResult(long ulDataInput) {
        long bound = ulDataInput;
        long num = ulDataInput;
        String res = "";
        for(long i = 2; i <= bound; i++) {
            while(num%i == 0) {
                res += String.valueOf(i);
                res += " ";
                num /= i;
            }
        }
        return res;
    }
}

题目描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
输入描述:
输入一个正浮点数值
输出描述:
输出该数值的近似整数值
输入例子:
5.5
输出例子:
6

#include<iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
using namespace std;
int main()
{
    double input;
    while(cin >> input) {
        cout << (long long)(input + 0.5) << endl;
    }
    return 0;
}

#include<iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
using namespace std;
int main()
{
    double input;
    while(cin >> input) {
        long long value = (long long)input;
        double remain = input - value;
        if(remain >= 0.5) {
            cout << value + 1 << endl;
        } else {
            cout << value << endl;
        }
    }
}

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()) {
            double input = scanner.nextDouble();
            long value = (long)input;
            double remain = input - value;
            if(remain >= 0.5) {
                System.out.println(value + 1);
            } else {
                System.out.println(value);
            }
        }
    }
}

题目描述
数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
输入描述:
先输入键值对的个数
然后输入成对的index和value值，以空格隔开
输出描述:
输出合并后的键值对（多行）
输入例子:
4
0 1
0 2
1 2
3 4
输出例子:
0 3
1 2
3 4

#include<iostream>
#include <cstdio>
#include <map>
using namespace std;
int main()
{
    int inputNum;
    cin >> inputNum;
    int key, value;
    map<int, int> myMap;
    map<int, int>::iterator it;
    for(int i = 0; i < inputNum; i++) {
        cin >> key >> value;
        it = myMap.find(key);
        if(it == myMap.end()) {
            myMap[key] = value;
        } else {
            myMap[key] += value;
        }
    }
    for(it = myMap.begin(); it != myMap.end(); it++) {
        cout << it->first << " " << it->second;
        cout << endl;
    }
    return 0;
}

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int inputNum = scanner.nextInt();
        Map<Integer, Integer> myMap = new TreeMap<Integer, Integer>();
        int key, value;
        for(int i = 0; i < inputNum; i++) {
            key = scanner.nextInt();
            value = scanner.nextInt();
            if(myMap.containsKey(key)) {
                myMap.put(key, myMap.get(key) + value);
            } else {
                myMap.put(key, value);
            }
        }
        for(Integer resKey : myMap.keySet()) {
            System.out.println(resKey + " " + myMap.get(resKey));
        }
    }
}

题目描述
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
输入例子:
9876673
输出例子:
37689
思考：因为数字一空0到9所以在判断重复的时候可以用hash的思维提高效率！

#include<iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
    int inputNum;
    scanf("%d", &inputNum);
    bool is_exist[12];
    int result = 0;
    //is_exist 判断是否出现过，出现过为true，否则为false
    memset(is_exist, false, sizeof(is_exist));
    while(inputNum) {
        int part = inputNum%10;
        if(is_exist[part] == false) {
            is_exist[part] = true;
            result = result *10 + part;
        }
        inputNum /= 10;
    }
    cout << result << endl;
    return 0;
}

import java.util.Arrays;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int inputNum = scanner.nextInt();
        boolean is_exist[] = new boolean[12];
        int result = 0;
        Arrays.fill(is_exist, false);
        while(inputNum != 0) {
            int part = inputNum%10;
            if(is_exist[part] == false) {
                is_exist[part] = true;
                result = result*10 + part;
            }
            inputNum /= 10;
        }
        System.out.println(result);
    }
}

题目描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
输入例子:
abc
输出例子:
3

#include<iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
    string str;
    bool is_exist[128];
    memset(is_exist, false, sizeof(is_exist));
    getline(cin, str);
    int cnt = 0;
    for(unsigned i = 0; i < str.length(); i++) {
        int index = (int)str[i];
        if(is_exist[index] == false) {
            is_exist[index] = true;
            cnt++;
        }
    }
    cout << cnt << endl;
    return 0;
}

import java.util.Arrays;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        boolean is_exist[] = new boolean[128];
        int cnt = 0;
        Arrays.fill(is_exist, false);
        for(int i = 0; i < str.length(); i++) {
            int index = (int)str.charAt(i);
            if(is_exist[index] == false) {
                cnt++;
                is_exist[index] = true;
            }
        }
        System.out.println(cnt);
    }
}