【专项刷题】— 模拟

1、替换所有的问号 - 力扣（LeetCode）

思路：

1. 首先找到需要替换的 ' ? '，位置
2. 然后遍历26个字母与 '?' 的左右两边的是否相同，不同的话就替换
3. 最后返回即可
4. 代码：

   public String modifyString(String s) {
           char[] ch = s.toCharArray();
           int n = s.length();
           for(int i = 0; i < n; i++){
               if(ch[i] == '?'){
                   //替换
                   for(char j = 'a'; j <= 'z'; j++){
                       //如果 i == 0 的话，就需要判断它前一个数相等不相等
                       //如果 i == n-1 的话，就需要判断它前一个数相不相等
                       if(((i == 0) || (ch[i-1] != j)) && ((i == n-1) || (ch[i+1] != j))){
                           ch[i] = j;
                           break;
                       }
                   } 
               }
           }
           return String.valueOf(ch);
       }

2、提莫攻击 - 力扣（LeetCode） 

思路：

1. 当差值小于中毒的持续时间时，那么中毒时间就是差值，大于中毒持续时间时， 那么时间就是d
2. 
3. 代码：

   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;
       }

3、Z 字形变换 - 力扣（LeetCode） 

思路：

1. 双层循环遍历矩阵，然后填写数组
2. 找规律，简化操作

3. public String convert(String s, int numRows) {
           //处理边界
           if(numRows == 1){
               return s;
           }
           int d =  2*numRows - 2;
           StringBuilder ret = new StringBuilder();
           //处理第一行
           for(int i = 0; i < s.length(); i += d){
               ret.append(s.charAt(i));
           }
           //处理中间行
           //依次枚举中间行
           for(int k = 1; k < numRows-1; k++){
               for(int i = k, j = d-i; i < s.length() || j < s.length(); i+=d, j+=d){
                   if(i < s.length()){
                       ret.append(s.charAt(i));
                   }
                   if(j < s.length()){
                       ret.append(s.charAt(j));
                   }
               }
           }
           //处理最后一行
           for(int i = numRows-1; i < s.length(); i+=d){
               ret.append(s.charAt(i));
           }
           return ret.toString();
       }

4、外观数列 - 力扣（LeetCode） 

思路：

1. 定义left和right两个指针从头开始
2. 如果left位置的值等于right的话，right向右移动
3. 直到不相等就统计一下，个数和值
4. 代码：

   public String countAndSay(int n) {
           String ret = "1";
           //解释n-1次 ret即可
           for(int i = 1; i < n; i++){
               int len = ret.length();
               StringBuilder tmp = new StringBuilder();
               for(int left = 0, right = 0; right < len; ){
                   // 防止越界
                   while(right < len && ret.charAt(right) == ret.charAt(left)){
                       right++;
                   }
                   //组合一下结果
                   tmp.append(Integer.toString(right - left));
                   tmp.append(ret.charAt(left));
                   left = right;
               }
               //内循环结束就赋值到最终结果上
               ret = tmp.toString();
           }
           return ret;
       }

5、数青蛙 - 力扣（LeetCode） 

思路：

1.  将蛙鸣存入哈希表，然后遍历目标字符串的时候就在哈希表中查看这个值是多少
2. 会出现两种情况：
3. 代码：

   public int minNumberOfFrogs(String croakOfFrogs) {
           char[] c = croakOfFrogs.toCharArray();
           //蛙鸣
           String t = "croak";
           int n = t.length();
           //存储蛙鸣的哈希表
           int[] hash = new int[n];
           //存储下标和字符的哈希表
           Map<Character,Integer> index = new HashMap<>();
           //存储下标
           for(int i = 0; i < n; i++){
               index.put(t.charAt(i),i);
           }
           //遍历蛙鸣，并且判断一下
           for(char ch : c){
               //判断是否等于第一个字符
               if(ch == t.charAt(0)){
                   //相等就判断最后一个字符的哈希值是否不等于0
                   if(hash[n-1] != 0){
                       //不等于0的话就--，第一个字符++，新一轮判断
                       hash[n-1]--;
                   }
                   hash[0]++;
               }else{
                   //不是一个字符的话,判断前一个字符的哈希值是否为0
                   if(hash[index.get(ch) - 1] == 0){
                       return -1;
                   }else{
                       hash[index.get(ch) - 1]--;
                       hash[index.get(ch)]++;
                   }
   
               }
           }
           for(int i = 0; i < n-1; i++){
               if(hash[i] != 0){
                   return -1;
               }
           }
           return hash[n-1];
       }