LeetCode第281场周赛

转x33g5p2x  于2022-02-20 转载在 其他  
字(3.5k)|赞(0)|评价(0)|浏览(347)

📒博客首页：崇尚学技术的科班人
🍣今天给大家带来的文章是《LeetCode第281场周赛》🍣
🍣希望各位小伙伴们能够耐心的读完这篇文章🍣
🙏博主也在学习阶段，如若发现问题，请告知，非常感谢🙏
💗同时也非常感谢各位小伙伴们的支持💗

🚀<1> 第一题🚀

✨题目✨

统计各位数字之和为偶数的整数个数
给你一个正整数 num ，请你统计并返回 小于或等于 num 且各位数字之和为 偶数 的正整数的数目。
正整数的 各位数字之和 是其所有位上的对应数字相加的结果。

✨示例✨

  • 示例1：
  1. 输入：num = 4
  2. 输出：2
  3. 解释：
  4. 只有 2 和 4 满足小于等于 4 且各位数字之和为偶数。
  • 示例2：
  1. 输入：num = 30
  2. 输出：14
  3. 解释：
  4. 只有 14 个整数满足小于等于 30 且各位数字之和为偶数，分别是： 
  5. 2、4、6、8、11、13、15、17、19、20、22、24、26 和 28 。

✨提示✨

  • 1 <= num <= 1000

⭐思路⭐

  • 思路

这道题是签到题，我的做法就是模拟这个过程，从 1 ~ num 进行枚举，然后对每一个数进行拆解查看是否符合要求。如果符合要求的话，我们就进行计数加一；如果不符合要求的话，那么不再任何事情。

✨代码实现✨

  1. class Solution {
  2.     public int sum(int n){
  3.         int num = 0;
  4.         while(n != 0){
  5.             int x = n % 10;
  6.             num += x;
  7.             n /= 10;
  8.         }
  9.         return num;
  10.     }
  11.     public int countEven(int num) {
  12.         int cnt = 0;
  13.         for(int i = 1; i <= num; i ++){
  14.             int nums = sum(i);
  15.             if(nums % 2 == 0) cnt ++;
  16.         }
  17.         return cnt;
  18.     }
  19. }

✨运行结果✨

🚀<2> 第二题🚀

✨题目✨

合并零之间的节点
给你一个链表的头节点 head ，该链表包含由 0 分隔开的一连串整数。链表的 开端 和 末尾 的节点都满足 Node.val == 0 。
对于每两个相邻的 0 ，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有 0 移除，修改后的链表不应该含有任何 0 。
返回修改后链表的头节点 head 。

✨示例✨

  • 示例1：

  1. 输入：head = [0,3,1,0,4,5,2,0]
  2. 输出：[4,11]
  3. 解释：
  4. 上图表示输入的链表。修改后的链表包含：
  5. - 标记为绿色的节点之和：3 + 1 = 4
  6. - 标记为红色的节点之和：4 + 5 + 2 = 11
  • 示例2：

  1. 输入：head = [0,1,0,3,0,2,2,0]
  2. 输出：[1,3,4]
  3. 解释：
  4. 上图表示输入的链表。修改后的链表包含：
  5. - 标记为绿色的节点之和：1 = 1
  6. - 标记为红色的节点之和：3 = 3
  7. - 标记为黄色的节点之和：2 + 2 = 4

✨提示✨

  • 列表中的节点数目在范围[3, 2 * 105]内
  • 0 <= Node.val <= 1000
  • 不 存在连续两个 Node.val == 0的节点
  • 链表的 开端 和 末尾 节点都满足 Node.val == 0

⭐思路⭐

  • 思路

其实这道题也是一道简单的模拟题，我们对两个 0 的链表节点之间进行求和，如果遇到链表的结点是 0 的话，那么就进行另一个链表节点的创建，然后将存储总和变量置为 0。

✨代码实现✨

  1. /**
  2.  * Definition for singly-linked list.
  3.  * public class ListNode {
  4.  *     int val;
  5.  *     ListNode next;
  6.  *     ListNode() {}
  7.  *     ListNode(int val) { this.val = val; }
  8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  9.  * }
  10.  */
  11. class Solution {
  12.     public ListNode mergeNodes(ListNode head) {
  13.         ListNode node = new ListNode(0);
  14.         
  15.         ListNode node1 = head.next;
  16.         ListNode node2 = node;
  17.         int sum = 0;
  18.         while(node1 != null){
  19.             sum += node1.val;
  20.             if(node1.val == 0){
  21.                 ListNode node3 = new ListNode(sum);
  22.                 node2.next = node3;
  23.                 node2 = node2.next;
  24.                 sum = 0;
  25.             }
  26.             node1 = node1.next;
  27.         }
  28.         return node.next;
  29.     }
  30. }

✨运行结果✨

🚀<3> 第三题🚀

✨题目✨

构造限制重复的字符串
给你一个字符串 s 和一个整数 repeatLimit ，用 s 中的字符构造一个新字符串 repeatLimitedString ，使任何字母 连续 出现的次数都不超过 repeatLimit 次。你不必使用 s 中的全部字符。
返回 字典序最大的 repeatLimitedString 。
如果在字符串 a 和 b 不同的第一个位置，字符串 a 中的字母在字母表中出现时间比字符串 b 对应的字母晚，则认为字符串 a 比字符串 b 字典序更大 。如果字符串中前 min(a.length, b.length) 个字符都相同，那么较长的字符串字典序更大。

✨示例✨

  • 示例1：
  1. 输入：s = "cczazcc", repeatLimit = 3
  2. 输出："zzcccac"
  3. 解释：使用 s 中的所有字符来构造 repeatLimitedString "zzcccac"。
  4. 字母 'a' 连续出现至多 1 次。
  5. 字母 'c' 连续出现至多 3 次。
  6. 字母 'z' 连续出现至多 2 次。
  7. 因此，没有字母连续出现超过 repeatLimit 次，字符串是一个有效的 repeatLimitedString 。
  8. 该字符串是字典序最大的 repeatLimitedString ，所以返回 "zzcccac" 。
  9. 注意，尽管 "zzcccca" 字典序更大，但字母 'c' 连续出现超过 3 次，所以它不是一个有效的 repeatLimitedString 。
  • 示例2：
  1. 输入：s = "aababab", repeatLimit = 2
  2. 输出："bbabaa"
  3. 解释：
  4. 使用 s 中的一些字符来构造 repeatLimitedString "bbabaa"。 
  5. 字母 'a' 连续出现至多 2 次。 
  6. 字母 'b' 连续出现至多 2 次。 
  7. 因此，没有字母连续出现超过 repeatLimit 次，字符串是一个有效的 repeatLimitedString 。 
  8. 该字符串是字典序最大的 repeatLimitedString ，所以返回 "bbabaa" 。 
  9. 注意，尽管 "bbabaaa" 字典序更大，但字母 'a' 连续出现超过 2 次，所以它不是一个有效的 repeatLimitedString 。

✨提示✨

  • 1 <= repeatLimit <= s.length <= 10^5
  • s由小写英文字母组成

⭐思路⭐

  • 思路

这道题我使用的解法是 贪心 + 双指针，我们先对数组进行从大到小的排序，然后进行双指针流程：首先我们进行对于同一个字符进行计数，然后对出现次数超过 repeatLimit 进行后面的字符进行间隔。

✨代码实现✨

  1. class Solution {
  2.     public String repeatLimitedString(String s, int repeatLimit) {
  3.         char[] charArray = s.toCharArray();
  4.         Arrays.sort(charArray);
  5.         int n = charArray.length;
  6.         StringBuilder sb = new StringBuilder();
  7.         for(int i = n - 1; i >= 0; ){
  8.             char a = charArray[i];
  9.             int j = i;
  10.             while(j >= 0 && a == charArray[j]) j --;
  11.             
  12.             int cnt = i - j;
  13.             if(j < 0){
  14.                 for(int k = 0; k < cnt && k < repeatLimit; k ++){
  15.                     sb.append(charArray[i]);
  16.                 }
  17.                 break;
  18.             }
  19.             //System.out.println(cnt + " " + i + " " + j);
  20.             for(int k = 1; k <= cnt; k ++){
  21.                 sb.append(charArray[i]);
  22.                 if(k % repeatLimit == 0 && k == cnt) break;
  23.                 if(k % repeatLimit == 0 && j < 0) break;
  24.                 else if(k % repeatLimit == 0 && j >= 0) sb.append(charArray[j --]);
  25.             }
  26.             i = j;
  27.         }
  28.         return new String(sb);
  29.     }
  30. }

✨运行结果✨

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_56727438/article/details/123032448

内容来源于网络，如有侵权，请联系作者删除！

leetcode算法链表

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com