刷题日记 - 6

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int sLen = s.length();  // 获取字符串s的长度
        int tLen = t.length();  // 获取字符串t的长度
        if(sLen != tLen) return false;  // 如果两个字符串长度不同，直接返回false
        if(sLen < 1) return true;  // 如果字符串长度小于1，返回true

        char[] sChars = s.toCharArray();  // 将字符串s转换为字符数组
        char[] tChars = t.toCharArray();  // 将字符串t转换为字符数组

        int[] map = new int[128];  // 创建一个数组用于存储s字符到t字符的映射
        int[] charStatus = new int[128];  // 记录当前字符串t是否已经被映射了 0表示未被映射，1表示被映射
        Arrays.fill(map, -1);  // 初始化数组，所有值为-1

        boolean res = true;  // 结果标志，初始设为true
        for (int i = 0; i < sLen; i++) {
            char s_ = sChars[i];  // 获取s当前字符
            char t_ = tChars[i];  // 获取t当前字符

            if (map[s_] == -1 && charStatus[t_] == 0) {  // 如果s当前字符还没有映射，并且目标t字符也没有被映射
                map[s_] = t_;  // 将s当前字符映射到t当前字符
                charStatus[t_] = 1;  // 记录t字符已经被映射了
            } else {  // 如果当前字符s已经有映射，或者字符t已经被映射了
                if (map[s_] == -1 || map[s_] != t_) {  // 检查是否与已有映射匹配, 或者当前映射的对不对
                    res = false;  // 如果不匹配，设置结果为false
                    break;  // 结束循环
                }
            }
        }
        return res;  // 返回结果
    }
}

class Solution {
    public boolean wordPattern(String pattern, String s) {
        // 使用空格分割字符串s，得到单词数组
        String[] words = s.split(" ");
        int len = words.length;

        // 如果单词数组的长度和模式字符串长度不一致，则返回false
        if (len != pattern.length()) return false;

        // 用于记录字符和单词的映射
        HashMap<Character, String> map = new HashMap<>();
        // 用于记录已经映射的单词
        HashSet<String> set = new HashSet<>();
        // 将模式字符串转换为字符数组
        char[] patternChars = pattern.toCharArray();

        // 遍历模式字符串和单词数组
        for (int i = 0; i < len; i++) {
            char cur = patternChars[i];
            String word = words[i];

            // 如果当前字符和单词都没有被映射，则建立映射关系
            if (!map.containsKey(cur) && !set.contains(word)) {
                map.put(cur, word);
                set.add(word);
            } else {
                // 如果字符已被映射但映射的单词不匹配，或单词已被映射但映射的字符不匹配，则返回false
                if (!map.containsKey(cur) || !map.get(cur).equals(word)) {
                    return false;
                }
            }
        }

        return true;
    }
}

class Solution {
    public boolean isAnagram(String s, String t) {
        int len = s.length();
        if(len!=t.length())return false;

        int[] sCnt = new int[26];
        int[] tCnt = new int[26];

        for(char ch:s.toCharArray()){
            sCnt[ch-'a']++;
        }
        for(char ch:t.toCharArray()){
            tCnt[ch-'a']++;
        }
    
        boolean res = true;
        for(int i=0;i<26;i++){
            if(sCnt[i]!=tCnt[i]){
                res = false;
                break;
            }
        }
        return res;
    }
}

class Solution {
    public boolean isHappy(int n) {
        // 使用HashSet来记录出现过的数字，防止无限循环
        HashSet<Integer> set = new HashSet<>();
        set.add(n);

        // 结果标志变量，初始化为true
        boolean res = true;
        
        // 当n不为1时继续循环
        while(n != 1) {
            int tmp = n; // 临时变量存储当前数字
            int sum = 0; // 存储每位数字平方和
            int cur = -1; // 当前位的数字
            
            // 计算每位数字的平方和
            while(tmp > 0) {
                cur = tmp % 10; // 取最后一位数字
                tmp /= 10; // 去掉最后一位数字
                sum += cur * cur; // 将平方加到sum中
            }
            n = sum; // 更新n为平方和
            
            // 如果新数字已经出现过，说明陷入循环，返回false
            if(set.contains(n)) {
                res = false;
                break;
            }
            // 将新数字加入集合
            set.add(n);
        }
        
        // 返回结果
        return res;
    }
}

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        // 使用HashMap来记录数字及其对应的最新出现位置
        HashMap<Integer, Integer> map = new HashMap<>();
        int len = nums.length; // 数组的长度
        
        boolean res = false; // 结果标志变量，初始化为false
        
        // 遍历数组
        for (int i = 0; i < len; i++) {
            int cur = nums[i]; // 当前数字
            
            // 如果当前数字不在map中，则将其加入map
            if (!map.containsKey(cur)) {
                map.put(cur, i);
            } else {
                // 如果当前数字已经在map中，获取上次出现的位置
                int lastCurIdx = map.get(cur);
                // 检查当前索引与上次出现位置的差是否小于等于k
                if (i - lastCurIdx <= k) {
                    res = true;
                    break; // 满足条件，退出循环
                }
                // 更新当前数字的最新出现位置
                map.put(cur, i);
            }
        }
        return res; // 返回结果
    }
}

class Solution {
    public List<String> summaryRanges(int[] nums) {

        int len = nums.length;
        List<String> res = new ArrayList<>();
        if (len < 1) return res; // 如果数组为空，返回空列表

        int start = nums[0]; // 初始化起始值为第一个元素
        int last = nums[0];  // 初始化最后一个值为第一个元素
        int p = 1; // 指针从第二个元素开始遍历

        while (p < len) {
            int cur = nums[p];
            if (last + 1 == cur) { // 如果当前元素是连续的
                last = cur; // 更新最后一个值为当前元素
            } else {
                // 构造字符串并加入结果列表
                if (start == last) {
                    res.add(String.valueOf(start)); // 单个元素
                } else {
                    res.add(start + "->" + last); // 区间
                }
                // 更新新区间的起始值和最后一个值
                start = cur;
                last = cur;
            }
            p++;
        }

        // 处理最后一个区间
        if (start == last) {
            res.add(String.valueOf(start));
        } else {
            res.add(start + "->" + last);
        }
        return res;
    }
}

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        // 创建一个用于存储结果的列表
        List<int[]> res = new ArrayList<>();
        int len = intervals.length;
        int p = 0;
        // 新区间的左右边界
        int left = newInterval[0];
        int right = newInterval[1];
        boolean flag = false; // 用于标记新区间是否已插入

        // 遍历所有区间
        while (p < len) {
            int[] interval = intervals[p];
            if (interval[1] < left) {
                // 当前区间在新区间左侧且不重叠，直接添加到结果列表
                res.add(interval);
            } else if (interval[0] <= right) {
                // 当前区间与新区间有重叠，更新新区间的左右边界
                left = Math.min(interval[0], left);
                right = Math.max(interval[1], right);
            } else if (interval[0] > right) {
                // 当前区间在新区间右侧且不重叠，插入新区间并标记为已插入
                res.add(new int[]{left, right});
                flag = true;
                break;
            }
            p++;
        }

        // 处理剩余的区间
        while (p < len) {
            res.add(intervals[p]);
            p++;
        }

        // 如果新区间还未被插入，则插入新区间
        if (!flag) {
            res.add(new int[]{left, right});
        }

        // 将结果列表转换为二维数组并返回
        return res.toArray(new int[res.size()][]);
    }
}