Java2023算法面试题java，python，go

public class Main {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 2; i <= 200; i++) {
            boolean isPrime = true;
            for (int j = 2; j <= Math.sqrt(i); j++) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.print(i + " ");
                count++;
            }
        }
        System.out.println("\n1-200之间有" + count + "个素数");
    }
}

count = 0  # initialize count variable to 0
for num in range(1, 201):  # iterate through numbers 1 to 200
    if num > 1:  # prime numbers are greater than 1
        for i in range(2, num):  # iterate through numbers 2 to num-1
            if (num % i) == 0:  # if num is divisible by i, it is not prime
                break
        else:  # if num is not divisible by any i, it is prime
            print(num)  # print the prime number
            count += 1  # increment the count variable
print("There are", count, "prime numbers between 1 and 200")  # print the total count of prime numbers

package main

import "fmt"

func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    count := 0
    for i := 2; i <= 200; i++ {
        if isPrime(i) {
            fmt.Println(i)
            count++
        }
    }
    fmt.Printf("1到200之间有%d个质数", count)
}

public class ArrayUtil {
    public static void findMinMax(int[] arr) {
        int min = arr[0];
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            } else if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("Minimum value: " + min);
        System.out.println("Maximum value: " + max);
    }
}

# 找到具有唯一值的数组的最大值和最小值，我们可以使用内置函数max()和min()
# 这些函数的时间复杂度为O(n)，这是找到数组的最大值和最小值的最有效方法

# 示例代码：
arr = [1, 2, 3, 4, 5]
max_val = max(arr)
min_val = min(arr)

print("最大值：", max_val)
print("最小值：", min_val)

// 使用动态规划方法查找两个字符串的最长公共子串

// 查找两个字符串的最长公共子串的函数
public static String longestCommonSubstring(String str1, String str2) {
    int m = str1.length();
    int n = str2.length();

    // 变量用于存储最长公共子串的长度
    int maxLength = 0;

    // 变量用于存储最长公共子串的结束索引
    int endIndex = 0;

    // 查找表用于存储子字符串的最长公共后缀的长度
    int[][] lookup = new int[m + 1][n + 1];

    // 遍历输入字符串并填充查找表
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            // 如果 `str1` 和 `str2` 的当前字符匹配
            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                lookup[i][j] = lookup[i - 1][j - 1] + 1;

                // 更新最长子串的最大长度和结束索引
                if (lookup[i][j] > maxLength) {
                    maxLength = lookup[i][j];
                    endIndex = i - 1;
                }
            }
        }
    }

    // 使用结束索引和长度返回最长公共子串
    return str1.substring(endIndex - maxLength + 1, endIndex + 1);
}

// 示例用法
public static void main(String[] args) {
    String str1 = "ABC", str2 = "BABA";
    System.out.println("最长公共子串是 " + longestCommonSubstring(str1, str2));
}

# 定义函数，求两个字符串的最长公共子串
def find_longest_common_substring(str1, str2):
    # 初始化矩阵
    matrix = [[0] * (len(str2) + 1) for _ in range(len(str1) + 1)]
    # 初始化最长公共子串长度
    max_len = 0
    # 初始化最长公共子串的结束位置
    end = 0
    # 遍历字符串
    for i in range(1, len(str1) + 1):
        for j in range(1, len(str2) + 1):
            if str1[i - 1] == str2[j - 1]:
                matrix[i][j] = matrix[i - 1][j - 1] + 1
                if matrix[i][j] > max_len:
                    max_len = matrix[i][j]
                    end = i
            else:
                matrix[i][j] = 0
    # 返回最长公共子串
    return str1[end - max_len:end]

# 测试
str1 = "abcdefg"
str2 = "defghijk"
print(find_longest_common_substring(str1, str2)) # 输出 "def"

// 使用go语言，求两个字符串的最长公共子串，并给出中文注释
func longestCommonSubstring(s1, s2 string) string {
    // 构建一个二维数组，用于存储最长公共子串的长度
    m := make([][]int, len(s1)+1)
    for i := range m {
        m[i] = make([]int, len(s2)+1)
    }
    // 记录最长公共子串的长度和结束位置
    maxLen, endIndex := 0, 0
    // 遍历两个字符串，找到最长公共子串
    for i := 1; i <= len(s1); i++ {
        for j := 1; j <= len(s2); j++ {
            if s1[i-1] == s2[j-1] {
                m[i][j] = m[i-1][j-1] + 1
                if m[i][j] > maxLen {
                    maxLen = m[i][j]
                    endIndex = i
                }
            }
        }
    }
    // 返回最长公共子串
    return s1[endIndex-maxLen : endIndex]
}