算法题记录
Posted 一人前行
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了算法题记录相关的知识，希望对你有一定的参考价值。
- 力扣的算法题：1154
给你一个字符串 date ，按 YYYY-MM-DD 格式表示一个 现行公元纪年法 日期。返回该日期是当年的第几天。
示例 1：
输入：date = “2019-01-09”
输出：9
解释：给定日期是2019年的第九天。
示例 2：
输入：date = “2019-02-10”
输出：41
class Solution
func dayOfYear(_ date: String) -> Int
let dateArray = date.split(separator: "-")
if dateArray.count < 3
return 0
var dayCount = 0
let year = (dateArray[0] as NSString).intValue
let month = (dateArray[1] as NSString).intValue
let day = (dateArray[2] as NSString).intValue
let thirtyOneDayArray:[Int] = [1,3,5,7,8,10,12]
let thirtyDayArray:[Int] = [4,6,9,11]
for index in thirtyOneDayArray
if index < month
dayCount += 31
else
break
if month > 2
if (year % 400 == 0) || (year % 4 == 0) && (year % 100 != 0)
dayCount += 29
else
dayCount += 28
for index in thirtyDayArray
if index < month
dayCount += 30
else
break
dayCount += Int(day);
return dayCount;
- 力扣的：125
如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。字母和数字都属于字母数字字符。给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
示例 1：
输入: s = “A man, a plan, a canal: Panama”
输出：true
解释：“amanaplanacanalpanama” 是回文串。
示例 2：
输入：s = “race a car”
输出：false
解释：“raceacar” 不是回文串。
示例 3：
输入：s = " "
输出：true
解释：在移除非字母数字字符之后，s 是一个空字符串 “” 。
由于空字符串正着反着读都一样，所以是回文串。
func isPalindrome(_ s: String) -> Bool
if s.count == 0
return true
var left = 0
var right = s.count-1
//! 字符串小写，并转化为数组
let array = Array(s.lowercased())
while left <= right
if !array[left].isLetter && !array[left].isNumber
left+=1
continue
if !array[right].isLetter && !array[right].isNumber
right-=1
continue
if array[left] == array[right]
left+=1
right-=1
else
return false
return true
-
- 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：
输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：
输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]
func reverseString(_ s: inout [Character])
var left = 0;
var right = s.count-1
while left <= right
let leftI = s[left]
let rightI = s[right]
let temp = s[right]
s[right] = s[left]
s[left] = temp
left = left + 1
right = right - 1
print(s)
-
- 有效的括号
给定一个只包括 ‘(’，‘)’，‘’，‘’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。
func isValid(_ s: String) -> Bool
guard s.count % 2 == 0 else
return false
// 存放对应关系
let mapDic:[Character:Character] = [
"(":")",
"":"",
"[":"]"]
var stack = [Character]()
for char in s
if mapDic[char] != nil
stack.append(char)
else
if stack.isEmpty
return false
else if mapDic[stack.last!] != char
return false
else
stack.removeLast()
return stack.isEmpty
-
- 判断子序列
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
进阶：
如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
示例 1：
输入：s = “abc”, t = “ahbgdc”
输出：true
示例 2：
输入：s = “axc”, t = “ahbgdc”
输出：false
class Solution
func isSubsequence(_ s: String, _ t: String) -> Bool
var allString = t
var queue = Array(s);
while !queue.isEmpty
let char = queue.removeFirst()
if let index = allString.firstIndex(of: char)
allString = allString.substring(from: allString.index(index, offsetBy: 1))
else
return false
return queue.isEmpty
-
- 最长回文串
给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。
在构造过程中，请注意 区分大小写 。比如 “Aa” 不能当做一个回文字符串。
示例 1:
输入:s = “abccccdd”
输出:7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。
示例 2:
输入:s = “a”
输出:1
示例 3：
输入:s = “aaaaaccc”
输出:7
func longestPalindrome(_ s: String) -> Int
let sArray = Array(s)
var charDic:[Character : Int] = [:]
for char in sArray
if var count = charDic[char]
count = count + 1
charDic.updateValue(count, forKey: char)
else
charDic[char] = 1
var maxCount = 0
var hasJiShuCount = false
for (_, value) in charDic
if value % 2 == 0
maxCount = maxCount + value
else
maxCount = maxCount + value - 1
hasJiShuCount = true
if hasJiShuCount
maxCount = maxCount + 1
return maxCount
-
- 亲密字符串
给你两个字符串 s 和 goal ，只要我们可以通过交换 s 中的两个字母得到与 goal 相等的结果，就返回 true ；否则返回 false 。
交换字母的定义是：取两个下标 i 和 j （下标从 0 开始）且满足 i != j ，接着交换 s[i] 和 s[j] 处的字符。
例如，在 “abcd” 中交换下标 0 和下标 2 的元素可以生成 “cbad” 。
示例 1：
输入：s = “ab”, goal = “ba”
输出：true
解释：你可以交换 s[0] = ‘a’ 和 s[1] = ‘b’ 生成 “ba”，此时 s 和 goal 相等。
示例 2：
输入：s = “ab”, goal = “ab”
输出：false
解释：你只能交换 s[0] = ‘a’ 和 s[1] = ‘b’ 生成 “ba”，此时 s 和 goal 不相等。
示例 3：
输入：s = “aa”, goal = “aa”
输出：true
解释：你可以交换 s[0] = ‘a’ 和 s[1] = ‘a’ 生成 “aa”，此时 s 和 goal 相等。
func buddyStrings(_ s: String, _ goal: String) -> Bool
if s.count != goal.count
return false
if s == goal, Set(s).count < s.count
return true
let goalArray = Array(goal)
var sArray = Array(s)
let count = sArray.count - 1
var lastNoSameIndex = 0
var hasFirstNoSameIndex = true
for i in 0...count
if goalArray[i] != sArray[i]
if hasFirstNoSameIndex
lastNoSameIndex = i
hasFirstNoSameIndex = false
else
sArray.swapAt(lastNoSameIndex, i)
if sArray == goalArray
return true
else
return false
return false
-
- 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
示例 1：
输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”
示例 2：
输入：strs = [“dog”,“racecar”,“car”]
输出：“”
解释：输入不存在公共前缀。
class Solution
func longestCommonPrefix(_ strs: [String]) -> String
if strs.count == 1
return strs.first!
let firstString = strs.first!
let firstArray = Array(firstString)
var prefixString = ""
for char in firstArray
var hasPre = true
prefixString = prefixString.appending(String(char))
for string in strs
if !string.hasPrefix(String(prefixString))
hasPre = false
if !hasPre
prefixString.removeLast()
return prefixString
-
- 重新格式化电话号码
给你一个字符串形式的电话号码 number 。number 由数字、空格 ’ '、和破折号 ‘-’ 组成。
请你按下述方式重新格式化电话号码。
首先，删除 所有的空格和破折号。
其次，将数组从左到右 每 3 个一组 分块，直到 剩下 4 个或更少数字。剩下的数字将按下述规定再分块：
2 个数字：单个含 2 个数字的块。
3 个数字：单个含 3 个数字的块。
4 个数字：两个分别含 2 个数字的块。
最后用破折号将这些块连接起来。注意，重新格式化过程中 不应该 生成仅含 1 个数字的块，并且 最多 生成两个含 2 个数字的块。
返回格式化后的电话号码。
示例 1：
输入：number = “1-23-45 6”
输出：“123-456”
解释：数字是 “123456”
步骤 1：共有超过 4 个数字，所以先取 3 个数字分为一组。第 1 个块是 “123” 。
步骤 2：剩下 3 个数字，将它们放入单个含 3 个数字的块。第 2 个块是 “456” 。
连接这些块后得到 “123-456” 。
示例 2：
输入：number = “123 4-567”
输出：“123-45-67”
解释：数字是 “1234567”.
步骤 1：共有超过 4 个数字，所以先取 3 个数字分为一组。第 1 个块是 “123” 。
步骤 2：剩下 4 个数字，所以将它们分成两个含 2 个数字的块。这 2 块分别是 “45” 和 “67” 。
连接这些块后得到 “123-45-67” 。
示例 3：
输入：number = “123 4-5678”
输出：“123-456-78”
解释：数字是 “12345678” 。
步骤 1：第 1 个块 “123” 。
步骤 2：第 2 个块 “456” 。
步骤 3：剩下 2 个数字，将它们放入单个含 2 个数字的块。第 3 个块是 “78” 。
连接这些块后得到 “123-456-78” 。
class Solution
func reformatNumber(_ number: String) -> String
var newNumber:String = ""
for char in number
if char.isNumber
newNumber.append(char)
var count = newNumber.count;
var offset = 0
while count > 4
offset = offset + 3
newNumber.insert("-", at: newNumber.index(newNumber.startIndex, offsetBy: offset))
// 因为插入了一个 “- ”符号，所以要加1
offset = offset + 1
count = count - 3
if (count == 4)
offset += 2;
newNumber.insert("-", at: newNumber.index(newNumber.startIndex, offsetBy: offset));
return newNumber
-
- 学生出勤记录 I
给你一个字符串 s 表示一个学生的出勤记录，其中的每个字符用来标记当天的出勤情况（缺勤、迟到、到场）。记录中只含下面三种字符：
‘A’：Absent，缺勤
‘L’：Late，迟到
‘P’：Present，到场
如果学生能够 同时 满足下面两个条件，则可以获得出勤奖励：
按 总出勤 计，学生缺勤（‘A’）严格 少于两天。
学生 不会 存在 连续 3 天或 连续 3 天以上的迟到（‘L’）记录。
如果学生可以获得出勤奖励，返回 true ；否则，返回 false 。
示例 1：
输入：s = “PPALLP”
输出：true
解释：学生缺勤次数少于 2 次，且不存在 3 天或以上的连续迟到记录。
示例 2：
输入：s = “PPALLL”
输出：false
解释：学生最后三天连续迟到，所以不满足出勤奖励的条件。
class Solution
func checkRecord(_ s: String) -> Bool
var countA = 0
var countL = 0
var lastChar = ""
for char in s
if char == "A"
lastChar = ""
countL = 0
countA += 1
if countA > 1
return false
else if char == "L"
countL += 1
if lastChar.isEmpty
lastChar = String(char)
else
if countL >= 3
return false
else
lastChar = ""
countL = 0
return countL < 3
-
- 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
class Solution
func twoSum(_ nums: [Int], _ target: Int) -> [Int]
var dict:[Int:Int] = [:]
for i in 0...(nums.count-1)
let other = target - nums[i]
if (dict[other] != nil)
return [dict[other]!, i]
else
dict[nums[i]] = i
return []
643. 子数组最大平均数 I
给你一个由 n 个元素组成的整数数组 nums 和一个整数 k 。
请你找出平均数最大且 长度为 k 的连续子数组，并输出该最大平均数。
任何误差小于 10-5 的答案都将被视为正确答案。
示例 1：
输入：nums = [1,12,-5,-6,50,3], k = 4
输出：12.75
解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75
示例 2：
输入：nums = [5], k = 1
输出：5.00000
class Solution
func findMaxAverage(_ nums: [Int], _ k: Int) -> Double
var sum = 0
var maxSum = 0
for i in 0..<nums.count
if i < k
sum = sum + nums[i]
maxSum = sum
else
sum = sum + nums[i] - nums[i-k]
maxSum = max(sum, maxSum)
return Double(maxSum) / Double(k)
463. 岛屿的周长
给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
示例 1：
输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边
示例 2：
输入：grid = [[1]]
输出：4
示例 3：
输入：grid = [[1,0]]
输出：4
class Solution
func islandPerimeter(_ grid: [[Int]]) -> Int
guard grid.count > 0 else
return 0
let length = grid[acwing 528. 奶酪 解题记录
LEETCODE 刷题记录与资料
以上是关于算法题记录的主要内容，如果未能解决你的问题，请参考以下文章