leecode第一天

1、两数之和

# 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
# 你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
# 你可以按任意顺序返回答案。

#自己
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]5
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i]+nums[j]==target:
                    return [i,j]
#hash表
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target- num], i]
            
            hashtable[num] = i

        return []

2、两数相加

# 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

# 请你将两个数相加，并以相同形式返回一个表示和的链表。

# 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution(object):

    def addTwoNumbers(self, l1, l2):
        """
        将两个表示非负整数的逆序链表相加，并返回一个新的逆序链表表示它们的和。

        每个链表的节点存储一位数字，且数字按逆序方式存储。函数将两个链表表示的数字相加，
        并以相同形式返回一个新链表表示它们的和。

        参数:
        l1 (ListNode): 第一个链表的头节点。
        l2 (ListNode): 第二个链表的头节点。

        返回:
        ListNode: 新链表的头节点，表示两个输入链表所表示数字的和。
        """
        # 创建虚拟头节点，用于简化边界条件处理
        dummy = ListNode()
        curr = dummy
        carry = 0  # 初始化进位为0

        # 当l1、l2链表中还有剩余节点或存在进位时继续循环
        while l1 or l2 or carry:
            # 获取当前节点的值，如果节点为空则默认为0
            val1 = l1.val if l1 else 0
            val2 = l2.val if l2 else 0
            
            # 计算当前位的总和及新的进位值
            total = val1 + val2 + carry
            carry = total // 10#进位：总和除以10
            digit = total % 10#余数：总和取余10
            
            # 创建新节点并将其连接到结果链表
            curr.next = ListNode(digit)
            curr = curr.next
            
            # 如果当前节点存在，则移动指针到下一个节点
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next
                
        # 返回虚拟头节点的下一个节点，即结果链表的头节点
        return dummy.next

# 正确初始化链表 l1: 2 -> 4 -> 3
l1 = ListNode(2)
l1.next = ListNode(4)
l1.next.next = ListNode(3)

# 正确初始化链表 l2: 5 -> 6 -> 4
l2 = ListNode(5)
l2.next = ListNode(6)
l2.next.next = ListNode(4)

# 创建类的实例并调用方法
solution = Solution()
result = solution.addTwoNumbers(l1, l2)

# 打印结果
while result:
    print(result.val, end=" ")
    result = result.next

9、回文数

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        
		"""
        emp=str(x)
        temp_reverse=temp[::-1]
        if temp==temp_reverse:
            return True
        else:
            return False
        """
        return str(x) == str(x)[::-1]

13、罗马数字转整数

def romanToInt(self, s):
    """
    将罗马数字转换为整数。
    
    罗马数字是用几个字母表示的：I（1），V（5），X（10），L（50），C（100），D（500）和M（1000）。
    例如，罗马数字 II 表示两个一，即2，而 XII 表示十加一加一，即12。
    通常，罗马数字中小的数字在大的数字左边，但也有例外，如 IV 表示4，IX 表示9。
    
    参数:
    s: 罗马数字字符串。
    
    返回值:
    转换后的整数。
    """
    # 定义罗马数字与对应整数值的字典
    roman = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
    # 初始化结果变量为0
    res = 0
    # 遍历罗马数字字符串，除了最后一个字符
    for i in range(len(s)-1):
        # 如果当前罗马数字小于后面的罗马数字，说明需要减去当前值
        if roman[s[i]] < roman[s[i+1]]:
            res -= roman[s[i]]
        else:
            # 否则，加上当前罗马数字的值
            res += roman[s[i]]
    # 加上最后一个罗马数字的值
    res += roman[s[-1]]
    # 返回转换后的整数结果
    return res

14、最长公共前缀

	def longestCommonPrefix(self, strs):
        """
        找到字符串列表中最长的公共前缀。
        
        :param strs: 包含多个字符串的列表
        :type strs: List[str]
        :return: 最长的公共前缀字符串
        :rtype: str
        """
        # 初始化结果变量为空字符串
        res = ""
        # 遍历第一个字符串的每个字符
        for i in range(len(strs[0])):
            # 遍历字符串列表中的每个字符串
            for j in strs:
                # 如果当前索引超出某个字符串的长度，或者字符不匹配，则返回当前结果
                if i == len(j) or j[i] != strs[0][i]:
                    return res
            # 如果所有字符串在当前索引处的字符都匹配，则将该字符添加到结果中
            res += strs[0][i]
        # 返回最终的公共前缀
        return res