Java 模拟算法题目练习 | 极客日志

Javajava算法

Java 模拟算法题目练习

模拟算法通过逐步执行题目要求的操作来解决问题，重点在于处理边界情况和细节。五个经典的 Java 模拟算法题目，包括替换问号、提莫攻击、Z 字形变换、外观数列和数青蛙。每个题目均提供了详细的解题思路、代码实现及复杂度分析，帮助读者掌握模拟类问题的核心技巧与常见陷阱。

狂少发布于 2026/2/8更新于 2026/4/182.8K 浏览

Java 模拟算法题目练习

模拟算法

模拟算法就是根据其题目进行一步一步操作即可，相对而言较简单，但是边界情况要处理好（细节问题）。

替换所有的问号

LeetCode 题目链接

题目解析：将 s 字符串中的？全部替换成小写字母，并且替换？的字符不可以与原本？相邻的两个字符相等。

模拟：只需要根据题目条件，找出所有？，并将其替换成符合要求的小写字母即可。

class Solution {
    public String modifyString(String s) {
        // 替换问号，但是相邻的不可以重复
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i++) {
            if (arr[i] == '?') {
                // 找一个符合条件的字母替换
                for (char ch = 'a'; ch <= 'z'; ch++) {
                    // 注意？在最左边和最右边这两个边界情况
                    if ((i == 0 || arr[i - 1] != ch) && (i == n - 1 || arr[i + 1] != ch)) {
                        arr[i] = ch;
                        break;
                    }
                }
            }
        }
        return String.valueOf(arr);
    }
}

时间复杂度：O(n) 空间复杂度：O(n)

提莫攻击

LeetCode 题目链接

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

Keycode 信息
查找任何按下的键的javascript键代码、代码、位置和修饰符。在线工具，Keycode 信息在线工具，online
Escape 与 Native 编解码
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。在线工具，Escape 与 Native 编解码在线工具，online
JavaScript / HTML 格式化
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。在线工具，JavaScript / HTML 格式化在线工具，online
JavaScript 压缩与混淆
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。在线工具，JavaScript 压缩与混淆在线工具，online
加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        // 判断这次攻击与上次攻击的时间差值即可
        // 差值 >= duration，上一次执行时间为 duration
        // 反之 < duration, 上一次执行的时间就是差值
        int sum = 0;
        for (int i = 1; i < timeSeries.length; i++) {
            int x = timeSeries[i] - timeSeries[i - 1];
            if (x >= duration) {
                sum += duration;
            } else {
                sum += x;
            }
        }
        // 加上最后一次技能的持续时间
        return sum + duration;
    }
}

class Solution {
    public String convert(String s, int numRows) {
        if (numRows < 2) {
            return s;
        }
        int n = s.length();
        // 公差
        int d = 2 * numRows - 2;
        StringBuffer ret = new StringBuffer();
        // 第一行
        for (int i = 0; i < n; i += d) {
            ret.append(s.charAt(i));
        }
        // 中间行
        for (int k = 1; k < numRows - 1; k++) {
            for (int i = k, j = d - i; i < n || j < n; i += d, j += d) {
                if (i < n) {
                    ret.append(s.charAt(i));
                }
                if (j < n) {
                    ret.append(s.charAt(j));
                }
            }
        }
        // 最后一行
        for (int i = numRows - 1; i < n; i += d) {
            ret.append(s.charAt(i));
        }
        return ret.toString();
    }
}

class Solution {
    public String countAndSay(int n) {
        // 一直解释，解释到第 n 行
        String ret = "1";
        for (int i = 1; i < n; i++) {
            // 存放当前这一行的解释
            StringBuilder tem = new StringBuilder();
            // 当前行的长度
            int len = ret.length();
            // 开始解释
            for (int left = 0, right = 0; right < len;) {
                while (right < len && ret.charAt(left) == ret.charAt(right)) {
                    right++;
                    // 直到不相同为止
                }
                tem.append(Integer.toString(right - left));
                tem.append(ret.charAt(left));
                left = right;
            }
            ret = tem.toString();
        }
        return ret;
    }
}

class Solution {
    public int minNumberOfFrogs(String croakOfFrogs) {
        if (croakOfFrogs.length() % 5 != 0) {
            return -1;
        }
        int c = 0;
        int r = 0;
        int o = 0;
        int a = 0;
        int k = 0;
        int ret = 0;
        for (int i = 0; i < croakOfFrogs.length(); i++) {
            char ch = croakOfFrogs.charAt(i);
            // 每次都哟啊判断其前驱字符个数
            if (ch == 'c') {
                // 判断又没有青蛙叫完，有的话就可以从后面直接调取即可
                if (k > 0) {
                    --k;
                    ++c;
                } else {
                    ++c;
                }
            } else if (ch == 'r') {
                if (c == 0) {
                    return -1;
                } else {
                    --c;
                    ++r;
                }
            } else if (ch == 'o') {
                if (r == 0) {
                    return -1;
                } else {
                    --r;
                    ++o;
                }
            } else if (ch == 'a') {
                if (o == 0) {
                    return -1;
                } else {
                    --o;
                    ++a;
                }
            } else {
                if (a == 0) {
                    return -1;
                } else {
                    --a;
                    ++k;
                }
            }
        }
        if (c != 0 || r != 0 || o != 0 || a != 0) {
            return -1;
        }
        return k;
    }
}

class Solution {
    public int minNumberOfFrogs(String croakOfFrogs) {
        // 使用数组模拟哈希
        String t = "croak";
        int n = t.length();
        int[] hash = new int[n];
        // 存放对应元素个数
        // 使用哈希表来映射他们的下标
        java.util.Map<Character, Integer> map = new java.util.HashMap<>();
        // 先放入哈希中
        for (int i = 0; i < n; i++) {
            map.put(t.charAt(i), i);
        }
        // 此时就要开始判断
        for (char ch : croakOfFrogs.toCharArray()) {
            // 如果是 c 字符要进行判断，k 是否存在
            if (ch == t.charAt(0)) {
                if (hash[n - 1] != 0) {
                    hash[n - 1]--;
                }
                hash[0]++;
            } else {
                // 中间字符
                // 因为要判断前驱字符，这里要获取下标
                int index = map.get(ch);
                if (hash[index - 1] == 0) {
                    return -1;
                } else {
                    hash[index - 1]--;
                    hash[index]++;
                }
            }
        }
        // 最后要判断其除了 k 字符，前面字符是否还有
        for (int i = 0; i < n - 1; i++) {
            if (hash[i] != 0) {
                return -1;
            }
        }
        return hash[n - 1];
    }
}