【2023-03-26】阿里巴巴暑期实习笔试三道题解

恭喜发现宝藏！搜索公众号【TechGuide】回复公司名，解锁更多新鲜好文和互联网大厂的笔经面经。
作者@TechGuide【全网同名】

订阅专栏【进阶版】2023最新大厂笔试真题 & 题解，不容错过的宝藏资源！

第一题：切割环形数组

题目描述

将一个数组首尾相接形成环，你需要切两刀，把它切成两段，使得两段的元素之和相等。请问有多少种切割方案？

输入描述

第一行输入一个正整数 n ，代表环形数组的元素数量。

第二行输入 n 个正整数 ai，代表环形数组的元素。

1≤n≤10^5
−10^9 ≤ ai ≤ 10^9

输出描述

一个整数，代表切割的方案数。

样例

输入

4
1 2 -1 2

输出

2

样例说明

如下图：

思路

前缀和 + 哈希表优化。

力扣560. 和为 K 的子数组 的变种题目，找出sum/2的连续数组有几个即可。

代码

Java版本

public class Solution {
	// 这里 k 改为 sum(nums)/2 即可，来源：力扣（LeetCode）
    public int subarraySum(int[] nums, int k) {
        int count = 0, pre = 0;
        HashMap < Integer, Integer > mp = new HashMap < > ();
        mp.put(0, 1);
        for (int i = 0; i < nums.length; i++) {
            pre += nums[i];
            if (mp.containsKey(pre - k)) {
                count += mp.get(pre - k);
            }
            mp.put(pre, mp.getOrDefault(pre, 0) + 1);
        }
        return count;
    }
}
// vx公众号关注TechGuide 实时题库 闪电速递

CPP版本

class Solution {
public:
	// 这里 k 改为 sum(nums)/2 即可，来源：力扣（LeetCode）
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        mp[0] = 1;
        int count = 0, pre = 0;
        for (auto& x:nums) {
            pre += x;
            if (mp.find(pre - k) != mp.end()) {
                count += mp[pre - k];
            }
            mp[pre]++;
        }
        return count;
    }
};
// vx公众号关注TechGuide 实时题库 闪电速递

第二题：报数字

题目描述

n 个学生围成一圈，编号从1到 n 。

每个学生将从1开始报数，报到素数的人出列，剩下的人继续报数。试求最终留下来的人的编号是多少。

输入描述

一个正整数n。代表学生的人数。
1≤n≤10^4

输出描述

一个正整数，代表最终留下来的学生编号。

样例

输入

4

输出

4

样例说明

报数流程如下：
1号报1。
2号报2，出队。
3号报3，出队。
4号报4。
1号报5，出队。
最后留下来的是4号

思路

模拟。先求出范围内的所有素数，然后依次模拟学生报数并判断是否为素数。若是素数，则该学生出列，否则模拟该学生不出列，将其重新加入队列中。最终剩下的一个学生即为所求。问题的关键在于如何判断是否为素数，具体见代码。

代码

Python版本

import queue

N = 1006000
prime = [0] * N
que = queue.Queue()

def get_prime():
    for i in range(2, N):
        if prime[i] == 0:
            for j in range(i + i, N, i):
                prime[j] = 1

def main():
    get_prime()
    prime[1] = 1
    n = int(input())
    for i in range(1, n + 1):
        que.put(i)
    count = 1
    while que.qsize() > 1:
        if prime[count] == 1:
            que.put(que.get())
        que.get()
        count += 1
    print(que.get())

if __name__ == '__main__':
    main()
# vx公众号关注TechGuide 实时题库 闪电速递。

Java版本

import java.util.Scanner;
import java.util.LinkedList;
import java.util.Queue;

public class Main {

    static final int N = 1006000;
    static int[] prime = new int[N];
    static Queue<Integer> que = new LinkedList<>();

    static void get_prime() {
        for (int i = 2; i < N; i++) {
            if (prime[i] == 0) {
                for (int j = i + i; j < N; j += i) {
                    prime[j] = 1;
                }
            }
        }
    }

    public static void main(String[] args) {
        get_prime();
        prime[1] = 1;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            que.offer(i);
        }
        int count = 1;
        while (que.size() > 1) {
            if (prime[count] == 1) {
                que.offer(que.poll());
            }
            que.poll();
            count++;
        }
        System.out.println(que.peek());
    }
}
// vx公众号关注TechGuide 实时题库 闪电速递

第三题：数组之和最小值

题目描述

给定一个数组，你可以进行最多k次以下操作：

每次操作指的是：选择一个大于1的元素ai，使得 ai 除以它的一个素因子p。

试求操作结束后，数组的所有元素之和的最小值是多少？

输入描述

第一行输入两个正整数n和k，代表数组大小以及操作次数。

第二行输入n个正整数ai，代表数组的元素。

1≤ n,k ≤200000
1≤ ai ≤10^6

输出描述

一个整数，代表操作后的所有元素最小的和。

样例

输入

2 1
5 6

输出

7

样例说明

只能操作一次，选择一个元素，5／5＝1即可，数组变成[1,6]。

思路

贪心。对每个数进行质因数分解，然后贪心选择将能够产生最小代价（即操作后值最小）的数进行操作。

可以用最小堆存储这些数，每次取出值最小的数进行操作，操作k次后将数全部取出求和即可。

代码

Python版本

import heapq
MAXN = 1_000_500
primes = [0] * MAXN

def get_primes():
    for i in range(2, MAXN):
        if primes[i] == 0:
            for j in range(i, MAXN, i):
                primes[j] = i

class Node:
    def __init__(self, data, prime):
        self.data = data
        self.prime = prime
    def __lt__(self, other):
        return (self.data - self.data // self.prime) < (other.data - other.data // other.prime)

n, k = map(int, input().split())
nums = list(map(int, input().split()))

get_primes()
pq = []
for num in nums:
    a = Node(num, primes[num])
    heapq.heappush(pq, a)

while k:
    x = heapq.heappop(pq).data
    x = x // heapq.heappop(pq).prime
    heapq.heappush(pq, Node(x, primes[x]))
    k -= 1

ans = 0
while pq:
    ans += heapq.heappop(pq).data
print(ans)
# vx公众号关注TechGuide 实时题库 闪电速递。

Java版本

import java.util.*;

public class Main {
    static final int MAXN = 1000500;
    static int[] primes = new int[MAXN];
    static {
        get_primes();
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        PriorityQueue<Node> pq = new PriorityQueue<>();
        for (int i = 0; i < n; ++i) {
            int x = scan.nextInt();
            Node a = new Node(x, primes[x]);
            pq.offer(a);
        }
        while (k-- > 0) {
            int x = pq.poll().data;
            x = x / pq.poll().prime;
            Node y = new Node(x, primes[x]);
            pq.offer(y);
        }
        int ans = 0;
        while (!pq.isEmpty()) {
            ans += pq.poll().data;
        }
        System.out.println(ans);
    }

    static void get_primes() {
        for (int i = 2; i < MAXN; ++i) {
            if (primes[i] == 0) {
                for (int j = i; j < MAXN; j += i) {
                    primes[j] = i;
                }
            }
        }
    }
}

class Node implements Comparable<Node>{
    int data, prime;
    Node(int data, int prime) {
        this.data = data;
        this.prime = prime;
    }
    @Override
    public int compareTo(Node o) {
        return (this.data - this.data/this.prime) - (o.data - o.data/o.prime);
    }
}
// vx公众号关注TechGuide 实时题库 闪电速递