每日一练＜1＞

最新推荐文章于 2024-08-17 20:25:49 发布

Al_tair

最新推荐文章于 2024-08-17 20:25:49 发布

阅读量900

点赞数 1

分类专栏： LeetCode 文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/al_tair/article/details/127193707

版权

LeetCode 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

每日一练

大家好呀！我是小笙，接下来分享下10月份每日一题的解题思路~

1694. 重新格式化电话号码

给你一个字符串形式的电话号码 number 。number 由数字、空格 ’ '、和破折号 ‘-’ 组成。

请你按下述方式重新格式化电话号码。

首先，删除所有的空格和破折号。
其次，将数组从左到右每 3 个一组分块，直到剩下 4 个或更少数字。剩下的数字将按下述规定再分块：
2 个数字：单个含 2 个数字的块。
3 个数字：单个含 3 个数字的块。
4 个数字：两个分别含 2 个数字的块。
最后用破折号将这些块连接起来。注意，重新格式化过程中不应该生成仅含 1 个数字的块，并且最多生成两个含 2 个数字的块。

返回格式化后的电话号码。

注意分二种情况：分明是剩下小于3位的电话号码或者是等于4位的电话号码

示例

输入：number = "1-23-45 6"
输出："123-456"
解释：数字是 "123456"
步骤 1：共有超过 4 个数字，所以先取 3 个数字分为一组。第 1 个块是 "123" 
步骤 2：剩下 3 个数字，将它们放入单个含 3 个数字的块。第 2 个块是 "456" 
连接这些块后得到 "123-456" 
------------------------------------------------------------------------
输入：number = "123 4-567"
输出："123-45-67"
解释：数字是 "1234567"
步骤 1：共有超过 4 个数字，所以先取 3 个数字分为一组。第 1 个块是 "123" 
步骤 2：剩下 4 个数字，所以将它们分成两个含 2 个数字的块。这 2 块分别是 "45" 和 "67" 
连接这些块后得到 "123-45-67"

代码主要思路就是分两种情况讨论

class Solution {
    public String reformatNumber(String number) {
        number = number.replaceAll(" ","").replaceAll("-","");
        int len = number.length();
        int index = 0;
        StringBuilder sb = new StringBuilder("");
        for(int i=0;len-i>4;i+=3){
            index = i + 3;
            sb.append(number.substring(i,i+3) + "-");
        }
        if(len - index <= 3){
            sb.append(number.substring(index,len));
        }else{
            sb.append(number.substring(index,index+2) + "-" + number.substring(index+2,len));
        }
        return sb.toString();
    }
}

777. 在LR字符串中交换相邻字符

在一个由 ‘L’ , ‘R’ 和 ‘X’ 三个字符组成的字符串（例如"RXXLRXRXL"）中进行移动操作。一次移动操作指用一个"LX"替换一个"XL"，或者用一个"XR"替换一个"RX"。现给定起始字符串start和结束字符串end，请编写代码，当且仅当存在一系列移动操作使得start可以转换成end时，返回True

意思就是 L 字母可以向左和 X 字母交换； R 字母可以向右和 X 字母交换

示例 :

输入: start = "RXXLRXRXL", end = "XRLXXRRLX"
输出: True
解释:
我们可以通过以下几步将start转换成end:
RXXLRXRXL ->
XRXLRXRXL ->
XRLXRXRXL ->
XRLXXRRXL ->
XRLXXRRLX

注意 L 是可以向左移动的，所以目标位置的 L 肯定是开始位置的相对位置的左边或者是当下

class Solution {
    public boolean canTransform(String start, String end) {
        // 必须要确保 L R 字母相对位置相同，因为这两个字母是不能相互交换的
        if (!start.replaceAll("X", "").equals(end.replaceAll("X", ""))) return false;
        for (int i = 0, j = 0; i < start.length(); ++i) {
            if (start.charAt(i) == 'X') continue;
            // 用来找到对应开始字母 L 或 R 的相对位置
            while (end.charAt(j) == 'X') ++j;
            // (start.charAt(i) == 'L') == (i < j) 既包括 L 的判断，也包括对 R 的判断
            // 就是当开始位置找到 L ，则判断两者相对位置，j > i 说明目标位置字母 L 在开始位置字母 L 的右边，所以无法实现，反之 R 字母也是同样的原理
            if (i != j && (start.charAt(i) == 'L') == (i < j)) return false;
            ++j;
        }
        return true;
    }
}

1784. 检查二进制字符串字段

给你一个二进制字符串 s ，该字符串不含前导零；如果 s 包含零个或一个由连续的 ‘1’ 组成的字段，返回 true 。否则，返回 false

示例

输入：s = "1001"
输出：false
解释：由连续若干个 '1' 组成的字段数量为 2，返回 false
--------------------------------------------------
输入：s = "110"
输出：true

思路：注意不含有前导零，意味着第一个字符不能是 0；然后就是用标志位判断何时出现 1 和 0 的分界线

class Solution {
    public boolean checkOnesSegment(String s) {
        if(s.charAt(0) == '0'){
            return false;
        }
        boolean flag = false;
        for(int i=1;i<s.length();i++){
            char ch = s.charAt(i);
            if(!flag && ch == '0'){
                flag = true;
            }
            if(flag && ch == '1'){
                return false;
            }
        }
        return true;
    }
}

921. 使括号有效的最少添加

给定一个括号字符串 s，添加 N 个括号字符，你就可以使所有字符内的括号有效！

示例 1：

输入：s = "())"
输出：1

示例 2：

输入：s = "((("
输出：3

我是通过栈来找到有效括号对数，剩下的都是无效括号

class Solution {
    public int minAddToMakeValid(String s) {
        if(s == null || "".equals(s)){
            return 0;
        }
        Deque<Character> stack = new LinkedList<>();
        int len = s.length();
        for(int i=0;i<len;i++){
            char ch = s.charAt(i);
            // 判断是否是有效括号对
            if(')' == ch && !stack.isEmpty() && '(' == stack.peek()){
                stack.poll();
            }else{
                stack.push(ch);
            }
        }
        // 剩下的都是无效括号对，都需要添加括号
        return stack.size();
    }
}

官方：优化空间，使用o(1) 常量来解决

class Solution {
    public int minAddToMakeValid(String s) {
        // 记录无效括号数
        int ans = 0;
        // 记录左括号多余的数量，最终加在无效括号数
        int leftCount = 0;
        int len = s.length();
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
            if (c == '(') {
                leftCount++;
            } else {
                if (leftCount > 0) {
                    leftCount--;
                } else {
                    ans++;
                }
            }
        }
        ans += leftCount;
        return ans;
    }
}

811. 子域名访问计数

网站域名 “discuss.leetcode.com” 由多个子域名组成。顶级域名为 “com” ，二级域名为 “leetcode.com” ，最低一级为 “discuss.leetcode.com” 。当访问域名 “discuss.leetcode.com” 时，同时也会隐式访问其父域名 “leetcode.com” 以及 “com” 。

计数配对域名是遵循 “rep d1.d2.d3” 或 “rep d1.d2” 格式的一个域名表示，其中 rep 表示访问域名的次数，d1.d2.d3 为域名本身。

例如，“9001 discuss.leetcode.com” 就是一个计数配对域名，表示 discuss.leetcode.com 被访问了 9001 次。
给你一个计数配对域名组成的数组 cpdomains ，解析得到输入中每个子域名对应的计数配对域名，并以数组形式返回。可以按任意顺序返回答案

示例

输入：cpdomains = ["900 google.mail.com", "50 yahoo.com", "1 intel.mail.com", "5 wiki.org"]
输出：["901 mail.com","50 yahoo.com","900 google.mail.com","5 wiki.org","5 org","1 intel.mail.com","951 com"]
注意分解和整合
分解：
900 google.mail.com -> 900 google.mail.com   |    900 mail.com    |  900 com
50 yahoo.com -> 50 yahoo.com   |    50 com  
1 intel.mail.com-> 1 intel.mail.com   |    1 mail.com    |  1 com
5 wiki.org -> 5 wiki.org   |   5 org
整合：
google.mail.com ： 900
mail.com  ：900 + 1
com ： 900 + 50 1
yahoo.com ： 50
intel.mail.com ： 1
wiki.org ： 5
org ： 5
对比输出就知道了

思路：主要是字符串的分割 splits 方法

class Solution {
    public List<String> subdomainVisits(String[] cpdomains) {
        int len  = cpdomains.length;
        // 用来存储字符以及字符对应的次数
        Map<String,Integer> map = new HashMap<>();
        for(String str:cpdomains){
            String[] splits = str.split(" ");
            StringBuilder sb = new StringBuilder(splits[1]);
            int index = 0;
            for(int i=0;i<splits[1].length();i++){
                char ch = splits[1].charAt(i);
                index++;
                if(i == 0 || ch == '.'){
                    if(i != 0){
                        sb.delete(0,index);
                        index = 0;
                    }
                    if(map.containsKey(sb.toString())){
                        map.put(sb.toString(),map.get(sb.toString()) + Integer.valueOf(splits[0]));
                    }else{
                        map.put(sb.toString(),Integer.valueOf(splits[0]));
                    }
                    
                }
            }
        }
        // 组装数据并返回
        List<String> list = new ArrayList<>();
        for(String str:map.keySet()){
            list.add(map.get(str) + " " + str);
        }
        return list;

    }
}

927. 三等分

给定一个由 0 和 1 组成的数组 arr ，将数组分成 3 个非空的部分 ，使得所有这些部分表示相同的二进制值

解读：允许有前导零（二进制数前加多少零值不变）

示例 1：

输入：arr = [1,0,1,0,1]
输出：[0,3]
解读：1,0,1,0,1 可以分割成 1  01  01 值都为 1 
输出的为[0,3] 分别指 [0,0] [1,2] [3,4]  前者 0 为 [0,0] 右边界 ；后者 3 为 [1,2] 右边界 + 1

我采用分成三段，使用哈希表来存储第几个1所在的下标位置

注意分割的时候要看最后一段结尾0的个数，这个决定了每一段的结尾0的个数必须大于它，不然就是无解

class Solution {
    public int[] threeEqualParts(int[] arr) {
        int sum = Arrays.stream(arr).sum();
        if(sum % 3 != 0){
            return new int[]{-1,-1};
        }else if(sum == 0){
            return new int[]{0,2};
        }
        int part = sum / 3;
        // 第几个1 和 1所在的下标
        Map<Integer,Integer> map = new HashMap<>();
        int count = 0;
        String str = "";
        for(int i=0;i<arr.length;i++){
            str += arr[i] + "";
            if(arr[i] == 1){
                map.put(++count,i);
            }
        }
        int zeroCount = arr.length - map.get(sum) - 1;
        if(map.get(part*2+1) - map.get(part*2) - 1 < zeroCount || map.get(part+1) - map.get(part) - 1 < zeroCount){
            return new int[]{-1,-1};
        }
        String str1= str.substring(map.get(1),map.get(part)+1);
        String str2= str.substring(map.get(part+1),map.get(part*2)+1);
        String str3= str.substring(map.get(part*2+1),map.get(sum)+1);
        if(!str1.equals(str2) || !str3.equals(str2)){
            return new int[]{-1,-1};
        }
        return new int[]{map.get(part) + zeroCount,map.get(part*2) + zeroCount + 1};
    }
}

进行优化 String 以及哈希表数据获取

class Solution {
    public int[] threeEqualParts(int[] arr) {
        // 第几个1 和 1所在的下标
        Map<Integer,Integer> map = new HashMap<>();
        int sum = 0,count = 0;
        StringBuilder str = new StringBuilder("");
        for(int i=0;i<arr.length;i++){
            str.append(arr[i] + "");
            if(arr[i] == 1){
                map.put(++count,i);
            }
            sum += arr[i];
        }
        if(sum % 3 != 0){
            return new int[]{-1,-1};
        }else if(sum == 0){
            return new int[]{0,2};
        }
        int part = sum / 3;
        int zeroCount = arr.length - map.get(sum) - 1;
        int part1 = map.get(part),part2 = map.get(part+1),part3 = map.get(part*2),part4 = map.get(part*2+1);
        if(part4 - part3 - 1 < zeroCount || part2 - part1 - 1 < zeroCount){
            return new int[]{-1,-1};
        }
        String str1= str.toString().substring(map.get(1),part1+1);
        String str2= str.toString().substring(part2,part3+1);
        String str3= str.toString().substring(part4,map.get(sum)+1);
        if(!str1.equals(str2) || !str3.equals(str2)){
            return new int[]{-1,-1};
        }
        return new int[]{part1 + zeroCount,part3 + zeroCount + 1};
    }
}

1800. 最大升序子数组和

给你一个正整数组成的数组 nums ，返回 nums 中一个升序子数组的最大可能元素和

示例 1：

输入：nums = [10,20,30,5,10,50]
输出：65
解释：[5,10,50] 是元素和最大的升序子数组，最大元素和为 65

暴力解法

class Solution {
    public int maxAscendingSum(int[] nums) {
        int max = nums[nums.length-1],sum = nums[0];
        for(int i=0;i<nums.length-1;i++){
            if(nums[i+1] > nums[i]){
                sum += nums[i+1];
            }else{
                max = max>sum?max:sum;
                sum = nums[i+1];
            }
        }
        max = max>sum?max:sum;
        return max;
    }
}

Al_tair

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
每日一练＜1＞

顶级域名为 “com” ，二级域名为 “leetcode.com” ，最低一级为 “discuss.leetcode.com”。计数配对域名是遵循 “rep d1.d2.d3” 或 “rep d1.d2” 格式的一个域名表示，其中 rep 表示访问域名的次数，d1.d2.d3 为域名本身。给你一个计数配对域名组成的数组 cpdomains ，解析得到输入中每个子域名对应的计数配对域名，并以数组形式返回。注意 L 是可以向左移动的，所以目标位置的 L 肯定是开始位置的相对位置的左边或者是当下。
复制链接

扫一扫