Leetcode刷题Day1

蔡小菜123

于 2024-05-15 21:35:33 发布

阅读量616

点赞数 10

文章标签： leetcode 算法职场和发展 python

本文链接：https://blog.csdn.net/m0_63318949/article/details/138908475

版权

Leetcode刷题Day1

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

示例：输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] +
nums[1] == 9 ，返回 [0, 1] 。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)
        for i in range(n):
            for j in range(i+1,n):
                if nums[i] + nums[j] == target:
                    return [i,j]
        return []

2.回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        s = str(x)
        return x >= 0 and s == s[::-1]

3.罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符	数值
I	1
V	5
X	10
L	50
C	100
D	500
M	1000

例如，罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。

示例：输入: s = “III” 输出: 3

class Solution:
    def romanToInt(self, s: str) -> int:
        dict_roman = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
        result = 0
        last_num = 0
        for i in range(len(s)):
            if dict_roman[s[i]] <= last_num:
                result = result + dict_roman[s[i]]
            else:
                result = result + dict_roman[s[i]] - 2*last_num
            last_num = dict_roman[s[i]]
        return result

4.最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

示例：输入：strs = [“flower”,“flow”,“flight”] 输出：“fl”

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        return os.path.commonprefix(strs)

5.有效的括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

class Solution:
    def isValid(self, s: str) -> bool:
        list1 = []
        for i in s:
            if i in ["(","[","{"]:
                list1.append(i)
            elif i == ")" and list1 and list1[-1] == "(":
                list1.pop()
            elif i == "]" and list1 and list1[-1] == '[':
                list1.pop()
            elif i == "}" and list1 and list1[-1] == "{":
                list1.pop()
            else:
                return False
        return not list1

6.合并两个有序链表
将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4]

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if not list1:
            return list2
        if not list2:
            return list1
        if list1.val < list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
    
        return list1 if list1.val < list2.val else list2

7.删除有序数组中的重复项
给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。返回 k 项。

class Solution(object):
    def removeDuplicates(self, nums):
        N = len(nums)
        left = 0
        for right in range(1, N):
            if nums[right] != nums[left]:
                left += 1
                nums[left] = nums[right]
        return left + 1

8.移除元素
给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        while val in nums:
            nums.remove(val)
        return len(nums)

9.找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例：输入：haystack = “sadbutsad”, needle = “sad” 输出：0 解释：“sad” 在下标 0 和 6
处匹配。第一个匹配项的下标是 0 ，所以返回 0 。

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        num = haystack.find(needle)
        return num

10.搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

示例：输入: nums = [1,3,5,6], target = 5 输出: 2

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        for i in range(len(nums)):
            if nums[i] == target:
                return i
            elif nums[i] > target:
                return i
        return len(nums)

11.最后一个单词长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例：输入：s = “Hello World” 输出：5 解释：最后一个单词是“World”，长度为 5。

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        return len(s.strip().split(" ")[-1])

strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
12.加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位，数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

示例：输入：digits = [1,2,3] 输出：[1,2,4] 解释：输入数组表示数字 123。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        result = []
        s = ""
        for i in digits:
            s += str(i)
        s = int(s)+1
        for i in str(s):
            result.append(int(i))
        return result

13.二进制求和
给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

示例：输入:a = “11”, b = “1” 输出：“100”

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        a1 = int(a,2)
        b1 = int(b,2)
        result = a1 + b1
        return bin(result)[2:]

14.x的平方根
给你一个非负整数 x ，计算并返回 x 的算术平方根。
由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例：输入：x = 4 输出：2

class Solution:
    def mySqrt(self, x: int) -> int:
        if x == 0 or x == 1:
            return x
        low, high, res = 1, x, 1
        while low <= high:
            mid = (low + high) // 2
            if mid*mid <= x:
                res = mid
                low = mid + 1
            else:
                high = mid - 1
        return res

15.删除排序链表中的重复元素
给定一个已排序的链表的头 head ，删除所有重复的元素，使每个元素只出现一次。返回已排序的链表。

示例：输入：head = [1,1,2] 输出：[1,2]

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head: return head
        current = head
        while current.next:
            if current.val == current.next.val:
                current.next = current.next.next
            else:
                current = current.next
        return head

蔡小菜123

关注

10
点赞
踩
8

收藏

觉得还不错? 一键收藏
2
评论
Leetcode刷题Day1

给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。返回已排序的链表。给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
复制链接

扫一扫