美团研发岗 4月18号笔试真题 - 数据清除

数据清除(Py/Java/C++/Js/Go)题解

美团研发岗 四月十八号笔试 第一题

题目内容

小美正在清除残留数据，这个过程可以抽象成一个长度为 nnn的序列 aaa。

小美会进行 mmm 轮清洗：每轮她会删除序列中最小的数 ；如果有多个相同的最小数，则清除最靠前的那个数 （即下标最小的那个）。

请输出小美进行完 mmm 轮清洗后的序列。

输入描述

每个测试文件均包含多组测试数据：

• 第一行输入一个整数 T(1≤T≤2×105)T(1 ≤ T ≤ 2 × 10^5)T(1≤T≤2×105)，代表数据组数。
• 每组测试数据描述如下：
• 第一行输入两个整数 n,m(1≤n≤2×105;0≤m<n)n, m(1 ≤ n ≤ 2 × 10^5;0 ≤ m < n)n,m(1≤n≤2×105;0≤m<n)，分别代表序列的长度和清洗轮数。
• 第二行输入 nnn 个整数 a1,a2,...,an(1≤ai≤n)a_1, a_2, ..., a_n(1 ≤ a_i ≤ n)a1,a2,...,an(1≤ai≤n)，代表初始序列。
  除此之外，保证单个测试文件的 nnn 之和不超过 4×1054 × 10^54×105。

输出描述

对于每一组测试数据，新起一行，输出最终的序列，元素之间用空格隔开。

样例1

输入

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

输出

3 4 5
1 2 3
5

题解和思路

思路

实现思路：自定义排序

1. 接收每组输入，然后将输入数组按照{值，下标}存储至数组中，然后按照值升序，值相同按照下标升序进行自定义排序。
2. 将排序后的数组对应前m个元素标记为删除。
3. 按题目要求格式按顺序输出未删除元素。

C++

#include<bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    cin >> T;
    while (T--){
        int n , m;
        cin >> n >> m;
        vector<bool> isDelete(n, false);
        vector<int> b(n);
        vector<vector<int>> a(n, vector<int>(2, 0));
        
        for (int i = 0; i < n; i++) {
            cin >> b[i] ;
            a[i] = {b[i], i};
        }
        
        // 自定义排序
        sort(a.begin(), a.end(), [](auto& a, auto & b) {
            if (a[0] == b[0]) {
                return a[1] < b[1]; 
            }
            return  a[0] < b[0];
        });
        
        for (int i = 0; i < m; i++) {
            isDelete[a[i][1]] = true;
        }
        // 输出结果
        bool isFirst = true;
        for (int i = 0; i < n; i++) {
            if (isDelete[i]) {
                continue;
            }
            if (!isFirst) {
                cout << " ";
            }
            isFirst = false;
            cout << b[i];
        }
        cout << endl;
    }

    return 0;
}

Java

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

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder ans = new StringBuilder();

        int T = Integer.parseInt(br.readLine());

        while (T-- > 0) {
            String[] first = br.readLine().split(" ");
            int n = Integer.parseInt(first[0]);
            int m = Integer.parseInt(first[1]);

            boolean[] isDelete = new boolean[n];
            int[] b = new int[n];
            int[][] a = new int[n][2];

            String[] nums = br.readLine().split(" ");

            for (int i = 0; i < n; i++) {
                b[i] = Integer.parseInt(nums[i]);
                a[i][0] = b[i];
                a[i][1] = i;
            }

            // 自定义排序
            Arrays.sort(a, (x, y) -> {
                if (x[0] == y[0]) {
                    return Integer.compare(x[1], y[1]);
                }
                return Integer.compare(x[0], y[0]);
            });

            for (int i = 0; i < m; i++) {
                isDelete[a[i][1]] = true;
            }

            // 输出结果
            boolean isFirst = true;
            for (int i = 0; i < n; i++) {
                if (isDelete[i]) {
                    continue;
                }
                if (!isFirst) {
                    ans.append(" ");
                }
                isFirst = false;
                ans.append(b[i]);
            }
            ans.append("\n");
        }

        System.out.print(ans);
    }
}

python

import sys

input = sys.stdin.readline

T = int(input())

for _ in range(T):
    n, m = map(int, input().split())

    is_delete = [False] * n
    b = list(map(int, input().split()))

    a = []

    for i in range(n):
        a.append((b[i], i))

    # 自定义排序
    a.sort(key=lambda x: (x[0], x[1]))

    for i in range(m):
        is_delete[a[i][1]] = True

    # 输出结果
    is_first = True

    for i in range(n):
        if is_delete[i]:
            continue

        if not is_first:
            print(" ", end="")

        is_first = False
        print(b[i], end="")

    print()

Javascript

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let input = [];

rl.on("line", (line) => {
    input.push(line.trim());
});

rl.on("close", () => {
    let idx = 0;
    let T = Number(input[idx++]);

    let output = [];

    while (T--) {
        let [n, m] = input[idx++].split(" ").map(Number);

        let isDelete = Array(n).fill(false);
        let b = input[idx++].split(" ").map(Number);

        let a = [];

        for (let i = 0; i < n; i++) {
            a.push([b[i], i]);
        }

        // 自定义排序
        a.sort((x, y) => {
            if (x[0] === y[0]) {
                return x[1] - y[1];
            }
            return x[0] - y[0];
        });

        for (let i = 0; i < m; i++) {
            isDelete[a[i][1]] = true;
        }

        // 输出结果
        let line = "";
        let isFirst = true;

        for (let i = 0; i < n; i++) {
            if (isDelete[i]) {
                continue;
            }

            if (!isFirst) {
                line += " ";
            }

            isFirst = false;
            line += b[i];
        }

        output.push(line);
    }

    console.log(output.join("\n"));
});

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var T int
	fmt.Fscan(in, &T)

	for T > 0 {
		T--

		var n, m int
		fmt.Fscan(in, &n, &m)

		isDelete := make([]bool, n)
		b := make([]int, n)
		a := make([][2]int, n)

		for i := 0; i < n; i++ {
			fmt.Fscan(in, &b[i])
			a[i] = [2]int{b[i], i}
		}

		// 自定义排序
		sort.Slice(a, func(i, j int) bool {
			if a[i][0] == a[j][0] {
				return a[i][1] < a[j][1]
			}
			return a[i][0] < a[j][0]
		})

		for i := 0; i < m; i++ {
			isDelete[a[i][1]] = true
		}

		// 输出结果
		isFirst := true

		for i := 0; i < n; i++ {
			if isDelete[i] {
				continue
			}

			if !isFirst {
				fmt.Fprint(out, " ")
			}

			isFirst = false
			fmt.Fprint(out, b[i])
		}

		fmt.Fprintln(out)
	}
}