Bilibili 2020校招 后端笔试试卷

Bilibili后端笔试试卷

第一题：原地翻转字符串，要求空间复杂度O（1），时间复杂度 O（n）

AC 100% 代码：

import java.util.Scanner;

/**
 * @author HGS
 * @date 2019/08/20
 */
public class BiliBili01 {

    public static void swap(char[] chars, int a, int b) {
        char temp = chars[a];
        chars[a] = chars[b];
        chars[b] = temp;
    }

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        char[] temp = s.toCharArray();

        int len = temp.length;
        int l = 0;
        int r = len - 1;
        // 第一步，首先把整个字符数组逆序过来
        while (l < r) {
            swap(temp, l++, r--);
        }
        l = 0;

        // 第二步，把以空格还原逆序的单词
        boolean isHaveBlank = false;
        for (int i = 0; i < len; i++) {
            if (temp[i] == ' ') {
                r = i - 1;
                while (l < r) {
                    swap(temp, l++, r--);
                }
                l = i + 1;
                isHaveBlank = true;  // 标记为真
            }
        }
        r = len - 1;
        while(l < r){  //最后剩下的一个单词也要逆序
            swap(temp,l++,r--);
        }

        if (!isHaveBlank) { // 如果不含空格再倒叙回来
            l = 0;
            r = len - 1;
            while (l < r) {
                swap(temp, l++, r--);
            }
        }

        for (int i = 0; i < len; i++) {
            System.out.print(temp[i]);
        }
    }
}

第二题：将一个数组，连接起来排成一个数，输出能排出的所有数字最小的一个

AC 100% 代码：

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author HGS
 * @date 2019/08/20
 */
public class BiliBili02 {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        String[] split = s.split(",");
        Arrays.sort(split, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i]);
        }
        System.out.println();
    }
}

第三题：01背包问题

AC 100% 代码：时间复杂度O（n*logn）

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/**
 * @author HGS
 * @date 2019/08/20
 */
public class BiliBili03 {

    public static class Node {
        int w;
        int v;
        double wv; // 单位w的价值

        Node(int w) {
            this.w = w;
        }
    }

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        Node[] nodes = new Node[n];
        for (int i = 0; i < n; i++) {
            int w = sc.nextInt();
            nodes[i] = new Node(w);
        }
        for (int i = 0; i < n; i++) {
            int v = sc.nextInt();
            nodes[i].v = v;
        }
        // 贪心思路，设置一个价值数组 单位w的价值v，价值大的优先
        for (int i = 0; i < n; i++) {
            if (nodes[i].w == 0) {
                nodes[i].wv = Integer.MAX_VALUE;
            } else {
                nodes[i].wv = nodes[i].v * 1.0 / nodes[i].w;
            }
        }
        Arrays.sort(nodes, new Comparator<Node>() { // 根据价值从大到小排序
            @Override
            public int compare(Node o1, Node o2) {
                String s1 = String.valueOf(o1.wv);
                String s2 = String.valueOf(o2.wv);
                return s2.compareTo(s1);
            }
        });
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (nodes[i].w <= m) {
                res += nodes[i].v;
                m -= nodes[i].w;
            }
            if (m <= 0) {
                break;
            }
        }
        System.out.println(res);
    }
}