每日编程（36）

最新推荐文章于 2024-01-08 20:10:01 发布

LYue123

最新推荐文章于 2024-01-08 20:10:01 发布

阅读量209

点赞数

分类专栏：每日编程

本文链接：https://blog.csdn.net/LYue123/article/details/88750688

版权

每日编程专栏收录该内容

44 篇文章 0 订阅

订阅专栏

题目：836. 矩形重叠

题目描述：矩形以列表 [x1, y1, x2, y2] 的形式表示，其中 (x1, y1) 为左下角的坐标，(x2, y2) 是右上角的坐标。

如果相交的面积为正，则称两矩形重叠。需要明确的是，只在角或边接触的两个矩形不构成重叠。

给出两个矩形，判断它们是否重叠并返回结果。

示例 1：

输入：rec1 = [0,0,2,2], rec2 = [1,1,3,3]
输出：true
示例 2：

输入：rec1 = [0,0,1,1], rec2 = [1,0,2,1]
输出：false
说明：

两个矩形 rec1 和 rec2 都以含有四个整数的列表的形式给出。
矩形中的所有坐标都处于 -10^9 和 10^9 之间。
分析：这种题主要是分析特点，什么情况下符合要求，利用坐标位置，先比较横坐标，在比较纵坐标，如果有交叉部分则认为存在重叠，注意只有一个点一条变得情况不算
代码：

func isRectangleOverlap(rec1 []int, rec2 []int) bool {

    if rec1[0]<=rec2[0] && rec1[2]>rec2[0]{
        if rec1[1]<=rec2[1] && rec1[3]>=rec2[1]{
            return true
        }
        if rec2[1]<=rec1[1] && rec2[3]>=rec1[1]{
            return true
        }
    }
    if rec2[0]<=rec1[0] && rec2[2]>rec1[0]{
         if rec1[1]<=rec2[1] && rec1[3]>=rec2[1]{
            return true
        }
        if rec2[1]<=rec1[1] && rec2[3]>=rec1[1]{
            return true
        }
    }
    return false
}

题目：838. 推多米诺

题目描述：
一行中有 N 张多米诺骨牌，我们将每张多米诺骨牌垂直竖立。

在开始时，我们同时把一些多米诺骨牌向左或向右推。

每过一秒，倒向左边的多米诺骨牌会推动其左侧相邻的多米诺骨牌。

同样地，倒向右边的多米诺骨牌也会推动竖立在其右侧的相邻多米诺骨牌。

如果同时有多米诺骨牌落在一张垂直竖立的多米诺骨牌的两边，由于受力平衡，该骨牌仍然保持不变。

就这个问题而言，我们会认为正在下降的多米诺骨牌不会对其它正在下降或已经下降的多米诺骨牌施加额外的力。

给定表示初始状态的字符串 “S” 。如果第 i 张多米诺骨牌被推向左边，则 S[i] = ‘L’；如果第 i 张多米诺骨牌被推向右边，则 S[i] = ‘R’；如果第 i 张多米诺骨牌没有被推动，则 S[i] = ‘.’。

返回表示最终状态的字符串。

示例 1：

输入：".L.R…LR…L…"
输出：“LL.RR.LLRRLL…”
示例 2：

输入：“RR.L”
输出：“RR.L”
说明：第一张多米诺骨牌没有给第二张施加额外的力。
提示：

0 <= N <= 10^5
表示多米诺骨牌状态的字符串只含有 ‘L’，‘R’; 以及 ‘.’;

分析：也没想出什么好办法来，直接暴力的，就三种情况，从左向右遍历，遇到L，如果前面没有记录的标志位就把前面的都变成L，调整下表位置，如果保留了R，就向中间倒；遇到R，先判断前面的情况，如果保留了R，就把之前的向右倒，此位置先保留，如果前面没记录，也先保留，最后便利到最后，要先判断一下有没有保留的R，最后执行一次操作

代码：

func pushDominoes(dominoes string) string {
    n:=len(dominoes)
    res:=[]string{}
    for i:=0;i<n;i++{
        res=append(res,string(dominoes[i]))
    }
    i:=0
    k:=0
    flag:=0                                               //flag=0标识没有jilu
    str :=string("LR")
    s1:=string(str[0])
    s2:=string(str[1])
    for i<n{
        if res[i]==s1 || res[i] == s2{
            if res[i]==s1 && flag==0{
                for j:=k;j<i;j++{
                    res[j]=res[i]
                }
                k=i+1
            }else if res[i]==s1 && flag==1{
                if (k+i)%2==0{
                    for j:=k;j<(k+i)/2;j++{
                        res[j]=res[k]
                    }
                    for j:=(k+i)/2+1;j<i;j++{
                         res[j]=res[i]
                    }
                }else{
                    for j:=k;j<=(k+i)/2;j++{
                        res[j]=res[k]
                    }
                    for j:=(k+i)/2+1;j<i;j++{
                         res[j]=res[i]
                    }
                }
                k=i+1
                flag=0
            }else if res[i]==s2 && flag==0{
                flag=1                                                //flag=1  保留R的标志
                k=i
            }else if res[i]==s2 && flag==1{
                for j:=k;j<i;j++{
                    res[j]=res[k]
                }
                k=i
            }
        }
        i++
    }
    if k<i && flag==1{
        for j:=k;j<n;j++{
                    res[j]=res[k]
                }
    }
    return strings.Join(res,"")
    
}

题目：有效的括号

题目描述：
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: “()”
输出: true
示例 2:

输入: “()[]{}”
输出: true
示例 3:

输入: “(]”
输出: false
示例 4:

输入: “([)]”
输出: false
示例 5:

输入: “{[]}”
输出: true

分析：一看就是考察栈的操作，进行匹配，然后我又利用go中的strings库，写了一下，替换，知道不能替换为止
注意，不管是哪种方法，最后一定要检查一下栈中的存留还有没有，就是会出现“（（”，这种情况

代码1：

func isValid(s string) bool {
	n:=len(s)
	if n%2!=0{
		return false
	}
	res:=[]byte{}
	str:=string("([{}])")
	s1:=str[0]
	s2:=str[1]
	s3:=str[2]
	s4:=str[3]
	s5:=str[4]
	s6:=str[5]
	for i:=0;i<n;i++{
		if s[i]==s1 || s[i]==s2 || s[i]==s3{

			res=append(res,s[i])


		}else{
            if len(res)==0{
                return false
            }

			if s[i]==s4 && res[len(res)-1]==s3{
				res=res[:len(res)-1]
			}else if s[i]==s4 && res[len(res)-1]!=s3{
				return false
			}

			if s[i]==s5 && res[len(res)-1]==s2{
				res=res[:len(res)-1]
			}else if s[i]==s5 && res[len(res)-1]!=s2{
				return false
			}

			if s[i]==s6 && res[len(res)-1]==s1{

				res=res[:len(res)-1]
			}else if s[i]==s6 && res[len(res)-1]!=s1{
				return false
			}
		}
	}
       if len(res)!=0{
     	return false
	 }
	return true
}

代码2：

func isValid(s string) bool {
	n:=len(s)
	if n%2!=0{
		return false
	}
	 for strings.Contains(s,"()") || strings.Contains(s,"{}") ||strings.Contains(s,"[]"){
		 s=strings.Replace(s,"()","",-1)
		 s=strings.Replace(s,"{}","",-1)
		 s=strings.Replace(s,"[]","",-1)
	 }
	 if s==""{
		 return true
	 }

return false
}