【Java笔试强训】day23编程题

编程题

红包

import java.util.Arrays;

@SuppressWarnings({"all"})
public class Gift {
    public int getValue(int[] gifts, int n) {
        // write code here
        Arrays.sort(gifts);
        int mid = gifts[n / 2];
        int count = 0;
        for (int i : gifts) {
            if (i == mid) {
                count++;
            }
        }
        if (count > n / 2) {
            return mid;
        } else {
            return 0;
        }
    }
}

计算字符串的编辑距离

import java.io.BufferedReader;
import java.io.InputStreamReader;

@SuppressWarnings({"all"})
public class Main {

    // 可用的操作：插入，删除，替换
    // 一次操作：只能操作一个字符
    // 编辑距离：最小的操作次数

    // 动态规划：
    // 问题：字符串A转成字符串B的编辑距离
    // 子问题：字符串A的一部分转换成字符串B的一部分的编辑距离
    // 状态F(i,j)：字符串A的前i个字符转换成字符串B的前j个字符的编辑距离
    // 状态转移方程：F(i,j) = min{F(i,j-1) + 1,F(i-1,j)+1,F(i-1,j-1)+(A[i]==B[i] ? 0 : 1)}
    // 初始状态:F(0,j) = j(插入) F(i,0) = i(删除)

    // A: a b c d e f g
    // B: a b c d e f
    // F(1,1): a --> a 0
    // F(2,2): ab --> ab 0
    // F(4,4): abcd --> abcd 0  F(3,4) + 删除：d
    // F(3,4): abc --> abcd 1

    // F(i,j): A[1,i] --> B[1,j]
    // 插入操作: F(i,j-1): A[1,i] --> B[1,j-1] + 插入第j个字符
    // 删除操作: F(i-1,j): A[1,i-1] --> B[1,j] + 删除第i个字符
    // 替换操作: A[1,i-1] --> B[j-1] + A[i] == B[l]
    //                                相等：不替换
    //                                不相等：把A的第i个字符替换成B的第j个字符
    // min(插入，删除，替换)


    private static int getDistance(String str1, String str2) {
        char[] wd1 = str1.toCharArray();
        char[] wd2 = str2.toCharArray();
        int len1 = wd1.length;
        int len2 = wd2.length;
        // 定义一个矩阵
        int[][] dist = new int[len1 + 1][len2 + 1];
        // 初始状态 F(i,0) = i,F(0,j) = l
        for (int i = 0; i <= len1; i++) {
            dist[i][0] = i;
        }
        for (int j = 0; j <= len2; j++) {
            dist[0][j] = j;
        }
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                // F(i,j) = min{F(i-1,j) + 1, F(i,j-1) + 1, F(i-1,j-1) + (wd1[i] == wd2[i] ? 0 : 1)}
                // 首先求出插入和删除的最小值
                dist[i][j] = Math.min(dist[i - 1][j], dist[i][j - 1]) + 1;
                // 再和替换进行比较
                if (wd1[i - 1] == wd2[j - 1]) {
                    // 不需要进行替换
                    dist[i][j] = Math.min(dist[i][j], dist[i - 1][j - 1]);
                } else {
                    dist[i][j] = Math.min(dist[i][j], dist[i - 1][j - 1] + 1);
                }
            }
        }
        return dist[len1][len2];
    }

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String str1;
        while ((str1 = reader.readLine()) != null) {
            String str2 = reader.readLine();
            System.out.println(getDistance(str1, str2));
        }
    }
}