力扣刷题

Posted 2021-12-01 chenych

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

def run(nums,target):
    '''
    解题思路：
    假定target是由nums列表内的两个元素 i2和i3 之和。先循环nums列表得到i2的值，再循环从当前i2位置往后的列表的元素是否有和i2相加为target的i3值
    有则返回这两个元素i2和i3在nums列表的索引值。
    '''
    for i2 in nums:
        for i3 in nums[nums.index(i2)+1:]:
            if i2 + i3 == target :
                return nums.index(i2),nums[nums.index(i2)+1:].index(i3)+len(nums[:nums.index(i2)+1])

res = run([2,7,11,15],9)
print(res)

(0, 1)

整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [?231, 231 ? 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

def reverse(x):
    
    x = str(x)
    lis1 = [ i for i in x ]
    lis3 = []
    <h2>判断x为负数的情况</h2>
    if lis1[0] == '-':
        lis2 = [i for i in lis1[1:]]
        lis2.reverse()
        <h2>反转之后，判断首个元素为0的情况</h2>
        for j in range(len(lis2)):
            if not lis2[0]:
                lis2.pop(0)
        lis1 = ['-']+lis2
    <h2>判断x为0的情况</h2>
    elif not int(x):
        lis1=['0']
    else:
        lis1.reverse()
        <h2>反转之后，判断首个元素为0的情况</h2>
        for j in range(len(lis1)):
            if not int(lis1[0]):
                lis1.pop(0)

    x = ''.join(lis1)
    x = int(x)
    if x > 2 ** 31 - 1 or x < (-2) ** 31 or x == 0:
        x = 0
    return x

res = reverse(0)
print(res)

0

res = reverse(123)
print(res)

321

res = reverse(-123)
print(res)

-321

res = reverse(120)
print(res)

21

回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

输入: -121
输出: false

解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:

输入: 10
输出: false

解释: 从右向左读, 为 01 。因此它不是一个回文数。

进阶:

你能不将整数转为字符串来解决这个问题吗？

def isPalindrome(self, x: int) -> bool:
    if x<0 or x%10==0 and x !=0:<h2>当x 不等于0时，x小于0，或者是10的倍数，都返回false</h2>
        return False
    if x ==0:<h2>当x=0时，返回True</h2>
        return True
    x = str(x)
    nums=0 #用于记录索引
    a = [i for i in x]  
    if len(a)%2==0:<h2>如果整数的长度为偶数</h2>
        nums = int(len(a)/2) <h2>获取中间值得索引</h2>
        b = [j for j in a[nums:]]<h2>获取后一半的列表切片，进行翻转</h2>
        b.reverse()
        if a[:nums] == b:return True<h2>翻转后，与前一半进行比较，相等则返回True</h2>
        else:return False#否则返回false
    else:<h2>如果整数的长度为奇数</h2>
        nums = int((len(a)-1)/2)#获取中间值得索引
        b = [x for x in a[nums+1:]]<h2>获取后一半的列表切片，进行翻转</h2>
        b.reverse()
        if a[:nums] == b:return True
        else:return False

移除元素

给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝

int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。

// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。

for (int i = 0; i < len; i++) {

print(nums[i]);

}

def removeElement(self, nums, val) -> int:
    a = 0
    for i in nums:#循环列表
        if val - i ==0:<h2>判断列表中 是否有元素等于val的值</h2>
            a = nums.count(i)<h2>计算出与val值相等的元素的个数</h2>
            for j in range(a):#从列表中循环删除这些元素
                nums.remove(i)
    return len(nums)

实现strStr()

实现 strStr() 函数。

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

示例 1:

输入: haystack = "hello", needle = "ll"
输出: 2

示例 2:

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

说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

def strStr(self, haystack: str, needle: str) -> int:
    num = 0 #初始值
    if needle=='':return num #如果needle是空字符串，返回0
    if needle in haystack: #haystack字符串包含needle中的字符串，如示例1
        num = haystack.index(needle)#检索needle中字符串在haystack中的索引
        return num#返回索引
    else:return -1<h2>如果needle不在haystack内，如示例2</h2>

最后一个单词的长度

给定一个仅包含大小写字母和空格 ‘ ‘ 的字符串，返回其最后一个单词的长度。

如果不存在最后一个单词，请返回 0 。

说明：一个单词是指由字母组成，但不包含任何空格的字符串。

示例:

输入: "Hello World"
输出: 5

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        if s in ['',' ']:return 0#如果不存在最后一个单词，请返回 0 
        s = s.strip()
        lis = s.split(' ')
        if len(lis) ==1: return len(lis[0])
        else:
            return len(lis[-1])
        

加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]

解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]

解释: 输入数组表示数字 4321。

class Solution:
    def plusOne(self, digits):
        if digits[-1]!=9:#最低位数字加一位不超过9，不进位
            digits[-1] = digits[-1]+1 #返回最低位加1后的值
            return digits
        else: #最低位数字加一位超过9，向前进一位
            if digits.count(9)==len(digits):#如果每一个数字都是9,
                digits.insert(0,1)#在首位插入1
                for i in range(len(digits)):#循环，将所有的9替换成0
                    for j in digits:
                        if j ==9:
                            digits[digits.index(9)]=0
                return digits
            else:#连续个别是9，如[1,2,9,9]
                digits.reverse()
                digits[0] = 0#第一位变为0
                digits[1] += 1#后一位+1
                for i in range(1, len(digits)): <h2>再循环判断是否后一位+1后变为10，</h2>
                    if digits[i] ==10 :
                        digits[i] = 0
                        digits[i + 1] += 1
                digits.reverse()
                return digits
                
                    

只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4

class Solution:
    def singleNumber(self, nums):
        <h2>for i in nums:</h2>
        <h2>    for j in nums[nums.index(i)+1:]:</h2>
        <h2>        if i^j == 0:</h2>
        <h2>            nums.remove(j)</h2>
        <h2>            nums.remove(j)</h2>
        <h2>return nums[0]</h2>
    
        a = sum(nums)
        nums = set(nums)
        b = sum(nums)*2
        return b-a
    

查找重复的电子邮箱

编写一个 SQL 查询，查找 Person 表中所有重复的电子邮箱。

示例：

+----+---------+
| Id | Email |
+----+---------+
| 1 | [email protected] |
| 2 | [email protected] |
| 3 | [email protected] |
+----+---------+

根据以上输入，你的查询应返回以下结果：

+---------+
| Email |
+---------+
| [email protected] |
+---------+
说明：所有电子邮箱都是小写字母。

Write your mysql query statement below

select distinct a.Email from Person a, Person b where a.Email = b.Email and a.Id != b.Id

反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

class Solution:
    def reverseString(self, s):
        """
        Do not return anything, modify s in-place instead.
        """
        <h2>解题思路：在列表后面增加倒序排列的字符，再将原本字符删除</h2>
        a = len(s)
        for i in range(a):
            s.append(s[a-1-i])
        for i in range(len(s)-a):
            s.pop(0)

两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

说明:

输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

class Solution:
    def intersection(self, nums1, nums2):
        '''
        思路：
        首先判断如果两个数组存在空数组的情况
        再将其中一个数组的元素循环与另一个数组比较，另一个数组也存在此元素的情况下 添加到设定的空集合中，最后返回列表
        '''
        if nums1==[] or nums2==[]:return [] 
        lis = set()
        for i in nums1:
            if i in nums2:
                lis.add(i)
        return list(lis)
            

两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。

我们可以不考虑输出结果的顺序。

进阶:

如果给定的数组已经排好序呢？你将如何优化你的算法？

如果 nums1 的大小比 nums2 小很多，哪种方法更优？

如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

class Solution:
    def intersect(self, nums1, nums2):
        '''
        思路：
        首先判断如果两个数组存在空数组的情况
        循环nums1中的元素，如果nums2中也有，则将此元素和它出现的最小次数添加到集合set1中，再对集合进行循环，转化成列表输出
        '''
        if nums1 == [] or nums2 == []: return []
        lis = []
        set1 = set()
        for i in nums1:
            if i in nums2:
                set1.add((i, min(nums1.count(i), nums2.count(i))))
        <h2>print(set1)</h2>
        for i in set1:
            for j in range(i[1]):
                lis.append(i[0])
        <h2>print(lis)  </h2>
        return lis
            

字符串中的单词数

统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

输入: "Hello, my name is John"
输出: 5

class Solution:
    def countSegments(self, s: str) -> int:
        l=len(s.split(' ')) #字符串以空格分隔后，计算得到的列表长度
        #l在上面赋值之后，在下面有计算，有变化。所以这里用了len(s.plit(' '))
        for i in range(len(s.split(' '))): 
            if len(s.split(' ')[i])==0:l-=1#如果列表中元素存在空字符串，则长度减去1
        return l  

宝石与石头

给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。

J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。

示例 1:

输入: J = "aA", S = "aAAbbbb"
输出: 3

示例 2:

输入: J = "z", S = "ZZ"
输出: 0

注意:

S 和 J 最多含有50个字母。
J 中的字符不重复。

class Solution:
    def numJewelsInStones(self, J: str, S: str) -> int:
        lis = []
        for i in J:
            lis.append(i)
        <h2>print(lis)</h2>
        lis1 = []
        for i in S:
            lis阿1.append(i)
        <h2>print(lis1)</h2>
        num = 0
        for i in range(len(J)):
            num += S.count(J[i])
        return num