【饿了么笔试题汇总】-2024-04-02-饿了么春招笔试题-三语言题解(CPP Python Java)

时间复杂度为

O

(

n

)

O(n)

O(n)，空间复杂度为

O

(

1

)

O(1)

O(1)。

参考代码

• Python

def solution():
    n, m = map(int, input().split())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))

    sumA = sum(A)
    sumB = sum(B)
    ans = 0

    for a in A:
        if a == sumB - sumA:
            ans += 1

    print(ans)

if __name__ == "\_\_main\_\_":
    solution()

• Java

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        long[] A = new long[n];
        long[] B = new long[m];

        long sumA = 0;
        for (int i = 0; i < n; i++) {
            A[i] = scanner.nextLong();
            sumA += A[i];
        }

        long sumB = 0;
        for (int i = 0; i < m; i++) {
            B[i] = scanner.nextLong();
            sumB += B[i];
        }

        int ans = 0;
        for (long a : A) {
            if (a == sumB - sumA) {
                ans++;
            }
        }

        System.out.println(ans);
    }
}

• Cpp

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<long long> A(n), B(m);

    long long sumA = 0;
    for (int i = 0; i < n; i++) {
        cin >> A[i];
        sumA += A[i];
    }

    long long sumB = 0;
    for (int i = 0; i < m; i++) {
        cin >> B[i];
        sumB += B[i];
    }

    int ans = 0;
    for (long long a : A) {
        if (a == sumB - sumA) {
            ans++;
        }
    }

    cout << ans << endl;
    return 0;
}

02.切绳子

问题描述

K 小姐有

n

n

n 根绳子，从

1

1

1 到

n

n

n 编号，第

i

i

i 根绳子的长度为

a

i

a_i

ai​。她希望通过切割操作，使所有绳子长度相等。每次切割操作可以选择一根长度为

s

s

s 的绳子，将其切成长度分别为

x

x

x 和

y

y

y 的两段，其中

x

x

x 和

y

y

y 均为正整数且满足

x

y

=

s

x+y=s

x+y=s。K 小姐最多进行

k

k

k 次切割操作。请你帮她判断是否可以通过不超过

k

k

k 次切割操作，使所有绳子长度相等。

输入格式

输入包含多组测试数据。第一行包含一个正整数

T

T

T（

1

≤

T

≤

1

0

4

1 \leq T \leq 10^4

1≤T≤104），表示测试数据的组数。

对于每组测试数据：

• 第一行包含两个正整数

n

n

n（

1

≤

n

<

1

0

5

1 \leq n < 10^5

1≤n<105）和

k

k

k（

0

≤

k

≤

1

0

14

0 \leq k \leq 10^{14}

0≤k≤1014），分别表示绳子的数量和最多允许的切割操作次数。

• 第二行包含

n

n

n 个正整数

a

1

,

a

2

,

…

,

a

n

a_1, a_2, \ldots, a_n

a1​,a2​,…,an​（

1

≤

a

i

≤

1

0

9

1 \leq a_i \leq 10^9

1≤ai​≤109），表示每根绳子的初始长度。

保证所有测试数据中

n

n

n 的总和不超过

1

0

5

10^5

105。

输出格式

对于每组测试数据，如果可以通过不超过

k

k

k 次切割操作使所有绳子长度相等，则输出 YES，否则输出 NO。

样例输入

2
3 4
1 3 2
4 1
2 2 2 3

样例输出

YES
NO

数据范围

• 1

≤

T

≤

1

0

4

1 \leq T \leq 10^4

1≤T≤104

• 1

≤

n

<

1

0

5

1 \leq n < 10^5

1≤n<105

• 0

≤

k

≤

1

0

14

0 \leq k \leq 10^{14}

0≤k≤1014

• 1

≤

a

i

≤

1

0

9

1 \leq a_i \leq 10^9

1≤ai​≤109

• 所有测试数据中

n

n

n 的总和不超过

1

0

5

10^5

105

题解

本题可以使用最大公约数（GCD）来求解。我们可以发现，如果所有绳子最终长度相等，那么它们的长度一定是所有初始绳子长度的最大公约数的倍数。因此，我们可以先求出所有绳子长度的最大公约数，然后计算每根绳子需要切割的次数，看是否不超过

k

k

k 即可。

具体步骤如下：

1. 求出所有绳子长度的最大公约数

g

g

g。
2. 对于每根绳子，计算它需要切割的次数，即

a

i

/

g

−

1

a_i / g - 1

ai​/g−1。
3. 将所有绳子需要切割的次数相加，如果不超过

k

k

k，则输出 YES，否则输出 NO。

时间复杂度为

O

(

n

log

⁡

a

max

⁡

)

O(n \log a_{\max})

O(nlogamax​)，其中

a

max

⁡

a_{\max}

amax​ 为绳子长度的最大值。空间复杂度为

O

(

1

)

O(1)

O(1)。

参考代码

• Python

def gcd(x, y):
    return x if y == 0 else gcd(y, x % y)

T = int(input())
for _ in range(T):
    n, k = map(int, input().split())
    a = list(map(int, input().split()))
    g = a[0]
    for i in range(1, n):
        g = gcd(g, a[i])
    cnt = sum(x // g - 1 for x in a)
    print("YES" if cnt <= k else "NO")

• Java

import java.io.\*;
import java.util.\*;

public class Main {
    static int gcd(int x, int y) {
        return y == 0 ? x : gcd(y, x % y);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while (T-- > 0) {
            int n = sc.nextInt();
            long k = sc.nextLong();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = sc.nextInt();
            }
            int g = a[0];
            for (int i = 1; i < n; i++) {
                g = gcd(g, a[i]);
            }
            long cnt = 0;
            for (int x : a) {
                cnt += x / g - 1;
            }
            System.out.println(cnt <= k ? "YES" : "NO");
        }
    }
}

• Cpp

#include <iostream>
using namespace std;

int gcd(int x, int y) {
    return y == 0 ? x : gcd(y, x % y);
}

int main() {
    ios::sync\_with\_stdio(false);
    cin.tie(0);

    int T;
    cin >> T;
    while (T--) {
        int n;
        long long k;
        cin >> n >> k;
        int g = 0;
        for (int i = 0; i < n; i++) {
            int x;
            cin >> x;
            g = i == 0 ? x : gcd(g, x);
        }
        long long cnt = 0;
        for (int i = 0; i < n; i++) {
            int x;
            cin >> x;
            cnt += x / g - 1;
        }
        cout << (cnt <= k ? "YES" : "NO") << '\n';
    }

    return 0;
}

03.卢小姐的魔法强化

问题描述

卢小姐是一位魔法少女，她拥有一把初始攻击力为

0

0

0 的魔法棒。现在，她面前有

n

n

n 块魔法石，每块魔法石都可以用于强化她的魔法棒。第

i

i

i 块魔法石有一个强化上限

a

i

a_i

ai​。

当卢小姐使用第

i

i

i 块魔法石强化她的魔法棒时，她需要选择一个不超过强化上限

a

i

a_i

ai​ 的非负整数

x

x

x 作为强化系数。假设卢小姐当前的魔法棒攻击力为

k

k

k，那么强化后的攻击力将变为

k

∣

x

k \mid x

k∣x（其中

∣

\mid

∣ 表示按位或操作）。每块魔法石只能使用一次，用后即失效。

卢小姐想知道，利用这

n

n

n 块魔法石，她的魔法棒最多能达到多大的攻击力。

输入格式

输入包含多组测试数据。

第一行输入一个正整数

T

T

T（

1

≤

T

≤

1

0

4

1 \leq T \leq 10^4

1≤T≤104），表示测试数据的组数。

接下来，对于每组测试数据：

• 第一行输入一个正整数

n

n

n（

1

≤

n

≤

2

×

1

0

5

1 \leq n \leq 2 \times 10^5

1≤n≤2×105），表示魔法石的数量。

• 第二行输入

n

n

n 个整数

a

1

,

a

2

,

…

,

a

n

a_1, a_2, \ldots, a_n

a1​,a2​,…,an​（

0

≤

a

i

≤

1

0

9

0 \leq a_i \leq 10^9

0≤ai​≤109），表示每块魔法石的强化上限。

保证所有测试数据中

n

n

n 的总和不超过

2

×

1

0

5

2 \times 10^5

2×105。

输出格式

输出包含

T

T

T 行，每行一个整数，表示对应测试数据中卢小姐的魔法棒能达到的最大攻击力。

样例输入

2
5
2 3 3 3 6
3
1 0 0

样例输出

7
1

数据范围

• 1

≤

T

≤

1

0

4

1 \leq T \leq 10^4

1≤T≤104

• 1

≤

n

≤

2

×

1

0

5

1 \leq n \leq 2 \times 10^5

1≤n≤2×105

• 0

≤

a

i

≤

1

0

9

0 \leq a_i \leq 10^9

0≤ai​≤109

• 所有测试数据中

n

n

n 的总和不超过

2

×

1

0

5

2 \times 10^5

2×105

题解

我们可以用贪心的思想来解决这个问题。对于每一个二进制位，我们优先使用能够强化该位的魔法石。如果该位已经被强化，我们就不需要再使用其他能够强化该位的魔法石了。

具体步骤如下：

1. 统计每个二进制位上有多少块魔法石能够强化该位。

2. 从高位到低位遍历每个二进制位：

   • 如果当前位上有能够强化该位的魔法石，我们就使用其中一块，将答案的该位置为

   1

   1

   1。

   • 如果当前位上还有剩余的能够强化该位的魔法石，我们可以使用它们来强化答案的低位。具体地，我们可以将答案的低位全部置为

   1

   1

   1，然后退出遍历。

时间复杂度为

O

(

n

log

⁡

a

max

⁡

)

O(n \log a_{\max})

O(nlogamax​)，其中

a

max

⁡

a_{\max}

amax​ 为魔法石强化上限的最大值。空间复杂度为

O

(

1

)

O(1)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）

所有测试数据中

n

n

n 的总和不超过

2

×

1

0

5

2 \times 10^5

2×105

题解

我们可以用贪心的思想来解决这个问题。对于每一个二进制位，我们优先使用能够强化该位的魔法石。如果该位已经被强化，我们就不需要再使用其他能够强化该位的魔法石了。

具体步骤如下：

1. 统计每个二进制位上有多少块魔法石能够强化该位。

2. 从高位到低位遍历每个二进制位：

   • 如果当前位上有能够强化该位的魔法石，我们就使用其中一块，将答案的该位置为

   1

   1

   1。

   • 如果当前位上还有剩余的能够强化该位的魔法石，我们可以使用它们来强化答案的低位。具体地，我们可以将答案的低位全部置为

   1

   1

   1，然后退出遍历。

时间复杂度为

O

(

n

log

⁡

a

max

⁡

)

O(n \log a_{\max})

O(nlogamax​)，其中

a

max

⁡

a_{\max}

amax​ 为魔法石强化上限的最大值。空间复杂度为

O

(

1

)

O(1)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-vmfsp1kI-1712626034215)]

[外链图片转存中…(img-i3UGazvQ-1712626034216)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）