标签：div 反转字符串 初始 elf 循环 rev python3 表示 rip
简单题：
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
思路：list.count(i)
class Solution(object): def singleNumber(self, nums): """ :type nums: List[int] :rtype: int """ for i in nums: if nums.count(i)==1: return i break
给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
思路：list和set的区别，比较二者的长度即可
class Solution(object): def containsDuplicate(self, nums): """ :type nums: List[int] :rtype: bool """ l=len(nums) l1=len(set(nums)) if l>l1: return True else: return False
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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"]
思路：其实我最开始是使用list[::-1]，但是我们要注意的是，即是这样，list原来的值还是没有改变，这个关系到位置index的事情，因此我们重新修改了一次
class Solution(object): def reverseString(self, s): """ :type s: List[str] :rtype: None Do not return anything, modify s in-place instead. """ s[::-1] = s #s=s[::-1] 这样是不行的 return s
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例：
输入："Let‘s take LeetCode contest"
输出："s‘teL ekat edoCteeL tsetnoc"
提示：
在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
解题思路：还是使用s[::-1]，再添加写细节的东西，衔接时注意添加空格，以及处理尾部的空格
class Solution(object): def reverseWords(self, s): """ :type s: str :rtype: str """ s= s.split(‘ ‘) s1=‘‘ for i in s: s1=s1+i[::-1]+‘ ‘ s1 = s1.rstrip() return s1
给定一个整数，编写一个函数来判断它是否是 2 的幂次方。
示例 1:
输入: 1
输出: true
解释: 20 = 1
示例 2:
输入: 16
输出: true
解释: 24 = 16
示例 3:
输入: 218
输出: false
解题思路：这个居然不能用math.log2(n)解决，导致我在使用循环做导致超时，不过可以使用np.log2(n)，其实在其他地方是可以使用math.log2的，不过可能我在力扣中使用的不是Python3
class Solution(object): def isPowerOfTwo(self, n): """ :type n: int :rtype: bool """ import numpy as np if np.log2(n)%1==0: return True else: return False
你和你的朋友，两个人一起玩 Nim 游戏：
桌子上有一堆石头。
你们轮流进行自己的回合，你作为先手。
每一回合，轮到的人拿掉 1 - 3 块石头。
拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。
解题思路：这个网友说，只有总石头数是4的倍数，先手必输，具体的不深究了，感觉像脑洞题
买股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
解题思路：运用比较的方法，注意该题不能刚开始就找最小值，而是要保存每一次的收益，比较每一次的收益
class Solution(object): def maxProfit(self, prices): """ :type prices: List[int] :rtype: int """ start=prices[0] #买进点 earn = 0 #收益 for i in prices[1:]: start = min(start,i) #得到最小的买进点 earn = max(earn,i-start) return earn
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
解题思路：这个使用递归就很好解决，倒推一下，假设当前位于第 n 阶，那么上一步可能在第 n-1 或者第 n-2 阶，分别需要爬 1 级台阶和 2 级台阶。那么，f(n) = f(n-1) + f(n-2)
# 暴力深搜 def climbStairs(self, n: int) -> int: if n == 0 or n == 1: return 1 return self.climbStairs(n - 1) + self.climbStairs(n - 2) # f(n)只依赖于f(n-1)和f(n-2)，只需要两项就足够了 def climbStairs(self, n: int) -> int: a = b = 1 for i in range(2, n + 1): a, b = b, a + b return b
标签：div 反转字符串 初始 elf 循环 rev python3 表示 rip
原文地址：https://www.cnblogs.com/cgmcoding/p/14765943.html
