(A卷,100分)- 预订酒店（Java & JS & Python）

题目描述

放暑假了，小明决定到某旅游景点游玩，他在网上搜索到了各种价位的酒店（长度为n的数组A），他的心理价位是x元，请帮他筛选出k个最接近x元的酒店（n>=k>0）,并由低到高打印酒店的价格。

输入描述

第一行：n, k, x
第二行：A[0] A[1] A[2]…A[n-1]

输出描述

从低到高打印筛选出的酒店价格

备注

1. 酒店价格数组A和小明的心理价位x均为整型数据
2. 优先选择价格最接近心理价位的酒店，若两家酒店距离心理价位差价相同，则选择价格较低的酒店。（比如100元和300元距离心理价位200元同样接近，此时选择100元）
3. 酒店价格可能相同重复

用例

Java算法源码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringJoiner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    int k = sc.nextInt();
    int x = sc.nextInt();

    int[] prices = new int[n];
    for (int i = 0; i < n; i++) {
      prices[i] = sc.nextInt();
    }

    System.out.println(getResult(n, k, x, prices));
  }

  /**
   * @param n 长度为n的价位数组
   * @param k 筛选出k个最接近x元的酒店
   * @param x 心理价位是x元
   * @param prices 价位数组
   * @return 筛选出k个最接近x元的酒店（n>=k>0）,并由低到高打印酒店的价格
   */
  public static String getResult(int n, int k, int x, int[] prices) {
    ArrayList<int[]> tmp = new ArrayList<>();

    for (int p : prices) {
      tmp.add(new int[] {p, Math.abs(p - x)});
    }

    tmp.sort((a, b) -> a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]);

    StringJoiner sj = new StringJoiner(" ");

    Integer[] ans = tmp.stream().limit(k).map(arr -> arr[0]).toArray(Integer[]::new);
    Arrays.sort(ans);

    for (Integer an : ans) {
      sj.add(an + "");
    }

    return sj.toString();
  }
}

JavaScript算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

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

const lines = [];
rl.on("line", (line) => {
  lines.push(line);

  if (lines.length === 2) {
    const [n, k, x] = lines[0].split(" ").map(Number);
    const prices = lines[1].split(" ").map(Number);

    console.log(getResult(n, k, x, prices));

    lines.length = 0;
  }
});

function getResult(n, k, x, prices) {
  const tmp = [];

  for (let p of prices) {
    tmp.push([p, Math.abs(p - x)]);
  }

  tmp.sort((a, b) => (a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]));

  return tmp
    .slice(0, k)
    .map((arr) => arr[0])
    .sort((a, b) => a - b)
    .join(" ");
}

Python算法源码

# 输入获取
n, k, x = map(int, input().split())
prices = list(map(int, input().split()))


# 算法入口
def getResult(n, k, x, prices):
    tmp = []

    for p in prices:
        tmp.append((p, abs(p - x)))

    tmp.sort(key=lambda x: (x[1], x[0]))

    ans = list(map(lambda x: x[0], tmp[:k]))

    ans.sort()

    return " ".join(map(str, ans))


# 调用算法
print(getResult(n, k, x, prices))