'''
1两数之和给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：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]:hashtable = dict()for i, num in enumerate(nums):if target - num in hashtable:return [hashtable[target - num], i]hashtable[nums[i]] = ireturn []

# class Solution:
#     def twoSum(self,nums,target):
#         for i in range(0,len(nums)-1):
#             for j in range(i+1,len(nums)):
#                 if nums[i]==nums[j]:
#                     return None
#                 if nums[i]+nums[j]==target:
#                     return [i,j]
#
# if __name__=="__main__":
#     solution=Solution()
#     print(solution.twoSum([2,7,11,15],9))'''
9. 回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。'''
class Solution(object):def isPalindrome(self, x):""":type x: int:rtype: bool"""s = str(x)if s == s[::-1]:return Trueelse:return False'''
13. 罗马数字转整数
罗马数字包含以下七种字符: 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。
给定一个罗马数字，将其转换成整数。
示例 1:输入: s = "III"
输出: 3
示例 2:输入: s = "IV"
输出: 4
示例 3:输入: s = "IX"
输出: 9
示例 4:输入: s = "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.'''class Solution(object):def romanToInt(self, s):""":type s: str:rtype: int"""a = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}ans = 0for i in range(len(s)):if i ListNode:res = ListNode(0)l3 = reswhile l1 and l2:if l1.val < l2.val:l3.next = l1l1 = l1.nextelse:l3.next = l2l2 = l2.nextl3 = l3.nextif l1:l3.next = l1if l2:l3.next = l2return res.next'''
26. 删除有序数组中的重复项
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。示例 1：输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2：输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。'''
class Solution:"""解题思路: 快慢指针,指针i控制控制不重复字符的长度，如果有不重复就向后移一位指针j每次计算后都向后移一位，直到移动到最后一个元素，遍历结束。"""def removeDuplicates(self, nums: List[int]) -> int:length = len(nums)i = 0j = 1# j 控制遍历的位置， i控制不重复字符的长度while length > j:if nums[i] != nums[j]:nums[i+1],nums[j] = nums[j], nums[i+1]i += 1j = j+1else:j += 1# i为索引，最后返回的长度为i+1return i+1'''
27. 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。示例 1：输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。'''
class Solution:def removeElement(self,nums:list,val)->int:if len(nums)==0:return 0if len(nums)==1:if nums[0]==val:return 0else:return 1for item in(nums):if item==val:nums.remove(item)return len(nums)'''
35. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。示例 1:输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:输入: nums = [1,3,5,6], target = 2
输出: 1'''
def searchNum(aList,target):for i in aList:if i>=target:return alist.index(i)if aList[0]>=target:return 0else:return len(aList)if __name__ == '__main__':alist=[1,3,5,6]target=2numIndex=searchNum(alist,target)print(numIndex)'''
58. 最后一个单词的长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。示例 1：输入：s = "Hello World"
输出：5
解释：最后一个单词是“World”，长度为5。
示例 2：输入：s = "   fly me   to   the moon  "
输出：4
解释：最后一个单词是“moon”，长度为4。'''def length0fLastWord2(s):return len(s.split()[-1])
print(length0fLastWord2('jjj kkk dss'))'''
66. 加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。示例 2：输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
示例 3：输入：digits = [0]
输出：[1]'''
# def plusOne(digits):
class Solution:def plusOne(self, digits: List[int]) -> List[int]:i = -1while i >= -len(digits):if digits[i] != 9:digits[i] += 1return digitselse:digits[i] = 0i -= 1return [1] + digits'''
67. 二进制求和
给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。
示例 1：输入:a = "11", b = "1"
输出："100"
示例 2：输入：a = "1010", b = "1011"
输出："10101"'''
class Solution(object):def addBinary(self, a, b):""":type a: str:type b: str:rtype: str"""return bin(int(a, 2)+int(b, 2))[2:]
# bin函数可以将十进制转换成二进制字符串形式，输出会带有两个首部字符，所以从第三个字符开始取。
# int函数先将二进制字符串转换成十进制然后相加。'''
88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。示例 1：输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。'''class Solution:def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:nums1[m:] = nums2[:n]nums1.sort()'''
69. x 的平方根 
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
示例 1：输入：x = 4
输出：2
示例 2：输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。'''
class Solution:def mySqrt(self, x: int) -> int:sq_x=math.exp(0.5*math.log(x))sq_x=int(sq_x)return sq_x'''
70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
'''# 动态规划
class Solution:def climbStairs(self, n: int) -> int:x0, x1, x2 = 0, 0, 1for i in range(n):x0 = x1x1 = x2x2 = x0 + x1return x2