LeetCode简单题目(#263 #268 #278 #283 #290)-5道（数字、字符串）

柔光的暖阳◎ 2023-06-23 06:59 86阅读 0赞

leetcode题库中共有350道简单题目。
本文记录已解决的题目和代码。
本文中的序号是leetcode题目中的真实序号。

文章目录

  • 263 丑数
    • 描述
    • 代码
    • 大神代码
  • 268 缺失数字
    • 描述
    • 代码
    • 大神代码
  • 278 第一个错误的版本
    • 描述
    • 代码
  • 283 移动零
    • 描述
    • 代码
    • 大神代码
  • 290 单词规律
    • 描述
    • 代码
    • 大神代码

263 丑数

描述

编写一个程序判断给定的数是否为丑数。
丑数就是只包含质因数 2, 3, 5 的正整数。

示例 1:
输入: 6
输出: true
解释: 6 = 2 × 3
示例 2:
输入: 8
输出: true
解释: 8 = 2 × 2 × 2
示例 3:
输入: 14
输出: false
解释: 14 不是丑数，因为它包含了另外一个质因数 7。
说明：
1 是丑数。
输入不会超过 32 位有符号整数的范围: [−231, 231 − 1]。

代码

  1. class Solution:
  2.     def isUgly(self, num: int) -> bool:
  3.         sp_num = [2,3,5]
  4.         if not num:
  5.             return False
  7.         while num != 1:
  8.             i = 0
  9.             while num%sp_num[i]:
  10.                 i += 1
  11.                 if i == 3:
  12.                     return False
  13.             num = num/sp_num[i]
  14.         return True

大神代码

https://leetcode-cn.com/u/powcai/

  1. class Solution:
  2.     def isUgly(self, num: int) -> bool:
  3.         for p in 2, 3, 5:
  4.             while num % p == 0 < num:
  5.                 num //= p
  6.         return num == 1

268 缺失数字

描述

给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 … n 中没有出现在序列中的那个数。
示例 1:

输入: [3,0,1]
输出: 2
示例 2:

输入: [9,6,4,2,3,5,7,0,1]
输出: 8

代码

  1. class Solution:
  2.     def missingNumber(self, nums: List[int]) -> int:
  3.         num_len = len(nums)
  4.         right_sum = num_len*(num_len+1)//2
  5.         return right_sum-sum(nums)

大神代码

方法总结
作者：LeetCode
链接：https://leetcode-cn.com/problems/missing-number/solution/que-shi-shu-zi-by-leetcode/

  1. # missing
  2. # =4∧(0∧0)∧(1∧1)∧(2∧3)∧(3∧4)
  3. # =(4∧4)∧(0∧0)∧(1∧1)∧(3∧3)∧2
  4. # =0∧0∧0∧0∧2
  5. # =2
  6. class Solution:
  7.     def missingNumber(self, nums):
  8.         missing = len(nums)
  9.         for i, num in enumerate(nums):
  10.             missing ^= i ^ num
  11.         return missing

278 第一个错误的版本

描述

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:
给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

代码

  1. # The isBadVersion API is already defined for you.
  2. # @param version, an integer
  3. # @return a bool
  4. # def isBadVersion(version):
  5. class Solution:
  6.     def firstBadVersion(self, n):
  7.         """
  8.         :type n: int
  9.         :rtype: int
  10.         """
  11.         left,right = 1,n
  12.         while left < right:
  13.             mid = left + (right-left)//2
  14.             if isBadVersion(mid):
  15.                 right = mid
  16.             else:
  17.                 left = mid + 1
  18.         return left

283 移动零

描述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

代码

  1. class Solution:
  2.     def moveZeroes(self, nums: List[int]) -> None:
  3.         """
  4.         Do not return anything, modify nums in-place instead.
  5.         """
  6.         zero_count = 0
  7.         for n in nums[:]:
  8.             if not n:
  9.                 nums.remove(0)
  10.                 zero_count += 1
  12.         nums.extend([0]*zero_count)

大神代码

https://leetcode-cn.com/u/jy317184/

  1. # python双指针，快指针遍历数组，若数字非0，则填充到慢指针处，遍历结束末尾补零
  2. class Solution:
  3.     def moveZeroes(self, nums: List[int]) -> None:
  4.         """
  5.         Do not return anything, modify nums in-place instead.
  6.         """
  7.         j=0
  8.         for i,_ in enumerate(nums):
  9.             if nums[i]!=0:
  10.                 nums[j]=nums[i]
  11.                 j+=1
  13.         for k in range(j,len(nums)):
  14.             nums[k]=0

290 单词规律

描述

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:
输入: pattern = “abba”, str = “dog cat cat dog”
输出: true
示例 2:
输入:pattern = “abba”, str = “dog cat cat fish”
输出: false
示例 3:
输入: pattern = “aaaa”, str = “dog cat cat dog”
输出: false
示例 4:
输入: pattern = “abba”, str = “dog dog dog dog”
输出: false
说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

代码

  1. class Solution:
  2.     def wordPattern(self, pattern: str, str: str) -> bool:
  3.         pattern_dic = {
  4.     }
  5.         str_list = str.split()
  6.         if len(pattern) != len(str_list):
  7.             return False
  8.         for i,j in zip(pattern,str_list):
  9.             if i in pattern_dic:
  10.                 if pattern_dic[i] != j:
  11.                     return False
  12.             else:
  13.                 pattern_dic[i] = j
  14.         value_list = pattern_dic.values()
  15.         if len(set(value_list)) < len(value_list):
  16.             return False
  17.         return True

大神代码

作者：mou-xiao-wei
链接：https://leetcode-cn.com/problems/word-pattern/solution/pythonliang-xing-by-mou-xiao-wei/

  1. def wordPattern(self, pattern: str, str: str) -> bool:
  2.     res=str.split()
  3.     return list(map(pattern.index, pattern))==list(map(res.index,res))
  4. # 如：s='abba',list(map(s.index,s)) 输出：[0,1,1,0]

发表评论

表情：
评论列表 （有 0 条评论，86人围观）

还没有评论，来说两句吧...

相关阅读