关键词：
两数之和
给定一个整数数组 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 xres = reverse(0)
print(res)0res = reverse(123)
print(res)321res = reverse(-123)
print(res)-321res = 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
力扣刷题(代码片段)
两数之和给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。示例:给定nums=[2... 查看详情
力扣刷题详解(含代码动态展示)(代码片段)
(文章目录)一、448.找到所有数组中消失的数字1.完整过程动态展示2.代码实现int*findDisappearedNumbers(int*nums,intnumsSize,int*returnSize)int*ptr=(int*)malloc(sizeof(int)*numsSize);intindex=0;intnoindex=0;while(index<numsSize)if(num 查看详情
力扣刷题-搜索插入位置(代码片段)
力扣题目链接题目描述给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。使用时间复杂度为O(logn)的算法。你可以假设数组中无重... 查看详情
力扣刷题：括号生成（java实现）(代码片段)
数字n代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。有效括号组合需满足：左括号必须以正确的顺序闭合。示例1：输入：n=3输出：["((()))","(()())",&... 查看详情
力扣刷题—两数之和(代码片段)
题目：给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重... 查看详情
力扣刷题：合并区间（java实现）(代码片段)
题目描述：以数组intervals表示若干个区间的集合，其中单个区间为intervals[i]=[starti,endi]。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。示例1：输入：in... 查看详情
力扣刷题：岛屿数量（java实现）(代码片段)
给你一个由'1'（陆地）和'0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以... 查看详情
力扣刷题：全排列（java实现）(代码片段)
题目：给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。示例1：输入：nums=[1,2,3]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]示例2：输入：nums=[0,1]输出&#x... 查看详情
力扣刷题：字母异位词分组（java实现）(代码片段)
题目：给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。字母异位词是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母都恰好只用一次。示例1:输入:strs=["eat... 查看详情
力扣刷题算法笔记（javascript版）(代码片段)
...很多算法这个up主讲的真的非常好适合小白去听算法都是力扣难度中等和简单的b站视频链接1、岛屿最大面积（求两数最大和）解析：提供一个数组，给了一个target要求是在数组中找到两个数的和为target思路：1... 查看详情
力扣刷题：寻找峰值（java实现）(代码片段)
题目：峰值元素是指其值严格大于左右相邻值的元素。给你一个整数数组nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。你可以假设nums[-1]=nums[n]=... 查看详情
力扣刷题之贪心算法（c++）(代码片段)
...求解每一个子集的最优解将局部最优解迭代成全局最优解力扣例题455.分发饼干分析：因为饥饿度最小的孩子最容易吃 查看详情
力扣刷题：四数之和（c#）(代码片段)
给你一个由n个整数组成的数组nums，和一个目标值target。请你找出并返回满足下述全部条件且不重复的四元组[nums[a],nums[b],nums[c],nums[d]]（若两个四元组元素一一对应，则认为两个四元组重复）：0<=a,b,c,d<... 查看详情
力扣刷题：四数之和（c#）(代码片段)
给你一个由n个整数组成的数组nums，和一个目标值target。请你找出并返回满足下述全部条件且不重复的四元组[nums[a],nums[b],nums[c],nums[d]]（若两个四元组元素一一对应，则认为两个四元组重复）：0<=a,b,c,d<... 查看详情
力扣刷题：四数之和（c++）(代码片段)
给你一个由n个整数组成的数组nums，和一个目标值target。请你找出并返回满足下述全部条件且不重复的四元组[nums[a],nums[b],nums[c],nums[d]]（若两个四元组元素一一对应，则认为两个四元组重复）：0<=a,b,c,d<... 查看详情
力扣刷题：四数之和（c++）(代码片段)
给你一个由n个整数组成的数组nums，和一个目标值target。请你找出并返回满足下述全部条件且不重复的四元组[nums[a],nums[b],nums[c],nums[d]]（若两个四元组元素一一对应，则认为两个四元组重复）：0<=a,b,c,d<... 查看详情
力扣刷题：单词搜索（java实现）(代码片段)
题目：给定一个mxn二维字符网格board和一个字符串单词word。如果word存在于网格中，返回true；否则，返回false。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相... 查看详情
力扣刷题记录——两数之和(代码片段)
题目：给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重... 查看详情