精华内容
下载资源
问答
  • 每日汇总题目,菜鸟小白的进阶之路。 有大神的助力,前路顺遂些! LeetCode All in One 题目讲解汇总(持续更新中…)

    每日汇总题目,菜鸟小白的进阶之路。

    有大神的助力,前路顺遂些!

    LeetCode All in One 题目讲解汇总(持续更新中…)

    展开全文
  • 整体总结 简单难度 383、387、389中等难度 2本次刷题 总结 以下4点 ascii码 可以简化 char类型的运算复杂度 统计的次数的时候可以借助map 做到空间换时间 char 加减法这种套路 有印象 以后...给定个赎金信 (ransom)

    刷题网站 :https://leetcode-cn.com/
    github地址: https://github.com/zhe8300975/myleetcode

    整体总结

    简单难度 383、387、389
    中等难度 2
    本次刷题 总结 以下4点

    1. ascii码 可以简化 char类型的运算复杂度
    2. 统计的次数的时候可以借助map 做到空间换时间
    3. char 加减法这种套路 有印象 以后说不定可以发散下
    4. 边界条件 要重视
      总的来说 对应重新开始刷题的你我来说很合适的 长期的业务开发 会让我们基础数据类型的操作变得生疏 这几道题既可以熟悉基础语法 也可以熟悉基本数据类型 不错不错 哈哈

    LeetCode 383

    题目 —— 赎金信

    给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串,判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成,返回 true ;否则返回 false。

    (题目说明:为了不暴露赎金信字迹,要从杂志上搜索各个需要的字母,组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

    注意:

    你可以假设两个字符串均只含有小写字母。

    canConstruct(“a”, “b”) -> false
    canConstruct(“aa”, “ab”) -> false
    canConstruct(“aa”, “aab”) -> true

    思路

    首先题干中可以得到两个点:

    • ransom里面的字符由magazine里面的字符组成
    • magazine里面的字符只能用到一遍

    所以可以得出

    • magazine里面的字符需要被记录
    • magazine里面的字符出现的次数需要被被记录

    PS :看题可以猜的到 时间复杂度应该O(n)就够用 为什么是O(n)
    正常我们应该遍历记录magazine (O(n) n是magazine的长度)
    然后遍历ransom一遍对比magazine中的数据 (O(m) m是ransom长度)
    整体时间复杂度 O(n+m) & m < n ----> O(2n) -> O(n)

    综上 我很容易想到需要用一个Map记录magazine

    key-出现的字符
    value-字符出现的次数

    解题

    下面是就开始敲代码了
    下面是第一版代码
    file

    通过 然而 平台提示的是运行速度和内存使用 都是下游水平的由此产生自我怀疑

    首先想到的是的思路是不是不对的 ——看起来思路上应该没有问题

    那就是代码上看能不能有所优化 —— 使用map的containKey 的话 会调用两次map 所以优化直接判断是不是为null可以做到一次
    下面是代码

    file

    通过 然而 平台提示的是运行速度和内存使用 还是不行 比较是开始刷题 我觉得可以看看答案了

    差异点 —— 官方答案中 利用字符的ascii编码 将hashmap退化成程度为26的数组 减少了hashmap 哈希的过程,内存上直接也限制了26 * int (int=4*8位)的数组大小长度
    效率和 内存上 都有了显著的提高 代码如下

    file

    file

    LeetCode 387

    题目 —— 字符串中的第一个唯一字符

    给定一个字符串,找到它的第一个不重复的字符,并返回它的索引。如果不存在,则返回 -1。
    示例:

    s = “leetcode”
    返回 0

    s = “loveleetcode”
    返回 2

    提示:你可以假定该字符串只包含小写字母。

    思路

    这到题 瞬间 双重遍历每一字符遍历对比一遍 没有出现的其实就是想要的解 时间复杂度O( n^2 ) 然后瞬间推翻 提示不是没用的 猜测一定O(n)内可以解决

    • O(n)内解决 肯定一两次循环就够
    • 提示:你可以假定该字符串只包含小写字母。 那么根据上面的经验,char可以通过ascii转成int 最多26个

    所以可以得出

    • int[] 记录没有展示string中字符出现的次数 一次遍历
    • 再遍历 找到第一个次数为1的
      时间复杂度O(n);

    解题

    file

    时间复杂度 和空间 复杂度 都在90%以上足够

    复盘看下答案

    1. 官方解法一和我们思路基本一致
    2. 官方解法二 比我们方式要好 为什么 ?(具解法有兴趣的可以官网去看)
      • 利用String 方法str.indexOf(ch) == str.lastIndexOf(ch) 判断是否有过重复 减少第一次循环次数
      • 利用一共小写字母是26个 把我们第二个循环退化成了26次

    LeetCode 389

    题目 —— 找不同

    给定两个字符串 s 和 t,它们只包含小写字母。

    字符串 t 由字符串 s 随机重排,然后在随机位置添加一个字母。

    请找出在 t 中被添加的字母。

    思路

    • 延续上面套路 还是list记录 出现次数容易可以得出如下代码

    解题

    file

    复盘看下答案

    发现一个更好的解决方案 ,官方合理的利用了 随机位置添加一个字母 这个条件

    利用减法 将两个字符串的ascii 做差 那么差值就是 差出来的那一个字符

    代码如下
    file

    对比
    file

    虽然两次的运行时间差别不大 但是在内存上 差别还是挺明显的 毕竟数组直接退化成一个值了

    LeetCode 2

    题目 —— 两数相加

    给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。

    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。

    您可以假设除了数字 0 之外,这两个数都不会以 0 开头。
    输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
    输出:7 -> 0 -> 8
    原因:342 + 465 = 807

    思路

    抽离核心点

    1. 逆序链表
    2. 非负
    3. 一个节点一个数

    综上所诉 其实最核心的就是逆序列表->链表头部是个位
    题目很符合人类认知 两个链表同时后移相加 再一个变量记录进位就好了

    解题

    file

    复盘看下答案

    看了下答案 发现思路基本一致 不过在结题过程中 发现 这个题还有一个隐形的考察点 其实就是边界条件 结题的方式其实很简单 ,但是想要一次写出来也是不容易的

    展开全文
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦 Leetcode题目 小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个,小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏,请返回 小A 猜对了...

    序言

    今天是刷LT的一天,好好干饭,好好努力,好好加油哦

    Leetcode题目
    小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个,小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏,请返回 小A 猜对了几次?
    输入的guess数组为 小A 每次的猜测,answer数组为 小B 每次的选择。guess和answer的长度都等于3

    例子

    输入:guess = [1,2,3], answer = [1,2,3]
    输出:3
    输入:guess = [2,2,3], answer = [3,2,1]
    输出:1
    

    这感觉是LT最简单的题啊哈哈哈哈
    只要挨个 匹配是否相等

    
    def game(guess,answer):
    	acc = 0 
        for i in range(3):
        	if guess[i] == answer[i]: 
        		acc += 1 
        return acc
    #或者简单缩写成这样子:
    def game(guess,answer):
    	return sum(guess[i]==answer[i] for i in range(3))
    

    题目二

    Leetcode题目:
    给你一个m x n的整数网格 accounts , 其中 accounts[i][j] 是第 i​​​​​​​​​​​​ 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量
    客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户

    例子

    输入:accounts = [[1,5],[7,3],[3,5]]
    输出:10
    解释:
    第 1 位客户的资产总量 = 62 位客户的资产总量 = 103 位客户的资产总量 = 82 位客户是最富有的,资产总量是 10
    

    这也很简单啊,只要sum计算出所有客户的资产,再return其中的最大值

    def maximumWealth(accounts):
    	num_client = len(accounts)             #客户的数量
        asset = []                             #收集每个客户的总资产
        for i in range(num_client):
        	asset.append(sum(accounts[i]))
        return max(asset)                      #返回最大资产
    

    题目三

    Leetcode题目:
    给你一个整数数组 nums 。
    如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ,就可以认为这是一组 好数对 。
    返回好数对的数目

    例子

    输入:nums = [1,2,3,1,1,3]
    输出:4  解释:有 4 组好数对,分别是 (0,3), (0,4), (3,4), (2,5) ,下标从 0 开始
    输入:nums = [1,1,1,1]
    输出:6  解释:数组中的每组数字都是好数对
    输入:nums = [1,2,3]
    输出:0
    

    这道题也很简单哎,今天随机刷的LT这几道题都很简单

    def numIdenticalPairs(nums):
    	n = 0
        num = len(nums)
        for i in range(num):
        	for j in range(i+1,num):
        		if nums[i] == nums[j]:
        			n += 1 
        return n 
    

    只要用两个for loop 一个一个匹配就行。
    复杂度分析:

    • 时间复杂度:O(n^2)
    • 空间复杂度:O(1)

    方法二
    假设nums出现的相同的数字次数为V,则出现的匹配的组数为V(V-1)/2。比如出现1的次数为3,则可匹配的相同组数为3✖️(3-1)/2 = 3组数。然后再sum up所有的组数。
    而计算相同次数的函数为collections.Counter(nums)
    而用collections.Counter自带的items()方法,能作为字典的输出,从而计算组数

    def numIdenticalPairs(nums):
    	dic = collections.Counter(nums)
    	return sum(((v-1)*v)//2 for k,v in dic.items())
    

    复杂度分析

    • 时间复杂度:O(n)
    • 空间复杂度:O(n), 即哈希表使用到的辅助空间的空间代价
    展开全文
  • 今天是LT的第一天,好好干饭,好好努力,好好加油哦! 第一题 题目描述: 找到几个字符串中最长公共前缀。 例子如下: Input: ["flower","flow","flight"] Output: "fl" Input: ["dog","racecar","car"] ...

    序言

    今天是刷LT的一天,好好干饭,好好努力,好好加油哦!

    1. 第一题

    题目描述:
    找到几个字符串中最长公共前缀。

    例子如下:

    Input: ["flower","flow","flight"]
    Output: "fl"
    Input: ["dog","racecar","car"]
    Output: ""
    

    方法一
    解析思路:
    这里需要使用的的是zip函数和set函数,先理解这两个函数的用法再做这道题。

    (1) zip() vs zip(*)

    zip()函数作用于可迭代的对象,将对象对应的元素组成一个个元组
    然后返回这些元组的列表, 例子如下:

    a = [1, 2, 3]
    b = ["a", "b", "c"]
    
    list(zip(a, b))  #用list列出来
    输出为:[(1, 'a'), (2, 'b'), (3, 'c')]
    

    zip(*)函数则相反,起到解压的作用,
    例子如下:

    example = ["flower", "flow", "flqwe"]
    list(zip(*example))
    输出为:[('f', 'f', 'f'), ('l', 'l', 'l'), ('o', 'o', 'q'), ('w', 'w', 'w')]
    

    (2)set()函数

    set() 函数创建一个无序不重复元素集,可用于删除重复值。例子如下

    a = set('abcdd')
    b = set('cdeff')
    a
    b
    输出为:
    {'a', 'b', 'c', 'd'}
    {'c', 'd', 'e', 'f'}
    
    a & b #交集 
    输出为 {'c', 'd'}
    a | b #并集 
    输出为 {'a', 'b', 'c', 'd', 'e', 'f'}
    

    回到之前的题目,需要返回列表中的几个字符中共同前缀。

    Input: ["flower","flow","flight"]
    Output: "fl"
    

    首先,用zip(*)把列表的几个字符解压出来,把input解压出来,变成[(‘f’, ‘f’, ‘f’), (‘l’, ‘l’, ‘l’), (‘o’, ‘o’, ‘q’), (‘w’, ‘w’, ‘w’)], 然后用set函数去掉重复值,变成[(‘f’), (‘l’), ( ‘o’, ‘q’), (‘w’)],最后用一个if函数,只取其中set后长度为1的字符。Python如下:

    def longestCommonPrefix(strs) -> str:
        opt = ''
        for i in zip (*strs):     #zip (*strs) 即是解压组合出来
            if len(set(i))==1:    #针对set后长度为1的字符
                opt += i[0]       #录入字符
            else:
                break
        return opt
    

    方法二:
    把列表的第一个字符串作为标准,跟剩余的其他字符串比较。而两个字符串的比较使用二分法来比较,最后的时间复杂度为O(N*log(N))。跟第一个方法的时间复杂度相比好很多。

    使用一个例子来理解两个字符串的二分法是:
    str = {leets, leetcode, leetc, leed}
    首先,leets 从中间拆开,5//2 = 2 即leets 分为 lee 和 ts
    然后,检查lee 是否 in {leetcode, leetc, leed} 一致通过
    再然后,把t加入lee 为leet,再次检查leet 是否 in {leetcode, leetc, leed} 并没有一致通过
    所以直接返回 lee为最长公共前缀。用这个方法执行起来更快。

    首先理解find函数用法,可以检测字符串中是否包含子字符串
    find()函数语法 :string.find(str, beg=0, end=len(string))

    1. str : 指定检索的字符串
    2. beg :开始索引,默认为0
    3. end :结束索引,默认为字符串的长度

    如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内
    如果包含子字符串返回开始的索引值,否则返回-1
    例子:

    str1 = "AppleandDoctor"
    str2 = "and"
    print(str1.find(str2))     #没有任何指定范围,默认整个字符串范围
    print(str1.find(str2, 1))  #指定从位置为1的开始检索
    print(str1.find(str2, 10)) #指定从位置为10的开始检索
    输出
    5
    5
    -1
    

    所以定义PassorNot函数 检测字符是否全部通过

    def PassorNot(strs,mid):
      s = strs[0][0:mid]
      #检测剩余的其他字符串
      for i in range(1,len(strs)):
        #如果出现了不通过的情况,则马上return false
        if strs[i].find(s)!=0:
          return False
      #如果都通过,即剩余的字符串都包含s,则return True
      return True
    

    现在可以定义整个函数

    def longestCommonPrefix(strs):
      '''
      :strs: List type 包含多个字符串的列表
      返回最长的公共前缀
      '''
      #取列表中的第一个字符串作为标准比较
      low, high = 1,len(strs[0]) 
      while low <= high:
        mid = (low + high)//2
        if PassorNot(strs,mid):
          low = mid + 1
        else:
          high = mid - 1
    
      return strs[0][0:(low+high)//2]
    
    1. 题目二

    题目描述:
    给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在,则返回 -1。

    例子如下:

    输入: haystack = "hello", needle = "ll"
    输出: 2
    输入: haystack = "aaaaa", needle = "bba"
    输出: -1
    

    解析思路:
    直接根据条件来,用多个if 来筛选。

    def strStr(haystack,needle):
        lh = len(haystack)         #haystack的长度
        ln = len(needle)           #needle的长度
        if ln == 0:                #当needle为空集return0
            return 0 
        if lh == 0 or lh < ln:     #当不符合条件无法查找 return -1
            return -1
        i = 0
        while(i<=lh-ln):           
            if haystack[i] == needle[0]:    
            #当出现和needle第一个字母相同的字符时,测试后面的是否一致。   
                if haystack[i:i+ln] == needle:
                #记住[i:i+ln]字符提取是取前不取后,即i+ln的字符是没有取到的。
                    return i
                else:
                    i+=1
            else:
                i+=1
        return -1 
    
    展开全文
  • 刷leetcode的第一天

    2019-01-08 16:17:00
    例是根据类创建出来的个个具体的“对象” 例: class Student(object): bart = Student() bart &lt;main.Student object at 0x10a67a590&gt; # 0x10a67a590是个内存地址 Student &lt;class...
  • 刷Leetcode25题的一天

    2020-03-19 23:04:34
    今早先整理了所有的书,真的,太多了。 “尽是些人类欺辱的历史,烧了也无所谓。... 当然,这其中也有畏难心理,几道题没有去,但是也算是破了记录,如果中间没有被打断的话。 明天,加油! ...
  • 文章目录整体总结LeetCode 1题目 —— 两数之和思路解题LeetCode 7题目 —— 整数反转思路解题LeetCode 9题目 —— 回文数思路解题LeetCode187题目 —— 重复的DNA序列思路解题 整体总结 简单难度 1、7、9 中等难度 ...
  • 给定个整数数组 nums 和个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。 你可以假设每种输入只会对应个答案。但是,数组中同个元素在答案里不能重复...
  • leetCode有兴趣的可以去看看,我们直接上干货啦= = 第道题 - 难度(★) 输入个数组跟个目标值,当数组中某两个数之和等于目标值,返回这两个数的索引(下标)注意这两个数不能相同。(如果内部有多对符合要求的...
  • java 刷LeetCode

    千次阅读 2017-09-10 10:15:49
    leetcode刷过7次的抢答。当年leetcode才153道题,现在题目数量好像突破200大关了。...第六次第七次的时候,一天70+道题。到后边,感觉这些题目已经倒背如流了。然后歇菜了半年,现在看起来还能记得起
  • 刷leetcode记录

    2015-04-20 09:31:08
    刷leetcode记录 目前已经刷了102道题目,进入hard攻克阶段。昨天围观大神敲代码,感到大神已经将很多内容训练为内隐知识。 另方面感觉到,目前可以先不求甚解。熟练了之后很多东西,自然而然就会了。先记熟练会...
  • leetcode 有感

    2020-10-21 02:25:30
    2年前就知道了 leetcode ,直接上去. 基础不牢再加上毫无准备, 随机抽两道题就做的我被当时的 leetcode 吊打, 自信心受到了很大打击. 即使这样, 也没唤醒当时自己的忧患意识. 前个来月, 觉得自己在基础方面需要下...
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦 leetcode题目: 给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s,返回其最后一个单词的长度。如果字符串从左向右滚动显示,那么最后一个单词就是最后出现的...
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦l leetcode题目: 给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度 例子 输入:nums = [3,2,2,3], val = 3...
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦! Leetcode题目: 给定一个整数数组 nums,其中恰好有两个元素只出现一次,其余所有元素均出现两次。 找出只出现一次的那两个元素。你可以按任意顺序 返回答案 ...
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦 Leetcode题目: 实现一种算法,删除单向链表中间的某个节点(即不是第一个或最后一个节点) 例子 输入:单向链表a->b->c->d->e->f中的节点c ...
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦! Leetcode题目: 给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现了三次。找出那个只出现了一次的元素。 例子 输入: [2,2,3,2] 输出: ...
  • 今天是LT的一天,好好干饭,好好努力,好好加油哦! Leetcode题: 给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度 例子 输入:nums = [1,1,2] 输出:2 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,548
精华内容 2,619
关键字:

一天刷leetcode