【蚂蚁笔试题汇总】2024-05-11-蚂蚁春招笔试题-三语言题解(CPP/Python/Java)

清隆学长

已于 2024-05-11 22:25:07 修改

阅读量597

点赞数 24

分类专栏：蚂蚁笔试题汇总文章标签： python java 算法开发语言 c语言

于 2024-05-11 20:50:30 首次发布

本文链接：https://blog.csdn.net/Qmtdearu/article/details/138729555

版权

蚂蚁笔试题汇总专栏收录该内容

4 篇文章 1 订阅

订阅专栏

🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员

✨ 本系列打算持续跟新蚂蚁近期的春秋招笔试题汇总～

💻 ACM银牌🥈| 多次AK大厂笔试｜编程一对一辅导

👏 感谢大家的订阅➕ 和喜欢💗

📧 清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下清隆领取，会在飞书进行同步的跟新。

⌚️ 01.最大化权值

问题描述

LYA 定义一个数组的权值为正数元素的数量减去负数元素的数量。例如， $[1, 2, - 3, - 4, 5]$ 的权值为 $1$ ，而 $[- 2, - 5]$ 的权值为 $- 2$ 。

现在 LYA 拿到了一个数组，她准备选择恰好 $k$ 个元素进行取反（同一个元素最多只能取反一次），目标是使得数组的权值尽可能大。你能帮她计算出操作后数组权值的最大值吗？

输入格式

第一行包含两个正整数 $n$ 和 $k$ ，分别表示数组的长度和选择的元素数量。

第二行包含 $n$ 个整数 $a_1, a_2, \ldots, a_n$ ，表示给定的数组。

输出格式

输出一个整数，表示操作后数组权值的最大值。

样例输入

5 3
-5 1 4 -2 3

样例输出

数据范围

$\le k \le n \le 10^5$
$-10^9 \le a_i \le 10^9$

可以统计数组中负数、正数和零的个数，分别记为 $l$ 、 $r$ 和 $c$ 。

如果 $\ge k$ ，即负数的个数大于等于可以取反的元素数量，那么我们只需要将 $k$ 个负数取反，最终的权值即为 $(r + k) - (l - k)$ 。

如果 $l < k$ ，那么我们需要先将所有负数取反，此时还剩下 $k - l$ 次取反操作。如果 $\le c$ ，即剩下的取反次数小于等于零的个数，那么我们无需进行更多操作，最终的权值为 $r + l$ 。否则，我们需要将 $k - l - c$ 个正数取反。

参考代码

Python

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

l, r, c = 0, 0, 0
for x in (list(map(int, input().split()))):
    if x < 0:
        l += 1
    elif x > 0:
        r += 1
    else:
        c += 1

t = l
l -= k
if l >= 0:
    r += k
    print(r - l)
else:
    l = 0
    k -= t
    k -= c
    r += t
    if k <= 0:
        print(r)
    else:
        r -= k
        l += k
        print(r - l)

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();

        int l = 0, r = 0, c = 0;
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            if (x < 0)
                l++;
            else if (x > 0)
                r++;
            else
                c++;
        }

        int t = l;
        l -= k;
        if (l >= 0) {
        	r += k;
            System.out.println(r - l);
        } else {
            l = 0;
            k -= t;
            k -= c;
            r += t;
            if (k <= 0)
                System.out.println(r);
            else {
                r -= k;
                l += k;
                System.out.println(r - l);
            }
        }
    }
}

#include <iostream>
using namespace std;

int main() {
    int n, k;
    cin >> n >> k;

    int l = 0, r = 0, c = 0;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        if (x < 0)
            l++;
        else if (x > 0)
            r++;
        else
            c++;
    }

    int t = l;
    l -= k;
    if (l >= 0) {
        r += k;
        cout << r - l << endl;
    } else {
        l = 0;
        k -= t;
        k -= c;
        r += t;
        if (k <= 0)
            cout << r << endl;
        else {
            r -= k;
            l += k;
            cout << r - l << endl;
        }
    }

    return 0;
}

📱 02.等腰梯形判定

问题描述

LYA 在平面上找到了四个点的坐标，想要判断这四个点能否构成一个等腰梯形。等腰梯形的定义为：四条边分为两对，有一对边平行且不相等，另一对边相等且不平行。

给定四个点的坐标，请帮助 LYA 判断它们是否能构成一个等腰梯形。

输入格式

第一行包含一个正整数 $q$ ，表示询问的次数。

接下来的 $q$ 行，每行包含 $8$ 个整数 $x_1,y_1,x_2,y_2,x_3,y_3,x_4,y_4$ ，分别表示四个点的坐标。

输出格式

对于每个询问，如果给定的四个点能构成等腰梯形，则输出 "Yes"，否则输出 "No"。

样例输入

3
0 0 2 4 5 0 3 4
0 0 1 4 2 0 3 4
0 1 2 1 3 2 3 4

样例输出

Yes
No
Yes

数据范围

$\le q \le 1000$
$\le x_i, y_i \le 1000$

题解

判断四个点是否能构成等腰梯形，可以按照以下步骤进行：

计算四条边的长度，分别记为 $d_{12}, d_{23}, d_{34}, d_{41}$ ，以及两条对角线的长度 $d_{13}, d_{24}$ 。
判断是否存在一对平行且不相等的边，以及另一对相等且不平行的边：
- 如果 $d_{12} \parallel d_{34}$ 且 $d_{12} \ne d_{34}$ ，则判断 $d_{13} = d_{24}$ 或者 $d_{41} = d_{23}$ 是否成立。
- 如果 $d_{13} \parallel d_{24}$ 且 $d_{13} \ne d_{24}$ ，则判断 $d_{12} = d_{34}$ 或者 $d_{41} = d_{23}$ 是否成立。
- 如果 $d_{41} \parallel d_{23}$ 且 $d_{41} \ne d_{23}$ ，则判断 $d_{12} = d_{34}$ 或者 $d_{13} = d_{24}$ 是否成立。
如果满足上述条件之一，则给定的四个点能构成等腰梯形，否则不能。

其中，判断两条线段是否平行可以通过比较它们的斜率是否相等来实现。

参考代码

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

struct Point {
    int x, y;
};

double dist(Point a, Point b) {
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}

bool isParallel(Point a, Point b, Point c, Point d) {
    return (b.y - a.y) * (d.x - c.x) == (d.y - c.y) * (b.x - a.x);
}

bool isIsosceles(Point a, Point b, Point c, Point d) {
    double d12 = dist(a, b), d23 = dist(b, c), d34 = dist(c, d), d41 = dist(d, a);
    double d13 = dist(a, c), d24 = dist(b, d);
    
    if (isParallel(a, b, c, d) && d12 != d34) {
        return (d13 == d24) || (d41 == d23);
    }
    if (isParallel(a, c, b, d) && d13 != d24) {
        return (d12 == d34) || (d41 == d23);
    }
    if (isParallel(a, d, b, c) && d41 != d23) {
        return (d12 == d34) || (d13 == d24);
    }
    return false;
}

int main() {
    int q;
    cin >> q;
    while (q--) {
        Point a, b, c, d;
        cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y >> d.x >> d.y;
        cout << (isIsosceles(a, b, c, d) ? "Yes" : "No") << endl;
    }
    return 0;
}

Python

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def dist(a, b):
    return math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2)

def is_parallel(a, b, c, d):
    return (b.y - a.y) * (d.x - c.x) == (d.y - c.y) * (b.x - a.x)

def is_isosceles(a, b, c, d):
    d12 = dist(a, b)
    d23 = dist(b, c)
    d34 = dist(c, d)
    d41 = dist(d, a)
    d13 = dist(a, c)
    d24 = dist(b, d)
    
    if is_parallel(a, b, c, d) and d12 != d34:
        return d13 == d24 or d41 == d23
    if is_parallel(a, c, b, d) and d13 != d24:
        return d12 == d34 or d41 == d23
    if is_parallel(a, d, b, c) and d41 != d23:
        return d12 == d34 or d13 == d24
    return False

q = int(input())
for _ in range(q):
    x1, y1, x2, y2, x3, y3, x4, y4 = map(int, input().split())
    a = Point(x1, y1)
    b = Point(x2, y2)
    c = Point(x3, y3)
    d = Point(x4, y4)
    print("Yes" if is_isosceles(a, b, c, d) else "No")

Java

import java.util.Scanner;

class Point {
    int x, y;
    
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

public class Main {
    static double dist(Point a, Point b) {
        return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
    }
    
    static boolean isParallel(Point a, Point b, Point c, Point d) {
        return (b.y - a.y) * (d.x - c.x) == (d.y - c.y) * (b.x - a.x);
    }
    
    static boolean isIsosceles(Point a, Point b, Point c, Point d) {
        double d12 = dist(a, b), d23 = dist(b, c), d34 = dist(c, d), d41 = dist(d, a);
        double d13 = dist(a, c), d24 = dist(b, d);
        
        if (isParallel(a, b, c, d) && d12 != d34) {
            return (d13 == d24) || (d41 == d23);
        }
        if (isParallel(a, c, b, d) && d13 != d24) {
            return (d12 == d34) || (d41 == d23);
        }
        if (isParallel(a, d, b, c) && d41 != d23) {
            return (d12 == d34) || (d13 == d24);
        }
        return false;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt();
        while (q-- > 0) {
            Point a = new Point(sc.nextInt(), sc.nextInt());
            Point b = new Point(sc.nextInt(), sc.nextInt());
            Point c = new Point(sc.nextInt(), sc.nextInt());
            Point d = new Point(sc.nextInt(), sc.nextInt());
            System.out.println(isIsosceles(a, b, c, d) ? "Yes" : "No");
        }
    }
}

💻 03.音乐会的座位安排

题目描述

K小姐是一名音乐会的组织者，她需要为一场音乐会安排座位。音乐会座位比较特殊只有一排，总共有 $n$ 个座位和 $m$ 个类型的观众。K小姐希望相邻的座位尽可能安排给相同类型的观众，以增加观众的互动和体验，。

我们定义一个观众类型的连续段为若干个连续的相同类型的观众。例如，在一排座位 $[1, 1, 2, 3, 3, 3, 3]$ 中，有 $3$ 个连续段，分别为两个 $1$ ，一个 $2$ 和四个 $3$ 。

现在K小姐想知道，对于给定的 $n$ 和 $m$ ，所有可能的座位安排方案中，连续段数量之和是多少？由于答案可能很大，请对 $10^9+7$ 取模。

输入格式

输入仅一行，包含两个正整数 $n$ 和 $m$ ，表示排数和观众类型数，中间用空格隔开。

输出格式

输出一个整数，表示所有可能的座位安排方案中，连续段数量之和对 $10^9+7$ 取模的结果。

样例输入

2 3

样例输出

数据范围

$\leq n, m < 10^9$

题解

这题建议直接打表找规律，表达式为: $\times m ^ n - (n - 1) \times m ^ {n - 1}$

最后用快速幂求次方即可。

参考代码

Python

n, m = map(int, input().split())
mod = 10 ** 9 + 7
res = n * pow(m, n, mod) - (n - 1) * pow(m, n - 1, mod) 
res %= mod
print(res)

Java

import java.util.Scanner;

public class Main {
    static final int MOD = 1000000007;

    static long qmi(long a, long b) {
        long res = 1 % MOD;
        while (b > 0) {
            if ((b & 1) == 1) {
                res = res * a % MOD;
            }
            a = a * a % MOD;
            b >>= 1;
        }
        return res;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextLong();
        long m = scanner.nextLong();

        long res = n * qmi(m, n) % MOD - (n - 1) * qmi(m, n - 1) % MOD;
        res = (res % MOD + MOD) % MOD;
        System.out.println(res);
    }
}

#include<bits/stdc++.h>

using namespace std;

typedef long long LL;
const int mod = 1e9 + 7;
LL qmi(LL a, LL b){
    LL res = 1 % mod;
    while(b)
    {
        if(b & 1)
            res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

int main (){
    LL n, m; cin >> n >> m;
    LL res = n * qmi(m, n) % mod - (n - 1) * qmi(m, n - 1) % mod;  
    res = (res % mod + mod) % mod;
    cout << res << "\n";
    return 0;
}

写在最后

📧 清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下清隆领取，会在飞书进行同步的跟新。

在这里插入图片描述

清隆学长

关注

24
点赞
踩
5

收藏

觉得还不错? 一键收藏
3
评论
【蚂蚁笔试题汇总】2024-05-11-蚂蚁春招笔试题-三语言题解(CPP/Python/Java)

LYA 定义一个数组的权值为正数元素的数量减去负数元素的数量。例如，[1,2,−3,−4,5][1, 2, -3, -4, 5][1,2,−3,−4,5] 的权值为 111，而 [−2,−5][-2, -5][−2,−5] 的权值为 −2-2−2。现在 LYA 拿到了一个数组，她准备选择恰好 kkk 个元素进行取反（同一个元素最多只能取反一次），目标是使得数组的权值尽可能大。你能帮她计算出操作后数组权值的最大值吗？第一行包含两个正整数 nnn 和 kkk，分别表示数组的长度和选择的元素数量。第二行包含 nn
复制链接

扫一扫