【美团&字节】四道编程题（含思路）2020/09/06

最新推荐文章于 2024-08-11 10:44:50 发布
最新推荐文章于 2024-08-11 10:44:50 发布
阅读量1.6k 收藏 5
点赞数
分类专栏： 【免费体验】2020-2023.3 大厂笔试真题解析 文章标签： leetcode 动态规划 dfs 1024程序员节 java
原文链接：https://www.nowcoder.com/discuss/500713?type=2
版权

备战秋招面试 微信搜索公众号【TechGuide】关注更多新鲜好文和互联网大厂的笔经面经。
作者@TechGuide
点赞再看，养成习惯，您动动手指对原创作者意义非凡🤝

美团笔试

第一题

给出A，B两国想要的土地，输出只有A国想要的土地数，只有B国想要的土地数，两个国家都想要的土地数。
思路：简单的求交集大小，甚至不用给出交集，先遍历A，用set存下来，再遍历B，遇到set中有的就cnt++，最后输出A-cnt, B-cnt, cnt。

作者：js8544
链接：https://www.nowcoder.com/discuss/500649
来源：牛客网
int n, p, q;
set<int> a;
void solve() {
  cin >> n >> p >> q;
  for (int i = 0; i < p; i++) {
    int x;
    cin >> x;
    a.insert(x);
  }
  int cnt = 0;
  for (int i = 0; i < q; i++) {
    int x;
    cin >> x;
    if (a.count(x)) cnt++;
  }
  cout<<p - cnt<<" "<<q - cnt<<" "<<cnt<<endl;
}

第二题，

给一串偶数个字符，只有大小写字母，求修改多少个字母可以让大小写数量相同。
思路：求出大小写个数，相减除以二即可。用islower判断大小写。

int n;
void solve() {
  char c;
  int l = 0, u = 0;
  while (cin >> c) {
    if (islower(c)) {
      l++;
    } else {
      u++;
    }
  }
  cout<<abs(l - u) / 2<<endl;
}

第三题

思路：观察到异或的两个性质：1. 可交换 2. 任何数异或自身为零。观察到mod的一个性质：循环。因此我们可以竖着求，而不是横着求。也就是我们遍历j去求，而不是i。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] pre = new int[n+1];
        pre[0] = 0;
        int res = 0;
        for (int i = 1; i < n+1; i++) {
            pre[i] = pre[i-1]^i;
        }
        for (int i = 1; i < n+1; i++) {
            res = res^pre[n%i];
            if((n/i)%2==1) res = res^pre[i-1];
        }
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            res = res^a;
        }
        System.out.println(res);
    }
}

int n;
int pre[100001];

void solve() {
  cin >> n;
  pre[0] = 0;
  for (int i = 1; i <= n; i++) {
    pre[i] = pre[i - 1] ^ i;
  }
  int ans = 0;
  for (int i = 1; i <= n; i++) {
    ans ^= pre[n % i];
    if ((n / i) % 2) {
      ans ^= pre[i - 1];
    }
  }
  for (int i = 0; i < n; i++) {
    int x;
    cin >> x;
    ans ^= x;
  }
  cout << ans << endl;
}

第四题

方法一：

作者：阿康201903182006590
链接：https://www.nowcoder.com/discuss/500551?type=6&channel=666&source_id=discuss_center_discuss_hot
来源：牛客网

import java.util.Scanner;

public class Main4 {
    public static void main(String[] args) {
        Scanner in  =new Scanner(System.in);
        while(in.hasNext()){
            int n=in.nextInt();
            boolean flag=false;
          
            int[] arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=in.nextInt();
            }
            int empcnt=0;
            for(int a:arr){
                if(n==2&&a==2){
                    flag=false;
                }
                if(a==1){
                    empcnt++;
                }else{
                    if(a==empcnt+1&&a>2&&a==n){
                        flag=true;
                    }
                }

            }
            if(flag==true){
                System.out.println("YES");
            }else {
                System.out.println("NO");
            }

        }
    }
}

方法二：

int n;
int arr[25];
int child[25];

bool dfs(int x, set<int>& can) {
  if (x == n) {
    for (int i = 0; i < n; i++) {
      if (arr[i] != 1 || child[i] == 1) return false;
    }
    return true;
  }
  set<int> new_can = can;
  if (arr[x] != 1) new_can.insert(x);
  for (int i : can) {
    if (arr[i] > arr[x]) {
      if (arr[i] == arr[x] + 1 && child[i] == 0) continue;
      arr[i] -= arr[x];
      child[i]++;
      if (arr[i] == 1) new_can.erase(i);
      if (dfs(x + 1, new_can)) return true;
      if (arr[i] == 1) new_can.insert(i);
      arr[i] += arr[x];
      child[i]--;
    }
  }
  return false;
}

void solve() {
  bool flag = true;
  REP(i, n) {
    cin >> arr[i];
    if (arr[i] == 2) {
      flag = false;
    }
  }
  if (!flag) {
    cout << "NO" << endl;
    return;
  }

  sort(arr, arr + n, greater<int>());

  if (arr[0] != n) {
    cout << "NO" << endl;
    return;
  }

  set<int> can;
  can.insert(0);
  memset(child, 0, sizeof(child));
  if (dfs(1, can)) {
    cout << "YES" << endl;
  } else {
    cout << "NO" << endl;
  }
}

第五题

在这里插入代码片

牛客美团2020年校招真题解7：

打车派单场景, 假定有N个订单， 待分配给N个司机。每个订单在匹配司机前，会对候选司机进行打分，打分的结果保存在N*N的矩阵A， 其中Aij 代表订单i司机j匹配的分值。

假定每个订单只能派给一位司机，司机只能分配到一个订单。求最终的派单结果，使得匹配的订单和司机的分值累加起来最大，并且所有订单得到分配。

import java.util.*;

public class Main {
    static double total = Integer.MIN_VALUE;
    static List<List<Integer>> res;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        sc.nextLine();
        double[][] scores = new double[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                scores[i][j] = sc.nextDouble();
            }
            sc.nextLine();
        }
        boolean[] vis = new boolean[N];
        dfs(0, N,scores,new ArrayList<>(),0, vis);
        System.out.println(total);
        for (int i = 0; i < res.size() ; i++) {
            for(int e:res.get(i)){
                System.out.print(e+1);
                System.out.print(" ");
            }
            System.out.println();
        }
    }

    public static void dfs(int x, int n, double[][] scores, List<List<Integer>> temp, double sum, boolean[] vis){
        if(x<0 || x>n) return;
//        System.out.println("x:"+x);
//        System.out.println("sum:"+sum);
        if(x==n && sum>total){
            res = new ArrayList<>(temp);
            total = sum;
            return;
        }
        for (int i = 0; i < n; i++) {
            if(!vis[i]){
                temp.add(Arrays.asList(x,i));
                vis[i] = true;
                dfs(x+1, n, scores, temp, sum+scores[x][i], vis);
                vis[i] = false;
                temp.remove(temp.size()-1);
            }
        }

    }
}

牛客美团2020年校招真题解8：

2110年美团外卖火星第3000号配送站点有26名骑手，分别以大写字母A-Z命名，因此可以称呼这些骑手为黄家骑士特工A，黄家骑士特工B…黄家骑士特工Z，某美团黑珍珠餐厅的外卖流水线上会顺序产出一组包裹，美团配送调度引擎已经将包裹分配到骑手，并在包裹上粘贴好骑手名称，如RETTEBTAE代表一组流水线包裹共9个，同时分配给了名字为A B E R T的5名骑手。请在不打乱流水线产出顺序的情况下，把这组包裹划分为尽可能多的片段，同一个骑手只会出现在其中的一个片段，返回一个表示每个包裹片段的长度的列表。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        String s=scanner.nextLine();
        int i=0,j=0,len=s.length();
        while(j<len){
            char c=s.charAt(j);
            int tail=s.lastIndexOf(c);
            int pre = j;
            int temp = tail;
            for (int k = j+1; k < temp; k++) {
                tail = Math.max(tail, s.lastIndexOf(s.charAt(k)));
                j = tail;
            }
            j++;
            System.out.print(j-pre+" ");
        }
    }
}

字节

第一题

  1. 动态规划。分别计算最后跳1步和跳2步的状态

作者：yuzining
链接：https://www.nowcoder.com/discuss/500713?type=2
来源：牛客网
#include <bits/stdc++.h>
using namespace std;
int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  vector<vector<int64_t>> dp(105, vector<int64_t>(2, 0));
  dp[0][0] = 1;
  for (int i = 1; i < 105; i++) {
    dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
    if (i >= 2) {
      dp[i][1] = dp[i - 2][0];
    }
  }
  int n; cin >> n;
  if (n == 0) {
    cout << 0 << '\n';
    return 0;
  }
  cout << (dp[n][0] + dp[n][1]) << '\n';
}
  1. 两次单调栈。
#include <bits/stdc++.h>
using namespace std;
int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n; cin >> n;
  int64_t ans = 0;
  vector<int> a(n), l(n, 0);
  stack<int> stk;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    while (!stk.empty() && a[stk.top()] <= a[i]) {
      stk.pop();
    }
    if (!stk.empty()) {
      l[i] = stk.top() + 1;
    }
    stk.push(i);
  }
  while (!stk.empty()) {
    stk.pop();
  }
  for (int i = n - 1; i >= 0; i--) {
    while (!stk.empty() && a[stk.top()] <= a[i]) {
      stk.pop();
    }
    if (!stk.empty()) {
      ans = max(ans, (int64_t)(1ll * l[i] * (stk.top() + 1)));
    }
    stk.push(i);
  }
  cout << ans << '\n';
}
  1. 最大子段和。M=1,2直接做；当M>2时，先做两段，如果整段之和大于0，最优解要再加上中间(m-2)段的和

java实现:

作者：OFFER—PLSxD
链接：https://www.nowcoder.com/discuss/500713?type=2
来源：牛客网

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        int [] arr = new int [n];
        int [] L = new int [n]; // L[i] = first j  satisfy arr[ j -1 ] > arr[i]
        for(int i=0 ; i< n ; i++ ){
            arr[i]  = sc.nextInt();
        }
        
        Deque<Integer> s1 = new LinkedList<>(); // montonic decreasing stack
        for(int i = n - 1  ; i >= 0 ; i-- ){
            while(!s1.isEmpty() && arr[s1.peek()] < arr[i]){
                L[s1.pop()] = i + 1 ; // idx start from 1
            }
            s1.push(i);
        }
        long max = 0L;
        
        s1 = new LinkedList<>(); // montonic decreasing stack
        for(int i = 0  ; i < n ; i++ ){
            while(!s1.isEmpty() && arr[s1.peek()] < arr[i]){
                int RR = (i + 1);// idx start from 1
                int LL = L[s1.pop()];
                max = Math.max (  max ,  1L *LL * RR ) ;
            }
            s1.push(i);
        }
        System.out.println(max);
    }
}

C++实现：

#include <bits/stdc++.h>
using namespace std;
int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n, m; cin >> n >> m;
  vector<int> a(n * 2);
  int64_t ans = LLONG_MIN, dp = 0, sum = 0;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    if (dp <= 0) {
      dp = a[i];
    } else {
      dp += a[i];
    }
    ans = max(ans, dp);
    sum += a[i];
  }
  if (m == 1) {
    cout << ans << '\n';
    return 0;
  }
  int64_t link = LLONG_MIN;
  for (int i = n; i < 2 * n; i++) {
    a[i] = a[i - n];
    if (dp <= 0) {
      dp = a[i];
    } else {
      dp += a[i];
    }
    link = max(link, dp);
  }
  if (sum > 0) {
    link += 1ll * sum * (m - 2);
  }
  cout << max(link, ans) << '\n';
}
  1. 差分数组，记录到当前位置上有多少个-1，分别讨论当前位置差分结果为-1,0,1的情况，递推更新答案。要用long long存。
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005];
const int64_t MOD = 1e9 + 7;
int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n, w; cin >> n >> w;
  bool ok = true;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
    a[i] = w - a[i];
    b[i] = a[i] - a[i - 1];
    if (a[i] < 0 || b[i] < -1 || b[i] > 1) {
      ok = false;
    }
  }
  b[n + 1] = -a[n];
  if (b[n + 1] < -1 || b[n + 1] > 1) {
    ok = false;
  }
  if (!ok) {
    cout << "0\n";
    return 0;
  }
  int64_t ans = 1;
  for (int i = 1; i <= n + 1; i++) {
    if (b[i] == 0 || b[i] == -1) {
      ans = (ans * (a[i] + 1)) % MOD;
    }
  }
  cout << ans << '\n';
}
TechGuide
关注
专栏目录
2023美团面试真题
喜欢猪猪
03-06 4371
在使用过程中，把最近使用的页面移动到队列头，最近没有使用的页面将被放在队列尾的位置l 使用一个哈希表，把页号作为键，把缓存在队列中的节点的地址作为值，只需要把这个页对应的节点移动到队列的前面，如果需要的页面在内存中，此时需要把这个页面加载到内存中，简单的说，就是将一个新节点添加到队列前面，并在哈希表中跟新相应的节点地址，如果队列是满的，那么就从队尾移除一个节点，并将新节点添加到队列的前面。完全以缓存为准，使用延迟异步加载的策略（异步线程负责维护缓存的数据，定期或根据条件触发更新），这样就不会触发更新。
美团前端二面必会手写面试题汇总
helloworld1024fd的博客
10-10 844
考点： 数组去重方法汇总 1. 双层 for 循环 2. Array.filter() 加 indexOf/includes 3. ES6 中的 Set 去重 4. reduce 实现对象数组去重复 实现观察者模式 观察者需要放到被观察者中，被观察者的状态变化需要通知观察者 我变化了 内部也是基于发布订阅模式，收集观察者，状态变化后要主动通知观察者 实现一个链表结构 链表结构看图理解next层级 参考前端手写面试题详细解答第一版 时间复杂度为 O(n^2) 第二版 标记法 / 自定义属性法 时间
美团2019秋招编程题-考试攻略-JavaScript解法
guowenf的博客
03-21 406
问题描述 小明同学在参加一场考试，考试时间2个小时。试卷上一共有n道题目，小明要在规定时间内，完成一定数量的题目。 考试中不限制试题作答顺序，对于 i 第道题目，小明有三种不同的策略可以选择: (1)直接跳过这道题目，不花费时间，本题得0分。 (2)只做一部分题目，花费pi分钟的时间，本题可以得到ai分。 (3)做完整个题目，花费qi分钟的时间，本题可以得到bi分。 小明想知道，他最多能得到多少...
美团编程题
anyi6536的博客
10-30 228
有一个X*Y的网格，小团要在此网格上从左上角到右下角，只能走格点且只能向右或向下走。请设计一个算法，计算小团有多少种走法。给定两个正整数int x,int y，请返回小团的走法数目。 解法：把网格看做二维坐标，向下为正，向右为正：设f(m,n)代表从坐标（m,n）到坐标（0,0）的移动方法，则f(m,n)=f(m-1,n)+f(m,n-1)开始为f(0,0)=0,f(0,1)=1,f(...
美团Ai面试、笔试记录
最新发布
TIANLEeeee的博客
08-11 3011
美团Ai面试、笔试10道选择题、3道算法题
9.6 美团笔试编程题
傻傻分不清、
09-06 1855
A 题意: 求一棵树中, 从点1遍历所有点的最短距离, 所有相邻点之间的距离都是1 思路: 假设问题是这样, 从点1遍历所有点最后回到点1, 很显然对于结果就是2 * (n - 1), 因为每条边都会遍历恰好两次, n是结点数目. 那么此时只需要遍历所有点, 不需要回到点1, 那么我们可以选择一条从1出发的最长路径, 这条路径中的边只会遍历一次. 答案就是 2 * (n - 1) - 从点1...
2018美团点评编程题第一题
共同交流与成长
09-01 2282
晚上参加美团的笔试，今天从坐了一天的车，到了学校匆忙吃了饭，然后就开始了。确实是，脑子有点不灵光。编程的第一题： 给定一个序列，输出这个序列子串的和为K的倍数的子串的长度，如果有重复，输出最大长度。 例如：序列为：{1,2,3,4,5} k = 5 那么子串的和为5的倍数的有{2,3}，{1,2,3,4}，{1,2,3,4,5},{5} ，而这时长度最大的是5，所以输出5。刚开始看到这道题，
2020春招 / 2021秋招阿里、腾讯、字节、快手、美团 JAVA 开发岗面试高频问题总结
weixin_44202871的博客
02-05 2985
2020春招 / 2021秋招阿里、腾讯、字节、快手、美团 JAVA 开发岗面试高频问题总结 2.1 进程和线程的区别？ 2.2 进程的调度算法有哪些？（主要） 2.3 常用 IO 模型？ 2.4 select、poll 和 epoll 的区别？epoll 的底层使用的数据结构。 2.5 进程的通信方式有哪些？线程呢？ 2.6 fork 函数的作用？ 2.7 协程的概念？ 2.8. linux 进程和线程？ 2.9 通过进程id查看占用的端口，通过端口号查看占用的进程 id？ 2.10 如何查看占用内存
2020美团面试真题解析
FB_YING的博客
12-03 728
2020美团面试真题解析 1.双链表找相交结点2.10亿数，找最大100个数3.synchronize 静态方法和普通方法4.ANR是什么，怎么解决 5.Activity生命周期，如何摧毁一个Activity（finsh()） 6.startserver和bindserver 7.聊项目 8.聊各种各样的工作 自我介绍实习时长 有没有做过相关的项目或者自己实现过小daemon吗 平时有跟其他同学合作过吗，你是写客户端的，遇到问题如何解决，你觉得跟你合作的同学水平如何？ 前后端通信用的什么协议？ 输入一个UR
2020届春招实习面经（含阿里、腾讯、网易、京东、华为、美团、快手、字节跳动）
程序员世杰
06-14 3578
前言： 之前发表了一篇实习复习的内容: 史上最全！20/21届春招/秋招 实习/校招 JAVA面试全攻略！复习回顾这一篇就够了！ 在这篇文章详细说了该如何去复习，也答应各位把面经整理一下，但是因为入职的事情耽搁了，现在整理出来回馈给大家！ PS:楼主只收到网易、快手、华为三家offer，也不是所谓的offer收割机。只是提供一些个人经验，这个平台帮了我很多，前人栽树后人乘凉，共勉！ 文章目录快手（已offer）一面（60mins）二面（55mins）HR面（15mins）阿里一面腾讯一面（40mi.
牛客网刷编程题-美团-1
尚墨1111的博客
05-07 232
美团：[编程题]正则序列 import java.util.*; public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); int n = sc.nextInt(); int[] dp = new int[n]; for(int i =0;i<n;i++){ dp[i] = sc.nextInt(); }
美团编程
赏星乐事
08-20 387
实现一个动态数组类，功能包括在位置 N 增加一个数据，在位置 N 删除一个数据，获取第 N 大的数据，获取第 N 小的数据，获取数组的第 N 个数据，其中， N 取任意值。#include <iostream>#include <stdio.h>#include <algorithm>struct my_list{ my_list *next; int value; my_list
美团笔试之编程题
阳仔的博客
10-05 1188
有一个长为n的数组A，求满足0≤a≤b 给定数组A及它的大小n，请返回最大差值。 class LongestDistance { public:     int getDis(vector A, int n) {         // write code here         int max_dis = 0; int min_num = A.at(0); int dis;
美团2017编程题—拼凑钱币&大富翁游戏&最大矩形面积&最长公共连续子串
CYF18120161685的专栏
08-31 1770
拼凑钱币题目描述给你六种面额 1、5、10、20、50、100 元的纸币，假设每种币值的数量都足够多，编写程序求组成N元（N为0~10000的非负整数）的不同组合的个数。 输入描述:输入包括一个整数n(1 ≤ n ≤ 10000)输出描述:输出一个整数,表示不同的组合方案数输入例子1:1输出例子1:1思路完全背包问题代码#include<iostream> using namespace std;
美团2018在线编程
pixiaopi87的博客
03-23 381
参考了大佬的c/c++，欢迎指正 https://blog.csdn.net/flushhip/article/details/79660602 import java.util.Scanner; /** * 2018美团校招后台开发在线测试第二题 * 求不能组成的最小正整数 * @author LP * */ public class Main { public stat...
【2021春招】美团春招练习题--编程题套1
qq_39457586的博客
03-09 216
美团春招练习题–编程题套1 import java.util.*; public class Main { public static void main(String[] args) { Scanner read = new Scanner(System.in); int[] starts = new int[5]; double sum = 0.0; int count = 0; for (int i = 0;
美团2019编程汇总
qq_33470207的博客
08-20 422
1、 给定一张包含N个点、N-1条边的无向连通图，节点从1到N编号，每条边的长度均为1。假设你从1号节点出发并打算遍历所有节点，那么总路程至少是多少？ 输入描述: 第一行包含一个整数N，1≤N≤10^5。 接下来N-1行，每行包含两个整数X和Y，表示X号节点和Y号节点之间有一条边，1≤X，Y≤N。 输出描述: 输出总路程的最小值。 示例1 输入 4 1 2 1 3 3 4 输出 4 解析：这首先不是一个环，如果要想路径最短那么只能最长路径走一遍，短的路径走两遍（要返回1）。 import java.util
美团编程——重要节点
清风拂面
10-10 273
题目描述 输入描述: 输出描述: 示例1 输入 输出 4 3 2 1 3 1 1 4 2 样例解释：重要节点是1，4。 代码： from queue import Queue n, m = [int(x) for x in input().split()] from_v = [[] for _ in range(n)] to_v = [[] for _ in range(n)] vers = [[] fo.
Java编程100道精选选择题解析
本资源是一份包含100道Java选择题的题库，旨在帮助学习者巩固和测试对Java编程语言的理解。以下是部分题目及其知识点的详细解析： 1. **标识符规则** - Java语言中的标识符命名不能以数字开头，因此选项D "112" 不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值