@[TOC](模拟) # 1.替换所有的问号（easy）

1.替换所有的问号（easy）

题⽬链接：1576. 替换所有的问号
题⽬描述：

给你⼀个仅包含⼩写英⽂字⺟和 ‘?’ 字符的字符串 s，请你将所有的 ‘?’ 转换为若⼲⼩写字⺟，使最终
的字符串不包含任何 连续重复 的字符。
注意：你 不能 修改⾮ ‘?’ 字符。
题⽬测试⽤例保证 除 ‘?’ 字符 之外，不存在连续重复的字符。
在完成所有转换（可能⽆需转换）后返回最终的字符串。如果有多个解决⽅案，请返回其中任何⼀个。可以证明，在给定的约束条件下，答案总是存在的。
⽰例 1：
输⼊：s = “?zs”
输出：“azs”
解释：该⽰例共有 25 种解决⽅案，从 “azs” 到 “yzs” 都是符合题⽬要求的。只有 “z” 是⽆效的修
改，因为字符串 “zzs” 中有连续重复的两个 ‘z’ 。
⽰例 2：
输⼊：s = “ubv?w”
输出：“ubvaw”
解释：该⽰例共有 24 种解决⽅案，只有替换成 “v” 和 “w” 不符合题⽬要求。因为 “ubvvw” 和"ubvww" 都包含连续重复的字符。
提⽰：
1 <= s.length <= 100
s 仅包含⼩写英⽂字⺟和 ‘?’ 字符

解法（模拟）：
算法思路：
纯模拟。从前往后遍历整个字符串，找到问号之后，就⽤ a ~ z 的每⼀个字符去尝试替换即可。
算法代码：

class Solution{public String modifyString(String ss) {char[] s = ss.toCharArray();int n = s.length;for(int i = 0; i < n; i++){if(s[i] == '?') {// 替换for(char ch = 'a'; ch <= 'z'; ch++){if((i == 0 || ch != s[i - 1]) && (i == n - 1 || ch != s[i + 1])){s[i] = ch;break;}}}}return String.valueOf(s);}
}

2.提莫攻击（easy）

题⽬链接：495. 提莫攻击
题⽬描述：

在《英雄联盟》的世界中，有⼀个叫 “提莫” 的英雄。他的攻击可以让敌⽅英雄艾希（编者注：寒冰射⼿）进⼊中毒状态。
当提莫攻击艾希，艾希的中毒状态正好持续 duration 秒。
正式地讲，提莫在 t 发起攻击意味着艾希在时间区间 [t, t + duration - 1]（含 t 和 t + duration - 1）处于中毒状态。如果提莫在中毒影响结束 前 再次攻击，中毒状态计时器将会 重置 ，在新的攻击之后，中毒影响将会在 duration 秒后结束。
给你⼀个 ⾮递减 的整数数组 timeSeries ，其中 timeSeries[i] 表⽰提莫在 timeSeries[i] 秒时对艾希发起攻击，以及⼀个表⽰中毒持续时间的整数 duration 。
返回艾希处于中毒状态的 总 秒数。
⽰例 1：
输⼊：timeSeries = [1,4], duration = 2
输出：4
解释：提莫攻击对艾希的影响如下：
◦ 第 1 秒，提莫攻击艾希并使其⽴即中毒。中毒状态会维持 2 秒，即第 1 秒和第 2 秒。
◦ 第 4 秒，提莫再次攻击艾希，艾希中毒状态⼜持续 2 秒，即第 4 秒和第 5 秒。
艾希在第 1、2、4、5 秒处于中毒状态，所以总中毒秒数是 4 。
⽰例 2：
输⼊：timeSeries = [1,2], duration = 2
输出：3
解释：提莫攻击对艾希的影响如下：
◦ 第 1 秒，提莫攻击艾希并使其⽴即中毒。中毒状态会维持 2 秒，即第 1 秒和第 2 秒。
◦ 第 2 秒，提莫再次攻击艾希，并重置中毒计时器，艾希中毒状态需要持续 2 秒，即第 2 秒和第 3 秒。
艾希在第 1、2、3 秒处于中毒状态，所以总中毒秒数是 3 。
提⽰：
1 <= timeSeries.length <= 10^4
0 <= timeSeries[i], duration <= 10^7
timeSeries 按 ⾮递减 顺序排列

解法（模拟 + 分情况讨论）：

算法思路：
模拟 + 分情况讨论。
计算相邻两个时间点的差值：
i. 如果差值⼤于等于中毒时间，说明上次中毒可以持续 duration 秒；
ii. 如果差值⼩于中毒时间，那么上次的中毒只能持续两者的差值。
算法代码：

class Solution {public int findPoisonedDuration(int[] timeSeries, int duration) {int ret = 0;for(int i = 1; i < timeSeries.length; i++) {int x = timeSeries[i] - timeSeries[i - 1];if(x >= duration) ret += duration;else ret += x;}return ret + duration;}
}

注意：
最后是return sum + duration;不是return sum;

3.Z 字形变换（medium）

题⽬链接：6. Z 字形变换
题⽬描述：

将⼀个给定字符串 s 根据给定的⾏数 numRows ，以从上往下、从左到右进⾏ Z 字形排列。
⽐如输⼊字符串为 “PAYPALISHIRING” ⾏数为 3 时，排列如下：
P A H N
A P L S I I G
Y I R
之后，你的输出需要从左往右逐⾏读取，产⽣出⼀个新的字符串，⽐如：“PAHNAPLSIIGYIR”。
请你实现这个将字符串进⾏指定⾏数变换的函数：
string convert(string s, int numRows);
⽰例 1：
输⼊：s = “PAYPALISHIRING”, numRows = 3
输出：“PAHNAPLSIIGYIR”
⽰例 2：
输⼊：s = “PAYPALISHIRING”, numRows = 4
输出：“PINALSIGYAHRPI”
解释：
P I N
A L S I G
Y A H R
P I
⽰例 3：
输⼊：s = “A”, numRows = 1
输出：“A”
提⽰：
1 <= s.length <= 1000
s 由英⽂字⺟（⼩写和⼤写）、‘,’ 和 ‘.’ 组成
1 <= numRows <= 1000

解法（模拟 + 找规律）：

算法思路：
找规律，⽤ row 代替⾏数，row = 4 时画出的 Z 字形如下：

不难发现，数据是以 2row - 2 为⼀个周期进⾏规律变换的。将所有数替换成⽤周期来表⽰的变量：
第⼀⾏的数是：0, 2row - 2, 4row - 4；
第⼆⾏的数是：1, (2row - 2) - 1, (2row - 2) + 1, (4row - 4) - 1, (4row - 4) + 1；
第三⾏的数是：2, (2row - 2) - 2, (2row - 2) + 2, (4row - 4) - 2, (4row - 4) + 2；
第四⾏的数是：3, (2row - 2) + 3, (4row - 4) + 3。
可以观察到，第⼀⾏、第四⾏为差为 2row - 2 的等差数列；第⼆⾏、第三⾏除了第⼀个数取值为⾏数，每组下标为(2n - 1, 2n)的数围绕（2row - 2）的倍数左右取值。
以此规律，我们可以写出迭代算法。
算法代码：

class Solution{public String convert(String s, int numRows) {// 处理⼀下边界情况if(numRows == 1) return s;int d = 2 * numRows - 2, n = s.length();StringBuilder ret = new StringBuilder();// 1. 处理第⼀⾏for(int i = 0; i < n; i += d)ret.append(s.charAt(i));// 2. 处理中间⾏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));}}// 3. 处理最后⼀⾏for(int i = numRows - 1; i < n; i += d)ret.append(s.charAt(i));return ret.toString();}
}

4.外观数列 (medium)

题⽬链接：38. 外观数列
题⽬描述：

给定⼀个正整数 n ，输出外观数列的第 n 项。
「外观数列」是⼀个整数序列，从数字 1 开始，序列中的每⼀项都是对前⼀项的描述。
你可以将其视作是由递归公式定义的数字字符串序列：
countAndSay(1) = “1”
countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另⼀个数字字符串。
前五项如下：
1.1
2.11
3.21
4.1211
5.111221
第⼀项是数字 1
描述前⼀项，这个数是 1 即 “ ⼀ 个 1 ”，记作 “11”
描述前⼀项，这个数是 11 即 “ ⼆ 个 1 ” ，记作 “21”
描述前⼀项，这个数是 21 即 “ ⼀ 个 2 + ⼀ 个 1 ” ，记作 “1211”
描述前⼀项，这个数是 1211 即 “ ⼀ 个 1 + ⼀ 个 2 + ⼆ 个 1 ” ，记作 “111221”
要 描述 ⼀个数字字符串，⾸先要将字符串分割为 最⼩ 数量的组，每个组都由连续的最多 相同字符组成。然后对于每个组，先描述字符的数量，然后描述字符，形成⼀个描述组。要将描述转换为数字字符串，先将每组中的字符数量⽤数字替换，再将所有描述组连接起来。
例如，数字字符串 “3322251” 的描述如下图：

⽰例 1：
输⼊：n = 1
输出：“1”
解释：这是⼀个基本样例。
⽰例 2：
输⼊：n = 4
输出：“1211”
解释：
countAndSay(1) = “1”
ountAndSay(2) = 读 “1” = ⼀ 个 1 = “11”
countAndSay(3) = 读 “11” = ⼆ 个 1 = “21”
countAndSay(4) = 读 “21” = ⼀ 个 2 + ⼀ 个 1 = “12” + “11” = “1211”
提⽰：
1 <= n <= 30

解法（模拟）：

算法思路：
所谓「外观数列」，其实只是依次统计字符串中连续且相同的字符的个数。依照题意，依次模拟即可。
算法代码：

class Solution{public String countAndSay(int n) {String ret = "1";for(int i = 1; i < n; i++) { // 解释 n - 1 次 ret 即可StringBuilder tmp = new StringBuilder();int len = ret.length();for(int left = 0, right = 0; right < len; ){while(right < len && ret.charAt(left) == ret.charAt(right)) right++;tmp.append(Integer.toString(right - left));tmp.append(ret.charAt(left));left = right;}ret = tmp.toString();}return ret;}
}

5.数⻘蛙（medium）

题⽬链接：1419. 数⻘蛙
题⽬描述：

给你⼀个字符串 croakOfFrogs，它表⽰不同⻘蛙发出的蛙鸣声（字符串 “croak” ）的组合。由于同⼀时间可以有多只⻘蛙呱呱作响，所以 croakOfFrogs 中会混合多个 “croak” 。
请你返回模拟字符串中所有蛙鸣所需不同⻘蛙的最少数⽬。
要想发出蛙鸣 “croak”，⻘蛙必须 依序 输出 ‘c’, ’r’, ’o’, ’a’, ’k’ 这 5 个字⺟。如果没有输出全部五个字⺟，那么它就不会发出声⾳。如果字符串 croakOfFrogs 不是由若⼲有效的"croak" 字符混合⽽成，请返回 -1 。
⽰例 1：
输⼊：croakOfFrogs = “croakcroak”
输出：1
解释：⼀只⻘蛙 “呱呱” 两次
⽰例 2：
输⼊：croakOfFrogs = “crcoakroak”
输出：2
解释：最少需要两只⻘蛙，“呱呱” 声⽤⿊体标注
第⼀只⻘蛙 “crcoakroak”
第⼆只⻘蛙 “crcoakroak”
⽰例 3：
输⼊：croakOfFrogs = “croakcrook”
输出：-1
解释：给出的字符串不是 “croak” 的有效组合。
提⽰：
1 <= croakOfFrogs.length <= 105
字符串中的字符只有 ‘c’, ‘r’, ‘o’, ‘a’ 或者 ‘k’

解法（模拟 + 分情况讨论）

算法思路：
模拟⻘蛙的叫声。
◦ 当遇到 ‘r’ ‘o’ ‘a’ ‘k’ 这四个字符的时候，我们要去看看每⼀个字符对应的前驱字符，
有没有⻘蛙叫出来。如果有⻘蛙叫出来，那就让这个⻘蛙接下来喊出来这个字符；如果没有，
直接返回 -1 ；
◦ 当遇到 ‘c’ 这个字符的时候，我们去看看 ‘k’ 这个字符有没有⻘蛙叫出来。如果有，就让
这个⻘蛙继续去喊 ‘c’ 这个字符；如果没有的话，就重新搞⼀个⻘蛙。
算法代码：

class Solution{public int minNumberOfFrogs(String c) {char[] croakOfFrogs = c.toCharArray();String t = "croak";int n = t.length();int[] hash = new int[n]; // 数组模拟哈希表Map<Character, Integer> index = new HashMap<>(); // [x, x这个字符对应的下标]for(int i = 0; i < n; i++)index.put(t.charAt(i), i);for(char ch : croakOfFrogs){if(ch == t.charAt(0)){if(hash[n - 1] != 0) hash[n - 1]--;hash[0]++;}else{int i = index.get(ch);if(hash[i - 1] == 0) return -1;hash[i - 1]--; hash[i]++;}}for(int i = 0; i < n - 1; i++)if(hash[i] != 0)return -1;return hash[n - 1];}
}