模拟-算法

替换所有的问号

算法思路：

从前往后遍历整个字符串，找到问号之后，就遍历 a ~ z 去尝试替换即可。

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

提莫攻击

算法思路：
模拟 + 分情况讨论。
计算相邻两个时间点的差值：
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;
        }
        ret += duration;
        return ret;
    }
}

Z字形变换

算法思路：
找规律，设行数为 numRows, numRows == 4 时画出的 Z 字形如下：
行号从0开始

不难发现，第零行和最后一行的数据是以 2numRows - 2 为公差递增的等差数列。
第一行、第二行第⼀个数取值为行数，第二个数夹在等差数列中间, 就是第零行的等差数列第二个数减去行数
以此规律，我们可以写出迭代算法。

class Solution {
    public String convert(String s, int numRows) {
        //处理边界情况
        if(numRows == 1) return s;

        int d = 2 * (numRows-1), 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();
    }
}

外观数列

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

class Solution {
    public String countAndSay(int n) {
        String ret = "1";
        for(int i = 1; i < n; i++) {
            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;
    }
}

数青蛙

算法思路：

• 当遇到 ‘r’ ‘o’ ‘a’ ‘k’ 这四个字符的时候，我们要去看看对应的前驱字符，如果有前驱字符，那就让这个青蛙喊出来这个字符(这个字符加一),并且消去一个前驱字符；如果没有前驱字符，直接返回 -1
• 当遇到 ‘c’ 这个字符的时候，我们去看看 ‘k’ 这个字符有没有青蛙叫出来。如果有，就让这个青蛙继续去喊 ‘c’ 这个字符(把’k’字符减去一个)；如果没有的话，就增加⼀个青蛙。不管怎样 'c’字符都要加一

Map只是记录字符以及对应下标而已
定义的哈希表hash记录蛙叫次数,除了’k’其他字符会被下一个字符消掉,'k’只有在新增’c’的时候消掉,最后留下多少’k’就是几只蛙

class Solution {
    public int minNumberOfFrogs(String croakOfFrogs) {
        char[] ch = 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 x : ch) {
            if(x == t.charAt(0)) {
                if(hash[n-1] != 0) hash[n-1]--;
                hash[0]++;
            } else {
                int i = index.get(x);
                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];
    }
}

排序子序列

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextInt();
            }

            // 用一个标志来区分,0表示不增不减，1表示递增，-1表示递减
            int flag = 0;
            // 统计能够划分的数组的个数
            int count = 1;

            for (int i = 0; i < arr.length - 1; i++) {
                if (arr[i] > arr[i + 1]) { //递减
                    if (flag == 0) {
                        flag = -1;
                    }
                    if (flag == 1) { //变化了，出现新的子序列
                        flag = 0; //这里是置为0而非-1
                        count++;
                    }

                } else if (arr[i] < arr[i + 1]) { //递增
                    if (flag == 0) {
                        flag = 1;
                    }
                    if (flag == -1) { //变化了，出现新的子序列
                        flag = 0;
                        count++;
                    }
                }
            }
            System.out.println(count);
        }
    }
}