联通1028秋招笔试

2023秋招

笔试真题

发布日期: 2023-10-30

更新日期: 2023-11-01

文章字数: 1.7k

阅读时长: 7 分

阅读次数:

联通1028秋招笔试

尝试下运营商的秋招题目，难度真的不大，就是注意完整的输入输出的判断就行。本次联通的题目主要考察的有模拟题、动态规划基础问题，比较简单。

1028.T1

1. 题目说明

给定一个整数数组nums和一个整数目标值target,.请在该数组中找出和为目标值target的两个整数，并返回它们在数组中的位置（按顺序为0,1,2…）。

可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

例如整数数组nums=[3,2,4]，整数目标值target=6

因为nums[1]+nums[2]=6,因此返回1,2

输入描述：

【一个整数数组】

一个整数目标值

输出描述：

和为目标值的两个整数对应数组里的位置

输入
[3,2,4] 
6
输出
1,2

2. 解答分析

Leetcode中的原题，两数之和的问题，利用哈希表的唯一性组合就行。利用map存出现过的数字，每次读入一个数字x，直到map中找到target-x即可。
注意本题的输入是关键，需要数组、列表两种数据结构方式：
- 直接输入一个列表的字符串，所以先是读入字符串，再根据List列表进行记录即可。
- 此时对读入的字符串进行边界空格的去除trim()方法；
- 接着创建字符数组，利用substring()方法对头尾的[ ]进行去除，其中再根据,对原字符串进行分割，得到每个字符的数组；
- 将每个字符通过Integer.parseInt(str.trim());转换为数字，add到List中即可。

3. 具体代码

import java.util.*;

public class title1 {
    
//    public static void main(String[] args) {
//            List<Integer> nums = new ArrayList<>();
//            Scanner scanner = new Scanner(System.in);
//
//            // 读取输入列表
//            String input = scanner.nextLine().trim();
//            String[] inputArray = input.substring(1, input.length() - 1).split(",");
//            for (String str : inputArray) {
//                nums.add(Integer.parseInt(str.trim()));
//            }
//
//            // 读取目标值
//            int target = scanner.nextInt();
//
//            // 调用twoSum方法计算结果
//            List<Integer> result = twoSum(nums, target);
//
//            // 输出结果
//            if (result.size() != 2) {
//                System.out.println(-1);
//            } else {
//                System.out.println(result.get(0) + "," + result.get(1));
//            }
//        }
//        public static List<Integer> twoSum(List<Integer> nums, int target) {
//            Map<Integer, Integer> numMap = new HashMap<>();
//            for (int i = 0; i < nums.size(); ++i) {
//                int complement = target - nums.get(i);
//                if (numMap.containsKey(complement)) {
//                    return List.of(numMap.get(complement), i);
//                }
//                numMap.put(nums.get(i), i);
//            }
//            return new ArrayList<>();
//        }
    
    public static int[]twoSum(int[]nums,int target){
        HashMap<Integer,Integer> map=new HashMap<>();
        int []res=new int[2];
        for(int i=0;i<nums.length;i++){
            int shen=target-nums[i];
            if(map.containsKey(shen)){
                res[0]=map.get(shen);
                res[1]=i;
            }
            map.put(nums[i],i);
        }
        return res;
    }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        List<Integer>nums=new ArrayList<>();
        //读取输入的列表
        String input=in.nextLine().trim();
        String[] a=input.substring(1,input.length()-1).split(",");
        for(String str:a){
            nums.add(Integer.parseInt(str.trim()));
        }
        int target=in.nextInt();
        int []numsArray=new int[nums.size()];
        for(int i=0;i<nums.size();i++){
            numsArray[i]=nums.get(i);
        }
        int []result=twoSum(numsArray,target);
        if(result.length!=2){
            System.out.println(-1);
        }else{
            System.out.println(result[0]+","+result[1]);
        }
    }
}

实际运行：
复杂度分析：
- 时间复杂度： $O(n)$
  
  我们遍历整数列表长度n，每次查询哈希表需要常数时间
- 空间复杂度： $O(n)$
  
  其中n是整数列表的长度。具体来说，我们需要将整数列表中的每个整数都存储在哈希表中，同时还需要存储它们的下标，因此空间复杂度为O(n)。

1028.T2

1. 题目说明

假设你正在完成一项爬楼梯任务，需要n个步骤才能完成。每次你可以完成1个步骤，或者2个步骤并行。你有多少种不同的方法可以完成任务? 例如，你需要3个步骤完成爬楼梯任务，你可以有以下方法: 1+1+1 1+2 2+1 共3种方法。

输入描述:

所需的步骤，为一个整数。例如3

输出描述:

能有的方法，为一个整数。例如:3

输入
3
输出
3

2. 解答分析

动态规划，走楼梯问题，给出递推公式dp[i]=dp[i-1]+dp[i-2];当前的i方法数可以是i-1的方法数加上i-2的方法数之和。
dp[i]：爬到第i层楼梯，有dp[i]种方法，
初始化：看递推公式可知：dp[0]=1;dp[1]=1;，可以用dp[2]进行验证，此时应该为2;
特例判断，n<=1，直接返回1就行；

3. 具体代码

import java.util.Scanner;

public class title2 {
    //动态规划 dp[i]=dp[i-1]+dp[i-2];
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] dp=new int[n+1];
        if(n<=1){
            System.out.println(1);
        }
        //初始状态，爬0阶楼梯或者爬1阶楼梯，都是1
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        System.out.println(dp[n]);
    }
}

复杂度分析：
- 时间复杂度： $O(n)$
- 空间复杂度： $O(n)$

1028.T3

1. 题目说明

假如一个n位自然数等于自身各个数位上数字的n次幂之和，则称此数为n位自幂数。例如: 153就是一个三位自幂数。因为153是三位数，各位数分别为: 1、5、3，且1^3 + 5^3+ 3^3 = 153 现给定一个大于等于3小于等于9的正整数n，以及正整数num，且n为num的位数，请判断该num是否为n位自幂数。如果是则输出1，否则输出-1。

输入描述:

大于等于3小于等于9的正整数n，以及正整数num

输出描述:

如果是则输出1，否则输出-1

输入样例:

3,153

输出样例:

输入
3,153
输出
1

2. 解答分析

直接模拟，提取num的每一位，求n次幂看是否等于num即可。

3. 具体代码

import java.util.Scanner;

public class title3 {
    //思路：简单模拟，直接提取num的每一位，看n次幂是否等于num即可
    public static int solve(int n,int num){
        int tmp=num;
        int sum=0;
        while(tmp>0){
            int digit=tmp%10;
            sum+=Math.pow(digit,n);
            tmp/=10;
        }
        if(sum==num){
            return 1;
        }
        else return 0;
    }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int result=solve(n,m);
        System.out.println(result);
    }
}