BiliBili2020校招笔试题

第一批

1.最小操作次数
题目描述：
给出两个单词word1和word2，计算出将word1 转换为word2的最少操作次数。
你总共三种操作方法：
插入一个字符
删除一个字符
替换一个字符

输入例子1:
abc
abd

输出例子1:
1

例子说明1:
把c->d，只需要一次操作

题解：与leetcode1143一致，找到两个字符串最长公共子序列即可。

import java.util.Scanner;

/**
 * 题目：将字符串a变成b，可以执行三种操作插入、删除、修改，求最少操作数
 */
public class test01 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String a=sc.nextLine();
        String b=sc.nextLine();
        int res=longResult(a,b);
        System.out.println(Math.max(a.length(),b.length())-res);
    }
    public static int longResult(String a,String b){
        char[] ch1=a.toCharArray();
        char[] ch2=b.toCharArray();
        int[][] dp=new int[ch1.length+1][ch2.length+1];
        for(int i=1;i<dp.length;i++){
            for(int j=1;j<dp[0].length;j++){
                if(ch1[i-1]==ch2[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[ch1.length][ch2.length];
    }
}

2.连续整数求和
题目描述：
给定一个正整数N，试求有多少组连续正整数满足所有数字之和为N? (1 <= N <= 10 ^ 9)

输入例子1:
5

输出例子1:
2

例子说明1:
5 = 5 = 2 + 3，共有两组连续整数([5],[2,3])求和后为 5。

题解：等差数列求和。
题目问题等价于：N=(a+a+k-1)k/2;【a指数列开始的数字，k指数列长度】
等价于：ak=N-(k-1)*k/2;
即要求：(k-1)*k/2<N && (N-(k-1)*k/2)能被k整除

import java.util.Scanner;

/**
 * leetcode829
 * 题目：给定一个正整数N，试求有多少组连续正整数满足所有数字之和为N? (1 <= N <= 10 ^ 9）
 */
public class test02 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        int res=CalMax(N);
        System.out.println(res);
    }

    public static int CalMax(int N){
        int count=0;
        for(int i=1;i*(i-1)/2<N;i++){
            int tmp=N-(i-1)*i/2;
            if(tmp%i==0)
                count++;
        }
        return count;
    }

}

3.字符串切分
题目描述：
从标准输入读取字符串，按照指定的两层分隔符切分成多对key-value，依次输出到标准输出中。
注意：仅输出key和value都为非空串的pair。

输入例子1:

# : a:3#b:8#c:9

输出例子1:
3
a 3
b 8
c 9

题解：

1. 先获取间隔符和关系符
2. 用split(间隔符)得到分离后的字符串数组
3. 用contains(关系符)检验各个字符串是否标准
4. 用replace(关系符, 空格)输出

import java.util.Scanner;

public class test03 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        if(str.length()<4)
            System.out.println(0);
        else {
            char a = str.charAt(0);
            char b = str.charAt(2);
            String[] strs = str.substring(4).split(a + "");
            int len = strs.length;
            for (String s : strs) {
                if (!s.contains(b + ""))
                    len--;
            }
            System.out.println(len);
            if (len > 0) {
                for (String s : strs) {
                    if (s.contains(b + ""))
                        System.out.println(s.replace(b, ' '));
                }
            }
        }

    }
}

第二批：
1.原地翻转句子中单词的顺序，但单词内字符的顺序不变。要求：空间复杂度O(1)，时间复杂度O(n)。

public class Main{
    public String reverseWords(String s) {
 
        s=s.trim();
        StringBuilder sb=new StringBuilder();
        int i=s.length()-1,j=i;
        while (i>=0){
            while (i>=0 &&s.charAt(i)!=' ') i--;
            sb.append(s.substring(i+1,j+1)+" ");
            while (i>=0 &&s.charAt(i)==' ') i--;
            j=i;
        }
        return sb.toString().trim();
 
    }
}

2.输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。

import java.util.Arrays;
 
public class Main {
    public String minNumber(int[] nums) {
        String[] str=new String[nums.length];
        for(int i=0;i<nums.length;i++){
            str[i]=String.valueOf(nums[i]);
        }
        Arrays.sort(str,(x,y)->(x+y).compareTo(y+x));
        StringBuilder sb=new StringBuilder();
        for (String s:str)
            sb.append(s);
        return sb.toString();
    }
}

3.有为N件物品，它们的重量w分别是w1,w2,…,wn，它们的价值v分别是v1,v2,…,vn，每件物品数量有且仅有一个，现在给你个承重为M的背包，求背包里装入的物品具有的价值最大总和？

public class Main{
    public int bag(int W,int N,int[] weight,int[] values){
        int[][] dp=new int[N+1][W+1];
        for(int i=0;i<dp.length;i++)
            dp[i][0]=0;
        for(int i=0;i<dp[0].length;i++)
            dp[0][i]=0;
        for(int i=1;i<dp.length;i++){
            for(int j=1;j<dp[0].length;j++){
                if(weight[i-1]>j)
                    dp[i][j]=dp[i-1][j];
                else
                    dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i-1]]+values[i-1]);
            }
        }
        return dp[N][W];
    }
}