字符串 on Coder_Studio

BISHI94 【模板】马拉车算法

Fri, 06 Mar 2026 20:32:16 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果，提高IO效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入字符串并去除首尾空格
        String s = br.readLine().trim();

        // 处理空字符串或null值的情况
        if (s == null || s.length() == 0) {
            out.println(0);  // 输出0
            out.flush();     // 确保所有输出都被刷新
            return;          // 提前返回
        }

        // 调用manacher算法处理字符串并输出结果
        out.println(manacher(s));
        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();   // 关闭输入流
    }

    /**
     * Manacher算法实现，用于查找字符串中的最长回文子串的长度
     * 该算法通过预处理字符串和利用回文对称性来高效地找到最长回文子串
     *
     * @param s 输入的字符串
     * @return 返回最长回文子串的长度
     */
    private static int manacher(String s) {
        // 构造新的字符串，以^开头，$结尾，并在每个字符间插入#，这样可以统一处理奇数和偶数长度的回文
        StringBuilder sb = new StringBuilder("^");

        // 在原字符串的每个字符前后添加特殊字符#
        for (char c : s.toCharArray()) {
            sb.append("#").append(c);
        }

        // 添加结尾标记
        sb.append("#$");

        // 将构造好的字符串转换为字符数组
        char[] t = sb.toString().toCharArray();

        // 获取新字符串的长度
        int n = t.length;
        // 创建数组p，p[i]表示以t[i]为中心的最长回文半径
        int[] p = new int[n];
        // c表示当前回文中心，r表示当前回文右边界
        int c = 0, r = 0;
        // 记录最长回文半径
        int maxLen = 0;

        // 遍历字符串，跳过首尾的特殊字符
        for (int i = 1; i < n - 1; i++) {
            // 利用回文对称性，如果i在当前回文范围内，则获取其对称位置的回文半径
            p[i] = r > i ? Math.min(r - i, p[2 * c - i]) : 0;

            // 尝试扩展以i为中心的回文
            while (t[i + p[i] + 1] == t[i - p[i] - 1]) {
                p[i]++;
            }

            // 如果当前回文右边界超过了r，更新中心和右边界
            if (i + p[i] > r) {
                c = i;
                r = i + p[i];
            }

            // 更新最大回文半径
            maxLen = Math.max(maxLen, p[i]);
        }

        // 返回最长回文半径，也就是最长回文子串的长度
        return maxLen;
    }

BISHI93 【模板】Trie 字典树

Thu, 05 Mar 2026 22:07:17 +0000

思路

求解代码

/**
     * trie[p][i]: 字典树的节点存储。
     * 第一维 p 代表节点的编号（行号）；
     * 第二维 i 代表字符的映射索引（0-51）。
     * 值存储的是该字符指向的下一个节点的编号。
     */
    private static int[][] trie = new int[1000005][52];

    /**
     * count[p]: 前缀统计的核心。
     * 记录有多少个模式串在插入过程中经过了编号为 p 的节点。
     * 因为我们要统计“以某串为前缀的个数”，所以每经过一个点都要加1。
     */
    private static int[] count = new int[1000005];

    /**
     * nodes: 记录当前字典树已经创建的节点总数。
     * 编号 0 始终代表根节点（不存储具体字符）。
     */
    private static int nodes = 0;

    public static void main(String[] args) throws IOException {
        // 使用高效的输入输出流处理百万级数据，防止超时
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行：模式串数量 n 和查询次数 q
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        // 1. 构建字典树阶段
        for (int i = 0; i < n; i++) {
            insert(br.readLine().trim());
        }

        // 2. 查询阶段
        for (int i = 0; i < q; i++) {
            // 直接输出以该文本串为前缀的模式串数量
            out.println(query(br.readLine().trim()));
        }

        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 将字符映射到 0-51 的索引空间。
     * 区分大小写：'A'-'Z' 映射到 0-25，'a'-'z' 映射到 26-51。
     */
    private static int getIndex(char c) {
        return c >= 'A' && c <= 'Z' ? c - 'A' : c - 'a' + 26;
    }

    /**
     * 模式串插入方法
     * 核心逻辑：沿着路径在每个经过的节点打标记计数。
     */
    private static void insert(String s) {
        int p = 0; // 从根节点 (编号 0) 开始
        for (char c : s.toCharArray()) {
            int i = getIndex(c);
            // 如果当前字符在当前节点下没有对应的子节点，则新建一个
            if (trie[p][i] == 0) {
                trie[p][i] = ++nodes;
            }
            // 移动到子节点
            p = trie[p][i];
            /**
             * 关键：只要经过这个节点，count 就自增。
             * 这样 count[p] 就代表了有多少个单词是以“从根到当前点”这一串字符为前缀的。
             */
            count[p]++;
        }
    }

    /**
     * 文本串查询方法
     * 核心逻辑：在字典树中顺着文本串寻找路径，若能走完路径，返回最后的 count。
     */
    private static int query(String t) {
        int p = 0; // 从根节点开始
        for (char c : t.toCharArray()) {
            int i = getIndex(c);
            /**
             * 如果在路径中发现某个字符没有对应的分支，
             * 说明没有任何一个模式串包含这个前缀，直接返回 0。
             */
            if (trie[p][i] == 0) {
                return 0;
            }
            p = trie[p][i]; // 顺着路径向下走
        }
        /**
         * 成功走完文本串 t 的所有字符，
         * 此时节点 p 的 count 值就是在插入阶段经过该点的字符串总数。
         */
        return count[p];
    }

BISHI92 【模板】前缀函数（kmp）

Thu, 05 Mar 2026 20:58:37 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 创建缓冲读取器，用于从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 创建打印输出器，用于向标准输出打印数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        // 读取测试用例的数量T
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- > 0) {
            // 读取一行输入并分割成字符串数组
            String[] s = br.readLine().trim().split("\\s+");
            // 获取字符串的长度n
            int n = Integer.parseInt(s[0]);

            // 计算前缀函数数组
            int[] pi = computePre(s[1], n);

            // 输出前缀函数数组，元素间用空格分隔
            for (int i = 0; i < n; i++) {
                out.print(pi[i] + (i == n - 1 ? "" : " "));
            }
            // 换行
            out.println();
        }

        // 刷新输出缓冲区，确保所有输出都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 计算字符串的前缀函数（Prefix Function）
     * 前缀函数pi[i]表示字符串s[0..i]的最长相等前后缀的长度（不包括s[0..i]本身）
     *
     * @param s 输入的字符串
     * @param n 字符串的长度
     * @return 返回前缀函数数组pi，其中pi[i]表示s[0..i]的最长相等前后缀长度
     */
    private static int[] computePre(String s, int n) {
        int[] pi = new int[n];  // 初始化前缀函数数组，长度为n

        // 从第二个字符开始遍历字符串
        for (int i = 1; i < n; i++) {
            int j = pi[i - 1];  // 初始化j为前一个字符的前缀函数值

            // 当j大于0且当前字符不匹配时，通过前缀函数回退
            while (j > 0 && s.charAt(i) != s.charAt(j)) {
                j = pi[j - 1];  // 回退到前一个可能匹配的位置
            }

            // 如果当前字符匹配，则增加匹配长度
            if (s.charAt(i) == s.charAt(j)) {
                j++;
            }

            // 将当前字符的前缀函数值存入数组
            pi[i] = j;
        }
        return pi;  // 返回计算得到的前缀函数数组
    }

数位差与数值和的构造

Wed, 11 Feb 2026 00:02:55 +0000

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.nextToken());
        for (int i = 0; i < t; i++) {
            in = new StringTokenizer(br.readLine());
            String s = in.nextToken();

            StringBuilder sb1 = new StringBuilder();
            StringBuilder sb2 = new StringBuilder();

            boolean flag = true;

            for (char c : s.toCharArray()) {
                int digit = c - '0';
                int half = digit / 2;

                //当前位是偶数 → 平分给sb1和sb2
                if (digit % 2 == 0) {
                    sb1.append(half);
                    sb2.append(half);
                } else {
                    //当前位是奇数 → 交替分配多的1（half+1）
                    if (flag) {
                        sb1.append(half + 1);
                        sb2.append(half);
                    } else {
                        sb1.append(half);
                        sb2.append(half + 1);
                    }

                    flag = !flag;
                }
            }
            out.println(Long.parseLong(sb1.toString()) + " " + Long.parseLong(
                    sb2.toString()));
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI20 回文日期

Sat, 07 Feb 2026 23:14:50 +0000

求解代码

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int a = (int) in.nval;

        in.nextToken();
        int b = (int) in.nval;

        int start = a / 10000;
        int end = b / 10000;

        int count = 0;

        for (int y = start; y <= end; y++) {
            // 年份转字符串（如2001→"2001"）
            String year = Integer.toString(y);
            // 反转年份得到MMDD
            String revYear = new StringBuilder(year).reverse().toString(); // 2001→"1002"

            // 拆分反转后的字符串为月份、日期（"1002"→month=10，day=02）
            int month = Integer.parseInt(revYear.substring(0, 2));
            int day = Integer.parseInt(revYear.substring(2, 4));

            // 拼接成8位日期
            int date = y * 10000 + month * 100 + day;

            // 日期在[a,b]区间内 并且 日期合法
            if (date >= a && date <= b) {
                if (isValidDate(y, month, day)) {
                    count++; // 符合条件则计数+1
                }
            }
        }
        out.println(count);

        out.flush();
        out.close();
        br.close();
    }

    private static boolean isValidDate(int y, int month, int day) {
        if (month < 1 || month > 12 || day < 1) {
            return false;
        }

        int[] monthDay = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        if (isLeap(y)) {
            monthDay[2] = 29;
        }

        return day <= monthDay[month];
    }

    private static boolean isLeap(int y) {
        return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
    }

BISHI19 乒乓球

Sat, 07 Feb 2026 21:28:21 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer in = new StringTokenizer(br.readLine());

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String str = in.nextToken();

        char[] s = str.toCharArray();

        printScore(11, s, out);
        out.println();
        printScore(21, s, out);

        out.flush();
        out.close();
        br.close();
    }

    private static void printScore(int score, char[] s, PrintWriter out) {
        int w = 0;
        int l = 0;

        // 遍历每一个得分字符（W/L）
        for (int i = 0; i < s.length; i++) {
            // 统计得分：W则w+1，否则（L）l+1
            if (s[i] == 'W') {
                w++;
            } else {
                l++;
            }

            // 判断是否赢下本局：
            // 条件1：分差≥2
            // 条件2：任意一方达到目标分数（w≥score 或 l≥score）
            if (Math.abs(w - l) >= 2 && (w >= score || l >= score)) {
                out.println(w + ":" + l); // 输出本局最终比分
                w = 0; // 重置得分，开始下一局
                l = 0;
            }
        }
        // 遍历完所有字符后，输出最后未完成局的剩余比分
        out.println(w + ":" + l);
    }

小红的字符串修改

Thu, 05 Feb 2026 22:51:14 +0000

求解代码

public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        StringTokenizer in = new StringTokenizer(br.readLine());
        String s= in.nextToken();
        
        in = new StringTokenizer(br.readLine());
        String t= in.nextToken();

        int min = Integer.MAX_VALUE;

        for(int i=0;i<=t.length()-s.length();i++){
            int count = 0;
            //截取t中从i开始、长度为s的连续子串x
            String x = t.substring(i,i+s.length());

            for(int j=0;j<s.length();j++){
                //26-差值：计算环形绕行的差值（26 个小写字母首尾相连）
                count+=Math.min(Math.abs(x.charAt(j)-s.charAt(j)), 26-Math.abs(x.charAt(j)-s.charAt(j)));
            }
            min=Math.min(min,count);
        }
        out.println(min);
        out.flush();
        out.close();
        br.close();
   }

字符串相乘

Mon, 02 Feb 2026 22:40:17 +0000

求解代码

public String multiply(String num1, String num2) {
            if ("0".equals(num1) || "0".equals(num2)) {
                return "0";
            }

            int len1 = num1.length();
            int len2 = num2.length();
            int[] res = new int[len1 + len2];

            // 从后往前遍历
            for (int i = len1 - 1; i >= 0; i--) {
                int n1 = num1.charAt(i) - '0';
                for (int j = len2 - 1; j >= 0; j--) {
                    int n2 = num2.charAt(j) - '0';
                    int sum = n1 * n2 + res[i + j + 1]; // 加上原来的低位
                    res[i + j + 1] = sum % 10;
                    res[i + j] += sum / 10;
                }
            }

            StringBuilder sb = new StringBuilder();
            for (int num : res) {
                if (!(sb.length() == 0 && num == 0)) {
                    sb.append(num);
                }
            }
            return sb.length() == 0 ? "0" : sb.toString();
        }

【中心扩展法】LCR_020_回文子串

Sun, 01 Feb 2026 23:41:08 +0000

求解代码

        public int countSubstrings(String s) {

            if(s==null||s.length()==0){
                return 0;
            }

            int ans = 0;

            for(int i=0;i<s.length();i++){
            		 // 1. 以i为中心（奇数长度回文）
                ans += countPalindrome(s, i, i);
                // 2. 以i和i+1为中心（偶数长度回文）
                ans += countPalindrome(s, i, i+1);
            }
            return ans;
        }

        private int countPalindrome(String s,int left,int right) {
            int count = 0;

            while(left>=0&& right< s.length()&&s.charAt(left)==s.charAt(right)){
                count++;
                left--;
                right++;
            }

            return count;
        }

LCR_019_验证回文串II

Sun, 01 Feb 2026 22:49:20 +0000

求解代码

public boolean validPalindrome(String s) {
            int len = s.length();
            int left = 0;
            int right = len-1;

            while(left<right){
                if(s.charAt(left)==s.charAt(right)){
                    left++;
                    right--;
                }else{
                    return valid(s,left+1,right)||valid(s, left, right-1);
                }
            }

            return true;

        }

        public boolean valid(String s,int left,int right) {
            while (left<right) {
                if(s.charAt(left)!=s.charAt(right)){
                    return false;
                }
                left++;
                right--;
            }
            return true;
        }

【滑动窗口+计数】LCR015找到字符串中所有字母异位词

Sat, 31 Jan 2026 22:51:13 +0000

求解代码

public List<Integer> findAnagrams(String s, String p) {
        List<Integer> ans = new ArrayList<>();

        if (s.length() < p.length()) {
            return ans;
        }

        int[] arrP = new int[26]; // 统计p的字符出现次数
        int[] arrS = new int[26]; // 统计s滑动窗口内的字符出现次数

        for (int i = 0; i < p.length(); i++) {
            arrP[p.charAt(i) - 'a']++; // p的第i个字符对应数组下标，计数+1
            arrS[s.charAt(i) - 'a']++; // 先统计s前p.length()个字符的计数
        }

        // 用于比较两个数组的内容是否完全相等
        if (Arrays.equals(arrP, arrS)) {
            ans.add(0);
        }

        // 初始窗口是[0, p.length()-1]，右边界从p.length()开始
        int left = 0;
        int right = p.length();

        while (right < s.length()) {
            // 右边界字符加入窗口：计数+1
            arrS[s.charAt(right) - 'a']++;
            // 左边界字符移出窗口：计数-1
            arrS[s.charAt(left) - 'a']--;

            // 窗口右移：左、右边界各+1
            left++;
            right++; 
                       
            // 此时窗口起始下标是left，判断是否匹配
            if (Arrays.equals(arrP, arrS)) {
                ans.add(left);
            }


        }

        return ans;
    }

小贴士

这道题思路和【滑动窗口+字符计数数组】LCR_014_字符串的排列基本一致，只不过有一些细节上的东西需要注意。

比如字符串排列那道题的处理顺序是：

更新计数 ➡️ 判断 ➡️ 移动边界

而这道题是：

更新计数 ➡️ 移动边界 ➡️ 判断

【滑动窗口+字符计数数组】LCR_014_字符串的排列

Sat, 31 Jan 2026 22:27:27 +0000

求解代码

public boolean checkInclusion(String s1, String s2) {
        if (s1.length() > s2.length()) {
            return false;
        }

        int[] a = new int[26]; // 统计s1的字符出现次数
        int[] b = new int[26]; // 统计s2滑动窗口内的字符出现次数

        for (int i = 0; i < s1.length(); i++) {
            a[s1.charAt(i) - 'a']++; // s1的第i个字符对应数组下标（如'a'→0，'b'→1），计数+1
            b[s2.charAt(i) - 'a']++; // 先统计s2前s1.length()个字符的计数
        }

        //用于比较两个数组的内容是否完全相等
        if (Arrays.equals(a, b)) {
            return true;
        }

        // 初始窗口是[0, s1.length()-1]，右边界从s1.length()开始
        int left = 0;
        int right = s1.length();

        while (right < s2.length()) {
            // 右边界字符加入窗口：计数+1
            b[s2.charAt(right) - 'a']++;
            // 左边界字符移出窗口：计数-1
            b[s2.charAt(left) - 'a']--;

            // 检查当前窗口计数是否匹配
            if (Arrays.equals(a, b)) {
                return true;
            }

            // 窗口右移：左、右边界各+1
            right++;
            left++;
        }

        return false;
    }

LCR005-最大单词长度乘积

Thu, 29 Jan 2026 23:59:13 +0000

求解代码

    public int maxProduct(String[] words) {
        int n = words.length;
        int[] masks = new int[n];
        int[] lens = new int[n]; 
        for (int i = 0; i < n; i++) {
            lens[i] = words[i].length(); 
            for (char c : words[i].toCharArray()) {
                masks[i] |= 1 << (c - 'a');
            }
        }
        int max = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if ((masks[i] & masks[j]) == 0) {
                    max = Math.max(max, lens[i] * lens[j]); 
                }
            }
        }
        return max;
    }

小贴士

遍历每个字符串，用一个 int 整数（掩码）表示该字符串包含的字符。

解释一下：

如果二进制第c-‘a’位为 1，则表示包含字符c。

比如包含a则第 0 位为 1，包含b则第 1 位为 1。

LCR002-二进制求和

Thu, 29 Jan 2026 21:44:50 +0000

求解代码

public String addBinary(String a, String b) {
        // 如果第一个字符串为空/长度为0，直接返回第二个字符串
        if (a.length() <= 0) {
            return b;
        }
        // 如果第二个字符串为空/长度为0，直接返回第一个字符串
        if (b.length() <= 0) {
            return a;
        }

        int i = a.length() - 1;

        int j = b.length() - 1;
        // 定义进位变量tmp
        int tmp = 0;
        // 定义StringBuilder拼接结果
        StringBuilder sb = new StringBuilder();

        // 需要注意：最后一位相加仍有进位时，需把进位1也拼接到结果
        while (i >= 0 || j >= 0 || tmp != 0) {

            tmp += i >= 0 ? a.charAt(i--) - '0' : 0;

            tmp += j >= 0 ? b.charAt(j--) - '0' : 0;

            // 取余2：得到当前位的计算结果
            sb.append(tmp % 2);
            // 除以2：更新进位值
            tmp = tmp / 2;
        }
        // 结果逆序：因为是从个位开始拼接，需要反转回正序，再转字符串返回
        return sb.reverse().toString();
    }

###小贴士

这道题本质上处理方式和【字节面试手撕】大数加法是一样的。

【双指针】反转字符串

Mon, 26 Jan 2026 23:11:14 +0000

求解代码

public String solve(String str) {
        // 空串/NULL直接返回
        if (str == null || str.length() == 0) {
            return str;
        }
        int i = 0; // 左指针
        int j = str.length() - 1; // 右指针
        char[] s = str.toCharArray(); // 由于String不可变,需要将字符串转成字符数组

        // 首尾双指针相向遍历
        while (i < j) {
            char c = s[i];
            s[i] = s[j];
            s[j] = c;
            i++;
            j--;
        }
        // 字符数组转回字符串返回
        return new String(s);
    }

【双指针】判断是否为回文字符串

Mon, 26 Jan 2026 19:48:17 +0000

求解代码

public boolean judge(String str) {
        int n = str.length(); // 获取字符串长度，用于定义右指针初始位置
        // 双指针遍历
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            // 逐位对比首尾字符，只要有一位不一致，直接判定不是回文
            if (str.charAt(i) != str.charAt(j)) {
                return false;
            }
        }
        // 所有对应位字符都一致，判定是回文
        return true;
    }

【字节面试手撕】大数加法

Sun, 25 Jan 2026 22:48:06 +0000

求解代码

public String solve(String s, String t) {
    // 如果第一个字符串为空/长度为0，直接返回第二个字符串
    if(s.length()<=0){
        return t;
    }
    // 如果第二个字符串为空/长度为0，直接返回第一个字符串
    if(t.length()<=0){
        return s;
    }

    int i = s.length()-1;

    int j = t.length()-1;
    // 定义进位变量tmp
    int tmp = 0;
    // 定义StringBuilder拼接结果
    StringBuilder sb = new StringBuilder();

    // 需要注意：最后一位相加仍有进位时，需把进位1也拼接到结果
    while (i>=0||j>=0||tmp!=0) {

        tmp += i>=0?s.charAt(i--)-'0':0;

        tmp += j>=0?t.charAt(j--)-'0':0;
        
        // 取余10：得到当前位的计算结果
        sb.append(tmp%10);
        // 除以10：更新进位值
        tmp=tmp/10;
    }
    // 结果逆序：因为是从个位开始拼接，需要反转回正序，再转字符串返回
    return sb.reverse().toString();
}

【字符串分割】验证IP地址

Sun, 25 Jan 2026 22:00:54 +0000

求解代码

public String solve(String IP) {
        // 校验是否为IPv4
        if (IP.indexOf(".") != -1) {
            // 按.分割，.是正则通配符，需转义为\\.
            String[] strs = IP.split("\\.");
            // IPv4核心规则：必须被.分割为4段
            if (strs.length != 4) {
                return "Neither";
            }
            // 校验IPv4
            for (int i = 0; i < strs.length; i++) {
                // 提前校验段非空，避免空串导致charAt/parseInt运行时异常
                if (strs[i].isEmpty()) {
                    return "Neither";
                }
                // 当前段仅能包含数字0-9
                for (char c : strs[i].toCharArray()) {
                    if (!(c >= '0' && c <= '9')) {
                        return "Neither";
                    }
                }
                // 数值≤255 且 无前导零（唯一例外：段本身是0，即长度1的0）
                if (Integer.parseInt(strs[i]) > 255 || (strs[i].charAt(0) == '0' && strs[i].length() > 1)) {
                    return "Neither";
                }
            }
            // 所有IPv4规则校验通过
            return "IPv4";
        }
        // 校验是否为IPv6
        else if (IP.indexOf(":") != -1) {
            // IPv6首尾不能为:
            if (IP.charAt(0) == ':' || IP.charAt(IP.length() - 1) == ':') {
                return "Neither";
            }
            // 按:分割IPv6字符串
            String[] strs = IP.split(":");
            // IPv6必须被:分割为8段
            if (strs.length != 8) {
                return "Neither";
            }
            // 校验IPv6
            for (int i = 0; i < strs.length; i++) {
                // 当前段仅能包含十六进制字符
                for (char c : strs[i].toCharArray()) {
                    if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F')) {
                        return "Neither";
                    }
                }
                // 段不能为空 且 长度≤4
                if (strs[i].equals("") || strs[i].length() > 4) {
                    return "Neither";
                }
            }
            // 所有IPv6规则校验通过
            return "IPv6";
        }
        // 既不包含.也不包含:，直接判定为非法IP
        else {
            return "Neither";
        }
    }

小贴士

题目意思不是太难理解，就是可能有点繁琐。理清思路应该问题不大。

【纵向扫描】最长公共前缀

Sun, 25 Jan 2026 20:27:14 +0000

求解代码

public String longestCommonPrefix (String[] strs) {
        if(strs==null||strs.length==0){
            return "";
        }
        int rows = strs.length;
        int cols = strs[0].length();

        for(int i=0;i<cols;i++){
            char c = strs[0].charAt(i);
            for(int j=1;j<rows;j++){
                if(strs[j].length()==i||strs[j].charAt(i)!=c){
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }

小贴士

纵向扫描的思路大概是：

以I【字符串数组】的第一个字符串的字符位置为 “列”，以i为列索引遍历每一列；

取第一个字符串的当前列字符c作为基准，以j为行索引遍历【字符串数组】的其他所有字符串，对比同列的字符。

如果某个字符串长度等于当前列索引了，说明这个字符串已经没有更多字符了，

或者同列字符不一致，

那就说明公共前缀到i-1列就结束了，

可直接返回strs[0].substring(0,i)；

如果所有列都对比通过，说明第一个字符串就是最长公共前缀，直接返回strs[0]。

【双指针+字符串】字符串变形

Sun, 25 Jan 2026 19:30:16 +0000

求解代码

public String trans(String s, int n) {
        if (s == null || s.length() == 0) {
            return s;
        }
        char[] str = s.toCharArray();
        reverse(str, 0, str.length - 1);
        int i = 0, j = 0;
        while (i < str.length) {
            j = i;
            while (j < str.length && str[j] != ' ') {
                if (str[j] >= 'a' && str[j] <= 'z') {
                    str[j] = (char) (str[j] - 'a' + 'A');
                } else {
                    str[j] = (char) (str[j] - 'A' + 'a');
                }
                j++;
            }
            reverse(str, i, j - 1);
            i = j + 1;
        }
        return new String(str);
    }

    public void reverse(char[] arr, int start, int end) {
        int i = start;
        int j = end;
        while (i < j) {
            char c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
            i++;
            j--;
        }
    }

小贴士

代码思路大概是：

整体反转➡️单词遍历➡️大小写互换➕局部反转