每日一练
大家好呀!我是小笙,接下来分享下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;
}
}