力扣-tengxun50

Posted 2021-05-13 小小喽啰

简单题：

只出现过一次数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 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的幂

给定一个整数，编写一个函数来判断它是否是 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游戏

你和你的朋友，两个人一起玩 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